[Raspberry Pi Pico (c-sdk)] Storage: Ep 6. SD Memory Card 4-bit wide bus and 1-bit data bus

 本文章介紹使用Raspberry Pi Pico PIO程式製作SD memory Card 4-bit wide bus and 1-bit data bus驅動程式。並與FatFs檔案系統結合，測試在SD card上進行檔案讀寫。

SD memory card主要分為Command, data read and data write三個部份。每個部份我們製作一個相對應的State machine：CMD, READ and WRITE。

一、CMD PIO state machine:

command為48bits:第一個byte:01開頭為HOST to Card, 00開頭為Card to Host, 其餘6bits為Command ID。接下來4 bytes為parameters。最後一個byte為CRC7and 1 bit(stop bit)。response分成0,48 and 136 bits三種。

CMD state machine使用1 CMD line and 1 CLK line:

CMD pin:IN/OUT/SET/JMP。 CLK pin:side-set

詳細程式碼附於文章末尾。

二、READ State machine:

Card output(HOST read): 每個data block為512 bytes後面跟著CRC16。4-bit wide bus DAT line分別需要個別的CRC16 data。 

READ state machine: 1 or 4 DAT line, 1 CLK line。

DAT pin(s): IN/SET/JMP, CLK pin:side-set

三、WRITE state machine:

Card input(HOST output):host寫入一個data block後面跟CRC16。Card於3 clocks後在DAT0 (DAT1~3 don't care) 送出CRC status(010為positive, 101為negative)。

WRITE state machine: 1~4 DAT line, 1 CLK line。

DAT pin(s): IN/OUT/SET/JMP, CLK pin:side-set

四、HOST read data:

1. 啟動CMD state machine, host向card 送出data read command(CMD17 or CMD18)，收到rsponse後，停止state machine(disable)。
2. 啟動READ state machine讀取資料。
3. CMD與READ state machine使用自己的CLK pin。因此在CMD state machine換成READ state machine時，clock會先暫停。根據SD specification "clock control"章節說明是允許的。

五、HOST DATA write:

1. 啟動CMD state machine, host向card 送出data write command(CMD24 or CMD25)，收到rsponse後，停止state machine(disable)。
2. 啟動WRITE state machine write data block and crc。接著讀取crc status。

參考資料為：
SD Specifications Part 1 Physical Layer Specification(https://www.sdcard.org/)

成果展示：

程式碼：

• sdio_mem_card.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/dma.h"
#include "hardware/pio.h"
#include "sdio_mem_card.h"
#include "sdio_mem_card.pio.h"
#include "hardware/clocks.h"
#include "crc7.h"
#include "crc-itu-t.h"
#include "string.h"
#include "inttypes.h"
 
/*
void pio_irq_read_data() {
     if (pio_interrupt_get(SDIO_MEM_PIO, 0)) {
        pio_interrupt_clear(SDIO_MEM_PIO, 0);
        printf("irq 0:\n");
     }
     if (pio_interrupt_get(SDIO_MEM_PIO, 1)) {
        pio_interrupt_clear(SDIO_MEM_PIO, 1);
        printf("irq:1\n");
     }
}
*/
 
/*!
* \brief sdio memory card pio initialize
* \param pio: pio number
* \param sm state machine
* \param cmd_pin command pin
* \param clk_pin CLK pin
* \param data_pin_base data 0~4 pins(D0~D3)
* \param clk_int Integer part of the divisor
* \param clk_frac – Fractional part in 1/256ths
*/
void sdio_pio_init(sd_memory_card_t* pSD, PIO pio,  uint cmd_pin, uint clk_pin, uint data_pin_base,  uint16_t clk_int, uint8_t clk_frac) {
    uint offset=0;
    pio_sm_config c;
    static uint8_t data_width;
 
    data_width = (pSD->is_wide_bus ? 4:1);
  
    pio_gpio_init(pio, cmd_pin);
    pio_gpio_init(pio, clk_pin);
    gpio_pull_up(cmd_pin);
    
    for (int i=0; i < 4; i++) {
        pio_gpio_init(pio, data_pin_base+i);
        gpio_pull_up(data_pin_base+i);
    }
    pio_enable_sm_mask_in_sync(pio, (1<<SDIO_CMD_SM)|(1<<SDIO_DATA_READ_SM)|(1<<SDIO_DATA_WRITE_SM));
        
    //== SDIO READ SM ==
    pio_sm_config cr;
    if (data_width == 1) {
        pSD->sd_data_rx_offset = pio_add_program(pio, &sdio_1_bit_rx_program);
        cr = sdio_1_bit_rx_program_get_default_config(pSD->sd_data_rx_offset);
    }
    else {
        pSD->sd_data_rx_offset = pio_add_program(pio, &sdio_4_bit_rx_program);
        cr = sdio_4_bit_rx_program_get_default_config(pSD->sd_data_rx_offset);
    }
    pio_sm_set_consecutive_pindirs(pio, SDIO_DATA_READ_SM, data_pin_base, 4, false);
    pio_sm_set_consecutive_pindirs(pio, SDIO_DATA_READ_SM, clk_pin, 1, true);
    //pio_sm_set_consecutive_pindirs(pio, SDIO_DATA_READ_SM, cmd_pin, 1, false);
    sm_config_set_in_pins(&cr, data_pin_base);
    sm_config_set_sideset_pins(&cr, clk_pin);
    sm_config_set_set_pins(&cr, data_pin_base,data_width);
    sm_config_set_jmp_pin(&cr, data_pin_base);
    sm_config_set_out_shift(&cr, false, true, 32);
    sm_config_set_in_shift(&cr, false, true, 32);
    sm_config_set_clkdiv_int_frac(&cr, clk_int,clk_frac);
    pio_sm_init(pio, SDIO_DATA_READ_SM, pSD->sd_data_rx_offset, &cr);
    
    //== SDIO WRITE SM ==
    pio_sm_config cw;
    if (data_width == 1) {
        pSD->sd_data_tx_offset = pio_add_program(pio, &sdio_1_bit_tx_program);
        cw = sdio_1_bit_rx_program_get_default_config(pSD->sd_data_tx_offset);
    }
    else {
        pSD->sd_data_tx_offset = pio_add_program(pio, &sdio_4_bit_tx_program);
        cw = sdio_4_bit_rx_program_get_default_config(pSD->sd_data_tx_offset);
    }
    pio_sm_set_consecutive_pindirs(pio, SDIO_DATA_WRITE_SM, data_pin_base, 4, true);
    pio_sm_set_consecutive_pindirs(pio, SDIO_DATA_WRITE_SM, clk_pin, 1, true);
    //pio_sm_set_consecutive_pindirs(pio, SDIO_DATA_WRITE_SM, cmd_pin, 1, false);
    sm_config_set_in_pins(&cw, data_pin_base);
    sm_config_set_out_pins(&cw, data_pin_base, data_width);
    sm_config_set_sideset_pins(&cw, clk_pin);
    sm_config_set_set_pins(&cw, data_pin_base,data_width);
    sm_config_set_jmp_pin(&cw, data_pin_base);
    sm_config_set_out_shift(&cw, false, true, 32);
    sm_config_set_in_shift(&cw, false, true, 32);
    sm_config_set_clkdiv_int_frac(&cw, clk_int,clk_frac);
    pio_sm_init(pio, SDIO_DATA_WRITE_SM, pSD->sd_data_tx_offset, &cw);
 
    //== SDIO command SM ==
    offset = pio_add_program(pio, &sdio_mem_cmd_program);
    c = sdio_mem_cmd_program_get_default_config(offset);
    pio_sm_set_consecutive_pindirs(pio, SDIO_CMD_SM, cmd_pin, 1, false);
    pio_sm_set_consecutive_pindirs(pio, SDIO_CMD_SM, clk_pin, 1, true);
    pio_sm_set_consecutive_pindirs(pio, SDIO_CMD_SM, data_pin_base, 4, false);
    sm_config_set_in_pins(&c, cmd_pin);
    sm_config_set_out_pins(&c, cmd_pin, 1);
    sm_config_set_set_pins(&c, cmd_pin,1);
    sm_config_set_sideset_pins(&c, clk_pin);
    sm_config_set_jmp_pin(&c, cmd_pin);
    sm_config_set_out_shift(&c, false, true, 32);
    sm_config_set_in_shift(&c, false, true, 32);
    sm_config_set_clkdiv_int_frac(&c, clk_int,clk_frac);
    pio_sm_init(pio, SDIO_CMD_SM, offset, &c);
 
      // initial state machine but not run
    pio_sm_set_enabled(pio, SDIO_CMD_SM, false);
    pio_sm_set_enabled(pio, SDIO_DATA_READ_SM, false);
    pio_sm_set_enabled(pio, SDIO_DATA_WRITE_SM, false);
 
    //** for test only
    //uint pio_irq = pio_get_index(pio)? PIO1_IRQ_0:PIO0_IRQ_0;
    //pio_set_irq0_source_enabled(pio, pis_interrupt0, true);
    //pio_set_irq0_source_enabled(pio, pis_interrupt1, true);
    //irq_add_shared_handler(pio_irq, pio_irq_read_data, PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);
    //irq_set_enabled(pio_irq, true);
   
    #if _DMA_TRANS_
    /*   DMA  */
    uint pio_base = (pio==pio0)?PIO0_BASE:PIO1_BASE;
    // ==== Write DMA ===
    pSD->dma_write_channel = dma_claim_unused_channel(true);
    dma_channel_config dcw = dma_channel_get_default_config(pSD->dma_write_channel);
    channel_config_set_write_increment(&dcw, false);
    channel_config_set_read_increment(&dcw, true);
    channel_config_set_bswap(&dcw, true);
    channel_config_set_dreq(&dcw, pio_get_dreq(pio, SDIO_DATA_WRITE_SM, true));
    channel_config_set_transfer_data_size(&dcw, DMA_SIZE_32); //DMA_SIZE_8,16,32
    dma_channel_configure(pSD->dma_write_channel,
             &dcw, (void*) (pio_base+PIO_TXF2_OFFSET),  // SDIO_DATA_WRITE_SM = 2
             NULL, MAX_RW_BLOCKS_TRANS>> DMA_SIZE_32, false); //DMA_SIZE_8 or 16 or 32
    
    //==== READ DMA ===
    pSD->dma_read_channel = dma_claim_unused_channel(true);
    dma_channel_config dcr = dma_channel_get_default_config(pSD->dma_read_channel);
    channel_config_set_write_increment(&dcr, true);
    channel_config_set_read_increment(&dcr, false);
    channel_config_set_bswap(&dcr, true);
    channel_config_set_dreq(&dcr, pio_get_dreq(pio, SDIO_DATA_READ_SM, false));
    channel_config_set_transfer_data_size(&dcr, DMA_SIZE_32); //DMA_SIZE_8,16,32
    dma_channel_configure(pSD->dma_read_channel,
             &dcr, NULL, (void*) (pio_base+PIO_RXF1_OFFSET),  // SDIO_DATA_READ_SM = 1
              MAX_RW_BLOCKS_TRANS>> DMA_SIZE_32, false); //DMA_SIZE_8 or 16 or 32
    /*  DMA */
    #endif
}
/*!
* \brief send SDIO CMD and recv RESPONSE
* \param cmd_id command ID
* \param arg args size 4 bytes(32bits)
* \param resp RESPONSE Register (48 bits / 136 bites)
* \param resp_bits response register length
*/
uint8_t sdio_send_recv_cmd(uint8_t cmd_id, uint8_t *arg, uint32_t *resp, uint8_t resp_bits) {
    uint8_t cmd;
    uint32_t cmd_buf[2];
    uint8_t crc = 0;
    cmd = cmd_id | 0x40; // start 0b01 send from host to card
 
    // crc7 
    crc = crc7_table[crc ^ cmd];
    for (int i=0; i < count_of(arg); i++)
        crc = crc7_table[crc ^ arg[i]];
    // crc7
    if (resp_bits > 0) resp_bits--;
    // put to fifo: 1byte command len,1byte command ID, 4bytes arg ,1byte crc ,1bytes RESP
    cmd_buf[0] = 47 << 24 | cmd << 16 | arg[0] << 8 | arg[1];
    cmd_buf[1] = arg[2] << 24 | arg[3] << 16 | (crc | 0x01) << 8 | (resp_bits);
 
    memset(resp, 0, sizeof(resp));
 
    pio_sm_clear_fifos(SDIO_MEM_PIO, SDIO_CMD_SM);
    pio_sm_exec(SDIO_MEM_PIO, SDIO_CMD_SM,pio_encode_set(pio_pins,1));
    pio_sm_exec(SDIO_MEM_PIO, SDIO_CMD_SM,pio_encode_set(pio_pindirs,1));
    //Output shift counter is reset to 0 by this operation, i.e. full)
    pio_sm_exec(SDIO_MEM_PIO, SDIO_CMD_SM, pio_encode_mov(pio_osr, pio_null));
    for (int i = 0; i < count_of(cmd_buf); i++) {
        pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_CMD_SM, cmd_buf[i]);
    }
    pio_sm_exec(SDIO_MEM_PIO, SDIO_CMD_SM, pio_encode_jmp(sdio_mem_cmd_offset_sdio_cmd_start));
    pio_sm_set_enabled(SDIO_MEM_PIO, SDIO_CMD_SM, true);     
  
    switch (resp_bits) {
        case 47:
            resp[0] = pio_sm_get_blocking(SDIO_MEM_PIO, SDIO_CMD_SM);
            resp[1] = pio_sm_get_blocking(SDIO_MEM_PIO, SDIO_CMD_SM);
            
        break;
        case 135:
            for (int i=0; i < 5; i++) {
                resp[i] = pio_sm_get_blocking(SDIO_MEM_PIO, SDIO_CMD_SM);
            }
        break;
        case 0:
            resp[0] = pio_sm_get_blocking(SDIO_MEM_PIO, SDIO_CMD_SM); //dummy
        break;
    }
    pio_sm_set_enabled(SDIO_MEM_PIO, SDIO_CMD_SM, false);
    
    return SD_OK;
}
 
bool format_sdio_response_136(uint32_t *resp_32, uint32_t *content) {
    if ((resp_32[0]>>24) != 0x3f){ printf("get CID/CSD error\n"); return false;}
    for (int i=0; i < 3;i++) {
        content[i] = resp_32[i] << 8 | resp_32[i+1] >> 24;
    }
    content[3] = (resp_32[3] >> 24) << 8 | resp_32[4]&0xff;
}
 
bool format_sdio_response_48(uint32_t *resp_32, uint8_t *resp_8) {
    resp_8[0] = resp_32[0] >> 24;
    resp_8[1] = (resp_32[0]&0x00ff0000) >> 16;
    resp_8[2] = (resp_32[0]&0x0000ff00) >> 8;
    resp_8[3] = resp_32[0] &0x000000ff;
    resp_8[4] = (resp_32[1]&0x0000ff00) >> 8;
    resp_8[5] = (resp_32[1] &0x000000ff) ;
    uint8_t crc = 0;
    for (int i=0; i < 5; i++)
        crc = crc7_table[crc ^ resp_8[i]];
    if (crc != (resp_8[5]&0xfe)) return false;
    return true;
}
 
uint32_t get_sd_card_status(sd_memory_card_t* pSD) {
    uint8_t arg[4];
    uint32_t resp[2];
    arg[0] = pSD->rca[0];
    arg[1] = pSD->rca[1];
    arg[2] = 0;
    arg[3] = 0;
 
    sdio_send_recv_cmd(CMD13, arg, resp, 48); 
    return (resp[0])<<8 | (resp[1]>>8);  
  
} 
 
uint32_t format_R1_response(uint32_t *resp) {
   
    return (resp[0]&0x00ffffff)<<8 | (resp[1]>>8); 
}
 
/*!
* \brief initialize sd card
* \param wide_bus true:4bit, false 1bit
*/
uint8_t sd_memory_card_init(sd_memory_card_t* pSD,  uint8_t wide_bus) {
    uint8_t arg[4];
    uint32_t resp[5];
    uint8_t resp_bytes[17];
    uint8_t ret_val;
    uint32_t CSID[5];
    uint8_t ret = SD_OK;
    
    pSD->SD_initialized=false;
 
    pio_clear_instruction_memory(SDIO_MEM_PIO);
 
    pSD->is_wide_bus = (wide_bus)? true:false;
    sdio_pio_init(pSD, SDIO_MEM_PIO,  SDIO_CMD_PIN,  SDIO_CLK_PIN, SDIO_D0_PIN, 1, 0);
 
    sleep_ms(2);
    memset(arg, 0, sizeof(arg));
    sdio_send_recv_cmd(CMD0, arg, resp, 0);  // CMD0: REEST
 
    for (int i=0; i < 10; i++) {
       
        memset(arg, 0, sizeof(arg));
        arg[2]=1;
        arg[3]=0xaa;
        sdio_send_recv_cmd(CMD8, arg, resp, 48);  //CMD8: SEND_IF_CONF
        
        if(format_sdio_response_48(resp, resp_bytes)) {
            if (resp_bytes[4]== arg[3])
                printf("cmd8 ok:%d\n",i);
                ret = SD_OK;
                break;
        } else {
            ret = SD_INIT_FAILURE;
        }
   }
    absolute_time_t timeout = make_timeout_time_ms(1000);
    do {
        memset(arg, 0, sizeof(arg));
        sdio_send_recv_cmd(CMD55, arg, resp, 48);   // next is APP_CMD
 
        arg[0] = 0x40; // HCS, XPC, S18R 
        arg[1] = 0x10;
        sdio_send_recv_cmd(ACMD41, arg, resp, 48); // R3
        format_sdio_response_48(resp, resp_bytes); // crc is always 1111111 
        //for (int i=0; i < 6; i++) { printf("%02x ",resp_bytes[i]);}  printf("\n");
        if (resp_bytes[0]==0x3f && (resp_bytes[1] & 0x80)) {
            ret = SD_OK;
            break;
        } 
        else {
            ret = SD_TIME_OUT;
        }
 
    } while (absolute_time_diff_us(get_absolute_time(), timeout) > 0);  
    // 0x80 initialize completely. R3[1]: Busy CCS UHS-II Reserved(0000) S18A
    if(ret != SD_OK) return ret;
 
    memset(arg, 0, sizeof(arg));
    if (resp_bytes[1] & 0x01) {
        sdio_send_recv_cmd(CMD11, arg, resp, 0); // voltage switch
    }
  
    sdio_send_recv_cmd(CMD2, arg, resp, 136);  // CID(R2) 
 
    sdio_send_recv_cmd(CMD3, arg, resp, 48);
    if (format_sdio_response_48(resp, resp_bytes)) {
        pSD->rca[0] = resp_bytes[1];
        pSD->rca[1] = resp_bytes[2];
        printf("rca received:%02x, %02x\n", pSD->rca[0], pSD->rca[1]);
    } else {
        printf("CMD3 response crc error\n");
        for (int i=0; i < 6; i++) {
            printf("%02x ",resp_bytes[i]);
        }
        printf("\n");
        return SD_CRC_ERROR;
    }
 
 
     //get CID regisger ===
    memset(arg,0,sizeof(arg));
    arg[0] = pSD->rca[0];
    arg[1] = pSD->rca[1];
    for (int i=0; i<10; i++) {
        if (sdio_send_recv_cmd(CMD10, arg, resp, 136)== SD_OK) {
            ret = SD_OK;
            break;  // CID (R2)
        }
        else {
            ret = SD_INIT_FAILURE;
        }
    }
    format_sdio_response_136(resp, CSID);
  
    pSD->pnm[0]= (uint8_t)(CSID[0]);
    pSD->pnm[1]= (uint8_t)((CSID[1]>>24));
    pSD->pnm[2]= (uint8_t)((CSID[1]>>16));
    pSD->pnm[3]= (uint8_t)((CSID[1])>>8);
    pSD->pnm[4]= (uint8_t)(CSID[1]);
    pSD->pnm[5]= '\0';
    pSD->prv = (uint8_t)(CSID[2]>>24);
    pSD->psn = (CSID[2]) << 8 | CSID[3]>>24;
    // === get CID end
    
    //===get CSD register ===
    memset(arg,0,sizeof(arg));
    arg[0] = pSD->rca[0];
    arg[1] = pSD->rca[1];
    for (int i=0; i<10; i++) {
        if (sdio_send_recv_cmd(CMD9, arg, resp, 136)== SD_OK) { 
            ret = SD_OK;
            break;  // CSD (R2) 
        }else {
            ret = SD_INIT_FAILURE;
        }
        sleep_ms(2);
    }
    format_sdio_response_136(resp, CSID);
    printf("CSD:%08x,%08x,%08x,%08x\n", CSID[0],CSID[1],CSID[2],CSID[3]);
    
    pSD->block_size = 1<<((CSID[1]>>16) & 0xf) ;
    pSD->total_blocks = (CSID[1]&0x1f) << 16 |CSID[2] >> 16;
 
    printf("block_size:%d, total_blocks:%u, capacity:%d KB\n", 
                    pSD->block_size,
                    pSD->total_blocks,
                    (pSD->total_blocks/(1024/pSD->block_size))
                    );
    // ==get CSD end===
 
    memset(arg,0,sizeof(arg));
    arg[0] = pSD->rca[0];
    arg[1] = pSD->rca[1];
    sdio_send_recv_cmd(CMD7, arg, resp, 48);  // R1b, SELECT_CARD
    //sdio_send_recv_cmd(CMD42, arg, resp, 48); //R1
    //format_sdio_response_48(resp, resp_bytes);
    
    arg[0] = pSD->rca[0];
    arg[1] = pSD->rca[1];
    sdio_send_recv_cmd(CMD55, arg, resp, 48);   // next is APP_CMD
    if (wide_bus) arg[3]=0x02;   // 4-bit
    sdio_send_recv_cmd(ACMD6, arg, resp, 48);  //R1, set bus width
    //format_sdio_response_48(resp, resp_bytes);
    //printf("status:%0x\n", resp_bytes[4]);
    sdio_send_recv_cmd(CMD13, arg, resp, 48);   
    format_sdio_response_48(resp, resp_bytes);
    if (resp_bytes[3] == 0x09 && resp_bytes[4]==0x00)
    {   
        uint8_t test[512];
        sd_read_single_block(pSD, (uint32_t*)test, pSD->total_blocks);
        if (get_sd_card_status(pSD)==0x0900) {
            pSD->SD_initialized=true;
            printf("SD card initialize successfully\n");
        }
    }
 
    return ret;
}
 
uint8_t sd_stop_trans() {
    uint8_t arg[4];
    uint32_t resp[2];
    uint8_t resp_bytes[5];
    memset(arg, 0, sizeof(arg));
    sdio_send_recv_cmd(CMD12, arg, resp, 48);  //R1b, 
     return SD_OK;
 
}
uint16_t calc_1bit_crc16(uint32_t *buff, uint16_t words_per_block){
    uint16_t crc =0;
    uint32_t temp;
    for (int i= 0; i< words_per_block; i++) {
        temp = __builtin_bswap32(buff[i]);
        crc = crc_itu_t_table[(crc >> 8) ^ (uint8_t)(temp>>24)] ^ (crc << 8);
        crc = crc_itu_t_table[(crc >> 8) ^ (uint8_t)(temp>>16)] ^ (crc << 8);
        crc = crc_itu_t_table[(crc >> 8) ^ (uint8_t)(temp>>8)] ^ (crc << 8);
        crc = crc_itu_t_table[(crc >> 8) ^ (uint8_t)(temp)] ^ (crc << 8);
    }
    return crc;
}
 
uint64_t calc_4bit_crc16(uint32_t *data, uint32_t num_words)
{
    uint64_t crc = 0;
    uint32_t *end = data + num_words;
    while (data < end)
    {
        for (int unroll = 0; unroll < 4; unroll++)
        {
            // Each 32-bit word contains 8 bits per line.
            // Reverse the bytes because SDIO protocol is big-endian.
            uint32_t data_in = __builtin_bswap32(*data++);    
 
            // Shift out 8 bits for each line
            uint32_t data_out = crc >> 32;
            crc <<= 32;
 
            // XOR outgoing data to itself with 4 bit delay
            data_out ^= (data_out >> 16);
 
            // XOR incoming data to outgoing data with 4 bit delay
            data_out ^= (data_in >> 16);
 
            // XOR outgoing and incoming data to accumulator at each tap
            uint64_t xorred = data_out ^ data_in;
            crc ^= xorred;
            crc ^= xorred << (5 * 4);
            crc ^= xorred << (12 * 4);
        }
    }
 
    return crc;
}
 
uint8_t pio_sd_read_blocks(sd_memory_card_t* pSD, uint32_t *buff, uint32_t count, uint32_t* crc) {
    uint32_t read_cycles;
    uint read_start_addr;
    uint8_t ret=SD_OK;
    uint16_t block_data_bytes;
    uint8_t crc_len;
    
 
    if (pSD->is_wide_bus) {
        block_data_bytes=(512+2*4);
        read_cycles=block_data_bytes*2-1;
        read_start_addr = pSD->sd_data_rx_offset+sdio_4_bit_rx_offset_rx_start;
        crc_len=2;
    }
    else
    {
        block_data_bytes = (512+2);
        read_cycles = block_data_bytes*8-1;
        read_start_addr = pSD->sd_data_rx_offset+sdio_1_bit_rx_offset_rx_start;
        crc_len=1;
    }
 
    pio_sm_clear_fifos(SDIO_MEM_PIO, SDIO_DATA_READ_SM);
    pio_sm_restart(SDIO_MEM_PIO, SDIO_DATA_READ_SM);
    pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_READ_SM,pio_encode_set(pio_pindirs, 0));
    //pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_READ_SM, pio_encode_mov(pio_isr, pio_null));
    pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_READ_SM, read_cycles);
    pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_READ_SM, pio_encode_out(pio_x, 32));
    pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_READ_SM, pio_encode_jmp(read_start_addr));
   
    pio_sm_set_enabled(SDIO_MEM_PIO, SDIO_DATA_READ_SM, true);
    for (int block_idx=0; block_idx < count; block_idx++) {
#if _DMA_TRANS_
        dma_channel_set_trans_count(pSD->dma_read_channel, SDIO_WORDS_PER_BLOCK, false);
        dma_channel_set_write_addr(pSD->dma_read_channel, buff+block_idx*SDIO_WORDS_PER_BLOCK, false);
        dma_channel_start(pSD->dma_read_channel);
        dma_channel_wait_for_finish_blocking(pSD->dma_read_channel);
        
        dma_channel_set_trans_count(pSD->dma_read_channel, crc_len, false);
        dma_channel_set_write_addr(pSD->dma_read_channel, crc+crc_len*block_idx, false);
        dma_channel_start(pSD->dma_read_channel);
        dma_channel_wait_for_finish_blocking(pSD->dma_read_channel);
#else
    for (int i=0; i < SDIO_WORDS_PER_BLOCK; i++) { 
 
        buff[i+SDIO_WORDS_PER_BLOCK*block_idx] = __builtin_bswap32(pio_sm_get_blocking(SDIO_MEM_PIO, SDIO_DATA_READ_SM));
 
    }
    for (int c=0; c < crc_len; c++) {
        crc[c+crc_len*block_idx] = __builtin_bswap32(pio_sm_get_blocking(SDIO_MEM_PIO, SDIO_DATA_READ_SM));
    }
#endif
    }
    pio_sm_set_enabled(SDIO_MEM_PIO, SDIO_DATA_READ_SM, false);
  
        
    return SD_OK;
}
 
