SD Card Public APIs

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.

Detailed Description

Function Documentation

sd_init_subsys()

ERR_te sd_init_subsys

(

void

)

Initializes the SD card subsystem.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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: