!263 添加emmc驱动和mount代码

Merge pull request !263 from lin123/rt-smart

bsp/imx6ull-artpi-smart/applications/filesystem.c

@@ -1,6 +1,8 @@
 #include <rtthread.h>
 
 #include <dfs_fs.h>
+#include <ioremap.h>
+#include <drv_sdio.h>
 
 #define DBG_TAG "app.filesystem"
 #define DBG_LVL DBG_INFO

bsp/imx6ull-artpi-smart/applications/mnt.c

@@ -16,6 +16,20 @@
 
 int mnt_init(void)
 {
+#ifdef RT_USING_SDIO2
+    int part_id = 1;
+    rt_thread_mdelay(500);
+
+    if (dfs_mount("emmc","/","ext",0,(void *)part_id) != 0)
+    {
+        rt_kprintf("Dir / mount failed!\n");
+        return -1;
+    }
+    else
+    {
+        rt_kprintf("file system initialization done!\n");
+    }
+#else
     rt_thread_mdelay(500);
     if (dfs_mount(NULL, "/", "rom", 0, &romfs_root) != 0)
     {
@@ -25,6 +39,7 @@ int mnt_init(void)
 
     sd_task();
     rt_kprintf("file system initialization done!\n");
+#endif
     return 0;
 }
 INIT_APP_EXPORT(mnt_init);

bsp/imx6ull-artpi-smart/drivers/drv_sdio.c

@@ -7,6 +7,7 @@
  * Date           Author       Notes
  * 2017-10-10     Tanek        first version
  * 2021-07-07     linzhenxing  add sd card drivers in mmu
+ * 2021-07-14     linzhenxing  add emmc
  */
 
 #include <rtthread.h>
@@ -20,7 +21,7 @@
 #include <fsl_iomuxc.h>
 
 #include <ioremap.h>
-
+#include <string.h>
 #define DBG_TAG               "drv_sdio"
 #ifdef RT_SDIO_DEBUG
 #define DBG_LVL               DBG_LOG
@@ -606,7 +607,7 @@ rt_int32_t imxrt_mci_init(void)
     mmcsd1 = rt_malloc(sizeof(struct imxrt_mmcsd));
     if (!mmcsd1)
     {
-        rt_kprintf("alloc mci failed\n");
+        LOG_E("alloc mci failed\n");
         goto err;
     }
 
@@ -615,6 +616,7 @@ rt_int32_t imxrt_mci_init(void)
     mmcsd1->usdhc_div = kCLOCK_Usdhc1Div;
     mmcsd1->usdhc_adma2_table = g_usdhcAdma2Table;
 
+    strncpy(host1->name, "sd", sizeof(host1->name)-1);
     host1->ops = &ops;
     host1->freq_min = 375000;
     host1->freq_max = 25000000;
@@ -647,19 +649,20 @@ rt_int32_t imxrt_mci_init(void)
     mmcsd2 = rt_malloc(sizeof(struct imxrt_mmcsd));
     if (!mmcsd2)
     {
-        rt_kprintf("alloc mci failed\n");
+        LOG_E("alloc mci failed\n");
         goto err;
     }
 
     rt_memset(mmcsd2, 0, sizeof(struct imxrt_mmcsd));
-    mmcsd2->usdhc_host.base = (struct USDHC_Type *)rt_ioremap((void*)USDHC2_BASE, 0x1000);
+    mmcsd2->usdhc_host.base = (USDHC_Type *)rt_ioremap((void*)USDHC2_BASE, 0x1000);
     mmcsd2->usdhc_div = kCLOCK_Usdhc1Div;
     mmcsd2->usdhc_adma2_table = g_usdhcAdma2Table;
 
+    strncpy(host2->name, "emmc", sizeof(host2->name)-1);
     host2->ops = &ops;
     host2->freq_min = 375000;
     host2->freq_max = 52000000;
-    host2->valid_ocr = VDD_32_33 | VDD_33_34;
+    host2->valid_ocr = VDD_35_36;
     host2->flags = MMCSD_BUSWIDTH_4 | MMCSD_MUTBLKWRITE | \
                   MMCSD_SUP_HIGHSPEED | MMCSD_SUP_SDIO_IRQ;
     host2->max_seg_size = 65535;
@@ -678,7 +681,7 @@ rt_int32_t imxrt_mci_init(void)
     mmcsd_mutex = rt_mutex_create("mmutex", RT_IPC_FLAG_FIFO);
     if (mmcsd_mutex == RT_NULL)
     {
-        rt_kprintf("create mmcsd mutex failed.\n");
+        LOG_E("create mmcsd mutex failed.\n");
         return -1;
     }
 

bsp/imx6ull-artpi-smart/drivers/drv_sdio.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-07-14     linzhenxing  first version
+ */
+#ifndef __DRV_SDIO_H__
+#define __DRV_SDIO_H__
+
+void host_change(void);
+
+#endif

bsp/imx6ull-artpi-smart/rtconfig.h

@@ -267,6 +267,9 @@
 
 /* Micrium: Micrium software products porting for RT-Thread */
 
+#define PKG_USING_LWEXT4
+#define RT_USING_DFS_LWEXT4
+#define PKG_USING_LWEXT4_LATEST_VERSION
 
 /* peripheral libraries and drivers */
 
@@ -313,6 +316,7 @@
 /* Select SDHC Driver */
 
 #define RT_USING_SDIO1
+#define RT_USING_SDIO2
 
 /* Select RTC Driver */
 

components/drivers/sdio/block_dev.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -76,7 +76,7 @@ rt_int32_t mmcsd_num_wr_blocks(struct rt_mmcsd_card *card)
     timeout_us += data.timeout_clks * 1000 /
         (card->host->io_cfg.clock / 1000);
 
-    if (timeout_us > 100000) 
+    if (timeout_us > 100000)
     {
         data.timeout_ns = 100000000;
         data.timeout_clks = 0;
@@ -119,9 +119,9 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
     rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
     req.cmd = &cmd;
     req.data = &data;
-    
+
     cmd.arg = sector;
-    if (!(card->flags & CARD_FLAG_SDHC)) 
+    if (!(card->flags & CARD_FLAG_SDHC))
     {
         cmd.arg <<= 9;
     }
@@ -130,7 +130,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
     data.blksize = SECTOR_SIZE;
     data.blks  = blks;
 
-    if (blks > 1) 
+    if (blks > 1)
     {
         if (!controller_is_spi(card->host) || !dir)
         {
@@ -149,7 +149,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
         w_cmd = WRITE_BLOCK;
     }
 
-    if (!dir) 
+    if (!dir)
     {
         cmd.cmd_code = r_cmd;
         data.flags |= DATA_DIR_READ;
@@ -164,9 +164,9 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
     data.buf = buf;
     mmcsd_send_request(host, &req);
 
-    if (!controller_is_spi(card->host) && dir != 0) 
+    if (!controller_is_spi(card->host) && dir != 0)
     {
-        do 
+        do
         {
             rt_int32_t err;
 
@@ -174,7 +174,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
             cmd.arg = card->rca << 16;
             cmd.flags = RESP_R1 | CMD_AC;
             err = mmcsd_send_cmd(card->host, &cmd, 5);
-            if (err) 
+            if (err)
             {
                 LOG_E("error %d requesting status", err);
                 break;
@@ -190,7 +190,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
 
     mmcsd_host_unlock(host);
 
-    if (cmd.err || data.err || stop.err) 
+    if (cmd.err || data.err || stop.err)
     {
         LOG_E("mmcsd request blocks error");
         LOG_E("%d,%d,%d, 0x%08x,0x%08x",
@@ -264,7 +264,7 @@ static rt_size_t rt_mmcsd_read(rt_device_t dev,
     rt_sem_release(part->lock);
 
     /* the length of reading must align to SECTOR SIZE */
-    if (err) 
+    if (err)
     {
         rt_set_errno(-EIO);
         return 0;
@@ -305,7 +305,7 @@ static rt_size_t rt_mmcsd_write(rt_device_t dev,
     rt_sem_release(part->lock);
 
     /* the length of reading must align to SECTOR SIZE */
-    if (err) 
+    if (err)
     {
         rt_set_errno(-EIO);
 
@@ -330,7 +330,7 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card)
     err = mmcsd_send_cmd(card->host, &cmd, 5);
     mmcsd_host_unlock(card->host);
 
-    if (err) 
+    if (err)
     {
         LOG_E("MMCSD: unable to set block size to %d: %d", cmd.arg, err);
 
@@ -341,7 +341,7 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card)
 }
 
 #ifdef RT_USING_DEVICE_OPS
-const static struct rt_device_ops mmcsd_blk_ops = 
+const static struct rt_device_ops mmcsd_blk_ops =
 {
     rt_mmcsd_init,
     rt_mmcsd_open,
@@ -357,12 +357,12 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
     rt_int32_t err = 0;
     rt_uint8_t i, status;
     rt_uint8_t *sector;
-    char dname[4];
-    char sname[8];
+    char dname[10];
+    char sname[16];
     struct mmcsd_blk_device *blk_dev = RT_NULL;
 
     err = mmcsd_set_blksize(card);
-    if(err) 
+    if(err)
     {
         return err;
     }
@@ -381,28 +381,68 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
     status = rt_mmcsd_req_blk(card, 0, sector, 1, 0);
     if (status == RT_EOK)
     {
+        blk_dev = rt_calloc(1, sizeof(struct mmcsd_blk_device));
+        if (!blk_dev)
+        {
+            LOG_E("mmcsd:malloc memory failed!");
+            return -1;
+        }
+
+        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);
+        blk_dev->part.offset = 0;
+        blk_dev->part.size   = 0;
+        rt_snprintf(sname, sizeof(sname)-1, "sem_%s%d", card->host->name,0);
+        blk_dev->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
+        /* register mmcsd device */
+        blk_dev->dev.type  = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+        blk_dev->dev.ops  = &mmcsd_blk_ops;
+#else
+        blk_dev->dev.init = rt_mmcsd_init;
+        blk_dev->dev.open = rt_mmcsd_open;
+        blk_dev->dev.close = rt_mmcsd_close;
+        blk_dev->dev.read = rt_mmcsd_read;
+        blk_dev->dev.write = rt_mmcsd_write;
+        blk_dev->dev.control = rt_mmcsd_control;
+#endif
+        blk_dev->card = card;
+
+        blk_dev->geometry.bytes_per_sector = 1<<9;
+        blk_dev->geometry.block_size = card->card_blksize;
+        blk_dev->geometry.sector_count =
+            card->card_capacity * (1024 / 512);
+
+        blk_dev->dev.user_data = blk_dev;
+
+        rt_device_register(&(blk_dev->dev), card->host->name,
+            RT_DEVICE_FLAG_RDWR);
+        rt_list_insert_after(&blk_devices, &blk_dev->list);
+
         for (i = 0; i < RT_MMCSD_MAX_PARTITION; i++)
         {
             blk_dev = rt_calloc(1, sizeof(struct mmcsd_blk_device));
-            if (!blk_dev) 
+            if (!blk_dev)
             {
                 LOG_E("mmcsd:malloc memory failed!");
                 break;
             }
 
-            blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs * 
-                                             card->host->max_seg_size) >> 9, 
-                                            (card->host->max_blk_count * 
+            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);
 
             /* get the first partition */
             status = dfs_filesystem_get_partition(&blk_dev->part, sector, i);
             if (status == RT_EOK)
             {
-                rt_snprintf(dname, 4, "sd%d",  i);
-                rt_snprintf(sname, 8, "sem_sd%d",  i);
+                rt_snprintf(dname, sizeof(dname)-1, "%s%d", card->host->name,i);
+                rt_snprintf(sname, sizeof(sname)-1, "sem_%s%d", card->host->name,i+1);
                 blk_dev->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
-    
+
                 /* register mmcsd device */
                 blk_dev->dev.type = RT_Device_Class_Block;
 #ifdef RT_USING_DEVICE_OPS
@@ -415,66 +455,31 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
                 blk_dev->dev.write = rt_mmcsd_write;
                 blk_dev->dev.control = rt_mmcsd_control;
 #endif
-                blk_dev->dev.user_data = blk_dev;
-
                 blk_dev->card = card;
-                
+
                 blk_dev->geometry.bytes_per_sector = 1<<9;
                 blk_dev->geometry.block_size = card->card_blksize;
                 blk_dev->geometry.sector_count = blk_dev->part.size;
-    
-                rt_device_register(&blk_dev->dev, dname,
-                    RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
+
+                blk_dev->dev.user_data = blk_dev;
+
+                rt_device_register(&(blk_dev->dev), dname,
+                    RT_DEVICE_FLAG_RDWR);
                 rt_list_insert_after(&blk_devices, &blk_dev->list);
             }
             else
             {
-                if (i == 0)
-                {
-                    /* there is no partition table */
-                    blk_dev->part.offset = 0;
-                    blk_dev->part.size   = 0;
-                    blk_dev->part.lock = rt_sem_create("sem_sd0", 1, RT_IPC_FLAG_FIFO);
-    
-                    /* register mmcsd device */
-                    blk_dev->dev.type  = RT_Device_Class_Block;
-#ifdef RT_USING_DEVICE_OPS
-                    blk_dev->dev.ops  = &mmcsd_blk_ops;
-#else
-                    blk_dev->dev.init = rt_mmcsd_init;
-                    blk_dev->dev.open = rt_mmcsd_open;
-                    blk_dev->dev.close = rt_mmcsd_close;
-                    blk_dev->dev.read = rt_mmcsd_read;
-                    blk_dev->dev.write = rt_mmcsd_write;
-                    blk_dev->dev.control = rt_mmcsd_control;
-#endif
-                    blk_dev->dev.user_data = blk_dev;
-
-                    blk_dev->card = card;
-
-                    blk_dev->geometry.bytes_per_sector = 1<<9;
-                    blk_dev->geometry.block_size = card->card_blksize;
-                    blk_dev->geometry.sector_count = 
-                        card->card_capacity * (1024 / 512);
-    
-                    rt_device_register(&blk_dev->dev, "sd0",
-                        RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
-                    rt_list_insert_after(&blk_devices, &blk_dev->list);
-                }
-                else
-                {
-                    rt_free(blk_dev);
-                    blk_dev = RT_NULL;
-                    break;
-                }
+                rt_free(blk_dev);
+                blk_dev = RT_NULL;
+                break;
             }
 
 #ifdef RT_USING_DFS_MNTTABLE
             if (blk_dev)
             {
-            	LOG_I("try to mount file system!");
-            	/* try to mount file system on this block device */
-            	dfs_mount_device(&(blk_dev->dev));
+                LOG_I("try to mount file system!");
+                /* try to mount file system on this block device */
+                dfs_mount_device(&(blk_dev->dev));
             }
 #endif
         }
@@ -484,10 +489,10 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
         LOG_E("read mmcsd first sector failed");
         err = -RT_ERROR;
     }
-    
+
     /* release sector buffer */
     rt_free(sector);
-    
+
     return err;
 }
 
@@ -499,15 +504,15 @@ void rt_mmcsd_blk_remove(struct rt_mmcsd_card *card)
     for (l = (&blk_devices)->next, n = l->next; l != &blk_devices; l = n)
     {
         blk_dev = (struct mmcsd_blk_device *)rt_list_entry(l, struct mmcsd_blk_device, list);
-        if (blk_dev->card == card) 
+        if (blk_dev->card == card)
         {
-        	/* unmount file system */
-        	const char * mounted_path = dfs_filesystem_get_mounted_path(&(blk_dev->dev));
-        	if (mounted_path)
-        	{
+            /* unmount file system */
+            const char * mounted_path = dfs_filesystem_get_mounted_path(&(blk_dev->dev));
+            if (mounted_path)
+            {
                   dfs_unmount(mounted_path);
                   LOG_D("unmount file system %s for device %s.\r\n", mounted_path, blk_dev->dev.parent.name);
-        	}
+            }
             rt_sem_delete(blk_dev->part.lock);
             rt_device_unregister(&blk_dev->dev);
             rt_list_remove(&blk_dev->list);

components/drivers/sdio/mmc.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -45,9 +45,9 @@ static const rt_uint8_t tacc_value[] =
 rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp,
                                rt_uint32_t  start,
                                rt_uint32_t  size)
-{                               
+{
         const rt_int32_t __size = size;
-        const rt_uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; 
+        const rt_uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1;
         const rt_int32_t __off = 3 - ((start) / 32);
         const rt_int32_t __shft = (start) & 31;
         rt_uint32_t __res;
@@ -67,7 +67,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
       rt_uint32_t a, b;
       struct rt_mmcsd_csd *csd = &card->csd;
       rt_uint32_t *resp = card->resp_csd;
-      
+
       /*
       * We only understand CSD structure v1.1 and v1.2.
       * v1.2 has extra information in bits 15, 11 and 10.
@@ -76,10 +76,10 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
       csd->csd_structure = GET_BITS(resp, 126, 2);
       if (csd->csd_structure == 0) {
         LOG_E("unrecognised CSD structure version %d!", csd->csd_structure);
-        
+
         return -RT_ERROR;
       }
-      
+
       csd->taac = GET_BITS(resp, 112, 8);
       csd->nsac = GET_BITS(resp, 104, 8);
       csd->tran_speed = GET_BITS(resp, 96, 8);
@@ -95,7 +95,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
       csd->wr_blk_len = GET_BITS(resp, 22, 4);
       csd->wr_blk_partial = GET_BITS(resp, 21, 1);
       csd->csd_crc = GET_BITS(resp, 1, 7);
-      
+
       card->card_blksize = 1 << csd->rd_blk_len;
       card->tacc_clks = csd->nsac * 100;
       card->tacc_ns = (tacc_uint[csd->taac&0x07] * tacc_value[(csd->taac&0x78)>>3] + 9) / 10;
@@ -106,7 +106,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
         card->erase_size = (a + 1) * (b + 1);
         card->erase_size <<= csd->wr_blk_len - 9;
       }
-      
+
       return 0;
 }
 
@@ -119,12 +119,11 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
   struct rt_mmcsd_req req;
   struct rt_mmcsd_cmd cmd;
   struct rt_mmcsd_data data;
-  
+
   *new_ext_csd = RT_NULL;
-  
-  if (GET_BITS(card->resp_cid, 122, 4) < 4)
+  if (GET_BITS(card->resp_csd, 122, 4) < 4)
      return 0;
-  
+
   /*
   * As the ext_csd is so large and mostly unused, we don't store the
   * raw block in mmc_card.
@@ -134,29 +133,29 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
     LOG_E("alloc memory failed when get ext csd!");
     return -RT_ENOMEM;
   }
-  
+
   rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
   rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
   rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
-  
+
   req.cmd = &cmd;
   req.data = &data;
-  
+
   cmd.cmd_code = SEND_EXT_CSD;
   cmd.arg = 0;
-  
+
   /* NOTE HACK:  the RESP_SPI_R1 is always correct here, but we
   * rely on callers to never use this with "native" calls for reading
   * CSD or CID.  Native versions of those commands use the R2 type,
   * not R1 plus a data block.
   */
   cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;
-  
+
   data.blksize = 512;
   data.blks = 1;
   data.flags = DATA_DIR_READ;
   data.buf = ext_csd;
-  
+
   /*
   * Some cards require longer data read timeout than indicated in CSD.
   * Address this by setting the read timeout to a "reasonably high"
@@ -165,14 +164,14 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
   */
   data.timeout_ns = 300000000;
   data.timeout_clks = 0;
-  
+
   mmcsd_send_request(card->host, &req);
-  
+
   if (cmd.err)
     return cmd.err;
   if (data.err)
     return data.err;
-  
+
   *new_ext_csd = ext_csd;
   return 0;
 }
@@ -192,13 +191,13 @@ static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
 
   card->flags |=  CARD_FLAG_HIGHSPEED;
   card->hs_max_data_rate = 52000000;
-  
+
   card_capacity = *((rt_uint32_t *)&ext_csd[EXT_CSD_SEC_CNT]);
   card_capacity *= card->card_blksize;
   card_capacity >>= 10; /* unit:KB */
   card->card_capacity = card_capacity;
   LOG_I("emmc card capacity %d KB.", card->card_capacity);
-  
+
   return 0;
 }
 
@@ -211,41 +210,41 @@ static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
  *
  *   Modifies the EXT_CSD register for selected card.
  */
-static int mmc_switch(struct rt_mmcsd_card *card, rt_uint8_t set, 
+static int mmc_switch(struct rt_mmcsd_card *card, rt_uint8_t set,
                       rt_uint8_t index, rt_uint8_t value)
 {
   int err;
   struct rt_mmcsd_host *host = card->host;
   struct rt_mmcsd_cmd cmd = {0};
-  
+
   cmd.cmd_code = SWITCH;
   cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
     (index << 16) | (value << 8) | set;
-  cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_AC;
-  
+  cmd.flags = RESP_R1B | CMD_AC;
+
   err = mmcsd_send_cmd(host, &cmd, 3);
   if (err)
     return err;
-  
+
   return 0;
 }
 
-static int mmc_compare_ext_csds(struct rt_mmcsd_card *card, 
+static int mmc_compare_ext_csds(struct rt_mmcsd_card *card,
                                 rt_uint8_t *ext_csd, rt_uint32_t bus_width)
 {
   rt_uint8_t *bw_ext_csd;
   int err;
-  
+
   if (bus_width == MMCSD_BUS_WIDTH_1)
     return 0;
-  
+
   err = mmc_get_ext_csd(card, &bw_ext_csd);
-  
+
   if (err || bw_ext_csd == RT_NULL) {
     err = -RT_ERROR;
     goto out;
   }
-  
+
   /* only compare read only fields */
   err = !((ext_csd[EXT_CSD_PARTITION_SUPPORT] == bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
           (ext_csd[EXT_CSD_ERASED_MEM_CONT] == bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
@@ -273,10 +272,10 @@ static int mmc_compare_ext_csds(struct rt_mmcsd_card *card,
           (ext_csd[EXT_CSD_PWR_CL_DDR_52_195] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
           (ext_csd[EXT_CSD_PWR_CL_DDR_52_360] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
           (ext_csd[EXT_CSD_PWR_CL_DDR_200_360] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
-  
+
   if (err)
      err = -RT_ERROR;
-  
+
 out:
   rt_free(bw_ext_csd);
   return err;
@@ -302,10 +301,10 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
   struct rt_mmcsd_host *host = card->host;
   unsigned idx, bus_width = 0;
   int err = 0;
-  
-  if (GET_BITS(card->resp_cid, 122, 4) < 4)
+
+  if (GET_BITS(card->resp_csd, 122, 4) < 4)
      return 0;
-  
+
   /*
   * Unlike SD, MMC cards dont have a configuration register to notify
   * supported bus width. So bus test command should be run to identify
@@ -323,21 +322,25 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
     * set by drivers.
     */
      if ((!(host->flags & MMCSD_BUSWIDTH_8) &&
-	  ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8) ||
+      ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8) ||
          (!(host->flags & MMCSD_BUSWIDTH_4) &&
-	  (ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_4 ||
-	  ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8)))
-	     continue;
+      (ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_4 ||
+      ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8)))
+         continue;
 
     err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                      EXT_CSD_BUS_WIDTH,
                      ext_csd_bits[idx]);
     if (err)
       continue;
-    
+    err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                     EXT_CSD_HS_TIMING,
+                     1);
+
+    if (err)
+      continue;
     bus_width = bus_widths[idx];
     mmcsd_set_bus_width(host, bus_width);
-    mmcsd_delay_ms(20); //delay 10ms
     err = mmc_compare_ext_csds(card, ext_csd, bus_width);
     if (!err) {
       err = bus_width;
@@ -358,10 +361,10 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
       }
     }
   }
-  
+
   return err;
 }
-rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host, 
+rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
                           rt_uint32_t ocr, rt_uint32_t *rocr)
 {
     struct rt_mmcsd_cmd cmd;
@@ -369,20 +372,20 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
     rt_err_t err = RT_EOK;
 
     rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
-    
+
     cmd.cmd_code = SEND_OP_COND;
     cmd.arg = controller_is_spi(host) ? 0 : ocr;
     cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR;
-  
+
     for (i = 100; i; i--) {
       err = mmcsd_send_cmd(host, &cmd, 3);
       if (err)
         break;
-      
+
       /* if we're just probing, do a single pass */
       if (ocr == 0)
         break;
-      
+
       /* otherwise wait until reset completes */
       if (controller_is_spi(host)) {
         if (!(cmd.resp[0] & R1_SPI_IDLE))
@@ -391,15 +394,15 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
         if (cmd.resp[0] & CARD_BUSY)
           break;
       }
-      
+
       err = -RT_ETIMEOUT;
-      
+
       mmcsd_delay_ms(10); //delay 10ms
     }
-  
+
   if (rocr && !controller_is_spi(host))
     *rocr = cmd.resp[0];
-  
+
   return err;
 }
 
@@ -407,17 +410,17 @@ static rt_err_t mmc_set_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 = SET_RELATIVE_ADDR;
   cmd.arg = rca << 16;
   cmd.flags = RESP_R1 | CMD_AC;
-  
+
   err = mmcsd_send_cmd(host, &cmd, 3);
   if (err)
     return err;
-  
+
   return 0;
 }
 
@@ -432,19 +435,19 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     struct rt_mmcsd_card *card = RT_NULL;
 
     mmcsd_go_idle(host);
-    
+
     /* The extra bit indicates that we support high capacity */
     err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
     if (err)
       goto err;
-    
-    if (controller_is_spi(host)) 
+
+    if (controller_is_spi(host))
     {
         err = mmcsd_spi_use_crc(host, 1);
         if (err)
             goto err1;
     }
-    
+
     if (controller_is_spi(host))
         err = mmcsd_get_cid(host, resp);
     else
@@ -453,7 +456,7 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
         goto err;
 
     card = rt_malloc(sizeof(struct rt_mmcsd_card));
-    if (!card) 
+    if (!card)
     {
         LOG_E("malloc card failed!");
         err = -RT_ENOMEM;
@@ -469,7 +472,7 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     /*
      * For native busses:  get card RCA and quit open drain mode.
      */
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmc_set_card_addr(host, card->rca);
         if (err)
@@ -486,24 +489,24 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     if (err)
         goto err1;
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmcsd_select_card(card);
         if (err)
             goto err1;
     }
-    
+
     /*
     * Fetch and process extended CSD.
     */
-    
+
     err = mmc_get_ext_csd(card, &ext_csd);
     if (err)
       goto err1;
     err = mmc_parse_ext_csd(card, ext_csd);
     if (err)
       goto err1;
-    
+
     /* If doing byte addressing, check if required to do sector
     * addressing.  Handle the case of <2GB cards needing sector
     * addressing.  See section 8.1 JEDEC Standard JED84-A441;
@@ -511,18 +514,17 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     */
     if (!(card->flags & CARD_FLAG_SDHC) && (rocr & (1<<30)))
         card->flags |= CARD_FLAG_SDHC;
- 
+
     /* set bus speed */
-    if (card->flags & CARD_FLAG_HIGHSPEED) 
+    if (card->flags & CARD_FLAG_HIGHSPEED)
         max_data_rate = card->hs_max_data_rate;
     else
         max_data_rate = card->max_data_rate;
 
-    mmcsd_set_clock(host, max_data_rate);
-
-    /*switch bus width*/
+    /*switch bus width and bus mode*/
     mmc_select_bus_width(card, ext_csd);
-    
+
+    mmcsd_set_clock(host, max_data_rate);
     host->card = card;
 
     rt_free(ext_csd);

components/drivers/sdio/mmcsd_core.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -13,6 +13,7 @@
 #include <drivers/sd.h>
 #include <drivers/mmc.h>
 #include <drivers/sdio.h>
+#include <string.h>
 
 #define DBG_TAG               "SDIO"
 #ifdef RT_SDIO_DEBUG
@@ -63,7 +64,7 @@ void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
         req->cmd->err = 0;
         req->cmd->mrq = req;
         if (req->data)
-        {   
+        {
             req->cmd->data = req->data;
             req->data->err = 0;
             req->data->mrq = req;
@@ -72,12 +73,12 @@ void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
                 req->data->stop = req->stop;
                 req->stop->err = 0;
                 req->stop->mrq = req;
-            }       
+            }
         }
         host->ops->request(host, req);
 
         rt_sem_take(&host->sem_ack, RT_WAITING_FOREVER);
-          
+
     } while(req->cmd->err && (req->cmd->retries > 0));
 
 
@@ -122,7 +123,7 @@ rt_int32_t mmcsd_go_idle(struct rt_mmcsd_host *host)
 
     mmcsd_delay_ms(1);
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         mmcsd_set_chip_select(host, MMCSD_CS_IGNORE);
         mmcsd_delay_ms(1);
@@ -179,7 +180,7 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
     struct rt_mmcsd_data data;
     rt_uint32_t *buf = RT_NULL;
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         if (!host->card)
             return -RT_ERROR;
@@ -198,7 +199,7 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
     }
 
     buf = (rt_uint32_t *)rt_malloc(16);
-    if (!buf) 
+    if (!buf)
     {
         LOG_E("allocate memory failed!");
 
@@ -274,7 +275,7 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd)
     }
 
     buf = (rt_uint32_t*)rt_malloc(16);
-    if (!buf) 
+    if (!buf)
     {
         LOG_E("allocate memory failed!");
 
@@ -336,12 +337,12 @@ static rt_int32_t _mmcsd_select_card(struct rt_mmcsd_host *host,
 
     cmd.cmd_code = SELECT_CARD;
 
-    if (card) 
+    if (card)
     {
         cmd.arg = card->rca << 16;
         cmd.flags = RESP_R1 | CMD_AC;
-    } 
-    else 
+    }
+    else
     {
         cmd.arg = 0;
         cmd.flags = RESP_NONE | CMD_AC;
@@ -442,7 +443,7 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
 {
     rt_uint32_t mult;
 
-    if (card->card_type == CARD_TYPE_SDIO) 
+    if (card->card_type == CARD_TYPE_SDIO)
     {
         data->timeout_ns = 1000000000;  /* SDIO card 1s */
         data->timeout_clks = 0;
@@ -468,7 +469,7 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
     /*
      * SD cards also have an upper limit on the timeout.
      */
-    if (card->card_type == CARD_TYPE_SD) 
+    if (card->card_type == CARD_TYPE_SD)
     {
         rt_uint32_t timeout_us, limit_us;
 
@@ -488,21 +489,21 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
         /*
          * SDHC cards always use these fixed values.
          */
-        if (timeout_us > limit_us || card->flags & CARD_FLAG_SDHC) 
+        if (timeout_us > limit_us || card->flags & CARD_FLAG_SDHC)
         {
             data->timeout_ns = limit_us * 1000; /* SDHC card fixed 250ms */
             data->timeout_clks = 0;
         }
     }
 
-    if (controller_is_spi(card->host)) 
+    if (controller_is_spi(card->host))
     {
-        if (data->flags & DATA_DIR_WRITE) 
+        if (data->flags & DATA_DIR_WRITE)
         {
             if (data->timeout_ns < 1000000000)
                 data->timeout_ns = 1000000000;  /* 1s */
-        } 
-        else 
+        }
+        else
         {
             if (data->timeout_ns < 100000000)
                 data->timeout_ns =  100000000;  /* 100ms */
@@ -522,7 +523,7 @@ rt_uint32_t mmcsd_select_voltage(struct rt_mmcsd_host *host, rt_uint32_t ocr)
     ocr &= host->valid_ocr;
 
     bit = __rt_ffs(ocr);
-    if (bit) 
+    if (bit)
     {
         bit -= 1;
 
@@ -530,8 +531,8 @@ rt_uint32_t mmcsd_select_voltage(struct rt_mmcsd_host *host, rt_uint32_t ocr)
 
         host->io_cfg.vdd = bit;
         mmcsd_set_iocfg(host);
-    } 
-    else 
+    }
+    else
     {
         LOG_W("host doesn't support card's voltages!");
         ocr = 0;
@@ -549,7 +550,7 @@ static void mmcsd_power_up(struct rt_mmcsd_host *host)
     {
         host->io_cfg.chip_select = MMCSD_CS_HIGH;
         host->io_cfg.bus_mode = MMCSD_BUSMODE_PUSHPULL;
-    } 
+    }
     else
     {
         host->io_cfg.chip_select = MMCSD_CS_IGNORE;
@@ -580,7 +581,7 @@ static void mmcsd_power_off(struct rt_mmcsd_host *host)
 {
     host->io_cfg.clock = 0;
     host->io_cfg.vdd = 0;
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         host->io_cfg.bus_mode = MMCSD_BUSMODE_OPENDRAIN;
         host->io_cfg.chip_select = MMCSD_CS_IGNORE;
@@ -619,7 +620,7 @@ void mmcsd_detect(void *param)
     rt_uint32_t  ocr;
     rt_int32_t  err;
 
-    while (1) 
+    while (1)
     {
         if (rt_mb_recv(&mmcsd_detect_mb, (rt_ubase_t *)&host, RT_WAITING_FOREVER) == RT_EOK)
         {
@@ -644,7 +645,7 @@ void mmcsd_detect(void *param)
                  * detect SD card
                  */
                 err = mmcsd_send_app_op_cond(host, 0, &ocr);
-                if (!err) 
+                if (!err)
                 {
                     if (init_sd(host, ocr))
                         mmcsd_power_off(host);
@@ -652,12 +653,12 @@ void mmcsd_detect(void *param)
                     rt_mb_send(&mmcsd_hotpluge_mb, (rt_ubase_t)host);
                     continue;
                 }
-                
+
                 /*
                  * detect mmc card
                  */
                 err = mmc_send_op_cond(host, 0, &ocr);
-                if (!err) 
+                if (!err)
                 {
                     if (init_mmc(host, ocr))
                         mmcsd_power_off(host);
@@ -669,21 +670,21 @@ void mmcsd_detect(void *param)
             }
             else
             {
-            	/* card removed */
-            	mmcsd_host_lock(host);
-            	if (host->card->sdio_function_num != 0)
-            	{
-            		LOG_W("unsupport sdio card plug out!");
-            	}
-            	else
-            	{
-            		rt_mmcsd_blk_remove(host->card);
-            		rt_free(host->card);
-
-            		host->card = RT_NULL;
-            	}
-            	mmcsd_host_unlock(host);
-            	rt_mb_send(&mmcsd_hotpluge_mb, (rt_ubase_t)host);
+                /* card removed */
+                mmcsd_host_lock(host);
+                if (host->card->sdio_function_num != 0)
+                {
+                    LOG_W("unsupport sdio card plug out!");
+                }
+                else
+                {
+                    rt_mmcsd_blk_remove(host->card);
+                    rt_free(host->card);
+
+                    host->card = RT_NULL;
+                }
+                mmcsd_host_unlock(host);
+                rt_mb_send(&mmcsd_hotpluge_mb, (rt_ubase_t)host);
             }
         }
     }
@@ -694,7 +695,7 @@ struct rt_mmcsd_host *mmcsd_alloc_host(void)
     struct rt_mmcsd_host *host;
 
     host = rt_malloc(sizeof(struct rt_mmcsd_host));
-    if (!host) 
+    if (!host)
     {
         LOG_E("alloc host failed");
 
@@ -702,7 +703,7 @@ struct rt_mmcsd_host *mmcsd_alloc_host(void)
     }
 
     rt_memset(host, 0, sizeof(struct rt_mmcsd_host));
-
+    strncpy(host->name, "sd", sizeof(host->name)-1);
     host->max_seg_size = 65535;
     host->max_dma_segs = 1;
     host->max_blk_size = 512;
@@ -736,16 +737,16 @@ int rt_mmcsd_core_init(void)
         &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, 
+     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) 
+    if (ret == RT_EOK)
     {
         rt_thread_startup(&mmcsd_detect_thread);
     }
 
     rt_sdio_init();
 
-	return 0;
+    return 0;
 }
 INIT_PREV_EXPORT(rt_mmcsd_core_init);