uint8_t pio_sd_write_blocks(sd_memory_card_t* pSD, uint32_t *buff, uint32_t count) {
    uint32_t write_cycles;
    uint write_start_addr;
    uint8_t ret=SD_OK;
    uint16_t block_data_bytes;
    uint16_t crc;
    uint32_t start, end;
    uint32_t lines=1;
    if (pSD->is_wide_bus) {
        block_data_bytes=(4+512+2*4); // start 0xfffffff0, end 0xffffffff
        write_cycles=block_data_bytes*2;
        write_start_addr = pSD->sd_data_tx_offset+sdio_4_bit_tx_offset_tx_start;
        start=0xfffffff0;
        end = 0xffffffff;
        lines=4;
    }
    else
    {
        block_data_bytes = (4+512+2); // start 0xfffffffe,  
        write_cycles = block_data_bytes*8;
        write_start_addr = pSD->sd_data_tx_offset+sdio_1_bit_tx_offset_tx_start;
        start = 0xfffffffe;
        end =0xffffffff;
        lines=1;
    }
   
    pio_sm_clear_fifos(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM);
    pio_sm_restart(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM);
    // set pins output
    uint pindirs;
    if (pSD->is_wide_bus){
        pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, pio_encode_set(pio_pins, 15));
        pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, pio_encode_set(pio_pindirs, 15));
    } else {
        pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, pio_encode_set(pio_pins, 1));
        pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, pio_encode_set(pio_pindirs, 1));
    }   
    
    pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, write_cycles);
    pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, pio_encode_out(pio_x, 32));
    
    pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, 31);//
    pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, pio_encode_out(pio_y, 32));
 
    pio_sm_exec(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, pio_encode_jmp(write_start_addr));
 
    uint32_t crc_and_stop_bit;
    uint32_t crc32_h, crc32_l;
 
    if (pSD->is_wide_bus) {
        
        uint64_t crc64 = calc_4bit_crc16(buff, SDIO_WORDS_PER_BLOCK);
        crc32_h = (uint32_t)(crc64>>32);
        crc32_l = (uint32_t)crc64;
    } else {
        crc = calc_1bit_crc16(buff, SDIO_WORDS_PER_BLOCK);
        crc_and_stop_bit = crc <<16 | 0xffff;
    } 
    
    pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, start); //start bit
    pio_sm_set_enabled(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, true);
     
