SD Internal Helpers

Functions
static ERR_te	sd_send_cmd (SPI_REGDEF_ts *spi_instance, uint8_t index, uint32_t arg, bool acmd, CMD_RESPONSE_ts *cmd_response_o)
	Transmits a single SPI-mode SD command and receives the response.
static ERR_te	sd_cease_comms (SD_HANDLE_ts *sd_handle, bool deinit)
	Raises CS, sends two dummy bytes, and disables SPI. Optionally deinitializes the handle.
static ERR_te	sd_go_idle_state (SD_HANDLE_ts *sd_handle)
	Issues CMD0 to reset the SD card into idle (SPI) mode.
static ERR_te	sd_send_if_cond (SD_HANDLE_ts *sd_handle, bool *match_o, bool *no_resp_o)
	Issues CMD8 to determine whether the card is SD Ver.2 or older.
static ERR_te	sd_app_send_op_cond (SD_HANDLE_ts *sd_handle, uint32_t arg)
	Issues ACMD41 to initiate SD card initialization (SD Ver.2 and Ver.1).
static ERR_te	sd_read_ocr (SD_HANDLE_ts *sd_handle)
	Reads the OCR register via CMD58 and stores power-up status, addressing mode, and voltage range.
static ERR_te	sd_send_op_cond (SD_HANDLE_ts *sd_handle)
	Issues CMD1 to initiate MMC Ver.3 card initialization.
static ERR_te	sd_set_blocklen (SD_HANDLE_ts *sd_handle)
	Issues CMD16 to set the block length to 512 bytes for byte-addressed cards.
static ERR_te	sd_read_csd (SD_HANDLE_ts *sd_handle)
	Issues CMD9 to read the CSD register and stores capacity information in the handle.
static ERR_te	decode_csd_v1 (const uint8_t *csd_raw, SD_CSD_INFO_ts *csd_info_o)
	Decodes a CSD v1.0 register (SDSC cards) into a SD_CSD_INFO_ts structure.
static ERR_te	decode_csd_v2 (const uint8_t *csd_raw, SD_CSD_INFO_ts *csd_info_o)
	Decodes a CSD v2.0 register (SDHC/SDXC cards) into a SD_CSD_INFO_ts structure.

Detailed Description

Function Documentation

sd_send_cmd()

ERR_te sd_send_cmd ( SPI_REGDEF_ts * spi_instance, uint8_t index, uint32_t arg, bool acmd, CMD_RESPONSE_ts * cmd_response_o )

static

Transmits a single SPI-mode SD command and receives the response.

Builds the 6-byte command frame (start bit | index, 4-byte argument, CRC), transmits it over SPI, and receives the R1 response byte. For application- specific commands (ACMD), CMD55 is sent first automatically.

Trailing response bytes are handled per command:

• R1 only: CMD0, CMD1, CMD9, CMD10, CMD16, CMD17, CMD18, CMD23, CMD24, CMD25, CMD41, CMD55
• R3 (4 extra bytes, OCR): CMD58
• R7 (4 extra bytes, interface condition): CMD8
• R1B (busy polling): CMD12 — discards stuff byte, then polls until card releases MISO

CRC is required for CMD0 (0x95) and CMD8 (0x87); dummy CRC (0x00) is used for all other commands, as CRC checking is disabled after initialization.

Parameters

[in]	spi_instance	Pointer to the SPI peripheral to use.
[in]	index	Command index (0–63, without the 0x40 start bit).
[in]	arg	32-bit command argument.
[in]	acmd	If true, CMD55 is sent before this command to prefix it as an application-specific command.
[out]	cmd_response_o	Pointer to the response structure to populate.

Returns

• ERR_OK on success
• ERR_TIMEOUT if R1 or R1B is not received within the configured timeout
• Propagated error from the CMD55 prefix call if acmd is true

Definition at line 1131 of file sd.c.

                                                                                                                                {
    ERR_te err;
    uint32_t start_time;
    uint32_t elapsed_time;
 
    uint8_t crc = 0x00;
    uint8_t cmd[6];
 
    if(acmd) {
        CMD_RESPONSE_ts dummy;
        err = sd_send_cmd(spi_instance, 55, 0, false, &dummy);
        if(err != ERR_OK) {
            LOG_ERROR(
                internal_state.subsys,
                LOG_LEVEL_ERROR,
                "sd_send_cmd: unknown error"
            );
 
            return err;
        }
    }
 
    if(index == 0x00) {
        crc = 0x95; // CMD0 requires valid CRC
    }
    else if(index == 0x08) {
        crc = 0x87; // CMD8 requires valid CRC
    }
 
    cmd[0] = 0x40 | index;
    cmd[1] = (arg >> 24) & 0xFF;
    cmd[2] = (arg >> 16) & 0xFF;
    cmd[3] = (arg >> 8) & 0xFF;
    cmd[4] = arg & 0xFF;
    cmd[5] = crc;
 
    spi_send(spi_instance, cmd, sizeof(cmd));
 
    // CMD12 requires discarding the first byte (stuff byte) before the R1 response
    if(index == 12) {
        uint8_t stuff_byte;
        spi_receive(spi_instance, &stuff_byte, 1);
    }
 
    uint8_t r1 = 0xFF;
    start_time = systick_get_ms();
 
    do {
        spi_receive(spi_instance, &r1, 1);
        elapsed_time = systick_get_ms() - start_time;
    } while ((r1 & 0x80) && elapsed_time <= CONFIG_SD_R1_RESP_TIMEOUT);
 
    cmd_response_o->r1 = r1;
 
    if(elapsed_time > CONFIG_SD_R1_RESP_TIMEOUT) {
        LOG_ERROR(
            internal_state.subsys,
            LOG_LEVEL_ERROR,
            "sd_send_cmd: timed out"
        );
 
        return ERR_TIMEOUT;
    }
 
    if(
        index == 0  || index == 1  || index == 41 || index == 9  ||
        index == 10 || index == 16 || index == 17 || index == 18 ||
        index == 23 || index == 24 || index == 25 || index == 55
    ) {
        // R1 only — zero unused fields
        memset(cmd_response_o->r3, 0, sizeof(cmd_response_o->r3));
        memset(cmd_response_o->r7, 0, sizeof(cmd_response_o->r7));
    }
    else if(index == 58) {
        // R3 (OCR) — receive 4 trailing bytes
        memset(cmd_response_o->r7, 0, sizeof(cmd_response_o->r7));
        spi_receive(spi_instance, cmd_response_o->r3, 4);
    }
    else if(index == 8) {
        // R7 (interface condition) — receive 4 trailing bytes
        memset(cmd_response_o->r3, 0, sizeof(cmd_response_o->r3));
        spi_receive(spi_instance, cmd_response_o->r7, 4);
    }
    else if(index == 12) {
        // R1B — poll until card releases MISO (busy signal ends)
        memset(cmd_response_o->r3, 0, sizeof(cmd_response_o->r3));
        memset(cmd_response_o->r7, 0, sizeof(cmd_response_o->r7));
 
        uint8_t rx = 0x00;
        start_time = systick_get_ms();
 
        do {
            spi_receive(spi_instance, &rx, 1);
            elapsed_time = systick_get_ms() - start_time;
        } while(rx == 0x00 && elapsed_time <= CONFIG_SD_R1B_RESP_TIMEOUT);
 
        if(elapsed_time > CONFIG_SD_R1B_RESP_TIMEOUT) {
            LOG_ERROR(
                internal_state.subsys,
                LOG_LEVEL_ERROR,
                "sd_send_cmd: timed out"
            );
 
            return ERR_TIMEOUT;
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_cease_comms()

ERR_te sd_cease_comms ( SD_HANDLE_ts * sd_handle, bool deinit )

static

Raises CS, sends two dummy bytes, and disables SPI. Optionally deinitializes the handle.

Called after every completed or failed SPI transaction to return the bus to an idle state. When deinit is true, temporarily sets the handle's initialized flag to allow sd_deinit_handle to run, then calls it to release the pool slot.

Parameters

[in]	sd_handle	Pointer to the SD card handle.
[in]	deinit	If true, deinitializes the handle after ending communication.

Returns

• ERR_OK always

Definition at line 1256 of file sd.c.

                                                                   {
    gpio_write(sd_handle->cs_gpio_port, sd_handle->cs_gpio_pin, HIGH);
 
    uint8_t dummy[2] = { 0xFF, 0xFF };
    spi_send(sd_handle->spi_instance, dummy, 2);
 
    spi_set_comm(sd_handle->spi_instance, DISABLE);
 
    if(deinit) {
        // Bypass init guard to allow sd_deinit_handle to proceed
        sd_handle->initialized = true;
        sd_deinit_handle(sd_handle);
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_go_idle_state()

ERR_te sd_go_idle_state ( SD_HANDLE_ts * sd_handle )

static

Issues CMD0 to reset the SD card into idle (SPI) mode.

Retries up to CONFIG_SD_CMD_SEND_ERROR_RETRY_NUM times with CONFIG_SD_CMD_SEND_ERROR_RETRY_LATENCY ms between attempts. Succeeds when R1 bit 0 (idle state) is set.

Parameters

[in]

sd_handle

Pointer to the SD card handle.

Returns

• ERR_OK on success
• ERR_UNSUCCESFUL_ACTION if the card does not enter idle state within the retry limit

Definition at line 1287 of file sd.c.

                                                        {
    ERR_te err;
    CMD_RESPONSE_ts cmd_response = { 0 };
 
    uint8_t retries = 0;
    do {
        retries++;
        err = sd_send_cmd(sd_handle->spi_instance, 0, 0, false, &cmd_response);
        if(err != ERR_OK || !(cmd_response.r1 & 0x01)) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "sd_go_idle_state: command execution failure, retry %d/%d in %d ms",
                retries, CONFIG_SD_CMD_SEND_ERROR_RETRY_NUM, CONFIG_SD_CMD_SEND_ERROR_RETRY_LATENCY
            );
            DELAY(CONFIG_SD_CMD_SEND_ERROR_RETRY_LATENCY);
        }
    } while ((err != ERR_OK || !(cmd_response.r1 & 0x01)) && retries < CONFIG_SD_CMD_SEND_ERROR_RETRY_NUM);
 
    if(err != ERR_OK || !(cmd_response.r1 & 0x01)) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_go_idle_state: command execution failure"
        );
 
        return ERR_UNSUCCESFUL_ACTION;
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_send_if_cond()

ERR_te sd_send_if_cond ( SD_HANDLE_ts * sd_handle, bool * match_o, bool * no_resp_o )

static

Issues CMD8 to determine whether the card is SD Ver.2 or older.

Sends CMD8 with the standard voltage argument 0x000001AA.

• If the R7 response echoes 0x000001AA, the card is SD Ver.2 and match_o is set.
• If CMD8 times out, the card is SD Ver.1 or MMC and no_resp_o is set.
• If the R7 does not match, the card is incompatible and an error is returned.

Parameters

[in]	sd_handle	Pointer to the SD card handle.
[out]	match_o	Set to true if R7 echoes 0x000001AA (SD Ver.2).
[out]	no_resp_o	Set to true if CMD8 produces no response (SD Ver.1 / MMC).

Returns

• ERR_OK on success (either match or no response)
• ERR_INITIALIZATION_FAILURE if R7 does not match the expected echo

Definition at line 1336 of file sd.c.

                                                                                       {
    ERR_te err;
    CMD_RESPONSE_ts cmd_response = { 0 };
 
    err = sd_send_cmd(sd_handle->spi_instance, 8, 0x000001AA, false, &cmd_response);
    if(err != ERR_OK) {
        *no_resp_o = true;
 
        return ERR_OK;
    }
 
    uint8_t expected[] = { 0x00, 0x00, 0x01, 0xAA };
    for(uint8_t i = 0; i < 4; i++) {
        if(cmd_response.r7[i] != expected[i]) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "sd_send_if_cond: initialization failure"
            );
 
            return ERR_INITIALIZATION_FAILURE;
        }
    }
 
    *match_o = true;
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_app_send_op_cond()

ERR_te sd_app_send_op_cond ( SD_HANDLE_ts * sd_handle, uint32_t arg )

static

Issues ACMD41 to initiate SD card initialization (SD Ver.2 and Ver.1).

Retries up to CONFIG_SD_INVALID_RESP_RETRY_NUM times while R1 equals 0x01 (still initializing). Pass arg = 0x40000000 for SD Ver.2 (HCS bit set) or arg = 0 for SD Ver.1.

Parameters

[in]	sd_handle	Pointer to the SD card handle.
[in]	arg	ACMD41 argument. Use 0x40000000 for SDHC support, 0x00000000 for SDSC only.

Returns

• ERR_OK on success
• ERR_TIMEOUT if the R1 response is not received within timeout
• ERR_INITIALIZATION_FAILURE if the card does not complete initialization within the retry limit

Definition at line 1383 of file sd.c.

                                                                         {
    ERR_te err;
    CMD_RESPONSE_ts cmd_response = { 0 };
    uint32_t retries = 0;
 
    do {
        retries++;
        err = sd_send_cmd(sd_handle->spi_instance, 41, arg, true, &cmd_response);
        if(err == ERR_TIMEOUT) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "sd_app_send_op_cond: R1 response timeout"
            );
 
            return ERR_TIMEOUT;
        }
 
        if(cmd_response.r1 != 0x00) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "sd_app_send_op_cond: invalid R1 response, retry %d/%d in %d ms",
                retries, CONFIG_SD_INVALID_RESP_RETRY_NUM, CONFIG_SD_INVALID_RESP_RETRY_TIMEOUT
            );
            DELAY(CONFIG_SD_INVALID_RESP_RETRY_TIMEOUT);
        }
    } while(cmd_response.r1 == 0x01 && retries < CONFIG_SD_INVALID_RESP_RETRY_NUM);
 
    if(cmd_response.r1 != 0x00) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_app_send_op_cond: initialization failure"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_read_ocr()

