1
2
3
High Voltage SD Memory Card: 操作的电压范围在2.7-3.6V
UHS-II SD Memory Card： 操作的电压范围VDD1: 2.7-3.6V, VDD2: 1.70-1.95V

1
2
3
4
5
6
7
8
9
Default Speed mode: 3.3V供电模式，频率上限25MHz，速度上限 12.5MB/sec
High Speed mode: 3.3V供电模式，频率上限50MHz，速度上限 25MB/sec
SDR12： UHS-I卡， 1.8V供电模式，频率上限25MHz，速度上限 12.5MB/sec
SDR25： UHS-I卡， 1.8V供电模式，频率上限50MHz，速度上限 25MB/sec
SDR50： UHS-I卡， 1.8V供电模式，频率上限100MHz，速度上限 50MB/sec
SDR104： UHS-I卡， 1.8V供电模式，频率上限208MHz，速度上限 104MB/sec
DDR50： UHS-I卡， 1.8V供电模式，频率上限50MHz，性能上限 50MB/sec
UHS156： UHS-II RCLK Frequency Range 26MHz - 52MHz, up to 1.56Gbps per lane.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rt_int32_t mmcsd_go_idle(struct rt_mmcsd_host *host)
{
 ...

    rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));

    cmd.cmd_code = GO_IDLE_STATE;
    cmd.arg = 0;
    cmd.flags = RESP_SPI_R1 | RESP_NONE | CMD_BC;

    err = mmcsd_send_cmd(host, &cmd, 0);

    mmcsd_delay_ms(1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
rt_int32_t mmcsd_all_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
{
    rt_int32_t err;
    struct rt_mmcsd_cmd cmd;

    rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));

    cmd.cmd_code = ALL_SEND_CID;
    cmd.arg = 0;
    cmd.flags = RESP_R2 | CMD_BCR;

    err = mmcsd_send_cmd(host, &cmd, 3);
    if (err)
        return err;

    rt_memcpy(cid, cmd.resp, sizeof(rt_uint32_t) * 4);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
rt_err_t mmcsd_get_card_addr(struct rt_mmcsd_host *host, rt_uint32_t *rca)
{
    rt_err_t err;
    struct rt_mmcsd_cmd cmd;

    rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));

    cmd.cmd_code = SD_SEND_RELATIVE_ADDR;
    cmd.arg = 0;
    cmd.flags = RESP_R6 | CMD_BCR;

    err = mmcsd_send_cmd(host, &cmd, 3);
    if (err)
        return err;

    *rca = cmd.resp[0] >> 16;
    ...

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef struct
    {
    UINT8       structure;         /* csd struct */
    UINT8       taac;              /* data read access-time */
    UINT8       nsac;              /* data read access-time in CLK */
    UINT8       tranSpeed;         /* data transfer rate */
    UINT16      commClass;         /* command class */
    UINT8       resvData0[4];      /* reserved data */
    UINT16      eraseSize;         /* erase size */
    UINT16      r2wFactor;         /* write speed factor */
    UINT16      fileFormat;        /* file format */
    } SDMMC_CSD;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
STATUS sdCmdSendStatus
    (
    VXB_DEVICE_ID pDev,
    UINT32 * stsData
    )
    {
...

    SD_CMD_FORM (cmd, SDMMC_CMD_SEND_STATUS,
                 SDMMC_CMD_ARG_RCA (pSdHardWare->rcaValue),
                 SDMMC_CMD_RSP_R1, FALSE);
    pSdHardWare->dataErr = 0x0;
    pSdHardWare->cmdErr = 0x0;

    rc = pSdHardWare->vxbSdCmdIssue(pSdHardWare->pHostDev, &cmd);
    if (rc == ERROR)
        return (ERROR);

    *stsData = cmd.cmdRsp[0]; (1)
    ..
 }

    while (1)
        {
        rc = sdCmdSendStatus (pDev, &rspValue);
        if (rc == ERROR)
            return ERROR;
        if (rspValue & CARD_STS_READY_FOR_DATA) (2)
            break;
        }
    return OK;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