#if _DMA_TRANS_      
        dma_channel_set_trans_count(pSD->dma_write_channel, SDIO_WORDS_PER_BLOCK, false);
        dma_channel_set_read_addr(pSD->dma_write_channel, buff, false);
        dma_channel_start(pSD->dma_write_channel);
        dma_channel_wait_for_finish_blocking(pSD->dma_write_channel);
#else
        for (int i=0; i < SDIO_WORDS_PER_BLOCK; i++) {     
            pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, __builtin_bswap32(buff[i]));
        }
#endif
        if (pSD->is_wide_bus) {
            pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM,crc32_h);
            pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM,crc32_l);
            pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM,end);
        } else {
            pio_sm_put_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM,crc_and_stop_bit);
        }
        uint32_t crc_status;
       
        crc_status= pio_sm_get_blocking(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM);
        pio_sm_set_enabled(SDIO_MEM_PIO, SDIO_DATA_WRITE_SM, false);  
 
        // card report postive crc:010, neg:101(card status)
         if (crc_status>>24 != 0xe5){   // EZZS...E(pos:e5, net:e9)
            //printf("write CRC Error\n");
            ret = SD_CRC_ERROR;
        }
    
    return ret;
}
 
 
uint8_t sd_read_single_block(sd_memory_card_t *pSD, uint32_t *buff, uint32_t address) {
    uint8_t arg[4];
    uint32_t resp[2];
    uint32_t read_crc[2]; 
 
    uint8_t ret = SD_OK;
    arg[0] = address >> 24;
    arg[1] = (address & 0x00ff0000) >> 16;
    arg[2] = (address & 0x0000ff00) >> 8;
    arg[3] = (address & 0x000000ff);
 
    sdio_send_recv_cmd(CMD17, arg, resp, 48);  //R1, 
 
    if (format_R1_response(resp) == 0x0900) 
    {
        ret = pio_sd_read_blocks(pSD, buff, 1, read_crc);
    } else {
        printf("read single bolck error:%08x\n", format_R1_response(resp));
        return SD_STATE_ERROR;
    }
 
    // check CRC;
    if (pSD->is_wide_bus) {
        uint64_t data_crc;
        uint64_t crc;
        data_crc = (uint64_t)(__builtin_bswap32(read_crc[0]))<<32|(__builtin_bswap32(read_crc[1]));
        crc = calc_4bit_crc16(buff,SDIO_WORDS_PER_BLOCK);
//printf("data_crc:%016llu\n     crc:%016llu\n\n", data_crc, crc);  
//printf("data_crc:%08x,%08x\n     crc:%08x,%08x\n\n", read_crc[0],read_crc[1], (uint32_t)(crc>>32),(uint32_t)crc) ; 
        if (data_crc != crc) {
printf("crc error:wide bus\n");
            return SD_CRC_ERROR;
        }      
    } else {
        uint16_t data_crc;
        uint16_t crc;
     
        data_crc = (uint16_t)(__builtin_bswap32(read_crc[0])>>16);
        crc = calc_1bit_crc16(buff,SDIO_WORDS_PER_BLOCK);
//printf("data_crc:%08x     crc:%08x, dd:%08x\n", data_crc, crc, read_crc[0]);          
        if (data_crc!=crc){
printf("crc error:1 bit\n");
            return SD_CRC_ERROR; 
        }
    }
 
    return ret;
}
 
uint8_t sd_read_multiple_block(sd_memory_card_t* pSD, uint32_t *buff, uint32_t address, uint32_t count) {
    uint8_t arg[4];
    uint32_t resp[2];
    uint32_t read_crc[2*count];
    uint8_t ret = SD_OK;
    uint32_t crc_len=(pSD->is_wide_bus)?2:1;  
    arg[0] = address >> 24;
    arg[1] = (address & 0x00ff0000) >> 16;
    arg[2] = (address & 0x0000ff00) >> 8;
    arg[3] = (address & 0x000000ff);
 
    sdio_send_recv_cmd(CMD18, arg, resp, 48);  //R1, 
    if (format_R1_response(resp) == 0x0900) 
    {                
        ret = pio_sd_read_blocks(pSD, buff, count, read_crc);   
    } else {
        printf("read multiple error:%08x\n", format_R1_response(resp));
        return SD_STATE_ERROR;
    }
 
    sd_stop_trans();
 
    // check CRC;
    if (pSD->is_wide_bus) {
        uint64_t data_crc;
        uint64_t crc;
        for (int i=0; i < count; i++)  {
            data_crc = (uint64_t)(__builtin_bswap32(read_crc[2*i]))<<32|(__builtin_bswap32(read_crc[2*i+1]));
            crc = calc_4bit_crc16(buff+(i*SDIO_WORDS_PER_BLOCK),SDIO_WORDS_PER_BLOCK);
//printf("data_crc:%016llu\n     crc:%016llu\n", data_crc, crc);  
            if (data_crc != crc) {
printf("crc error: wide bus\n\n");
                return SD_CRC_ERROR;
            }  
        }
    } else {
        uint16_t data_crc;
        uint16_t crc;
        for (int i=0; i < count; i++)  {
            data_crc = (uint16_t)(__builtin_bswap32(read_crc[i])>>16);
            crc = calc_1bit_crc16(buff+(i*(SDIO_WORDS_PER_BLOCK)),SDIO_WORDS_PER_BLOCK);
 //printf("data_crc:%08x     crc:%08x\n", data_crc, crc);           
            if (data_crc!=crc){
printf("crc error: 1bit\n");
                return SD_CRC_ERROR; 
            }
        }
    }
 
    return ret ;
}
 
uint8_t sd_write_single_block(sd_memory_card_t* pSD, uint32_t *buff, uint32_t address) {
    uint8_t arg[4];
    uint32_t resp[2];
    uint8_t resp_bytes[6];
    uint8_t ret=SD_ERROR_CODE;
 
 
    //CMD16 SET_BLOCKLEN
    memset(arg,0,sizeof(arg));
    arg[2]=0x02;
    sdio_send_recv_cmd(CMD16, arg, resp, 48);  //R1,
 
 
    arg[0] = address >> 24;
    arg[1] = (address & 0x00ff0000) >> 16;
    arg[2] = (address & 0x0000ff00) >> 8;
    arg[3] = (address & 0x000000ff);
    sdio_send_recv_cmd(CMD24, arg, resp, 48);  //R1, 
 // uint32_t count=0;
    if (format_R1_response(resp) == 0x0900) { 
        ret = pio_sd_write_blocks(pSD, buff, 1);
        for (int idx=0; idx< 10000;idx++) {
            uint32_t ss= get_sd_card_status(pSD);
            
            if (ss == 0x0900) break;
            sleep_us(10);
//            count++;
        };
    }
    else {
        printf("write single error :%08x\n",format_R1_response(resp) );
        return SD_STATE_ERROR;
    }
    //printf("error count:%d\n", count);
    return ret;
}
 
uint8_t sd_write_multiple_block(sd_memory_card_t* pSD, uint32_t *buff, uint32_t address, uint32_t count) {
    uint8_t arg[4];
    uint32_t resp[2];
    uint8_t resp_bytes[6];
    uint8_t ret=SD_OK;
 
    //CMD16 SET_BLOCKLEN
    memset(arg,0,sizeof(arg));
    arg[2]=0x02;
    sdio_send_recv_cmd(CMD16, arg, resp, 48);  //R1,
 
    // pre-erase
    arg[0] = pSD->rca[0];
    arg[1] = pSD->rca[1];
    sdio_send_recv_cmd(CMD55, arg, resp, 48);   // next is APP_CMD
    arg[0] = count >> 24;
    arg[1] = (count & 0x00ff0000) >> 16;
    arg[2] = (count & 0x0000ff00) >> 8;
    arg[3] = (count & 0x000000ff);
    sdio_send_recv_cmd(ACMD23, arg, resp, 48);  //R1, pre-erase blocks
    arg[0] = address >> 24;
    arg[1] = (address & 0x00ff0000) >> 16;
    arg[2] = (address & 0x0000ff00) >> 8;
    arg[3] = (address & 0x000000ff);
 
    sdio_send_recv_cmd(CMD25, arg, resp, 48);  //R1, 
//    uint32_t errors=0;
        for (int i=0; i < count; i++) {
            for (int idx=0; idx < 100000; idx++) { // max 100ms wait for status : READY_FOR_DATA
                if (get_sd_card_status(pSD) & 0x0100) {ret=SD_OK;break;}
                sleep_us(1);
                ret = SD_TIME_OUT; 
        //        errors++;
            }
            if (ret == SD_OK) {
                ret = pio_sd_write_blocks(pSD, buff+i*SDIO_WORDS_PER_BLOCK, 1);
                if (ret != SD_OK) break;
            } else {
                return ret;
            }
    }
  
    sd_stop_trans();
    if (ret != SD_OK) { sleep_ms(1); return ret;}
    uint32_t cardStatus;
//    errors=0;
    for (int timeout=0; timeout<10000;timeout++) { // wait for card ready
        cardStatus = get_sd_card_status(pSD);
        if (cardStatus == 0x0900) break;
//        errors++;
        sleep_us(10);
    }
    //printf("not finish count:%d\n", errors);
    // send ACMD22 to get how many blocks well writen, no arg, R1 32bit+CRC
    return ret;
}
 
