SD Card Public API

Public functions to interact with the SD card subsystem. More...

Collaboration diagram for SD Card Public API:

Functions
ERR_te	sd_init_subsys (void)
	Initializes the SD card subsystem.
ERR_te	sd_deinit_subsys (void)
	Deinitializes the SD card subsystem.
ERR_te	sd_start_subsys (void)
	Starts the SD card subsystem.
ERR_te	sd_stop_subsys (void)
	Stops the SD card subsystem.
ERR_te	sd_init_handle (SD_CFG_ts *sd_cfg, SD_HANDLE_ts **sd_handle_o)
	Initializes an SD card handle and performs the full SPI-mode power-up sequence.
ERR_te	sd_deinit_handle (SD_HANDLE_ts *sd_handle)
	Deinitializes an SD card handle and resets the SPI peripheral.
ERR_te	sd_get_handle_init (SD_HANDLE_ts *sd_handle, bool *handle_init_o)
	Retrieves the initialization state of an SD card handle.
ERR_te	sd_get_sector_count (SD_HANDLE_ts *sd_handle, uint32_t *sector_count_o)
	Retrieves the total sector (block) count of the SD card.
ERR_te	sd_get_sector_size (SD_HANDLE_ts *sd_handle, uint32_t *sector_size_o)
	Retrieves the sector (block) size of the SD card in bytes.
ERR_te	sd_read (SD_HANDLE_ts *sd_handle, uint8_t *read_buf, uint32_t start_sector, uint32_t num_sectors)
	Reads one or more sectors from the SD card.
ERR_te	sd_write (SD_HANDLE_ts *sd_handle, uint8_t *write_buf, uint32_t start_sector, uint32_t num_sectors)
	Writes one or more sectors to the SD card.
ERR_te	sd_ioctl (SD_HANDLE_ts *sd_handle)
	Executes an IOCTL control command on the SD card handle.

Detailed Description

Public functions to interact with the SD card subsystem.

Function Documentation

sd_init_subsys()

ERR_te sd_init_subsys

(

void

)

Initializes the SD card subsystem.

Resets the internal state, initializes logging and systick dependencies, and registers the CLI commands.

Must be called before any other SD API function.

Returns

• ERR_OK on success
• ERR_MODULE_ALREADY_INITIALIZED if the subsystem is already initialized
• Propagated error from cmd_register on failure

See also

sd_init_subsys

Definition at line 325 of file sd.c.

                            {
    ERR_te err;
 
    if(internal_state.initialized) {
        return ERR_MODULE_ALREADY_INITIALIZED;
    }
 
    internal_state = (struct internal_state_s){ 0 };
 
    internal_state.log_level = LOG_LEVEL_INFO;
    internal_state.subsys = MODULES_SD;
    internal_state.initialized = true;
    internal_state.started = false;
 
    init_log();
    init_systick();
 
    err = cmd_register(&sd_cmd_client_info);
    if(err != ERR_OK) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_init_subsys: cmd_register error"
        );
        return err;
    }
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "sd_init_subsys: subsys initialized"
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

sd_deinit_subsys()

ERR_te sd_deinit_subsys

(

void

)

Deinitializes the SD card subsystem.

Resets the internal state to zero and deregisters the CLI commands.

Returns

• ERR_OK on success
• ERR_DEINITIALIZATION_FAILURE if the subsystem is not initialized

See also

sd_deinit_subsys

Definition at line 361 of file sd.c.

                              {
    if(internal_state.initialized) {
        internal_state = (struct internal_state_s){ 0 };
 
        cmd_deregister(&sd_cmd_client_info);
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_deinit_subsys: subsys is not initialized"
        );
 
        return ERR_DEINITIALIZATION_FAILURE;
    }
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "sd_deinit_subsys: subsys deinitialized"
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

sd_start_subsys()

ERR_te sd_start_subsys

(

void

)

Starts the SD card subsystem.

Enables sd_read and sd_write operations.

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or already started

See also

sd_start_subsys