STATUS sdACmdSendSsr
    (
    VXB_DEVICE_ID  pDev,
    UINT8 * ssrData
    )
    {
...

    rc = sdCmdAppCmd (pDev);
    if (rc == ERROR)
        {
        (void)cacheDmaFree((void *)ssr);
        return ERROR;
        }

    SD_CMD_FORM (cmd, SD_ACMD_SD_STATUS, 0, SDMMC_CMD_RSP_R1, TRUE);
    SD_DATA_FORM (cmd, ssr, 1, sizeof(UINT8) * SD_SSR_SIZE, TRUE);
    pSdHardWare->dataErr = 0x0;
    pSdHardWare->cmdErr = 0x0;

    rc = pSdHardWare->vxbSdCmdIssue(pSdHardWare->pHostDev, &cmd);
    if (rc == ERROR)
        {
        (void)cacheDmaFree((void *)ssr);
        return ERROR;
        }

    bcopy ((char *)ssr, (char *)(ssrData), sizeof(UINT8) * SD_SSR_SIZE); (1)
...
}

    ret = sdACmdSendSsr (pDev, &(pSdInfo->ssr.ssrData[0]));
    if (ret == ERROR)
        {
        SD_CARD_DBG (SD_CARD_DBG_ERR,
                    "sdDecodeSsr() - send sdACmdSendSsr faultn",
                    0, 0, 0, 0, 0 ,0);
        return ERROR;
        }
    pSdInfo->speedClass = pSdInfo->ssr.ssrData[8]; (2)
    pSdInfo->auSize = pSdInfo->ssr.ssrData[10] & 0xF0;
    pSdInfo->eraseSize = (UINT32)(pSdInfo->ssr.ssrData[11] << 8) | 
                                    pSdInfo->ssr.ssrData[12];
    pSdInfo->eraseTimeout = pSdInfo->ssr.ssrData[13] & 0xFC;
    pSdInfo->eraseOffset = pSdInfo->ssr.ssrData[13] & 0x03;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