uint32_t sd_get_total_blocks(sd_memory_card_t* pSD) {
    return pSD->total_blocks;
}
 
uint16_t sd_get_block_size(sd_memory_card_t* pSD) {
    return pSD->block_size;
}
 
/* sdio_memory_disk_initizlize, sdio_memory_disk_read, sdio_memory_disk_write, sdio_memory_disk_status, sdio_memory_disk_ioctl*/
/* sdmmc_disk_initialize*/
DSTATUS sdio_memory_disk_initialize(sd_memory_card_t* pSD, uint8_t wide_bus)
{
    DSTATUS stat = sd_memory_card_init(pSD, wide_bus);
	return RES_OK;
}
/* sdmmc disk status*/
DSTATUS sdio_memory_disk_status(sd_memory_card_t* pSD)
{
    if (pSD->SD_initialized) 
        return RES_OK;
     else 
        return RES_PARERR;
}
 
/* sdmmc disk read*/
DSTATUS sdio_memory_disk_read(
	BYTE *buff,	  /* Pointer to the data buffer to store read data */
	LBA_t sector, /* Start sector number (LBA) */
	UINT count,	  /* Number of sectors to read (1..128) */
	sd_memory_card_t* pSD)
{
    DSTATUS ret=RES_OK;
	DWORD sect = (DWORD)(sector);
	if (!count)
		return RES_PARERR; /* Check parameter */
    if (!pSD->SD_initialized)
		return RES_NOTRDY; /* Check if drive is ready */
	if (count == 1)
	{	
        for (int retry=0; retry < CRC_ERROR_RETRY_COUNT; retry++) {
            ret = sd_read_single_block(pSD, (uint32_t*)buff, sector);
            if (ret == SD_OK)  break;//crc error try again
            if (ret == SD_CRC_ERROR) continue; else break;
        //led_blinking(); //// LED blinking
        }
	}
	else
	{ /* Multiple sector read */
        for (int retry=0; retry < CRC_ERROR_RETRY_COUNT; retry++) {
            ret = sd_read_multiple_block(pSD, (uint32_t*)buff, sect, count);
            if (ret == SD_OK)  break;//crc error try again
            if (ret == SD_CRC_ERROR) continue; else break;
        //led_blinking(); //// LED blinking
        }
	}
	//led_blinking_off();  //// LED blinking off
 
	return ret; /* Return result */
}
 
DSTATUS sdio_memory_disk_write(
	const BYTE *buff, /* Ponter to the data to write */
	LBA_t sector,	  /* Start sector number (LBA) */
	UINT count,		  /* Number of sectors to write (1..128) */
	sd_memory_card_t *pSD)
{
	DWORD sect = (DWORD)sector;
	if (!count)
		return RES_PARERR; /* Check parameter */
	if (!pSD->SD_initialized)
		return RES_NOTRDY; /* Check if drive is ready */
 
	if (count == 1)
	{												  /* Single block write */
		return sd_write_single_block(pSD, (uint32_t*)buff, sect);
		//led_blinking();  //// LED_blinking
	}
	else
	{ /* Multiple sector write */
		return sd_write_multiple_block(pSD, (uint32_t*)buff, sect, count);
	}
	return RES_OK; /* Return result */
}
 
/* sdmmc disk ioctl*/
DSTATUS sdio_memory_disk_ioctl(
	BYTE cmd,	/* Control command code */
	void *buff, /* Pointer to the conrtol data */
	sd_memory_card_t* pSD)
{
	DRESULT res;
	BYTE n, csd[16];
	DWORD st, ed, csize;
	LBA_t *dp;
 
	BYTE src = 0xFF;
 
	if (!pSD->SD_initialized)
		return RES_NOTRDY; /* Check if drive is ready */
 
	res = RES_ERROR;
	switch (cmd)
	{
	case CTRL_SYNC: /* Wait for end of internal write process of the drive */
		if (get_sd_card_status(pSD) == 0x0900)
			res = RES_OK;
		break;
	case GET_SECTOR_COUNT: /* Get drive capacity in unit of sector (DWORD) */
        *(LBA_t *)buff = *(LBA_t *)sd_get_total_blocks(pSD);	
		res = RES_OK;
 
		break;
	case GET_SECTOR_SIZE: // FF_MAX_SS != FX_MIN_SS
		//*(WORD*)buff=512; // SDHC, SDXC sector size is 512
		*(WORD *)buff = pSD->block_size;
		res = RES_OK;
		break;
	case GET_BLOCK_SIZE: /* Get erase block size in unit of sector (DWORD) */
        //printf("get_block_size\n");
        /* ACMD13,CMD9 */
        res = RES_OK;
		break;
 
	case CTRL_TRIM: /* Erase a block of sectors (used when _USE_ERASE == 1) */
        //printf("CTL_TRIM\n");
        /* CMD32  */
       res = RES_OK;
		/* Following commands are never used by FatFs module */
        break;
	case MMC_GET_TYPE: /* Get MMC/SDC type (BYTE) */
        //printf("MMC_GET_TYPE\n");
       
		res = RES_OK;
		break;
 
	case MMC_GET_CSD: /* Read CSD (16 bytes) CMD9*/
        //printf("MMC_GET_CSD\n");
        res = RES_OK;
		break;
 
	case MMC_GET_CID: /* Read CID (16 bytes) CMD10*/
        //printf("MMC_GET_CID\n");
        res = RES_OK;
		break;
 
	case MMC_GET_OCR: /* Read OCR (4 bytes)  CMD58*/
        //printf("MMC_GET_OCR\n");
        
        res = RES_OK;
		break;
 
	case MMC_GET_SDSTAT: /* Read SD status (64 bytes) ACMD13*/
        //printf("MMC_GET_SDSTAT\n");
        res = RES_OK;
		break;
 
	default:
        //printf("default:%d\n",cmd);
		res = RES_PARERR;
	}
	return res;
}
 

• sdio_mem_card.h

#ifndef __SDIO_MEM_H_
#define __SDIO_MEM_H_
 
#include "ff.h"
#include "diskio.h"
#include "pico_storage.h"
 
#define SDIO_CLK_PIN    16    // PIO sideset pin
#define SDIO_CMD_PIN    17    // 
#define SDIO_D0_PIN     18    // D0~D3 must consecutive and D0 PIN number is minium
#define SDIO_D1_PIN     19
#define SDIO_D2_PIN     20
#define SDIO_D3_PIN     21
 
#define SDIO_MEM_PIO    pio0
#define SDIO_CMD_SM          0
#define SDIO_DATA_READ_SM    1
#define SDIO_DATA_WRITE_SM   2
#define SDIO_CLK_SM          3
 
#define _DMA_TRANS_          1
 
#define SDIO_WORDS_PER_BLOCK 128
#define SDIO_RW_WORDS_PER_BLOCK 130 //128+2
#define MAX_RW_BLOCKS_TRANS    16
#define CRC_ERROR_RETRY_COUNT          3
 
typedef struct {
    uint8_t rca[2];
    uint8_t SD_initialized;
    int sd_data_rx_offset;
    int sd_data_tx_offset;
    int sd_data_cmd_offset;
    uint8_t is_wide_bus;
    uint8_t pnm[6];   // product name
    uint8_t prv;      // product revision BCD(4.4)
    uint32_t psn;     //product serial number
  
    uint16_t block_size;
    uint32_t total_blocks;
    int dma_write_channel;
    int dma_read_channel;
} sd_memory_card_t;
 
enum {
    CLK_FREQ_400K=0,
    CLK_FREQ_1M,
    CLK_FREQ_12_5M,
    CLK_FREQ_25M,
    CLK_FREQ_50M,
 
} SDIO_CLK_FREQ;
 
enum {
    CMD0 = 0,
    CMD2 = 2,
    CMD3 = 3,       //SEND_RELATIVE_ADDR
    CMD4 = 4,       //SET_DSR
    CMD7 = 7,       //SELECT_CARD
    CMD8 = 8,
    CMD9 = 9,       //SEND_CSD
    CMD10 = 10,     //SEND_CID
    CMD11 = 11,
    CMD12 = 12,     //STOP_TRANSMISSION
    CMD13 = 13,     //SEND_STATUS
    CMD16 = 16,     // BLOCK LENGTH
    CMD17 = 17,     // read single block
    CMD18 = 18,     // read mutiple block  
    CMD24 = 24,     // write single block
    CMD25 = 25,     // write mutiple block
    CMD42 = 42,
    CMD55 = 55,     // APP_CMD, next is app command
    ACMD22 = 22,    // SEND_NUM_WR_BLOCKS
    ACMD23 = 23,    //SET_WR_BLK_ERASE_COUNT
    ACMD6 = 6,      // SET_BUS_WIDTH, param:00b-1 bit, 10b-4 bits
    ACMD41 = 41,    //SD_SEND_OP_COND    
} SDIO_CMD_LIST;
 
enum {
    IDLE_STATE=             0x01,
    ERASE_RESET=            0x02,
    ILLEAGAL_COMMAND=       0x04,
    CRC_ERROR=              0x08,
    ERASE_SEQUENCE_ERROR=   0x10,
    ADDRESS_ERROR=          0x20,
    PARAMETER_ERROR=        0x40,
} SDIO_R1;
 
enum {
    SD_OK=0,
    SD_INIT_FAILURE,
    SD_CRC_ERROR,
    SD_TIME_OUT,
    SD_STATE_ERROR,
    SD_READ_ERROR,
    SD_WRITE_ERROR,
} SD_ERROR_CODE;
 
//void sdio_pio_init(PIO pio, uint cmd_pin, uint clk_pin, uint data_pin_base, uint16_t clk_int, uint8_t clk_frac);
uint8_t sd_memory_card_init(sd_memory_card_t* sd_mem_card, uint8_t wide_bus);
uint8_t sd_read_single_block(sd_memory_card_t* pSD,uint32_t *buff, uint32_t address);
uint8_t sd_read_multiple_block(sd_memory_card_t* pSD,uint32_t *buff, uint32_t address, uint32_t count);
uint8_t sd_write_single_block(sd_memory_card_t* pSD,uint32_t *buff, uint32_t address);
uint8_t sd_write_multiple_block(sd_memory_card_t* pSD,uint32_t *buff, uint32_t address, uint32_t count);
uint32_t sd_get_total_blocks(sd_memory_card_t* pSD);
uint16_t sd_get_block_size(sd_memory_card_t* pSD);
DSTATUS sdio_memory_disk_initialize(sd_memory_card_t* pSD, uint8_t wide_bus);
DSTATUS sdio_memory_disk_status(sd_memory_card_t* pSD);
DSTATUS sdio_memory_disk_read(BYTE *buff, LBA_t sector,	UINT count, sd_memory_card_t *pSD); 
DSTATUS sdio_memory_disk_write(const BYTE *buff, LBA_t sector,UINT count, sd_memory_card_t *pSD);
DSTATUS sdio_memory_disk_ioctl(BYTE cmd, void *buff, sd_memory_card_t* pSD);
#endif

• sdio_mem_card.pio

; SD clock frequency: 125M/(DL+DH+2). 
; DL=2, DH=1: 25Mhz
; DL=1, DH=1: 31.25Mhz. 
; DL=1, DH=0: 41.67Mhz. 
.define DL 1
.define DH 0
; ===cmd state machine===
.program sdio_mem_cmd
.origin 0
.side_set 1
 
.wrap_target
public sdio_cmd_start:
    out null, 32                side 0 [1]      ;discard data
    out x, 8                    side 1 [1]      ;command bits
send_cmd_bits:      
    out pins, 1                 side 0 [1]
    jmp x--, send_cmd_bits      side 1 [1]
 
    set pindirs, 0              side 0 [1]
     
    out x, 8                    side 1 [1] ;response bits
    jmp !x, sdio_cmd_stop       side 0 [1]
  
 
wait_recv:  
    nop                         side 1 [1]
    jmp pin, wait_recv          side 0 [1]
   
recv_resp:  
    in pins, 1                  side 1 [1] 
    jmp x--, recv_resp          side 0 [1]
sdio_cmd_stop:
    ;nop                         side 1
    set x,7                     side 1 [1]
wait_Ncr_Ncc:
    nop                         side 0 [1]
    jmp x--, wait_Ncr_Ncc       side 1 [1]
    push                        side 0 [1]
wait_shutdown:
    jmp wait_shutdown           side 0 [1]
    ;irq nowait 0 side 1
.wrap
 
;========== 1 bit READ ============
.program sdio_1_bit_rx
.side_set 1
 
public rx_start:
.wrap_target
wait_start:
    mov y,x                     side 0 [DL] 
    jmp pin, wait_start         side 1 [DH]
 
    nop                         side 0 [DL]
rx_data_bit:
    in PINS, 1                  side 1 [DH]        
    jmp y--, rx_data_bit        side 0 [DL]
    IN NULL,16                  side 0 [DL]
 
.wrap    
    
;========== 4 bit READ ============
.program sdio_4_bit_rx
.side_set 1
.wrap_target
public rx_start:
wait_start:
    mov y,x                     side 0 [DL]
    jmp pin, wait_start         side 1 [DH]
    nop                         side 0 [DL]
    
rx_data_bit:
    in PINS, 4                  side 1 [DH]         
    jmp y--, rx_data_bit        side 0 [DL]
    nop                         side 0 [DL]
   
.wrap    
 
 
 
;========== 1 bit WRITE ============
.program sdio_1_bit_tx
.side_set 1
.wrap_target
public tx_start:
tx_data_bit:
    out PINS, 1                 side 0 [DL]   
    jmp x--, tx_data_bit        side 1 [DH]
    
    set pindirs, 0              side 0 [DL]
response_loop:
    in PINS, 1                  side 1 [DH]  
    jmp Y--, response_loop      side 0 [DL]
    nop                         side 1 [DH]
    push                        side 0 [DL]  
.wrap
 
;========== 4 bit WRITE ============
.program sdio_4_bit_tx
.side_set 1
.wrap_target
public tx_start:
tx_data_bit:
    out PINS, 4                 side 0 [DL]    
    jmp x--, tx_data_bit        side 1 [DH]
    set pindirs, 0              side 0 [DL]
response_loop:
    in PINS, 1                  side 1 [DH] 
    jmp Y--, response_loop      side 0 [DL]
    nop                         side 1 [DH]
    push                        side 0 [DL]
 
    ;nop side 1 
 
.wrap
 
 
 

• CMakeLists.txt(pico_strorage_drv)

add_library(pico_storage_drv INTERFACE)
pico_generate_pio_header(pico_storage_drv ${CMAKE_CURRENT_LIST_DIR}/sdio_mem_card/sdio_mem_card.pio)
target_sources(pico_storage_drv INTERFACE
    ${CMAKE_CURRENT_LIST_DIR}/glue.c
    ${CMAKE_CURRENT_LIST_DIR}/FatFs/ff.c
    ${CMAKE_CURRENT_LIST_DIR}/FatFs/ffunicode.c
    ${CMAKE_CURRENT_LIST_DIR}/FatFs/ffsystem.c
    ${CMAKE_CURRENT_LIST_DIR}/spi_sdmmc/spi_sdmmc.c
    ${CMAKE_CURRENT_LIST_DIR}/flash/W25Q.c
    ${CMAKE_CURRENT_LIST_DIR}/usb_msc/usb_msc.c
    ${CMAKE_CURRENT_LIST_DIR}/sdio_mem_card/sdio_mem_card.c
)
 
target_include_directories(pico_storage_drv INTERFACE
    ${CMAKE_CURRENT_LIST_DIR}
    ${CMAKE_CURRENT_LIST_DIR}/FatFs
    ${CMAKE_CURRENT_LIST_DIR}/flash
    ${CMAKE_CURRENT_LIST_DIR}/spi_sdmmc
    ${CMAKE_CURRENT_LIST_DIR}/usb_msc
    ${CMAKE_CURRENT_LIST_DIR}/sdio_mem_card
)
 
target_link_libraries(pico_storage_drv INTERFACE
        hardware_spi
        hardware_dma
        hardware_pio
        hardware_rtc
        pico_stdlib
        tinyusb_board
        tinyusb_host
)
 
 

• pico_storage.h

#ifndef _PICO_STORAGE_H_
#define _PICO_STORAGE_H_
 
/* used by my project */
#define SD_4_BIT_PATH       "0:"
#define SPI_SDMMC_PATH      "1:"
#define SD_1_BIT_PATH       "2:"
#define W25Q_PATH           "3:"
#define USB_MSC_PATH	    "4:"
 
#define SPI_BAUDRATE_LOW (1000*1000)
#define SPI_BAUDRATE_HIGH (10*1000*1000)
/* =================================  */
#define  LED_BLINKING_PIN     25
void led_blinking(void);
void led_blinking_off(void);
/* =================================  */
#endif

• glue.c

#include "stdio.h"
#include "stdlib.h"
#include "ff.h"
#include "diskio.h"
#include "sdio_mem_card.h"
#include "spi_sdmmc.h"
#include "W25Q.h"
#include "usb_msc.h"
#include "hardware/rtc.h"
#include "inttypes.h"
#include "hardware/gpio.h"
 
#define SD_4_BIT_DRV        0
#define SPI_SDMMC_DRV       1
#define SD_1_BIT_DRV        2
#define W25Q_DRV            3
#define USB_MSC_DRV         4
 
sd_memory_card_t *pSDIO_MEM_CARD_4=NULL;
sd_memory_card_t *pSDIO_MEM_CARD_1=NULL;
spi_sdmmc_data_t *pSPI_SDMMC=NULL;
w25q_data_t *pW25Q = NULL;
usb_msc_t    *pUSB_MSC=NULL;
 
 
//==================//
DSTATUS disk_initialize (BYTE drv){
    DSTATUS stat;
    switch (drv) {
        case SD_4_BIT_DRV:
            if (pSDIO_MEM_CARD_4 == NULL) {
                pSDIO_MEM_CARD_4 = (sd_memory_card_t*)malloc(sizeof(sd_memory_card_t));
                pSDIO_MEM_CARD_4->SD_initialized=false;
            }
            stat = sdio_memory_disk_initialize(pSDIO_MEM_CARD_4, true);
            return stat;
        break;
       case SD_1_BIT_DRV:
            if (pSDIO_MEM_CARD_1 == NULL) {
                pSDIO_MEM_CARD_1 = (sd_memory_card_t*)malloc(sizeof(sd_memory_card_t));
                pSDIO_MEM_CARD_1->SD_initialized=false;
            }
            stat = sdio_memory_disk_initialize(pSDIO_MEM_CARD_1, false);
            return stat;
        break;
        case SPI_SDMMC_DRV:
            if (pSPI_SDMMC == NULL) {
                pSPI_SDMMC = (spi_sdmmc_data_t*)malloc(sizeof(spi_sdmmc_data_t));
                pSPI_SDMMC->csPin = SDMMC_PIN_CS;
                pSPI_SDMMC->spiPort = SDMMC_SPI_PORT;
                pSPI_SDMMC->spiInit=false;
                pSPI_SDMMC->sectSize=512;
#ifdef __SPI_SDMMC_DMA
                pSPI_SDMMC->dmaInit=false;
#endif
    }
            stat = sdmmc_disk_initialize(pSPI_SDMMC);
            return stat;
        break;
        case W25Q_DRV:
        if (pW25Q == NULL) {
            pW25Q = (w25q_data_t*)malloc(sizeof(w25q_data_t));
            pW25Q->spiInit=false;
            pW25Q->Stat=STA_NOINIT;
        }
		stat = w25q_disk_initialize(W25Q_SPI_PORT, W25Q_PIN_CS, pW25Q); 
		return stat;
		
	    break;
        case USB_MSC_DRV:
        if (pUSB_MSC == NULL) {
            pUSB_MSC = (usb_msc_t*)malloc(sizeof(usb_msc_t));
        }
        stat = usb_msc_initialize(pUSB_MSC);
        return stat;
        break;
    }
    return STA_NOINIT;
 }