ERR_te sd_read_ocr ( SD_HANDLE_ts * sd_handle )

static

Reads the OCR register via CMD58 and stores power-up status, addressing mode, and voltage range.

Reconstructs the 32-bit OCR value from the 4-byte R3 response and extracts: power-up completion flag (SD_PWRUP_STATUS_te), Card Capacity Status (block vs byte addressing), and the supported voltage window (stored but not currently used for filtering).

Parameters

[in]

sd_handle

Pointer to the SD card handle.

Returns

• ERR_OK on success
• ERR_UNSUCCESFUL_ACTION if CMD58 fails

Definition at line 1440 of file sd.c.

                                                   {
    ERR_te err;
    CMD_RESPONSE_ts cmd_response = { 0 };
 
    err = sd_send_cmd(sd_handle->spi_instance, 58, 0, false, &cmd_response);
    if(err != ERR_OK) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_read_ocr: failed to read ocr"
        );
 
        return ERR_UNSUCCESFUL_ACTION;
    }
 
    uint32_t ocr =
        ((uint32_t)cmd_response.r3[0] << 24) |
        ((uint32_t)cmd_response.r3[1] << 16) |
        ((uint32_t)cmd_response.r3[2] << 8)  |
        ((uint32_t)cmd_response.r3[3]);
 
    sd_handle->pwrup_status = ((ocr >> OCR_PWRUP_STATUS) & 0x1) ?
        SD_PWRUP_STATUS_READY : SD_PWRUP_STATUS_BUSY;
 
    sd_handle->addr_mode = ((ocr >> OCR_CAPACITY_STATUS) & 0x1) ?
        SD_ADDR_MODE_BLOCK : SD_ADDR_MODE_BYTE;
 
    bool voltage_low_found = false;
    for(uint8_t ocr_counter = 4; ocr_counter < 24; ocr_counter++) {
        if((ocr >> ocr_counter) & 0x1 && !voltage_low_found) {
            sd_handle->min_operating_voltage = (SD_MIN_OPERATING_VOLTAGE_te)(23 - ocr_counter);
            voltage_low_found = true;
        }
        else if((ocr >> ocr_counter) & 0x1 && voltage_low_found) {
            sd_handle->max_operating_voltage = (SD_MAX_OPERATIING_VOLTAGE_te)(23 - ocr_counter);
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_send_op_cond()

ERR_te sd_send_op_cond ( SD_HANDLE_ts * sd_handle )

static

Issues CMD1 to initiate MMC Ver.3 card initialization.

Used as a fallback when ACMD41 fails (card is MMC, not SD). Retries while R1 equals 0x01 (still initializing).

Parameters

[in]

sd_handle

Pointer to the SD card handle.

Returns

• ERR_OK on success
• ERR_TIMEOUT if the R1 response is not received within timeout
• ERR_INITIALIZATION_FAILURE if the card does not complete initialization

Definition at line 1495 of file sd.c.

                                                       {
    ERR_te err;
    CMD_RESPONSE_ts cmd_response = { 0 };
    uint32_t retries = 0;
 
    do {
        retries++;
        err = sd_send_cmd(sd_handle->spi_instance, 1, 0, false, &cmd_response);
        if(err == ERR_TIMEOUT) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "sd_send_op_cond: R1 response timeout"
            );
 
            return ERR_TIMEOUT;
        }
    } while(cmd_response.r1 == 0x01 && retries < CONFIG_SD_INVALID_RESP_RETRY_NUM);
 
    if(cmd_response.r1 != 0x00) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_send_op_cond: initialization failure"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_set_blocklen()

ERR_te sd_set_blocklen ( SD_HANDLE_ts * sd_handle )

static

Issues CMD16 to set the block length to 512 bytes for byte-addressed cards.

Only called for SDSC (byte-addressed) cards. SDHC cards always use a fixed 512-byte block length and do not require this command.

Parameters

[in]

sd_handle

Pointer to the SD card handle.

Returns

• ERR_OK on success
• ERR_UNSUCCESFUL_ACTION if CMD16 fails or the card returns a non-zero R1

Definition at line 1540 of file sd.c.

                                                       {
    ERR_te err;
    CMD_RESPONSE_ts cmd_response = { 0 };
 
    err = sd_send_cmd(sd_handle->spi_instance, 16, 0x00000200, false, &cmd_response);
    if(err != ERR_OK) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_set_blocklen: failed to set block length"
        );
 
        return ERR_UNSUCCESFUL_ACTION;
    }
 
    if(cmd_response.r1 != 0x00)
        return ERR_UNSUCCESFUL_ACTION;
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_read_csd()

ERR_te sd_read_csd ( SD_HANDLE_ts * sd_handle )

static

Issues CMD9 to read the CSD register and stores capacity information in the handle.

Waits for the data token (0xFE), reads the 16-byte CSD register, and dispatches to decode_csd_v1 or decode_csd_v2 based on the CSD structure version field. CSD version 3 is treated as v2. The resulting sd_handle_s::capacity_mb, sd_handle_s::block_count, and sd_handle_s::block_len fields are populated from the decoded data.

Parameters

[in]

sd_handle

Pointer to the SD card handle.

Returns

• ERR_OK on success
• ERR_UNSUCCESFUL_ACTION if CMD9 fails or the data token times out

Definition at line 1577 of file sd.c.

                                                   {
    ERR_te err;
    CMD_RESPONSE_ts cmd_response = { 0 };
    uint8_t csd_raw[16];
    SD_CSD_INFO_ts csd_info = { 0 };
 
    err = sd_send_cmd(sd_handle->spi_instance, 9, 0, false, &cmd_response);
    if (err != ERR_OK || cmd_response.r1 != 0x00) {
        LOG_ERROR(internal_state.subsys, internal_state.log_level,
                  "sd_read_csd: failed to send CMD9");
        return ERR_UNSUCCESFUL_ACTION;
    }
 
    uint8_t token = 0;
    uint32_t start_time = systick_get_ms();
    uint32_t elapsed_time = 0;
 
    do {
        spi_receive(sd_handle->spi_instance, &token, 1);
        elapsed_time = systick_get_ms() - start_time;
    } while (token != 0xFE && elapsed_time <= CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT);
 
    if (elapsed_time > CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT || token != 0xFE) {
        LOG_ERROR(internal_state.subsys, internal_state.log_level,
                  "sd_read_csd: timeout waiting for data token");
        return ERR_UNSUCCESFUL_ACTION;
    }
 
    memset(csd_raw, 0, sizeof(csd_raw));
    spi_receive(sd_handle->spi_instance, csd_raw, 16);
 
    uint8_t crc[2];
    spi_receive(sd_handle->spi_instance, crc, 2);
 
    memset(&csd_info, 0, sizeof(SD_CSD_INFO_ts));
 
    uint8_t csd_structure = extract_bits(csd_raw, 126, 2);
 
    switch (csd_structure) {
        case 0:
            decode_csd_v1(csd_raw, &csd_info);
            break;
        case 1:
            decode_csd_v2(csd_raw, &csd_info);
            break;
        case 3:
            decode_csd_v2(csd_raw, &csd_info);
            // SDHC newer version — treated as v2
            break;
    }
 
    sd_handle->capacity_mb = csd_info.capacity_mb;
    sd_handle->block_count = csd_info.block_count;
    sd_handle->block_len   = csd_info.block_len;
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_csd_v1()

ERR_te decode_csd_v1 ( const uint8_t * csd_raw, SD_CSD_INFO_ts * csd_info_o )

static

Decodes a CSD v1.0 register (SDSC cards) into a SD_CSD_INFO_ts structure.

Extracts all fields from the 16-byte big-endian CSD register using extract_bits and computes derived values:

• block_len = 2^READ_BL_LEN
• block_count = (C_SIZE + 1) × 2^(C_SIZE_MULT + 2)
• capacity_bytes = block_count × block_len
• capacity_mb = capacity_bytes / (1024 × 1024)

Parameters

[in]	csd_raw	Pointer to the 16-byte raw CSD register data.
[out]	csd_info_o	Pointer to the structure that will receive the decoded fields.

Returns

• ERR_OK always

Definition at line 1652 of file sd.c.

                                                                                {
    csd_info_o->csd_structure      = extract_bits(csd_raw, 126, 2);
    csd_info_o->taac               = extract_bits(csd_raw, 112, 8);
    csd_info_o->nsac               = extract_bits(csd_raw, 104, 8);
    csd_info_o->tran_speed         = extract_bits(csd_raw,  96, 8);
    csd_info_o->ccc                = extract_bits(csd_raw,  84, 12);
    csd_info_o->v1.read_bl_len     = extract_bits(csd_raw,  80, 4);
    csd_info_o->read_bl_partial    = extract_bits(csd_raw,  79, 1);
    csd_info_o->write_blk_misalign = extract_bits(csd_raw,  78, 1);
    csd_info_o->read_blk_misalign  = extract_bits(csd_raw,  77, 1);
    csd_info_o->dsr_imp            = extract_bits(csd_raw,  76, 1);
    csd_info_o->v1.c_size          = extract_bits(csd_raw,  62, 12);
    csd_info_o->v1.c_size_mult     = extract_bits(csd_raw,  47, 3);
    csd_info_o->erase_blk_en       = extract_bits(csd_raw,  46, 1);
    csd_info_o->sector_size        = extract_bits(csd_raw,  39, 7);
    csd_info_o->wp_grp_size        = extract_bits(csd_raw,  32, 7);
    csd_info_o->wp_grp_enable      = extract_bits(csd_raw,  31, 1);
    csd_info_o->r2w_factor         = extract_bits(csd_raw,  26, 3);
    csd_info_o->write_bl_len       = extract_bits(csd_raw,  22, 4);
    csd_info_o->write_bl_partial   = extract_bits(csd_raw,  21, 1);
    csd_info_o->file_format_grp    = extract_bits(csd_raw,  15, 1);
    csd_info_o->copy               = extract_bits(csd_raw,  14, 1);
    csd_info_o->perm_write_protect = extract_bits(csd_raw,  13, 1);
    csd_info_o->tmp_write_protect  = extract_bits(csd_raw,  12, 1);
    csd_info_o->file_format        = extract_bits(csd_raw,  10, 2);
    csd_info_o->wp_upc             = extract_bits(csd_raw,   9, 1);
    csd_info_o->crc                = extract_bits(csd_raw,   1, 7);
 
    csd_info_o->block_len    = 1 << csd_info_o->v1.read_bl_len;
    uint32_t mult            = 1 << (csd_info_o->v1.c_size_mult + 2);
    csd_info_o->block_count  = (csd_info_o->v1.c_size + 1) * mult;
    csd_info_o->capacity_bytes = csd_info_o->block_count * csd_info_o->block_len;
    csd_info_o->capacity_mb  = csd_info_o->capacity_bytes / (1024 * 1024);
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_csd_v2()

ERR_te decode_csd_v2 ( const uint8_t * csd_raw, SD_CSD_INFO_ts * csd_info_o )

static

Decodes a CSD v2.0 register (SDHC/SDXC cards) into a SD_CSD_INFO_ts structure.

Extracts all fields from the 16-byte big-endian CSD register using extract_bits and computes derived values:

• block_len = 512 (fixed for SDHC)
• capacity_bytes = (C_SIZE + 1) × 512 × 1024
• capacity_mb = capacity_bytes / (1024 × 1024)
• block_count = capacity_bytes / 512

Parameters

[in]	csd_raw	Pointer to the 16-byte raw CSD register data.
[out]	csd_info_o	Pointer to the structure that will receive the decoded fields.

Returns

• ERR_OK always

Definition at line 1706 of file sd.c.

                                                                                {
    csd_info_o->csd_structure      = extract_bits(csd_raw, 126, 2);
    csd_info_o->taac               = extract_bits(csd_raw, 112, 8);
    csd_info_o->nsac               = extract_bits(csd_raw, 104, 8);
    csd_info_o->tran_speed         = extract_bits(csd_raw,  96, 8);
    csd_info_o->ccc                = extract_bits(csd_raw,  84, 12);
    csd_info_o->v1.read_bl_len     = extract_bits(csd_raw,  80, 4);
    csd_info_o->read_bl_partial    = extract_bits(csd_raw,  79, 1);
    csd_info_o->write_blk_misalign = extract_bits(csd_raw,  78, 1);
    csd_info_o->read_blk_misalign  = extract_bits(csd_raw,  77, 1);
    csd_info_o->dsr_imp            = extract_bits(csd_raw,  76, 1);
    csd_info_o->v2.c_size          = extract_bits(csd_raw,  48, 22);
    csd_info_o->erase_blk_en       = extract_bits(csd_raw,  46, 1);
    csd_info_o->sector_size        = extract_bits(csd_raw,  39, 7);
    csd_info_o->wp_grp_size        = extract_bits(csd_raw,  32, 7);
    csd_info_o->wp_grp_enable      = extract_bits(csd_raw,  31, 1);
    csd_info_o->r2w_factor         = extract_bits(csd_raw,  26, 3);
    csd_info_o->write_bl_len       = extract_bits(csd_raw,  22, 4);
    csd_info_o->write_bl_partial   = extract_bits(csd_raw,  21, 1);
    csd_info_o->file_format_grp    = extract_bits(csd_raw,  15, 1);
    csd_info_o->copy               = extract_bits(csd_raw,  14, 1);
    csd_info_o->perm_write_protect = extract_bits(csd_raw,  13, 1);
    csd_info_o->tmp_write_protect  = extract_bits(csd_raw,  12, 1);
    csd_info_o->file_format        = extract_bits(csd_raw,  10, 2);
    csd_info_o->wp_upc             = extract_bits(csd_raw,   9, 1);
    csd_info_o->crc                = extract_bits(csd_raw,   1, 7);
 
    csd_info_o->block_len      = 512;
    csd_info_o->capacity_bytes = (csd_info_o->v2.c_size + 1) * 512 * 1024;
    csd_info_o->capacity_mb    = csd_info_o->capacity_bytes / (1024 * 1024);
    csd_info_o->block_count    = csd_info_o->capacity_bytes / 512;
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: