sdcard.c

#include "types.h"
#include "riscv.h"
#include "defs.h"
#include "pinmux.h"
#include "spi.h"
#include "sdcard.h"
#include "fs.h"

struct spi_config spi = {
    .port = 1,
    .baud_rate = 400000,
    .polarity = 0,
    .phase = 0,
};

static uint8 spi_transfer(uint8 data) {
    uint8 rx_data;

    int ret = pl022_spi_xfer(8, &data, &rx_data, SPI_XFER_BEGIN);
    if(ret < 0){
        return -1;
    }

    return rx_data;
}

// Helper function to send a command to the SD card over SPI
static uint8 sd_send_command(uint8 cmd, uint32 arg, uint8 crc) {
    spi_transfer(0x40 | cmd);  // Command token
    spi_transfer((arg >> 24) & 0xFF);  // Argument: 4 bytes
    spi_transfer((arg >> 16) & 0xFF);
    spi_transfer((arg >> 8) & 0xFF);
    spi_transfer(arg & 0xFF);
    spi_transfer(crc);  // CRC for CMD0 and CMD8; for others, any value is fine.

    // Wait for a response (timeout after a certain number of tries)
    for (int i = 0; i < 8; i++) {
        uint8 response = spi_transfer(0xFF);
        if (response != 0xFF) {
            return response;
        }
    }

    return 0xFF;  // Timeout
}

// Initialize the SD card
int sd_init(uint8 iface, uint8 cs, uint8 miso, uint8 clk, uint8 mosi) {

    if (init_spi_bus(&spi, cs, miso, clk, mosi) < 0) {
        return -1;
    }
    if (pl022_spi_probe() < 0) {
        return -1;
    }
    if (pl022_spi_claim_bus() < 0) {
        return -1;
    }
    if (pl022_spi_set_speed(&spi) < 0) {
        return -1;
    }
    if (pl022_spi_set_mode(&spi) < 0) {
        return -1;
    }
    
    // Send at least 74 clock cycles with CS high to initialize card
    pl022_spi_cs_hold(1);
    for (int i = 0; i < 10; i++) {
        spi_transfer(0xFF);
    }
    pl022_spi_cs_auto();

    // Dummy command
    sd_send_command(CMD0, 0, 0x95);

    // CMD0: reset the card
    if (sd_send_command(CMD0, 0, 0x95) != 0x01) {
        return -1;  // Card should respond with "in idle" (0x01)
    }

    // CMD8: check voltage range
    if (sd_send_command(CMD8, 0x1AA, 0x87) != 0x01) {
        return -1;  // Card should respond with 0x01 if compatible
    } else {
        // Read remaining R7 response bytes
        uint8 r7[4];
        for(int i = 0; i < 4; i++) {
            r7[i] = spi_transfer(0xFF);
        }
        // Check voltage acceptance pattern
        if (!((r7[2] == 0x01) && (r7[3] == 0xAA))){
           return -1;  // Card is not SD v2.0+
        }
    }

    // ACMD41: initialize card
    while (sd_send_command(CMD55, 0, 0xFF), sd_send_command(ACMD41, 0x40000000, 0xFF) != 0x00) {}
    
    return 0;
}

int sd_deinit(){
    while(spi_transfer(0xFF) != 0xFF){};

    if (pl022_spi_release_bus() < 0) {
        return -1;
    }
    return 0;
}

// Read a 512-bytes block from the SD Card
int sd_read_block(uint32 blockno, uint8 *buffer) {
    // Send read command
    if (sd_send_command(CMD17, blockno, 0xFF) != 0x00) {
        return -1;
    }

    // Wait for data token (0xFE)
    while (spi_transfer(0xFF) != 0xFE){}
    // Read data block
    for(int i = 0; i < SD_BSIZE; i++){
        buffer[i] = spi_transfer(0xFF);
    }

    // Read CRC (2 bytes, discard)
    spi_transfer(0xFF);
    spi_transfer(0xFF);
    return 0;
}

// Write a 512-bytes block from the SD Card
int sd_write_block(uint32 blockno, const uint8 *buffer) {
    // Send write command
    if (sd_send_command(CMD24, blockno, 0xFF) != 0x00) {
        return -1;
    }

    // Send data token (0xFE)
    spi_transfer(0xFE);
    // Write data block
    for(int i = 0; i < SD_BSIZE; i++){
        spi_transfer(buffer[i]);
    }

    // Write CRC (2 bytes, dummy)
    spi_transfer(0xFF);
    spi_transfer(0xFF);

    // Check data response token
    if ((spi_transfer(0xFF) & 0x1F) != 0x05) {
        return -1;
    }

    // Wait for the card to finish writing
    while (spi_transfer(0xFF) == 0x00) {}
    return 0;
}