STATUS sdCmdSendIfCond
    (
    VXB_DEVICE_ID pDev,
    UINT32 capbility
    )
    {
...

    arg = (SD_CMD8_ARG_VHS_27_36 << SD_CMD8_ARG_VHS_SHIFT) |
           SD_CMD8_ARG_CHK_PATTERN;

    SD_CMD_FORM (cmd, SD_CMD_SEND_IF_COND, arg, SDMMC_CMD_RSP_R7, FALSE);
...

    if (cmd.cmdErr & SDMMC_CMD_ERR_TIMEOUT)
        {
        pSdHardWare->version = SD_VERSION_100; /* cmd-8 would failed for sd v1.0 */
        SD_LIB_DBG (SD_LIB_DBG_CMD,
                    "sdCmdSendIfCond() - sd target version is SD_VERSION_100n",
                    0, 0, 0, 0, 0 ,0);
        return (OK);
        }
...

    if ((cmd.cmdRsp[0] & 0xff) != SD_CMD8_ARG_CHK_PATTERN)
        {
        SD_LIB_DBG (SD_LIB_DBG_CMD,
                    "sdCmdSendIfCond() - sd target version is SD_VERSION_UNKNOWNn",
                    0, 0, 0, 0, 0 ,0);
        pSdHardWare->version = SD_VERSION_UNKNOWN;
        }
    else
        {
        SD_LIB_DBG (SD_LIB_DBG_CMD,
                    "sdCmdSendIfCond() - sd target version is SD_VERSION_200n",
                    0, 0, 0, 0, 0 ,0);
        pSdHardWare->version = SD_VERSION_200;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
STATUS sdMmcACmdSendOpCond
    (
    SDMMC_CARD * card
    )
    {
...

    rc = sdMmcCmdAppCmd (card);
    if (rc == ERROR)
        return ERROR;

    arg = card->host->capbility & OCR_VDD_VOL_MASK;
    if (card->info.version == SD_VERSION_200)
        {
        if (card->host->capbility & OCR_CARD_CAP_STS)
            arg |= OCR_CARD_CAP_STS;
        }

   /*
    * Set ACMD41 argument to 3.3V if both 3.0V & 3.3V are not reported
    * by host controller's capbilities register
    */

    if (!(arg & (OCR_VDD_VOL_29_30 | OCR_VDD_VOL_30_31 | OCR_VDD_VOL_32_33 | OCR_VDD_VOL_33_34)))
        arg |= (OCR_VDD_VOL_32_33 | OCR_VDD_VOL_33_34);
    SDMMC_CMD_FORM (cmd, SD_ACMD_SEND_OP_COND, arg, SDMMC_CMD_RSP_R3, FALSE);
...

    if (rc == OK && (cmd->cmdRsp[0] & OCR_CARD_PWRUP_STS))
        {
        card->info.voltage = cmd->cmdRsp[0] & OCR_VDD_VOL_MASK;
        card->info.highCapacity = ((cmd->cmdRsp[0] & OCR_CARD_CAP_STS) > 0) ? TRUE : FALSE;
        return OK;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
STATUS sdACmdSwitchFunc
    (
    VXB_DEVICE_ID pDev,
    void * buffer,
    UINT32 len,
    int    mode, /* mode set/inquiry */
    int    group, /* group 1~6 */
    int    val /* group function */
    )
...

    arg = mode; /* set mode bits */
    arg |= 0xffffff;
    arg &= ~(0xf << (group * 4));
    arg |= (val << (group * 4)); /* select one function group */

    SD_CMD_FORM (cmd, SD_CMD_SWITCH_FUNC, arg, SDMMC_CMD_RSP_R1, TRUE);
    SD_DATA_FORM (cmd, buffer, 1, len, TRUE); /* buffer to get status data */
...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
{

...

    cmd.cmd_code = SD_SWITCH;
    cmd.arg = 0x00FFFFF1; /* group 1: access mode, inquiry mode */（1）
    cmd.flags = RESP_R1 | CMD_ADTC;

    rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));

    mmcsd_set_data_timeout(&data, card);

    data.blksize = 64;
    data.blks = 1;
    data.flags = DATA_DIR_READ;
    data.buf = (rt_uint32_t *)buf;

    rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));

    req.cmd = &cmd;
    req.data = &data;

    mmcsd_send_request(host, &req);

    if (cmd.err || data.err)
    {
        goto err1;
    }

    if (buf[13] & 0x02) /* SDR50 supported */
        card->hs_max_data_rate = 50000000;

    rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));

    cmd.cmd_code = SD_SWITCH;
    cmd.arg = 0x80FFFFF1; /* group 1: access mode, set mode */
    cmd.flags = RESP_R1 | CMD_ADTC;

    rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));

    mmcsd_set_data_timeout(&data, card);

    data.blksize = 64;
    data.blks = 1;
    data.flags = DATA_DIR_READ;
    data.buf = (rt_uint32_t *)buf;

    rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));

    req.cmd = &cmd;
    req.data = &data;

    mmcsd_send_request(host, &req);

    if (cmd.err || data.err)
    {
        goto err1;
    }

    if ((buf[16] & 0xF) != 1) /* check if high speed is enabled */
    {
        LOG_I("switching card to high speed failed!");
        goto err;
    }

    card->flags |= CARD_FLAG_HIGHSPEED;

1
2
3
4
5
6
7
8
9
10
struct mmcsd_blk_device
{
    struct rt_mmcsd_card *card; (1)
    rt_list_t list;
    struct rt_device dev;
    struct dfs_partition part; (2)
    struct rt_device_blk_geometry geometry; (3)
    rt_size_t max_req_size; (4)
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
{
...

    err = mmcsd_set_blksize(card); (1)
    if(err)
    {
        return err;
    }

...

    status = rt_mmcsd_req_blk(card, 0, sector, 1, 0); (2)
    if (status == RT_EOK)
    {

...

        /* Always create the super node, given name is with allocated host id. */
        rt_snprintf(dname, sizeof(dname), "sd%d", host_id);
        blk_dev = rt_mmcsd_create_blkdev(card, (const char*)dname, RT_NULL); (3)
        if ( blk_dev == RT_NULL )
        {
            err = -RT_ENOMEM;
            goto exit_rt_mmcsd_blk_probe;
        }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
const static struct rt_device_ops mmcsd_blk_ops =
{
    rt_mmcsd_init,
    rt_mmcsd_open,
    rt_mmcsd_close, (3)
    rt_mmcsd_read,
    rt_mmcsd_write,
    rt_mmcsd_control
};

static struct mmcsd_blk_device * rt_mmcsd_create_blkdev(struct rt_mmcsd_card *card, const char* dname, struct dfs_partition* psPart)
{
...
    blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs *
                                     card->host->max_seg_size) >> 9,
                                    (card->host->max_blk_count *
                                     card->host->max_blk_size) >> 9); （1）

    /* register mmcsd device */
    blk_dev->dev.type = RT_Device_Class_Block;
    blk_dev->dev.ops  = &mmcsd_blk_ops; (2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int rt_mmcsd_core_init(void)
{
    rt_err_t ret;

    /* initialize detect SD cart thread */
    /* initialize mailbox and create detect SD card thread */
    ret = rt_mb_init(&mmcsd_detect_mb, "mmcsdmb",
        &mmcsd_detect_mb_pool[0], sizeof(mmcsd_detect_mb_pool) / sizeof(mmcsd_detect_mb_pool[0]),
        RT_IPC_FLAG_FIFO); (2)
    RT_ASSERT(ret == RT_EOK);

   ret = rt_mb_init(&mmcsd_hotpluge_mb, "mmcsdhotplugmb",
        &mmcsd_hotpluge_mb_pool[0], sizeof(mmcsd_hotpluge_mb_pool) / sizeof(mmcsd_hotpluge_mb_pool[0]),
        RT_IPC_FLAG_FIFO);
    RT_ASSERT(ret == RT_EOK);
     ret = rt_thread_init(&mmcsd_detect_thread, "mmcsd_detect", mmcsd_detect, RT_NULL,
                 &mmcsd_stack[0], RT_MMCSD_STACK_SIZE, RT_MMCSD_THREAD_PREORITY, 20);
    if (ret == RT_EOK)
    {
        rt_thread_startup(&mmcsd_detect_thread);
    }

    rt_sdio_init();

    return 0;
}
INIT_PREV_EXPORT(rt_mmcsd_core_init);（1）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void mmcsd_change(struct rt_mmcsd_host *host) (1)
{
    rt_mb_send(&mmcsd_detect_mb, (rt_ubase_t)host);
}

void mmcsd_detect(void *param)
{
    struct rt_mmcsd_host *host;
    rt_uint32_t  ocr;
    rt_int32_t  err;

    while (1)
    {
        if (rt_mb_recv(&mmcsd_detect_mb, (rt_ubase_t *)&host, RT_WAITING_FOREVER) == RT_EOK) (2)
        {
        ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int mmcsd_wait_cd_changed(rt_int32_t timeout) (1)
{
    struct rt_mmcsd_host *host;
    if (rt_mb_recv(&mmcsd_hotpluge_mb, (rt_ubase_t *)&host, timeout) == RT_EOK)
    {
        if(host->card == RT_NULL)
        {
            return MMCSD_HOST_UNPLUGED;
        }
        else
        {
            return MMCSD_HOST_PLUGED;
        }
    }
    return -RT_ETIMEOUT;
}
RTM_EXPORT(mmcsd_wait_cd_changed);

1
2
3
4
5
void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req);
rt_int32_t mmcsd_send_cmd(struct rt_mmcsd_host *host,
                          struct rt_mmcsd_cmd  *cmd,
                          int                   retries);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#define VDD_165_195     (1 << 7)    /* VDD voltage 1.65 - 1.95 */
#define VDD_20_21       (1 << 8)    /* VDD voltage 2.0 ~ 2.1 */
#define VDD_21_22       (1 << 9)    /* VDD voltage 2.1 ~ 2.2 */
#define VDD_22_23       (1 << 10)   /* VDD voltage 2.2 ~ 2.3 */
#define VDD_23_24       (1 << 11)   /* VDD voltage 2.3 ~ 2.4 */
#define VDD_24_25       (1 << 12)   /* VDD voltage 2.4 ~ 2.5 */
#define VDD_25_26       (1 << 13)   /* VDD voltage 2.5 ~ 2.6 */
#define VDD_26_27       (1 << 14)   /* VDD voltage 2.6 ~ 2.7 */
#define VDD_27_28       (1 << 15)   /* VDD voltage 2.7 ~ 2.8 */
#define VDD_28_29       (1 << 16)   /* VDD voltage 2.8 ~ 2.9 */
#define VDD_29_30       (1 << 17)   /* VDD voltage 2.9 ~ 3.0 */
#define VDD_30_31       (1 << 18)   /* VDD voltage 3.0 ~ 3.1 */
#define VDD_31_32       (1 << 19)   /* VDD voltage 3.1 ~ 3.2 */
#define VDD_32_33       (1 << 20)   /* VDD voltage 3.2 ~ 3.3 */
#define VDD_33_34       (1 << 21)   /* VDD voltage 3.3 ~ 3.4 */
#define VDD_34_35       (1 << 22)   /* VDD voltage 3.4 ~ 3.5 */
#define VDD_35_36       (1 << 23)   /* VDD voltage 3.5 ~ 3.6 */

		/* drv_sdio.c */
    host->valid_ocr = 0X00FFFF80; /* The voltage range supported is 1.65v-3.6v */ (1)

rt_uint32_t mmcsd_select_voltage(struct rt_mmcsd_host *host, rt_uint32_t ocr)
{
    int bit;
    extern int __rt_ffs(int value);

    ocr &= host->valid_ocr;

    bit = __rt_ffs(ocr); (2)
    if (bit)
    {
        bit -= 1;

        ocr &= 3 << bit;

        host->io_cfg.vdd = bit;
        mmcsd_set_iocfg(host);
    }

rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr)
{
...

    current_ocr = mmcsd_select_voltage(host, ocr);

    /*
     * Can we support the voltage(s) of the card(s)?
     */
    if (!current_ocr) （3）
    {
        err = -RT_ERROR;
        goto err;
    }

   /*
     * Detect and init the card.
     */
    err = mmcsd_sd_init_card(host, current_ocr); (4)
    if (err)
        goto err;

    err = rt_mmcsd_blk_probe(host->card); （5）
    if (err)
        goto remove_card;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
                                     rt_uint32_t           ocr)
{
    struct rt_mmcsd_card *card;
    rt_int32_t err;
    rt_uint32_t resp[4];
    rt_uint32_t max_data_rate;

    mmcsd_go_idle(host); (1)

    /*
     * If SD_SEND_IF_COND indicates an SD 2.0
     * compliant card and we should set bit 30
     * of the ocr to indicate that we can handle
     * block-addressed SDHC cards.
     */
    err = mmcsd_send_if_cond(host, ocr); (2)
    if (!err)
        ocr |= 1 << 30; （3）

    err = mmcsd_send_app_op_cond(host, ocr, RT_NULL); （4）
    if (err)
        goto err;

		err = mmcsd_all_get_cid(host, resp);

    err = mmcsd_get_card_addr(host, &card->rca);
    if (err)
        goto err1;

    err = mmcsd_get_csd(card, card->resp_csd);
    if (err)
        goto err1;