/*-----------------------------------------------------------------------*/
/* Get disk status                                                       */
/*-----------------------------------------------------------------------*/
DSTATUS disk_status (BYTE drv) {
    DSTATUS stat;
    switch (drv) {
        case SD_4_BIT_DRV:
            stat = sdio_memory_disk_status(pSDIO_MEM_CARD_4);          
            return stat;
        break;
        case SD_1_BIT_DRV:
            stat = sdio_memory_disk_status(pSDIO_MEM_CARD_1);
            return stat;
        break;
        case SPI_SDMMC_DRV:
            stat=  sdmmc_disk_status(pSPI_SDMMC); /* Return disk status */
            return stat;
        break;
        case W25Q_DRV:
            stat = pW25Q->Stat;
            return stat;
        break;
        case USB_MSC_DRV:
            //uint8_t dev_addr = pdrv + 1;
            return tuh_msc_mounted(pUSB_MSC->dev_addr) ? 0 : STA_NODISK;
        break;
    }
    return RES_PARERR;
	
}
 
/*-----------------------------------------------------------------------*/
/* Read sector(s)                                                        */
/*-----------------------------------------------------------------------*/
DRESULT disk_read (
	BYTE drv,		/* Physical drive number (0) */
	BYTE *buff,		/* Pointer to the data buffer to store read data */
	LBA_t sector,	/* Start sector number (LBA) */
	UINT count		/* Number of sectors to read (1..128) */
)
{
    DSTATUS stat;
    switch (drv) {
        case SD_4_BIT_DRV:       
 
            stat = sdio_memory_disk_read(buff, sector, count, pSDIO_MEM_CARD_4);       
            return stat;
        break;
        case SD_1_BIT_DRV:
            stat = sdio_memory_disk_read(buff, sector, count, pSDIO_MEM_CARD_1);
            return stat;
        break;
        case SPI_SDMMC_DRV: 
            stat = sdmmc_disk_read(buff, sector, count, pSPI_SDMMC);
            return stat;
        break;
        case W25Q_DRV:
            if (pW25Q->Stat & STA_NOINIT) return RES_NOTRDY;
		    w25q_read_sector((uint32_t)sector, 0, buff, count*pW25Q->sectorSize, pW25Q);
            return pW25Q->Stat;
        break;
        case USB_MSC_DRV:
            stat = usb_msc_disk_read(buff, sector, count, pUSB_MSC);
            return stat;
        break;
    }
	return RES_PARERR;
}
 
/*-----------------------------------------------------------------------*/
/* Write sector(s)                                                       */
/*-----------------------------------------------------------------------*/
#if FF_FS_READONLY == 0
DRESULT disk_write (
	BYTE drv,			/* Physical drive number (0) */
	const BYTE *buff,	/* Ponter to the data to write */
	LBA_t sector,		/* Start sector number (LBA) */
	UINT count			/* Number of sectors to write (1..128) */
)
{
    DSTATUS stat = STA_NODISK;
    switch (drv) {
        case SD_4_BIT_DRV:
            stat = sdio_memory_disk_write(buff, sector, count, pSDIO_MEM_CARD_4);
            return stat;
        break;
        case SD_1_BIT_DRV:
            stat = sdio_memory_disk_write(buff, sector, count, pSDIO_MEM_CARD_1);
            return stat;
        break;
        case SPI_SDMMC_DRV:
            stat = sdmmc_disk_write(buff, sector, count, pSPI_SDMMC);
            return stat;
        break;
        case W25Q_DRV:
            stat = w25q_disk_write(buff, sector, count, pW25Q);
            return stat;
        break;
        case USB_MSC_DRV:
            stat = usb_msc_disk_write(buff, sector, count, pUSB_MSC);
            return stat;
        break;
    }
	return RES_PARERR;
 
}
#endif
 
 
/*-----------------------------------------------------------------------*/
/* Miscellaneous drive controls other than data read/write               */
/*-----------------------------------------------------------------------*/
 
DRESULT disk_ioctl (
	BYTE drv,		/* Physical drive number (0) */
	BYTE cmd,		/* Control command code */
	void *buff		/* Pointer to the conrtol data */
)
{
    DSTATUS stat;
    switch (drv) {
        case SD_4_BIT_DRV:
            stat = sdio_memory_disk_ioctl(cmd, buff, pSDIO_MEM_CARD_4);
            return stat;
        break;
        case SD_1_BIT_DRV:
            stat = sdio_memory_disk_ioctl(cmd, buff, pSDIO_MEM_CARD_1);
            return stat;
        break;
        case W25Q_DRV:
            stat = w25q_disk_ioctl(cmd, buff, pW25Q);
            return stat;
        break;
        case USB_MSC_DRV:
            stat = usb_msc_ioctl(cmd, buff, pUSB_MSC);
            return stat;
        break;
    }
	return RES_PARERR;
}
 
DWORD get_fattime(void) {
    datetime_t t = {0, 0, 0, 0, 0, 0, 0};
    bool rc = rtc_get_datetime(&t);
    if (!rc) return 0;
 
    DWORD fattime = 0;
    // bit31:25
    // Year origin from the 1980 (0..127, e.g. 37 for 2017)
    uint32_t yr = t.year - 1980;
    fattime |= (0b01111111 & yr) << 25;
    // bit24:21
    // Month (1..12)
    uint32_t mo = t.month;
    fattime |= (0b00001111 & mo) << 21;
    // bit20:16
    // Day of the month (1..31)
    uint32_t da = t.day;
    fattime |= (0b00011111 & da) << 16;
    // bit15:11
    // Hour (0..23)
    uint32_t hr = t.hour;
    fattime |= (0b00011111 & hr) << 11;
    // bit10:5
    // Minute (0..59)
    uint32_t mi = t.min;
    fattime |= (0b00111111 & mi) << 5;
    // bit4:0
    // Second / 2 (0..29, e.g. 25 for 50)
    uint32_t sd = t.sec / 2;
    fattime |= (0b00011111 & sd);
    return fattime;
}
 
void led_blinking(void)
{
    static absolute_time_t  t1;
    static bool state=false;
        
    // Blink every interval ms
    if ( absolute_time_diff_us(t1, get_absolute_time()) < 100000) return; // not enough time
    t1 = get_absolute_time();
    gpio_put(LED_BLINKING_PIN, state);
    state = !state;
}
 
void led_blinking_off(void) {
    gpio_put(LED_BLINKING_PIN, false);
}

• main.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/dma.h"
#include "hardware/pio.h"
//#include "sdio_mem_card/sdio_mem_card.h"
#include "string.h"
#include "ff.h"
#include "diskio.h"
#include "pico_storage.h"
#include "hardware/rtc.h"
 
//sd_memory_card_t sd;
 
void test_data(uint8_t* buff) {
     // test write data    
    uint8_t ch='A';
    for (int i=0; i < 512;i++){
        buff[i] = ch;
        ch++;
        if (ch > 'Z') ch='A';
    }
    memcpy(buff+512, buff, 512);
    buff[511]='\n';
    buff[0+512] = 'a';
    buff[26+512] = 'b';
    buff[52+512] = 'c';
    buff[512+511]='\n';
 
    
    memcpy(buff+1024, buff, 512);
    buff[0+1024] = '1';
    buff[26+1024] = '2';
    buff[52+1024] = '3';
    buff[1024+511]='\n';
    for (uint32_t i = 1536; i< 8192; i+=512)
        memcpy(buff+i, buff, 512);
}
 
uint8_t test_4_bit() {
     FATFS fs;
     FIL fil_r, fil_w;
     FRESULT res;
     uint bw, br;
     uint8_t buff[16384];
    if (f_mount(&fs, SD_4_BIT_PATH, 1) != FR_OK) {
        printf("mount error\n");
        return 0;
     }
     printf("mount ok\n");
     printf("\n ==============================\ntest under 41.66Mhz SD clock frequency\n");
     
     res = f_open(&fil_r, SD_4_BIT_PATH"/pico_storage.mp4", FA_READ);
    if (res != FR_OK) {
        printf("open read error:\n");
        f_unmount(SD_4_BIT_PATH);
        return 0;
     }
    uint64_t r_out=0;
    uint64_t fsize=f_size(&fil_r);
    uint32_t i=0;
    f_close(&fil_r);
    printf("file size:%llu\n",fsize);
    uint16_t buff_size[4] = {1024, 4096, 8192, 12288};
 
    for (int r=0; r<4; r++) { 
         res = f_open(&fil_r, SD_4_BIT_PATH"/pico_storage.mp4", FA_READ);
        if (res != FR_OK) {
            printf("open read error:\n");
            f_unmount(SD_4_BIT_PATH);
            return 0;
        }
    r_out=0;
    printf("Test file read speed(SD-4bit): using %dK buffer\n", buff_size[r]/1024);
    absolute_time_t tt=get_absolute_time();
    do {
        res = f_read(&fil_r, buff, buff_size[r], &br);
        if (res != FR_OK) {
            printf("read error:%d\n", res);
            break;
        }
        r_out += br;
    } while(r_out < fsize);
    int64_t et=absolute_time_diff_us(tt, get_absolute_time())/1000;
    double dd = (double)(r_out)/et*1000/1024/1024;
    printf("total time:%llu ms, total_read:%d bytes, = %0.2lfMB/s\n", et, r_out, dd);
  
    printf("--------------\n\n");
    f_close(&fil_r);
    }
 
    printf("\n======================\n");
    printf("Test file write speed(SD-4bit): using 8K buffer\n");
    test_data(buff);
    res = f_open(&fil_w, SD_4_BIT_PATH"/8k_4_buff.txt", FA_CREATE_ALWAYS|FA_WRITE);
     if (res != FR_OK) {
        printf("open file error:\n");
        f_unmount(SD_4_BIT_PATH);
        return 0;
     }
     absolute_time_t tw=get_absolute_time();
     for (int s=0; s < 8192;s++) { // 64MB
        f_write(&fil_w, buff, 8192, &bw);
    //printf("write:%d\n", bw);
     }
     int64_t et=absolute_time_diff_us(tw, get_absolute_time())/1000;
    double dd = (double)(8192*8192)/et*1000/1024/1024;
    printf("total time:%llu ms, total_write:%d bytes, = %0.2lfMB/s\n", et, 8192*8192, dd);
    f_close(&fil_w);
 
 
    printf("\n======================\n");
    printf("Test file read in and write out speed(SD-4bit): using 8K buffer\n");
    res = f_open(&fil_r, SD_4_BIT_PATH"/pico_storage.mp4", FA_READ);
        if (res != FR_OK) {
            printf("open read error:\n");
            f_unmount(SD_4_BIT_PATH);
            return 0;
        }
    res = f_open(&fil_w, SD_4_BIT_PATH"/test_out_4.mp4", FA_CREATE_ALWAYS|FA_WRITE);
     if (res != FR_OK) {
        printf("open file error:\n");
        f_unmount(SD_4_BIT_PATH);
        return 0;
     }
    r_out=0;
     absolute_time_t tt=get_absolute_time();
    do {
    res = f_read(&fil_r, buff, 8192, &br);
    if (res != FR_OK) {
        printf("read error:%d\n", res);
        break;
    }
    f_write(&fil_w, buff, br, &bw);
    if (res != FR_OK) {
        printf("write error:%d\n", res);
        break;
    }
    r_out += br;
    //if ((i++%100)==0) { 
    //printf("read bytes:%d\n", br);
   // printf("write  :%llu\n", r_out);
    //}
    } while(r_out < fsize);
    printf("total time:%llu ms, total_read:%d bytes\n", absolute_time_diff_us(tt, get_absolute_time())/1000, r_out);
    f_close(&fil_r);
    f_close(&fil_w);
 
 
    printf("\n#=============#\n");
 
 
     f_unmount(SD_4_BIT_PATH);
}
 
uint8_t test_1_bit() {
     FATFS fs;
     FIL fil_r, fil_w;
     FRESULT res;
     uint bw, br;
     uint8_t buff[16384];
    if (f_mount(&fs, SD_1_BIT_PATH, 1) != FR_OK) {
        printf("mount error\n");
        return 0;
     }
     printf("mount ok\n");
     printf("\n ==============================\ntest under 41.66Mhz SD clock frequency\n");
     
     res = f_open(&fil_r, SD_1_BIT_PATH"/pico_storage.mp4", FA_READ);
    if (res != FR_OK) {
        printf("open read error:\n");
        f_unmount(SD_1_BIT_PATH);
        return 0;
     }
    uint64_t r_out=0;
    uint64_t fsize=f_size(&fil_r);
    uint32_t i=0;
    f_close(&fil_r);
    printf("file size:%llu\n",fsize);
    uint16_t buff_size[4] = {1024, 4096, 8192, 12288};
 
    for (int r=0; r<4; r++) { 
         res = f_open(&fil_r, SD_1_BIT_PATH"/pico_storage.mp4", FA_READ);
        if (res != FR_OK) {
            printf("open read error:\n");
            f_unmount(SD_1_BIT_PATH);
            return 0;
        }
    r_out=0;
    printf("Test file read speed(SD-1bit): using %dK buffer\n", buff_size[r]/1024);
    absolute_time_t tt=get_absolute_time();
    do {
        res = f_read(&fil_r, buff, buff_size[r], &br);
        if (res != FR_OK) {
            printf("read error:%d\n", res);
            break;
        }
        r_out += br;
    } while(r_out < fsize);
    int64_t et=absolute_time_diff_us(tt, get_absolute_time())/1000;
    double dd = (double)(r_out)/et*1000/1024/1024;
    printf("total time:%llu ms, total_read:%d bytes, = %0.2lfMB/s\n", et, r_out, dd);
  
    printf("--------------\n\n");
    f_close(&fil_r);
    }
 
    printf("\n======================\n");
    printf("Test file write speed(SD-1bit): using 8K buffer\n");
    test_data(buff);
    res = f_open(&fil_w, SD_1_BIT_PATH"/8k_1_buff.txt", FA_CREATE_ALWAYS|FA_WRITE);
     if (res != FR_OK) {
        printf("open file error:\n");
        f_unmount(SD_1_BIT_PATH);
        return 0;
     }
     absolute_time_t tw=get_absolute_time();
     for (int s=0; s < 8192;s++) { // 64MB
        f_write(&fil_w, buff, 8192, &bw);
     }
     int64_t et=absolute_time_diff_us(tw, get_absolute_time())/1000;
    double dd = (double)(8192*8192)/et*1000/1024/1024;
    printf("total time:%llu ms, total_write:%d bytes, = %0.2lfMB/s\n", et, 8192*8192, dd);
    f_close(&fil_w);
 
 
    printf("\n======================\n");
    printf("Test file read in and write out speed(SD-1bit): using 8K buffer\n");
    res = f_open(&fil_r, SD_1_BIT_PATH"/pico_storage.mp4", FA_READ);
        if (res != FR_OK) {
            printf("open read error:\n");
            f_unmount(SD_1_BIT_PATH);
            return 0;
        }
    res = f_open(&fil_w, SD_1_BIT_PATH"/test_out_1.mp4", FA_CREATE_ALWAYS|FA_WRITE);
     if (res != FR_OK) {
        printf("open file error:\n");
        f_unmount(SD_1_BIT_PATH);
        return 0;
     }
    r_out=0;
     absolute_time_t tt=get_absolute_time();
    do {
    res = f_read(&fil_r, buff, 8192, &br);
    if (res != FR_OK) {
        printf("read error:%d\n", res);
        break;
    }
    f_write(&fil_w, buff, br, &bw);
    if (res != FR_OK) {
        printf("write error:%d\n", res);
        break;
    }
    r_out += br;
    //if ((i++%100)==0) { 
    //printf("read bytes:%d\n", br);
   // printf("write  :%llu\n", r_out);
    //}
    } while(r_out < fsize);
    printf("total time:%llu ms, total_read:%d bytes\n", absolute_time_diff_us(tt, get_absolute_time())/1000, r_out);
    f_close(&fil_r);
    f_close(&fil_w);
 
    printf("\n#=============#\n");
 
 
     f_unmount(SD_1_BIT_PATH);
}
 
 
int main()
{
     stdio_init_all();
     printf("start\n");
     
    
 
     
 
     datetime_t t = {2023, 10, 20, 5, 3, 0, 0};
    rtc_set_datetime(&t);
    sleep_ms(1000);
 
    test_1_bit();
    test_4_bit();
        
 
    while(1);
    
    puts("Hello, world!");
 
    return 0;
}

• CMakeListx.txt(root)

# Generated Cmake Pico project file
 
cmake_minimum_required(VERSION 3.13)
 
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
 
# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)
set(PICO_SDK_PATH "/home/duser/pico/pico-sdk")
 
set(PICO_BOARD pico CACHE STRING "Board type")
 
# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)
 
if (PICO_SDK_VERSION_STRING VERSION_LESS "1.4.0")
  message(FATAL_ERROR "Raspberry Pi Pico SDK version 1.4.0 (or later) required. Your version is ${PICO_SDK_VERSION_STRING}")
endif()
 
project(SDIO_MEM C CXX ASM)
 
# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()
 
# Add executable. Default name is the project name, version 0.1
 
add_executable(SDIO_MEM main.c)
 
pico_set_program_name(SDIO_MEM "SDIO_MEM")
pico_set_program_version(SDIO_MEM "0.1")
 
pico_enable_stdio_uart(SDIO_MEM 1)
pico_enable_stdio_usb(SDIO_MEM 0)
 
# Add the standard library to the build
target_link_libraries(SDIO_MEM
        pico_stdlib)
 
# Add the standard include files to the build
target_include_directories(SDIO_MEM PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
  ${CMAKE_CURRENT_LIST_DIR}/.. # for our common lwipopts or any other standard includes, if required
)
 
 
# Add any user requested libraries
#target_link_libraries(SDIO_MEM 
#        hardware_dma
#        hardware_pio
#                )
 
add_subdirectory(pico_storage_drv)
# Add any user requested libraries
target_link_libraries(SDIO_MEM 
        tinyusb_host 
        tinyusb_board
        pico_storage_drv
        ) 
 
 
pico_add_extra_outputs(SDIO_MEM)