Definition at line 386 of file sd.c.

                             {
    if(internal_state.initialized && !internal_state.started) {
        internal_state.started = true;
 
        LOG_INFO(
            internal_state.subsys,
            internal_state.log_level,
            "sd_start_subsys: subsys started"
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_start_subsys: subsys not initialized or already started"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

sd_stop_subsys()

ERR_te sd_stop_subsys

(

void

)

Stops the SD card subsystem.

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or already stopped

See also

sd_stop_subsys

Definition at line 410 of file sd.c.

                            {
    if(internal_state.initialized && internal_state.started) {
        internal_state.started = false;
 
        LOG_INFO(
            internal_state.subsys,
            internal_state.log_level,
            "sd_stop_subsys: subsys stopped"
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_stop_subsys: subsys not initialized or already already stopped"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

sd_init_handle()

ERR_te sd_init_handle	(	SD_CFG_ts *	sd_cfg,
		SD_HANDLE_ts **	sd_handle_o )

Initializes an SD card handle and performs the full SPI-mode power-up sequence.

Configures all GPIO pins and the SPI peripheral, then executes the SD card initialization sequence (idle state, interface condition check, ACMD41/CMD1, OCR read, CSD read). On success, the SPI clock is ramped to maximum speed.

If any step of the initialization sequence fails, the handle is automatically deinitialized and an error is returned.

Parameters

[in]	sd_cfg	Pointer to the SD card configuration structure.
[out]	sd_handle_o	Pointer to a handle pointer that will be set to the allocated SD card instance.

Returns

• ERR_OK on success
• ERR_INITIALIZATION_FAILURE if the subsystem is not initialized
• ERR_NOT_ENOUGH_SPACE if the maximum number of handles is reached
• ERR_INVALID_ARGUMENT if sd_cfg is NULL
• ERR_UNSUCCESFUL_ACTION if any step of the SD initialization sequence fails

See also

sd_init_handle

Definition at line 434 of file sd.c.

                                                                     {
    ERR_te err;
    uint8_t free_index;
 
    if(!internal_state.initialized) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_init_handle: subsys not initialized"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    if(internal_state.sd_num == CONFIG_SD_MAX_OBJECTS) {
        LOG_CRITICAL(
            internal_state.subsys,
            internal_state.log_level,
            "sd_init_handle: subsystem out of memory space"
        );
 
        return ERR_NOT_ENOUGH_SPACE;
    }
 
    if(!sd_cfg) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_init_handle: invalid argument"
        );
        return ERR_INVALID_ARGUMENT;
    }
 
    bool found = false;
 
    for(uint32_t i = 0; i < CONFIG_SD_MAX_OBJECTS; i++) {
        if(!internal_state.sds[i].in_use) {
            free_index = i;
            found = true;
            break;
        }
    }
 
    if(!found)
        return ERR_NOT_ENOUGH_SPACE;
 
    GPIO_CFG_ts sd_sclk = { 0 };
    sd_sclk.port = sd_cfg->sclk_gpio_port;
    sd_sclk.pin = sd_cfg->sclk_gpio_pin;
    sd_sclk.mode = GPIO_MODE_ALTERNATE_FUNCTION;
    sd_sclk.alternate_function = sd_cfg->gpio_alternate_function;
    gpio_init(&sd_sclk);
 
    GPIO_CFG_ts sd_cs = { 0 };
    sd_cs.port = sd_cfg->cs_gpio_port;
    sd_cs.pin = sd_cfg->cs_gpio_pin;
    sd_cs.mode = GPIO_MODE_OUTPUT;
    gpio_init(&sd_cs);
 
    GPIO_CFG_ts sd_mosi = { 0 };
    sd_mosi.port = sd_cfg->mosi_gpio_port;
    sd_mosi.pin = sd_cfg->mosi_gpio_pin;
    sd_mosi.mode = GPIO_MODE_ALTERNATE_FUNCTION;
    sd_mosi.alternate_function = sd_cfg->gpio_alternate_function;
    gpio_init(&sd_mosi);
 
    GPIO_CFG_ts sd_miso = { 0 };
    sd_miso.port = sd_cfg->miso_gpio_port;
    sd_miso.pin = sd_cfg->miso_gpio_pin;
    sd_miso.mode = GPIO_MODE_ALTERNATE_FUNCTION;
    sd_miso.alternate_function = sd_cfg->gpio_alternate_function;
    gpio_init(&sd_miso);
 
    // Configure SPI
    SPI_CFG_ts sd_spi = { 0 };
    sd_spi.instance = sd_cfg->spi_instance;
    sd_spi.bit_first = SPI_BIT_FIRST_MSB;
    sd_spi.clock_phase = SPI_CLOCK_PHASE_FIRST_TRANSITION;
    sd_spi.clock_polarity = SPI_CLOCK_POLARITY_0_IDLE;
    sd_spi.data_frame_format = SPI_DATA_FRAME_FORMATE_8_BIT;
    sd_spi.slave_select_mode = SPI_SLAVE_SELECT_MODE_SW;
    sd_spi.mode = SPI_MODE_MASTER;
 
    IO_CFG_ts io_cs_conf = { 0 };
    IO_HANDLE_ts *io_cs_handle = { 0 };
    io_cs_conf.gpio_handle = &sd_miso;
    str_cpy(io_cs_conf.name, "sd_cs", get_str_len("sd_cs") + 1);
    io_init_subsys();
    io_init_handle(&io_cs_conf, &io_cs_handle);
    io_start_subsys();
 
    // Set SPI speed between 100 and 400 KHz for initialization, then initialize
    uint32_t spi_pclk = 0;
 
    if(sd_cfg->spi_instance == SPI1 || sd_cfg->spi_instance == SPI4) {
        spi_pclk = rcc_get_apb2_clk();
    }
    else if(sd_cfg->spi_instance == SPI2 || sd_cfg->spi_instance == SPI3) {
        spi_pclk = rcc_get_apb1_clk();
    }
 
    uint32_t spi_pclk_cpy = spi_pclk;
    uint32_t div_factor = 2;
    while(div_factor <= 256) {
        spi_pclk = spi_pclk / div_factor;
 
        if(spi_pclk >= 100000 && spi_pclk <= 400000) {
            break;
        }
 
        spi_pclk = spi_pclk_cpy;
        div_factor *= 2;
    }
 
    switch (div_factor) {
        case 2:   sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_2;   break;
        case 4:   sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_4;   break;
        case 8:   sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_8;   break;
        case 16:  sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_16;  break;
        case 32:  sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_32;  break;
        case 64:  sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_64;  break;
        case 128: sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_128; break;
        case 256: sd_spi.master_sclk_speed = SPI_MASTER_SCLK_SPEED_PCLK_DIV_256; break;
    }
 
    spi_init(&sd_spi);
 
    str_cpy(
        internal_state.sds[free_index].name,
        sd_cfg->name,
        get_str_len(sd_cfg->name) + 1
    );
 
    internal_state.sds[free_index].spi_instance = sd_cfg->spi_instance;
    internal_state.sds[free_index].sclk_gpio_port = sd_cfg->sclk_gpio_port;
    internal_state.sds[free_index].cs_gpio_port = sd_cfg->cs_gpio_port;
    internal_state.sds[free_index].sclk_gpio_pin = sd_cfg->sclk_gpio_pin;
    internal_state.sds[free_index].miso_gpio_port = sd_cfg->miso_gpio_port;
    internal_state.sds[free_index].mosi_gpio_port = sd_cfg->mosi_gpio_port;
    internal_state.sds[free_index].cs_gpio_pin = sd_cfg->cs_gpio_pin;
    internal_state.sds[free_index].sclk_gpio_pin = sd_cfg->sclk_gpio_pin;
    internal_state.sds[free_index].miso_gpio_pin = sd_cfg->miso_gpio_pin;
    internal_state.sds[free_index].mosi_gpio_pin = sd_cfg->mosi_gpio_pin;
    internal_state.sds[free_index].gpio_alternate_function = sd_cfg->gpio_alternate_function;
    internal_state.sds[free_index].in_use = true;
 
    *sd_handle_o = &internal_state.sds[free_index];
 
    internal_state.sd_num++;
 
    // Wait for >= 1 ms after supply reached at least 2.2V
    DELAY(CONFIG_SD_HW_INIT_WAIT_TIME);
 
    // Enable SPI communication
    spi_set_comm(sd_cfg->spi_instance, ENABLE);
 
    // 1. Start initialization — set CS high and send at least 74 dummy clocks
    gpio_write(sd_cfg->cs_gpio_port, sd_cfg->cs_gpio_pin, HIGH);
 
    uint8_t dummy_tx = 0xFF;
    for(uint8_t i = 0; i < 10; i++) {
        spi_send(sd_cfg->spi_instance, &dummy_tx, 1);
    }
 
    gpio_write(sd_cfg->cs_gpio_port, sd_cfg->cs_gpio_pin, LOW);
 
    // 2. Enter idle state
    err = sd_go_idle_state(&internal_state.sds[free_index]);
    if(err != ERR_OK) {
        LOG_CRITICAL(internal_state.subsys,
            internal_state.log_level,
            "sd_init_handle: failed to enter idle state, deinitializing handle"
        );
 
        sd_cease_comms(&internal_state.sds[free_index], true);
 
        return ERR_UNSUCCESFUL_ACTION;
    }
 
    // 3. Detect card type and version
    bool match = false;
    bool no_response = false;
 
    err = sd_send_if_cond(&internal_state.sds[free_index], &match, &no_response);
    if(err != ERR_OK) {
        LOG_CRITICAL(internal_state.subsys,
            internal_state.log_level,
            "sd_init_handle: failed to get SD card type, deinitializing handle"
        );
 
        sd_cease_comms(&internal_state.sds[free_index], true);
 
        return ERR_UNSUCCESFUL_ACTION;
    }
 
    // 3.1 SD Ver.2 — determine byte or block addressing from OCR
    if(match) {
        err = sd_app_send_op_cond(&internal_state.sds[free_index], 0x40000000);
        if(err != ERR_OK) {
            LOG_CRITICAL(internal_state.subsys,
                internal_state.log_level,
                "sd_init_handle: failed to initiate initialization of SD Ver.2, deinitializing handle"
            );
 
            sd_cease_comms(&internal_state.sds[free_index], true);
 
            return ERR_UNSUCCESFUL_ACTION;
        }
 
        err = sd_read_ocr(&internal_state.sds[free_index]);
        if(err != ERR_OK) {
            LOG_CRITICAL(internal_state.subsys,
                internal_state.log_level,
                "sd_init_handle: failed to obtain SD Ver 2. information, deinitializing handle"
            );
 
            return ERR_UNSUCCESFUL_ACTION;
        }
    }
    // 3.2 SD Ver.1 or MMC Ver.3
    else if(no_response) {
        err = sd_app_send_op_cond(&internal_state.sds[free_index], 0);
        // SD Ver.1
        if(err == ERR_OK) {
            internal_state.sds[free_index].addr_mode = SD_ADDR_MODE_BYTE;
        }
        // MMC Ver.3 or unknown
        else if(err == ERR_TIMEOUT) {
            err = sd_send_op_cond(&internal_state.sds[free_index]);
            // Unknown card
            if(err != ERR_OK) {
                LOG_CRITICAL(internal_state.subsys,
                    internal_state.log_level,
                    "sd_init_handle: unknown card, deinitializing handle"
                );
 
                sd_cease_comms(&internal_state.sds[free_index], true);
 
                return ERR_UNSUCCESFUL_ACTION;
            }
            // MMC Ver.3
            else {
                internal_state.sds[free_index].addr_mode = SD_ADDR_MODE_BYTE;
            }
        }
        // Unknown card
        else {
            LOG_CRITICAL(internal_state.subsys,
                internal_state.log_level,
                "sd_init_handle: unknown card, deinitializing handle"
            );
 
            sd_cease_comms(&internal_state.sds[free_index], true);
 
            return ERR_UNSUCCESFUL_ACTION;
        }
    }
 
    if(internal_state.sds[free_index].addr_mode == SD_ADDR_MODE_BYTE) {
        err = sd_set_blocklen(&internal_state.sds[free_index]);
        if(err != ERR_OK) {
            LOG_CRITICAL(internal_state.subsys,
                internal_state.log_level,
                "sd_init_handle: failed to initialize, deinitializing handle"
            );
 
            sd_cease_comms(&internal_state.sds[free_index], true);
 
            return ERR_UNSUCCESFUL_ACTION;
        }
    }
 
    internal_state.sds[free_index].initialized = true;
 
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "sd_init_handle: sd handle %s initialized",
        internal_state.sds[free_index].name
    );
 
    // Read CSD to populate capacity, block size, and block count
    sd_read_csd(&internal_state.sds[free_index]);
 
    sd_cease_comms(&internal_state.sds[free_index], false);
 
    // Ramp SPI to maximum speed after initialization
    spi_set_pclk_div(internal_state.sds[free_index].spi_instance, SPI_MASTER_SCLK_SPEED_PCLK_DIV_2);
 
    return ERR_OK;
}

Here is the call graph for this function:

sd_deinit_handle()

ERR_te sd_deinit_handle

(

SD_HANDLE_ts *

sd_handle

)

Deinitializes an SD card handle and resets the SPI peripheral.

Parameters

[in]

sd_handle

Pointer to the handle to deinitialize.

Returns

• ERR_OK on success
• ERR_ILLEGAL_ACTION if the handle is not initialized
• ERR_UNINITIALZIED_OBJECT if the handle is not found in the pool

See also

sd_deinit_handle

Definition at line 727 of file sd.c.

                                                 {
    if(!sd_handle->initialized) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_deinit_handle: handle not initialized"
        );
        return ERR_ILLEGAL_ACTION;
    }
 
    if(internal_state.sd_num == 0) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_deinit_handle: no such handle to deinitialize"
        );
 
        return ERR_UNINITIALZIED_OBJECT;
    }
 
    for(uint32_t i = 0; i < CONFIG_SD_MAX_OBJECTS; i++) {
        if(&internal_state.sds[i] == sd_handle) {
            uint8_t name_len = get_str_len(internal_state.sds[i].name) + 1;
            char name[name_len];
            str_cpy(name, internal_state.sds[i].name, name_len);
 
            spi_deinit(internal_state.sds[i].spi_instance);
 
            internal_state.sds[i] = (SD_HANDLE_ts){ 0 };
 
            internal_state.sd_num--;
 
            LOG_INFO(
                internal_state.subsys,
                internal_state.log_level,
                "sd_deinit_handle: sd handle %s deinitialized",
                name
            );
 
            break;
        }
 
        if(i == CONFIG_SD_MAX_OBJECTS - 1) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "sd_deinit_handle: no such handle to deinitialize"
            );
 
            return ERR_UNINITIALZIED_OBJECT;
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sd_get_handle_init()

ERR_te sd_get_handle_init	(	SD_HANDLE_ts *	sd_handle,
		bool *	handle_init_o )

Retrieves the initialization state of an SD card handle.

Parameters

[in]	sd_handle	Pointer to the SD card handle to query.
[out]	handle_init_o	Pointer to a boolean that will receive the initialization state.

Returns

• ERR_OK always

See also

sd_get_handle_init

Definition at line 784 of file sd.c.

                                                                        {
    *handle_init_o = sd_handle->initialized;
 
    return ERR_OK;
}

sd_get_sector_count()

ERR_te sd_get_sector_count	(	SD_HANDLE_ts *	sd_handle,
		uint32_t *	sector_count_o )

Retrieves the total sector (block) count of the SD card.

The value is determined from the CSD register during sd_init_handle and is used by the FatFs diskio layer.

Parameters

[in]	sd_handle	Pointer to the SD card handle.
[out]	sector_count_o	Pointer to a variable that will receive the sector count.

Returns

• ERR_OK always

See also

sd_get_sector_count

Definition at line 791 of file sd.c.

                                                                              {
    *sector_count_o = sd_handle->block_count;
 
    return ERR_OK;
}

sd_get_sector_size()

ERR_te sd_get_sector_size	(	SD_HANDLE_ts *	sd_handle,
		uint32_t *	sector_size_o )

Retrieves the sector (block) size of the SD card in bytes.

For SDHC cards this is always 512 bytes. For SDSC cards it is determined from the CSD register. Used by the FatFs diskio layer.

Parameters

[in]	sd_handle	Pointer to the SD card handle.
[out]	sector_size_o	Pointer to a variable that will receive the sector size in bytes.

Returns

• ERR_OK always

See also

sd_get_sector_size

Definition at line 798 of file sd.c.

                                                                            {
    *sector_size_o = sd_handle->block_len;
 
    return ERR_OK;
}

sd_read()

ERR_te sd_read	(	SD_HANDLE_ts *	sd_handle,
		uint8_t *	read_buf,
		uint32_t	start_sector,
		uint32_t	num_sectors )

Reads one or more sectors from the SD card.

Reads num_sectors consecutive sectors starting at start_sector into read_buf. Uses CMD17 for single-sector reads and CMD18 + CMD12 for multi-sector reads. Handles both byte-addressed (SDSC) and block-addressed (SDHC) cards transparently.

Parameters

[in]	sd_handle	Pointer to the SD card handle.
[out]	read_buf	Pointer to the destination buffer. Must be at least num_sectors × sector size bytes.
[in]	start_sector	Zero-based index of the first sector to read.
[in]	num_sectors	Number of consecutive sectors to read.

Returns

• ERR_OK on success
• ERR_INITIALIZATION_FAILURE if the subsystem or handle is not initialized or started
• ERR_INVALID_ARGUMENT if sd_handle is NULL or num_sectors is 0
• ERR_TIMEOUT if the data token is not received within the configured timeout
• ERR_UNKNOWN if the card returns an error token or an unexpected response

See also

sd_read

Definition at line 805 of file sd.c.

                                                                                                        {
    ERR_te err;
    uint32_t start_time = 0;
    uint32_t elapsed_time = 0;
    CMD_RESPONSE_ts cmd_response = { 0 };
 
    if(!internal_state.initialized || !internal_state.started || !sd_handle->initialized) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_read: subsys or handle not initialized or started"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    if(sd_handle == NULL || num_sectors == 0) {
        return ERR_INVALID_ARGUMENT;
    }
 
    spi_set_comm(sd_handle->spi_instance, ENABLE);
    gpio_write(sd_handle->cs_gpio_port, sd_handle->cs_gpio_pin, LOW);
 
    if(sd_handle->addr_mode == SD_ADDR_MODE_BYTE) {
        start_sector = start_sector * sd_handle->block_len;
    }
 
    if(num_sectors == 1) {
        err = sd_send_cmd(sd_handle->spi_instance, 17, start_sector, false, &cmd_response);
        if(err != ERR_OK) {
            sd_cease_comms(sd_handle, true);
 
            return err;
        }
 
        if(cmd_response.r1 != 0x0) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_UNKNOWN;
        }
 
        uint8_t token = 0xFF;
        start_time = systick_get_ms();
 
        do {
            elapsed_time = systick_get_ms() - start_time;
            spi_receive(sd_handle->spi_instance, &token, 1);
        } while(token == 0xFF && elapsed_time <= CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT);
 
        if(elapsed_time > CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_TIMEOUT;
        }
 
        if(token != 0xFE) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_UNKNOWN;
        }
 
        spi_receive(sd_handle->spi_instance, read_buf, sd_handle->block_len);
 
        uint8_t crc[2];
        spi_receive(sd_handle->spi_instance, crc, 2);
    }
    else {
        err = sd_send_cmd(sd_handle->spi_instance, 18, start_sector, false, &cmd_response);
        if(err != ERR_OK) {
            sd_cease_comms(sd_handle, true);
 
            return err;
        }
 
        if(cmd_response.r1 != 0x0) {
            sd_cease_comms(sd_handle, true);
            return ERR_UNKNOWN;
        }
 
        for(uint32_t i = 0; i < num_sectors; i++) {
            uint8_t token = 0xFF;
            start_time = systick_get_ms();
 
            do {
                elapsed_time = systick_get_ms() - start_time;
                spi_receive(sd_handle->spi_instance, &token, 1);
            } while(token == 0xFF && elapsed_time <= CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT);
 
            if(elapsed_time > CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT) {
                sd_cease_comms(sd_handle, true);
 
                return ERR_TIMEOUT;
            }
 
            if(token != 0xFE) {
                sd_cease_comms(sd_handle, true);
 
                return ERR_UNKNOWN;
            }
 
            spi_receive(sd_handle->spi_instance, read_buf + (i * sd_handle->block_len), sd_handle->block_len);
 
            uint8_t crc[2];
            spi_receive(sd_handle->spi_instance, crc, 2);
        }
        uint8_t retry = 0;
        do {
            err = sd_send_cmd(sd_handle->spi_instance, 12, 0, false, &cmd_response);
            if(err != ERR_OK) {
                sd_cease_comms(sd_handle, true);
 
                return err;
            }
        } while(cmd_response.r1 != 0x0 && retry++ < CONFIG_SD_INVALID_RESP_RETRY_NUM);
 
        if(cmd_response.r1 != 0x00) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_UNKNOWN;
        }
    }
 
    sd_cease_comms(sd_handle, false);
 
    return ERR_OK;
}

Here is the call graph for this function:

sd_write()

ERR_te sd_write	(	SD_HANDLE_ts *	sd_handle,
		uint8_t *	write_buf,
		uint32_t	start_sector,
		uint32_t	num_sectors )

Writes one or more sectors to the SD card.

Writes num_sectors consecutive sectors from write_buf starting at start_sector. Uses CMD24 for single-sector writes and CMD25 + CMD12 for multi-sector writes. Handles both byte-addressed (SDSC) and block-addressed (SDHC) cards transparently.

Parameters

[in]	sd_handle	Pointer to the SD card handle.
[in]	write_buf	Pointer to the source data buffer. Must contain at least num_sectors × sector size bytes.
[in]	start_sector	Zero-based index of the first sector to write.
[in]	num_sectors	Number of consecutive sectors to write.

Returns

• ERR_OK on success
• ERR_INITIALIZATION_FAILURE if the subsystem is not initialized or started
• ERR_INVALID_ARGUMENT if sd_handle is NULL or num_sectors is 0
• ERR_TIMEOUT if the card does not complete the write within the configured timeout
• ERR_UNKNOWN if the card returns an unexpected response

See also

sd_write

Definition at line 933 of file sd.c.

                                                                                                          {
    ERR_te err;
    uint32_t start_time = 0;
    uint32_t elapsed_time = 0;
 
    if(!internal_state.initialized || !internal_state.started) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "sd_write: subsys not initialized or started"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    if(sd_handle == NULL || num_sectors == 0) {
        return ERR_INVALID_ARGUMENT;
    }
 
    spi_set_comm(sd_handle->spi_instance, ENABLE);
    gpio_write(sd_handle->cs_gpio_port, sd_handle->cs_gpio_pin, LOW);
 
    if(sd_handle->addr_mode == SD_ADDR_MODE_BYTE) {
        start_sector = start_sector * sd_handle->block_len;
    }
 
    CMD_RESPONSE_ts cmd_response = { 0 };
 
    if(num_sectors == 1) {
        err = sd_send_cmd(sd_handle->spi_instance, 24, start_sector, false, &cmd_response);
        if(err != ERR_OK) {
            sd_cease_comms(sd_handle, true);
 
            return err;
        }
 
        if(cmd_response.r1 != 0x0) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_UNKNOWN;
        }
 
        uint8_t token = 0xFE;
        spi_send(sd_handle->spi_instance, &token, 1);
        spi_send(sd_handle->spi_instance, write_buf, sd_handle->block_len);
 
        uint8_t dummy_crc[2] = { 0xFF, 0xFF };
        spi_send(sd_handle->spi_instance, dummy_crc, 2);
 
        uint8_t data_resp = 0xFF;
        start_time = systick_get_ms();
 
        do {
            elapsed_time = systick_get_ms() - start_time;
            spi_receive(sd_handle->spi_instance, &data_resp, 1);
        } while(data_resp == 0xFF && elapsed_time <= CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT);
 
        if(elapsed_time > CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_TIMEOUT;
        }
 
        if((data_resp & 0b11111) != 0b00101) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_UNKNOWN;
        }
 
        // Wait until card releases MISO (busy signal)
        uint8_t busy = 0x00;
        start_time = systick_get_ms();
        do {
            spi_receive(sd_handle->spi_instance, &busy, 1);
            elapsed_time = systick_get_ms() - start_time;
        } while(busy == 0x00 && elapsed_time <= CONFIG_SD_BUSY_TIMOUT);
 
        if(elapsed_time > CONFIG_SD_BUSY_TIMOUT) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_TIMEOUT;
        }
    }
    else {
        err = sd_send_cmd(sd_handle->spi_instance, 25, start_sector, false, &cmd_response);
        if(err != ERR_OK) {
            sd_cease_comms(sd_handle, true);
 
            return err;
        }
 
        if(cmd_response.r1 != 0x0) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_UNKNOWN;
        }
 
        for(uint32_t i = 0; i < num_sectors; i++) {
            uint8_t token = 0xFC;
            spi_send(sd_handle->spi_instance, &token, 1);
            spi_send(sd_handle->spi_instance, write_buf + (i * sd_handle->block_len), sd_handle->block_len);
 
            uint8_t dummy_crc[2] = { 0xFF, 0xFF };
            spi_send(sd_handle->spi_instance, dummy_crc, 2);
 
            uint8_t data_resp = 0xFF;
            start_time = systick_get_ms();
 
            do {
                elapsed_time = systick_get_ms() - start_time;
                spi_receive(sd_handle->spi_instance, &data_resp, 1);
            } while(data_resp == 0xFF && elapsed_time <= CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT);
 
            if(elapsed_time > CONFIG_SD_DATA_TOKEN_RECV_TIMEOUT) {
                sd_cease_comms(sd_handle, true);
 
                return ERR_TIMEOUT;
            }
 
            if((data_resp & 0b11111) != 0b00101) {
                sd_cease_comms(sd_handle, true);
 
                return ERR_UNKNOWN;
            }
 
            uint8_t busy = 0x00;
            start_time = systick_get_ms();
            do {
                spi_receive(sd_handle->spi_instance, &busy, 1);
                elapsed_time = systick_get_ms() - start_time;
            } while(busy == 0x00 && elapsed_time <= CONFIG_SD_BUSY_TIMOUT);
 
            if(elapsed_time > CONFIG_SD_BUSY_TIMOUT) {
                sd_cease_comms(sd_handle, true);
 
                return ERR_TIMEOUT;
            }
        }
 
        // Send stop transmission token
        uint8_t stop_tran_token = 0xFD;
        spi_send(sd_handle->spi_instance, &stop_tran_token, 1);
 
        uint8_t busy = 0x00;
        start_time = systick_get_ms();
        do {
            spi_receive(sd_handle->spi_instance, &busy, 1);
            elapsed_time = systick_get_ms() - start_time;
        } while(busy == 0x00 && elapsed_time <= CONFIG_SD_BUSY_TIMOUT);
 
        if(elapsed_time > CONFIG_SD_BUSY_TIMOUT) {
            sd_cease_comms(sd_handle, true);
 
            return ERR_TIMEOUT;
        }
    }
 
    sd_cease_comms(sd_handle, false);
 
    return ERR_OK;
}

Here is the call graph for this function:

sd_ioctl()

ERR_te sd_ioctl

(

SD_HANDLE_ts *

sd_handle

)

Executes an IOCTL control command on the SD card handle.

Used by the FatFs diskio layer to perform control operations such as flushing write buffers or querying card parameters.

Parameters

[in]

sd_handle

Pointer to the SD card handle.

Returns

• ERR_OK on success