Linux设备驱动程序架构分析之MMC/SD（一）

作者：刘昊昱 

博客：http://blog.csdn.net/liuhaoyutz

内核版本：3.10.1

MMC

MMC全称MultiMedia Card，由西门子公司和SanDisk公司1997年推出的多媒体记忆卡标准。MMC卡尺寸为32mm x24mm x 1.4mm，它将存贮单元和控制器一同做到了卡上，智能的控制器使得MMC保证兼容性和灵活性。

MMC卡具有MMC和SPI两种工作模式，MMC模式是默认工作模式，具有MMC的全部特性。而SPI模式则是MMC协议的一个子集，主要用于低速系统。

 

SD

SD卡全称Secure DigitalMemory Card，由松下、东芝和SanDisk公司于1999年8月共同开发的新一代记忆卡标准，已完全兼容MMC标准。SD卡比MMC卡多了一个进行数据著作权保护的暗号认证功能，读写速度比MMC卡快4倍。

SD卡尺寸为32mm x 24mm x2.1mm，长宽和MMC卡一样，只是比MMC卡厚了0.7mm，以容纳更大容量的存贮单元。SD卡与MMC卡保持向上兼容，也就是说，MMC卡可以被新的设有SD卡插槽的设备存取，但是SD卡却不可以被设有MMC插槽的设备存取。

 

SDIO

SDIO全称Secure DigitalInput and Output Card，SDIO是在SD标准上定义了一种外设接口，它使用SD的I/O接口来连接外围设备，并通过SD上的I/O数据接口与这些外围设备传输数据。现在已经有很多手持设备支持SDIO功能，而且许多SDIO外设也被开发出来，目前常见的SDIO外设有：WIFI Card、GPS Card、 Bluetooth Card等等。

 

eMMC

eMMC全称Embedded MultiMediaCard，是MMC协会所制定的内嵌式存储器标准规格，主要应用于智能手机和移动嵌入式产品等。eMMC是一种嵌入式非易失性存储系统，由闪存和闪存控制器两部分组成，它的一个明显优势是在封装中集成了一个闪存控制器，它采用JEDEC标准BGA封装，并采用统一闪存接口管理闪存。

eMMC结构由一个嵌入式存储解决方案组成，带有MMC接口、快闪存储设备及主控制器，所有这些由一个小型BGA封装。由于采用标准封装，eMMC也很容易升级，并不用改变硬件结构。

eMMC的这种将Nand Flash芯片和控制芯片封装在一起的设计概念，就是为了简化产品内存储器的使用，客户只需要采购eMMC芯片放进产品中，不需要处理其它复杂的Nand Flash兼容性和管理问题，减少研发成本和研发周期。

 

下面我们以Mini2440为例，分析其SDI驱动程序。

Mini2440 MMC/SD硬件接口电路原理图如下：

从Mini2440原理图可以看出，Mini2440 SDI使用的GPE7-GPE10作为4根数据信号线，使用GPE6作为命令信号线，使用GPE5作为时钟信号线。另外，使用GPG8的外部中断功能来作SD卡的插拨检测，使用GPH8来判断SD卡是否有写保护。

 

一、SDI设备的注册

先来看device注册过程，在arch/arm/mach-s3c24xx/mach-mini2440.c文件中，有如下内容：

505static struct platform_device*mini2440_devices[] __initdata = {
506   &s3c_device_ohci,
507   &s3c_device_wdt,
508   &s3c_device_i2c0,
509   &s3c_device_rtc,
510   &s3c_device_usbgadget,
511   &mini2440_device_eth,
512   &mini2440_led1,
513   &mini2440_led2,
514   &mini2440_led3,
515   &mini2440_led4,
516   &mini2440_button_device,
517   &s3c_device_nand,
518   &s3c_device_sdi,
519   &s3c_device_iis,
520   &uda1340_codec,
521   &mini2440_audio,
522};

这里定义了Mini2440所有的platform device，这里，我们要关注的是s3c_device_sdi，它是Mini2440的SDI控制器。

s3c_device_sdi定义在arch/arm/plat-samsung/devs.c文件中：

1172struct platform_device s3c_device_sdi ={
1173   .name       ="s3c2410-sdi",
1174   .id     = -1,
1175   .num_resources  =ARRAY_SIZE(s3c_sdi_resource),
1176   .resource   = s3c_sdi_resource,
1177};

回忆一下platform_device定义在include/linux/platform_device.h文件中：

 22structplatform_device {
 23   const char  *name;
 24   int     id;
 25   bool        id_auto;
 26   struct device   dev;
 27   u32     num_resources;
 28   struct resource *resource;
 29
 30   const struct platform_device_id *id_entry;
 31
 32    /*MFD cell pointer */
 33   struct mfd_cell *mfd_cell;
 34
 35    /*arch specific additions */
 36   struct pdev_archdata    archdata;
 37};

其中，s3c_sdi_resource定义在arch/arm/plat-samsung/devs.c文件中：

1167static struct resources3c_sdi_resource[] = {
1168   [0] = DEFINE_RES_MEM(S3C24XX_PA_SDI, S3C24XX_SZ_SDI),
1169   [1] = DEFINE_RES_IRQ(IRQ_SDI),
1170};

struct resource定义在include/linux/ioport.h文件中：

 14/*
 15 *Resources are tree-like, allowing
 16 *nesting etc..
 17*/
 18structresource {
 19   resource_size_t start;
 20   resource_size_t end;
 21   const char *name;
 22   unsigned long flags;
 23   struct resource *parent, *sibling, *child;
 24};

宏DEFINE_RES_MEM定义在include/linux/ioport.h文件中：

124#define DEFINE_RES_MEM(_start,_size)                   \
125   DEFINE_RES_MEM_NAMED((_start), (_size), NULL)
……
122#define DEFINE_RES_MEM_NAMED(_start,_size, _name)          \
123   DEFINE_RES_NAMED((_start), (_size), (_name), IORESOURCE_MEM)
……
109#define DEFINE_RES_NAMED(_start, _size,_name, _flags)          \
110   {                               \
111       .start = (_start),                 \
112       .end = (_start) + (_size) - 1,              \
113       .name = (_name),                   \
114       .flags = (_flags),                 \
115   }

宏DEFINE_RES_IRQ宏定义在include/linux/ioport.h文件中：

129#define DEFINE_RES_IRQ(_irq)                        \
130   DEFINE_RES_IRQ_NAMED((_irq), NULL)
……
127#define DEFINE_RES_IRQ_NAMED(_irq,_name)               \
128   DEFINE_RES_NAMED((_irq), 1, (_name), IORESOURCE_IRQ)
……
109#define DEFINE_RES_NAMED(_start, _size,_name, _flags)          \
110   {                               \
111       .start = (_start),                 \
112       .end = (_start) + (_size) - 1,              \
113       .name = (_name),                   \
114       .flags = (_flags),                  \
115   }

宏S3C24XX_PA_SDI定义在arch/arm/mach-s3c24xx/include/mach/map.h文件中：

155#define S3C24XX_PA_SDI      S3C2410_PA_SDI

宏S3C2410_PA_SDI定义在arch/arm/mach-s3c24xx/include/mach/map.h文件中：

105#define S3C2410_PA_SDI     (0x5A000000)

0x5A000000是S3C2440 SDICON寄存器的地址。

宏S3C24XX_SZ_SDI定义在arch/arm/mach-s3c24xx/include/mach/map.h文件中：

61#define S3C24XX_SZ_SDI      SZ_1M

宏SZ_1M定义在include/linux/sizes.h文件中：

33#define SZ_1M               0x00100000

宏IRQ_SDI定义在arch/arm/mach-s3c24xx/include/mach/irqs.h文件中：

48#define IRQ_SDI        S3C2410_IRQ(21)
……
23#define S3C2410_IRQ(x) ((x) +S3C2410_CPUIRQ_OFFSET)
……
21#define S3C2410_CPUIRQ_OFFSET    (16)

至此，我们知道了Mini2440的platform_device s3c_device_sdi的定义，下面就是要注册这个平台设备，在arch/arm/mach-s3c24xx/mach-mini2440.c文件中：

622static void __init mini2440_init(void)
{
          ……
678  platform_add_devices(mini2440_devices,ARRAY_SIZE(mini2440_devices));
          ……
}

platform_add_devices定义在drivers/base/platform.c文件中：

139/**
 140* platform_add_devices - add a numbers of platform devices
 141* @devs: array of platform devices to add
 142* @num: number of platform devices in array
 143*/
 144int platform_add_devices(structplatform_device **devs, int num)
 145{
 146   int i, ret = 0;
 147
 148   for (i = 0; i < num; i++) {
 149       ret = platform_device_register(devs[i]);
 150       if (ret) {
 151           while (--i >= 0)
 152               platform_device_unregister(devs[i]);
 153           break;
 154       }
 155    }
 156
 157   return ret;
 158}

149行，通过调用platform_device_register完成对平台设备的注册，其中包括s3c_device_sdi。

 

二、SDI驱动分析

Mini2440的SDI驱动定义在drivers/mmc/host/s3cmci.c文件中：

1980static struct platform_drivers3cmci_driver = {
1981   .driver = {
1982       .name   = "s3c-sdi",
1983       .owner  = THIS_MODULE,
1984       .pm = s3cmci_pm_ops,
1985   },
1986   .id_table   = s3cmci_driver_ids,
1987   .probe      = s3cmci_probe,
1988   .remove     = s3cmci_remove,
1989   .shutdown   = s3cmci_shutdown,
1990};

s3cmci_driver_ids定义在drivers/mmc/host/s3cmci.c文件中：

1936static struct platform_device_ids3cmci_driver_ids[] = {
1937   {
1938       .name   = "s3c2410-sdi",
1939       .driver_data    = 0,
1940   }, {
1941       .name   = "s3c2412-sdi",
1942       .driver_data    = 1,
1943   }, {
1944       .name   = "s3c2440-sdi",
1945       .driver_data    = 1,
1946   },
1947   { }
1948};

我们来看platform_driver s3cmci_driver 的注册，在drivers/mmc/host/s3cmci.c文件中：

1992module_platform_driver(s3cmci_driver);

module_platform_driver是一个宏，定义在include/linux/platform_device.h文件中：

203/* module_platform_driver() - Helpermacro for drivers that don't do
204 * anything special in moduleinit/exit.  This eliminates a lot of
205 * boilerplate.  Each module may only use this macro once, and
206 * calling it replaces module_init() andmodule_exit()
207 */
208#definemodule_platform_driver(__platform_driver) \
209   module_driver(__platform_driver, platform_driver_register, \
210            platform_driver_unregister)

宏module_driver定义在include/linux/device.h文件中，其内容如下：

1108/**
1109 * module_driver() - Helper macro fordrivers that don't do anything
1110 * special in module init/exit. Thiseliminates a lot of boilerplate.
1111 * Each module may only use this macroonce, and calling it replaces
1112 * module_init() and module_exit().
1113 *
1114 * @__driver: driver name
1115 * @__register: register function forthis driver type
1116 * @__unregister: unregister functionfor this driver type
1117 * @...: Additional arguments to bepassed to __register and __unregister.
1118 *
1119 * Use this macro to construct busspecific macros for registering
1120 * drivers, and do not use it on itsown.
1121 */
1122#define module_driver(__driver,__register, __unregister, ...) \
1123static int __init __driver##_init(void)\
1124{ \
1125   return __register(&(__driver) , ##__VA_ARGS__); \
1126} \
1127module_init(__driver##_init); \
1128static void __exit__driver##_exit(void) \
1129{ \
1130    __unregister(&(__driver) ,##__VA_ARGS__); \
1131} \
1132module_exit(__driver##_exit);

我们知道，注册s3cmci_driver的过程中，会触发s3cmci_probe函数的执行，所以先来看s3cmci_probe函数，它定义在drivers/mmc/host/s3cmci.c文件中，其内容如下：

1622static int s3cmci_probe(structplatform_device *pdev)
1623{
1624   struct s3cmci_host *host;
1625   struct mmc_host *mmc;
1626   int ret;
1627   int is2440;
1628   int i;
1629
1630   is2440 = platform_get_device_id(pdev)->driver_data;
1631
1632   mmc = mmc_alloc_host(sizeof(struct s3cmci_host), &pdev->dev);
1633   if (!mmc) {
1634       ret = -ENOMEM;
1635       goto probe_out;
1636   }
1637
1638   for (i = S3C2410_GPE(5); i <= S3C2410_GPE(10); i++) {
1639       ret = gpio_request(i, dev_name(&pdev->dev));
1640       if (ret) {
1641            dev_err(&pdev->dev,"failed to get gpio %d\n", i);
1642
1643            for (i--; i >= S3C2410_GPE(5);i--)
1644                gpio_free(i);
1645
1646            goto probe_free_host;
1647       }
1648   }
1649
1650   host = mmc_priv(mmc);
1651   host->mmc   = mmc;
1652   host->pdev  = pdev;
1653   host->is2440    = is2440;
1654
1655   host->pdata = pdev->dev.platform_data;
1656   if (!host->pdata) {
1657       pdev->dev.platform_data = &s3cmci_def_pdata;
1658       host->pdata = &s3cmci_def_pdata;
1659   }
1660
1661   spin_lock_init(&host->complete_lock);
1662   tasklet_init(&host->pio_tasklet, pio_tasklet, (unsigned long)host);
1663
1664   if (is2440) {
1665       host->sdiimsk   =S3C2440_SDIIMSK;
1666       host->sdidata   =S3C2440_SDIDATA;
1667       host->clk_div   = 1;
1668   } else {
1669       host->sdiimsk   =S3C2410_SDIIMSK;
1670       host->sdidata   =S3C2410_SDIDATA;
1671       host->clk_div   = 2;
1672   }
1673
1674   host->complete_what     =COMPLETION_NONE;
1675   host->pio_active    =XFER_NONE;
1676
1677#ifdef CONFIG_MMC_S3C_PIODMA
1678   host->dodma     =host->pdata->use_dma;
1679#endif
1680
1681   host->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1682   if (!host->mem) {
1683       dev_err(&pdev->dev,
1684           "failed to get io memoryregion resource.\n");
1685
1686       ret = -ENOENT;
1687       goto probe_free_gpio;
1688   }
1689
1690   host->mem = request_mem_region(host->mem->start,
1691                      resource_size(host->mem), pdev->name);
1692
1693   if (!host->mem) {
1694       dev_err(&pdev->dev, "failed to request io memoryregion.\n");
1695       ret = -ENOENT;
1696       goto probe_free_gpio;
1697   }
1698
1699   host->base = ioremap(host->mem->start,resource_size(host->mem));
1700   if (!host->base) {
1701       dev_err(&pdev->dev, "failed to ioremap() io memoryregion.\n");
1702       ret = -EINVAL;
1703       goto probe_free_mem_region;
1704   }
1705
1706   host->irq = platform_get_irq(pdev, 0);
1707   if (host->irq == 0) {
1708       dev_err(&pdev->dev, "failed to get interruptresource.\n");
1709       ret = -EINVAL;
1710       goto probe_iounmap;
1711   }
1712
1713   if (request_irq(host->irq, s3cmci_irq, 0, DRIVER_NAME, host)) {
1714       dev_err(&pdev->dev, "failed to request mciinterrupt.\n");
1715       ret = -ENOENT;
1716       goto probe_iounmap;
1717   }
1718
1719   /* We get spurious interrupts even when we have set the IMSK
1720    * register to ignore everything, so use disable_irq() to make
1721    * ensure we don't lock the system with un-serviceable requests. */
1722
1723   disable_irq(host->irq);
1724   host->irq_state = false;
1725
1726   if (!host->pdata->no_detect) {
1727       ret = gpio_request(host->pdata->gpio_detect, "s3cmcidetect");
1728       if (ret) {
1729            dev_err(&pdev->dev,"failed to get detect gpio\n");
1730            goto probe_free_irq;
1731       }
1732
1733       host->irq_cd = gpio_to_irq(host->pdata->gpio_detect);
1734
1735       if (host->irq_cd >= 0) {
1736            if (request_irq(host->irq_cd,s3cmci_irq_cd,
1737                    IRQF_TRIGGER_RISING |
1738                    IRQF_TRIGGER_FALLING,
1739                    DRIVER_NAME, host)) {
1740                dev_err(&pdev->dev,
1741                    "can't get card detectirq.\n");
1742                ret = -ENOENT;
1743                goto probe_free_gpio_cd;
1744            }
1745       } else {
1746            dev_warn(&pdev->dev,
1747                 "host detect has no irqavailable\n");
1748           gpio_direction_input(host->pdata->gpio_detect);
1749       }
1750   } else
1751       host->irq_cd = -1;
1752
1753   if (!host->pdata->no_wprotect) {
1754       ret = gpio_request(host->pdata->gpio_wprotect, "s3cmciwp");
1755       if (ret) {
1756            dev_err(&pdev->dev,"failed to get writeprotect\n");
1757            goto probe_free_irq_cd;
1758       }
1759
1760       gpio_direction_input(host->pdata->gpio_wprotect);
1761   }
1762
1763   /* depending on the dma state, get a dma channel to use. */
1764
1765   if (s3cmci_host_usedma(host)) {
1766       host->dma = s3c2410_dma_request(DMACH_SDI, &s3cmci_dma_client,
1767                        host);
1768       if (host->dma < 0) {
1769            dev_err(&pdev->dev,"cannot get DMA channel.\n");
1770            if (!s3cmci_host_canpio()) {
1771                ret = -EBUSY;
1772                goto probe_free_gpio_wp;
1773            } else {
1774                dev_warn(&pdev->dev,"falling back to PIO.\n");
1775                host->dodma = 0;
1776            }
1777       }
1778   }
1779
1780   host->clk = clk_get(&pdev->dev, "sdi");
1781   if (IS_ERR(host->clk)) {
1782       dev_err(&pdev->dev, "failed to find clock source.\n");
1783       ret = PTR_ERR(host->clk);
1784       host->clk = NULL;
1785       goto probe_free_dma;
1786   }
1787
1788   ret = clk_enable(host->clk);
1789   if (ret) {
1790       dev_err(&pdev->dev, "failed to enable clocksource.\n");
1791       goto clk_free;
1792   }
1793
1794   host->clk_rate = clk_get_rate(host->clk);
1795
1796   mmc->ops    = &s3cmci_ops;
1797   mmc->ocr_avail  = MMC_VDD_32_33| MMC_VDD_33_34;
1798#ifdef CONFIG_MMC_S3C_HW_SDIO_IRQ
1799   mmc->caps   =MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
1800#else
1801   mmc->caps   =MMC_CAP_4_BIT_DATA;
1802#endif
1803   mmc->f_min  = host->clk_rate/ (host->clk_div * 256);
1804   mmc->f_max  = host->clk_rate/ host->clk_div;
1805
1806   if (host->pdata->ocr_avail)
1807       mmc->ocr_avail = host->pdata->ocr_avail;
1808
1809   mmc->max_blk_count  = 4095;
1810   mmc->max_blk_size   = 4095;
1811   mmc->max_req_size   = 4095 *512;
1812   mmc->max_seg_size   =mmc->max_req_size;
1813
1814   mmc->max_segs       = 128;
1815
1816   dbg(host, dbg_debug,
1817       "probe: mode:%s mapped mci_base:%p irq:%u irq_cd:%udma:%u.\n",
1818       (host->is2440?"2440":""),
1819       host->base, host->irq, host->irq_cd, host->dma);
1820
1821   ret = s3cmci_cpufreq_register(host);
1822   if (ret) {
1823       dev_err(&pdev->dev, "failed to register cpufreq\n");
1824       goto free_dmabuf;
1825   }
1826
1827   ret = mmc_add_host(mmc);
1828   if (ret) {
1829       dev_err(&pdev->dev, "failed to add mmc host.\n");
1830       goto free_cpufreq;
1831   }
1832
1833   s3cmci_debugfs_attach(host);
1834
1835   platform_set_drvdata(pdev, mmc);
1836   dev_info(&pdev->dev, "%s - using %s, %s SDIO IRQ\n",mmc_hostname(mmc),
1837        s3cmci_host_usedma(host) ? "dma" : "pio",
1838        mmc->caps & MMC_CAP_SDIO_IRQ ? "hw" : "sw");
1839
1840   return 0;
1841
1842 free_cpufreq:
1843   s3cmci_cpufreq_deregister(host);
1844
1845 free_dmabuf:
1846   clk_disable(host->clk);
1847
1848 clk_free:
1849   clk_put(host->clk);
1850
1851 probe_free_dma:
1852   if (s3cmci_host_usedma(host))
1853       s3c2410_dma_free(host->dma, &s3cmci_dma_client);
1854
1855 probe_free_gpio_wp:
1856   if (!host->pdata->no_wprotect)
1857       gpio_free(host->pdata->gpio_wprotect);
1858
1859 probe_free_gpio_cd:
1860   if (!host->pdata->no_detect)
1861       gpio_free(host->pdata->gpio_detect);
1862
1863 probe_free_irq_cd:
1864   if (host->irq_cd >= 0)
1865       free_irq(host->irq_cd, host);
1866
1867 probe_free_irq:
1868   free_irq(host->irq, host);
1869
1870 probe_iounmap:
1871   iounmap(host->base);
1872
1873 probe_free_mem_region:
1874   release_mem_region(host->mem->start, resource_size(host->mem));
1875
1876 probe_free_gpio:
1877   for (i = S3C2410_GPE(5); i <= S3C2410_GPE(10); i++)
1878       gpio_free(i);
1879
1880 probe_free_host:
1881   mmc_free_host(mmc);
1882
1883 probe_out:
1884   return ret;
1885}

1624行，定义structs3cmci_host指针变量host，struct s3cmci_host定义在drivers/mmc/host/s3cmci.h文件中，其内容如下：

20struct s3cmci_host {
21   struct platform_device  *pdev;
22   struct s3c24xx_mci_pdata *pdata;
23   struct mmc_host     *mmc;
24   struct resource     *mem;
25   struct clk      *clk;
26   void __iomem        *base;
27   int         irq;
28   int         irq_cd;
29   int         dma;
30
31   unsigned long       clk_rate;
32   unsigned long       clk_div;
33   unsigned long       real_rate;
34   u8          prescaler;
35
36   int         is2440;
37   unsigned        sdiimsk;
38   unsigned        sdidata;
39   int         dodma;
40   int         dmatogo;
41
42   bool            irq_disabled;
43   bool            irq_enabled;
44   bool            irq_state;
45   int         sdio_irqen;
46
47   struct mmc_request  *mrq;
48   int         cmd_is_stop;
49
50   spinlock_t      complete_lock;
51   enum s3cmci_waitfor complete_what;
52
53   int         dma_complete;
54
55   u32         pio_sgptr;
56   u32         pio_bytes;
57   u32         pio_count;
58   u32         *pio_ptr;
59#define XFER_NONE 0
60#define XFER_READ 1
61#define XFER_WRITE 2
62   u32         pio_active;
63
64   int         bus_width;
65
66   char            dbgmsg_cmd[301];
67   char            dbgmsg_dat[301];
68   char            *status;
69
70   unsigned int        ccnt, dcnt;
71   struct tasklet_struct  pio_tasklet;
72
73#ifdef CONFIG_DEBUG_FS
74   struct dentry       *debug_root;
75   struct dentry       *debug_state;
76   struct dentry       *debug_regs;
77#endif
78
79#ifdef CONFIG_CPU_FREQ
80   struct notifier_block  freq_transition;
81#endif
82};

可以看到，struct s3cmci_host描述了整个SDI控制器。

1625行，定义了struct mmc_host指针变量mmc，structmmc_host定义在include/linux/mmc/host.h文件中，其内容如下：

198struct mmc_host {
199   struct device       *parent;
200   struct device       class_dev;
201   int         index;
202   const struct mmc_host_ops *ops;
203   unsigned int        f_min;
204   unsigned int        f_max;
205   unsigned int        f_init;
206   u32         ocr_avail;
207   u32         ocr_avail_sdio; /*SDIO-specific OCR */
208   u32         ocr_avail_sd;   /* SD-specific OCR */
209   u32         ocr_avail_mmc;  /* MMC-specific OCR */
210   struct notifier_block   pm_notify;
211   u32         max_current_330;
212   u32         max_current_300;
213   u32         max_current_180;
214
215#define MMC_VDD_165_195     0x00000080 /* VDD voltage 1.65 - 1.95 */
216#define MMC_VDD_20_21       0x00000100  /* VDD voltage 2.0 ~ 2.1 */
217#define MMC_VDD_21_22       0x00000200  /* VDD voltage 2.1 ~ 2.2 */
218#define MMC_VDD_22_23       0x00000400  /* VDD voltage 2.2 ~ 2.3 */
219#define MMC_VDD_23_24       0x00000800  /* VDD voltage 2.3 ~ 2.4 */
220#define MMC_VDD_24_25       0x00001000  /* VDD voltage 2.4 ~ 2.5 */
221#define MMC_VDD_25_26       0x00002000  /* VDD voltage 2.5 ~ 2.6 */
222#define MMC_VDD_26_27       0x00004000  /* VDD voltage 2.6 ~ 2.7 */
223#define MMC_VDD_27_28       0x00008000  /* VDD voltage 2.7 ~ 2.8 */
224#define MMC_VDD_28_29       0x00010000  /* VDD voltage 2.8 ~ 2.9 */
225#define MMC_VDD_29_30       0x00020000  /* VDD voltage 2.9 ~ 3.0 */
226#define MMC_VDD_30_31       0x00040000  /* VDD voltage 3.0 ~ 3.1 */
227#define MMC_VDD_31_32       0x00080000  /* VDD voltage 3.1 ~ 3.2 */
228#define MMC_VDD_32_33       0x00100000  /* VDD voltage 3.2 ~ 3.3 */
229#define MMC_VDD_33_34       0x00200000  /* VDD voltage 3.3 ~ 3.4 */
230#define MMC_VDD_34_35       0x00400000  /* VDD voltage 3.4 ~ 3.5 */
231#define MMC_VDD_35_36       0x00800000  /* VDD voltage 3.5 ~ 3.6 */
232
233   u32         caps;       /* Host capabilities */
234
235#define MMC_CAP_4_BIT_DATA  (1 << 0)    /* Can the host do 4 bit transfers */
236#define MMC_CAP_MMC_HIGHSPEED   (1 << 1)    /* Can do MMC high-speed timing */
237#define MMC_CAP_SD_HIGHSPEED    (1 << 2)    /*Can do SD high-speed timing */
238#define MMC_CAP_SDIO_IRQ    (1 << 3)    /* Can signal pending SDIO IRQs */
239#define MMC_CAP_SPI     (1 << 4)    /* Talks only SPI protocols */
240#define MMC_CAP_NEEDS_POLL  (1 << 5)    /* Needs polling for card-detection */
241#define MMC_CAP_8_BIT_DATA  (1 << 6)    /* Can the host do 8 bit transfers */
242
243#define MMC_CAP_NONREMOVABLE    (1 << 8)    /* Nonremovable e.g. eMMC */
244#define MMC_CAP_WAIT_WHILE_BUSY (1<< 9)    /* Waits while card isbusy */
245#define MMC_CAP_ERASE       (1 << 10)   /* Allow erase/trim commands */
246#define MMC_CAP_1_8V_DDR    (1 << 11)   /* can support */
247                        /* DDR mode at 1.8V */
248#define MMC_CAP_1_2V_DDR    (1 << 12)   /* can support */
249                        /* DDR mode at 1.2V */
250#define MMC_CAP_POWER_OFF_CARD  (1 << 13)   /* Can power off after boot */
251#define MMC_CAP_BUS_WIDTH_TEST  (1 << 14)   /* CMD14/CMD19 bus width ok */
252#define MMC_CAP_UHS_SDR12   (1 << 15)   /* Host supports UHS SDR12 mode */
253#define MMC_CAP_UHS_SDR25   (1 << 16)   /* Host supports UHS SDR25 mode */
254#define MMC_CAP_UHS_SDR50   (1 << 17)   /* Host supports UHS SDR50 mode */
255#define MMC_CAP_UHS_SDR104  (1 << 18)   /* Host supports UHS SDR104 mode */
256#define MMC_CAP_UHS_DDR50   (1 << 19)   /* Host supports UHS DDR50 mode */
257#define MMC_CAP_DRIVER_TYPE_A   (1 << 23)   /* Host supports Driver Type A */
258#define MMC_CAP_DRIVER_TYPE_C   (1 << 24)   /* Host supports Driver Type C */
259#define MMC_CAP_DRIVER_TYPE_D   (1 << 25)   /* Host supports Driver Type D */
260#define MMC_CAP_CMD23       (1 << 30)   /* CMD23 supported. */
261#define MMC_CAP_HW_RESET    (1 << 31)   /* Hardware reset */
262
263   u32         caps2;      /* More host capabilities */
264
265#define MMC_CAP2_BOOTPART_NOACC (1<< 0)    /* Boot partition noaccess */
266#define MMC_CAP2_CACHE_CTRL (1 <<1)    /* Allow cache control */
267#define MMC_CAP2_POWEROFF_NOTIFY (1<< 2)   /* Notify poweroffsupported */
268#define MMC_CAP2_NO_MULTI_READ  (1 << 3)    /* Multiblock reads don't work */
269#define MMC_CAP2_NO_SLEEP_CMD   (1 << 4)    /* Don't allow sleep command */
270#define MMC_CAP2_HS200_1_8V_SDR (1<< 5)        /* can support */
271#define MMC_CAP2_HS200_1_2V_SDR (1<< 6)        /* can support */
272#define MMC_CAP2_HS200      (MMC_CAP2_HS200_1_8V_SDR | \
273                 MMC_CAP2_HS200_1_2V_SDR)
274#define MMC_CAP2_BROKEN_VOLTAGE (1<< 7)    /* Use the broken voltage*/
275#define MMC_CAP2_DETECT_ON_ERR  (1 << 8)    /* On I/O err check card removal */
276#define MMC_CAP2_HC_ERASE_SZ    (1 << 9)    /* High-capacity erase size */
277#define MMC_CAP2_CD_ACTIVE_HIGH (1<< 10)   /* Card-detect signalactive high */
278#define MMC_CAP2_RO_ACTIVE_HIGH (1<< 11)   /* Write-protect signalactive high */
279#define MMC_CAP2_PACKED_RD  (1 << 12)   /* Allow packed read */
280#define MMC_CAP2_PACKED_WR  (1 << 13)   /* Allow packed write */
281#define MMC_CAP2_PACKED_CMD(MMC_CAP2_PACKED_RD | \
282                 MMC_CAP2_PACKED_WR)
283#define MMC_CAP2_NO_PRESCAN_POWERUP (1<< 14)   /* Don't power up beforescan */
284
285   mmc_pm_flag_t       pm_caps;    /* supported pm features */
286
287#ifdef CONFIG_MMC_CLKGATE
288   int         clk_requests;   /* internal reference counter */
289   unsigned int       clk_delay;  /* number of MCI clkhold cycles */
290   bool            clk_gated;  /* clock gated */
291   struct delayed_work clk_gate_work; /* delayed clock gate */
292   unsigned int        clk_old;    /* old clock value cache */
293   spinlock_t      clk_lock;   /* lock for clk fields */
294   struct mutex       clk_gate_mutex; /* mutex for clock gating */
295   struct device_attribute clkgate_delay_attr;
296   unsigned long          clkgate_delay;
297#endif
298
299   /* host specific block data */
300   unsigned int       max_seg_size;   /* seeblk_queue_max_segment_size */
301   unsigned short      max_segs;   /* see blk_queue_max_segments */
302   unsigned short      unused;
303   unsigned int        max_req_size;   /* maximum number of bytes in one req */
304   unsigned int       max_blk_size;   /* maximum size ofone mmc block */
305   unsigned int       max_blk_count;  /* maximum numberof blocks in one req */
306   unsigned int       max_discard_to; /* max. discard timeout in ms */
307
308   /* private data */
309   spinlock_t      lock;       /* lock for claim and bus ops */
310
311   struct mmc_ios      ios;        /* current io bus settings */
312   u32         ocr;        /* the current OCR setting */
313
314   /* group bitfields together to minimize padding */
315   unsigned int        use_spi_crc:1;
316   unsigned int       claimed:1;  /* host exclusivelyclaimed */
317   unsigned int        bus_dead:1; /* bus has been released */
318#ifdef CONFIG_MMC_DEBUG
319   unsigned int       removed:1;  /* host is beingremoved */
320#endif
321
322   int         rescan_disable; /*disable card detection */
323   int         rescan_entered; /* usedwith nonremovable devices */
324
325   struct mmc_card     *card;      /* device attached to this host */
326
327   wait_queue_head_t   wq;
328   struct task_struct  *claimer;   /* task that has host claimed */
329   int         claim_cnt;  /* "claim" nesting count */
330
331   struct delayed_work detect;
332   int         detect_change;  /* card detect flag */
333   struct mmc_slot     slot;
334
335   const struct mmc_bus_ops *bus_ops; /* current bus driver */
336   unsigned int        bus_refs;   /* reference counter */
337
338   unsigned int        sdio_irqs;
339   struct task_struct *sdio_irq_thread;
340   bool            sdio_irq_pending;
341   atomic_t       sdio_irq_thread_abort;
342
343   mmc_pm_flag_t       pm_flags;   /* requested pm features */
344
345   struct led_trigger  *led;       /* activity led */
346
347#ifdef CONFIG_REGULATOR
348   bool            regulator_enabled;/* regulator state */
349#endif
350   struct mmc_supply   supply;
351
352   struct dentry       *debugfs_root;
353
354   struct mmc_async_req   *areq;      /* active async req */
355   struct mmc_context_info context_info;  /* async synchronization info */
356
357#ifdef CONFIG_FAIL_MMC_REQUEST
358   struct fault_attr  fail_mmc_request;
359#endif
360
361   unsigned int       actual_clock;   /* Actual HC clockrate */
362
363   unsigned int        slotno; /*used for sdio acpi binding */
364
365   unsigned long       private[0]____cacheline_aligned;
366};

1630行，调用platform_get_device_id宏，取得处理器类型，该宏定义在include/linux/platform_device.h文件中：

39#define platform_get_device_id(pdev)    ((pdev)->id_entry)

但是，回忆一下我们注册的platform_device s3c_device_sdi，我们并没有初始化platform_device.id_entry成员，那么这里的platform_get_device_id宏返回值是NULL吗？如果不是NULL，应该是什么值呢？

答案是platform_get_device_id(pdev)->driver_data返回值为1。

原因是s3cmci_driver.id_table被设置为s3cmci_driver_ids。s3cmci_driver_ids定义在drivers/mmc/host/s3cmci.c文件中：

1936static struct platform_device_ids3cmci_driver_ids[] = {
1937   {
1938       .name   = "s3c2410-sdi",
1939       .driver_data    = 0,
1940   }, {
1941       .name   = "s3c2412-sdi",
1942       .driver_data    = 1,
1943   }, {
1944       .name   = "s3c2440-sdi",
1945       .driver_data    = 1,
1946   },
1947   { }
1948};

struct platform_device_id定义在include/linux/mod_devicetable.h文件中：

482struct platform_device_id {
483   char name[PLATFORM_NAME_SIZE];
484   kernel_ulong_t driver_data;
485};

platform_driver.id_table是platform_driver所支持的设备列表。可以看到，s3cmci_driver支持3种设备，分别是"s3c2410-sdi"、"s3c2412-sdi"和"s3c2440-sdi"。对于"s3c2410-sdi"，其driver_data成员值为0，对于其它两种设备，它们的driver_data成员值为1。

当调用platform_driver_register函数注册s3cmci_driver时，s3cmci_driver.driver.bus被设置为 platform_bus_type，structbus_type platform_bus_type定义在drivers/base/platform.c文件中：

 

895structbus_type platform_bus_type = {
 896    .name      = "platform",
 897   .dev_attrs  = platform_dev_attrs,
 898   .match      = platform_match,
 899   .uevent     = platform_uevent,
 900   .pm     =&platform_dev_pm_ops,
 901};

根据《Linux设备模型分析之device_driver（基于3.10.1内核）》一文对Linux设备模型的分析，在s3cmci_driver.probe函数被调用执行之前，platform_bus_type.match即platform_match首先会被调用执行。platform_match函数定义在drivers/base/platform.c文件中：

 710/**
 711* platform_match - bind platform device to platform driver.
 712* @dev: device.
 713* @drv: driver.
 714*
 715* Platform device IDs are assumed to be encoded like this:
 716* "<name><instance>", where <name> is a shortdescription of the type of
 717* device, like "pci" or "floppy", and <instance> isthe enumerated
 718* instance of the device, like '0' or '42'. Driver IDs are simply
 719* "<name>".  So, extractthe <name> from the platform_device structure,
 720* and compare it against the name of the driver. Return whether they match
 721* or not.
 722*/
 723static int platform_match(struct device*dev, struct device_driver *drv)
 724{
 725   struct platform_device *pdev = to_platform_device(dev);
 726   struct platform_driver *pdrv = to_platform_driver(drv);
 727
 728   /* Attempt an OF style match first */
 729   if (of_driver_match_device(dev, drv))
 730       return 1;
 731
 732   /* Then try ACPI style match */
 733   if (acpi_driver_match_device(dev, drv))
 734       return 1;
 735
 736   /* Then try to match against the id table */
 737   if (pdrv->id_table)
 738       return platform_match_id(pdrv->id_table, pdev) != NULL;
 739
 740   /* fall-back to driver name match */
 741   return (strcmp(pdev->name, drv->name) == 0);
 742}

737行，如果pdrv->id_table不为空，则调用platform_match_id函数。而我们的platform_drivers3cmci_driver.id_table被设置为s3cmci_driver_ids，所以platform_match_id函数会被执行。

platform_match_id函数定义在drivers/base/platform.c文件中：

 696staticconst struct platform_device_id *platform_match_id(
 697           const struct platform_device_id *id,
 698           struct platform_device *pdev)
 699{
 700   while (id->name[0]) {
 701        if (strcmp(pdev->name, id->name)== 0) {
 702           pdev->id_entry = id;
 703           return id;
 704       }
 705       id++;
 706    }
 707   return NULL;
 708}

可以看到，在701行，如果platform_device.name与platform_device_id.name相同，则将id赋值给pdev->id_entry。

回到我们的platform_driver s3cmci_driver和platform_device s3c_device_sdi，s3c_device_sdi.name被初始化为"s3c2410-sdi"，但是因为我们基于的平台是Mini2440，处理器是S3C2440，所以s3c244x_map_io函数会被调用，至于什么时候该函数会被调用我还没有搞清楚，呵呵！该函数定义在arch/arm/mach-s3c24xx/s3c244x.c文件中：

 63void__init s3c244x_map_io(void)
 64{
 65    /* register our io-tables */
 66
 67   iotable_init(s3c244x_iodesc, ARRAY_SIZE(s3c244x_iodesc));
 68
 69    /*rename any peripherals used differing from the s3c2410 */
 70
 71   s3c_device_sdi.name  ="s3c2440-sdi";
 72   s3c_device_i2c0.name  ="s3c2440-i2c";
 73   s3c_nand_setname("s3c2440-nand");
 74   s3c_device_ts.name = "s3c2440-ts";
 75   s3c_device_usbgadget.name = "s3c2440-usbgadget";
 76}

71行，将s3c_device_sdi.name设置为"s3c2440-sdi"

而s3cmci_driver.id_table被设置为s3cmci_driver_ids，s3cmci_driver_ids[2].name同样为"s3c2440-sdi"，所以，虽然s3c_device_sdi.id_entry在初始化时没有赋值，但是在platform_match_id函数中，它会被赋值为s3cmci_driver_ids[2]。

现在我们可以回到s3cmci_probe函数了：

1630行，经过前面的分析，我们知道platform_get_device_id(pdev)->driver_data的值其实就是s3cmci_driver_ids[2].driver_data，其值为1。所以，对于Mini2440平台，is2440变量被赋值为1。

1632行，调用mmc_alloc_host函数为struct mmc_host指针变量mmc分配内存空间并初始化。注意mmc_alloc_host的第一个参数表示除了mmc_host结构体外，还要额外多分配的内存空间大小，所以这里分配的内存大小是struct mmc_host加上struct s3cmci_host。

mmc_alloc_host函数定义在drivers/mmc/core/host.c文件中，其内容如下：

420/**
421 * mmc_alloc_host - initialise the per-host structure.
422 * @extra: sizeof private data structure
423 * @dev: pointer to host device model structure
424 *
425 * Initialise the per-host structure.
426 */
427struct mmc_host *mmc_alloc_host(intextra, struct device *dev)
428{
429   int err;
430   struct mmc_host *host;
431
432   host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
433   if (!host)
434       return NULL;
435
436   /* scanning will be enabled when we're ready */
437   host->rescan_disable = 1;
438   idr_preload(GFP_KERNEL);
439   spin_lock(&mmc_host_lock);
440   err = idr_alloc(&mmc_host_idr, host, 0, 0, GFP_NOWAIT);
441   if (err >= 0)
442       host->index = err;
443   spin_unlock(&mmc_host_lock);
444   idr_preload_end();
445   if (err < 0)
446       goto free;
447
448   dev_set_name(&host->class_dev, "mmc%d",host->index);
449
450   host->parent = dev;
451   host->class_dev.parent = dev;
452   host->class_dev.class = &mmc_host_class;
453   device_initialize(&host->class_dev);
454
455   mmc_host_clk_init(host);
456
457   mutex_init(&host->slot.lock);
458   host->slot.cd_irq = -EINVAL;
459
460   spin_lock_init(&host->lock);
461   init_waitqueue_head(&host->wq);
462   INIT_DELAYED_WORK(&host->detect, mmc_rescan);
463#ifdef CONFIG_PM
464   host->pm_notify.notifier_call = mmc_pm_notify;
465#endif
466
467   /*
468    * By default, hosts do not support SGIO or large requests.
469    * They have to set these according to their abilities.
470    */
471   host->max_segs = 1;
472   host->max_seg_size = PAGE_CACHE_SIZE;
473
474   host->max_req_size = PAGE_CACHE_SIZE;
475   host->max_blk_size = 512;
476   host->max_blk_count = PAGE_CACHE_SIZE / 512;
477
478   return host;
479
480free:
481   kfree(host);
482   return NULL;
483}

回到s3cmci_probe函数：

1638-1648行，通过gpio_request函数申请获取GPE5-GPE10。从Mini2440原理图可以看出，Mini2440SDI使用的GPE7-GPE10作为4根数据信号线，使用GPE6作为命令信号线，使用GPE5作为时钟信号线。另外，使用GPG8的外部中断功能来作SD卡的插拨检测，使用GPH8来判断SD卡是否有写保护。

1650行，通过调用mmc_priv(mmc)取得s3cmci_host指针变量host。

下面的内容就是初始化host的各个成员变量。

1681行，调用platform_get_resource(pdev,IORESOURCE_MEM, 0)取得IORESOURCE_MEM类型资源。IORESOURCE_MEM宏定义在include/linux/ioport.h文件中：

32#define IORESOURCE_IO       0x00000100  /* PCI/ISA I/O ports */
33#define IORESOURCE_MEM      0x00000200
34#define IORESOURCE_REG      0x00000300  /* Register offsets */
35#define IORESOURCE_IRQ      0x00000400
36#define IORESOURCE_DMA      0x00000800
37#define IORESOURCE_BUS      0x00001000

platform_get_resource函数定义在drivers/base/platform.c文件中：

  59/**
  60* platform_get_resource - get a resource for a device
  61* @dev: platform device
  62* @type: resource type
  63* @num: resource index
  64*/
 65struct resource *platform_get_resource(struct platform_device *dev,
 66                       unsigned int type, unsigned int num)
  67{
 68    int i;
  69
 70    for (i = 0; i <dev->num_resources; i++) {
 71        struct resource *r =&dev->resource[i];
  72
 73        if (type ==resource_type(r) && num-- == 0)
 74            return r;
 75    }
 76    return NULL;
  77}

resource_type定义在include/linux/ioport.h文件中：

168static inline unsigned longresource_type(const struct resource *res)
169{
170   return res->flags & IORESOURCE_TYPE_BITS;
171}

回忆一下，Mini2440的资源文件s3c_sdi_resource定义在arch/arm/plat-samsung/devs.c文件中：

1167static struct resources3c_sdi_resource[] = {
1168   [0] = DEFINE_RES_MEM(S3C24XX_PA_SDI, S3C24XX_SZ_SDI),
1169   [1] = DEFINE_RES_IRQ(IRQ_SDI),
1170};

宏S3C24XX_PA_SDI定义在arch/arm/mach-s3c24xx/include/mach/map.h文件中：

155#define S3C24XX_PA_SDI      S3C2410_PA_SDI

宏S3C2410_PA_SDI定义在arch/arm/mach-s3c24xx/include/mach/map.h文件中：

105#define S3C2410_PA_SDI     (0x5A000000)

0x5A000000是S3C2440 SDICON寄存器的地址。

宏S3C24XX_SZ_SDI定义在arch/arm/mach-s3c24xx/include/mach/map.h文件中：

61#define S3C24XX_SZ_SDI      SZ_1M

宏SZ_1M定义在include/linux/sizes.h文件中：

33#define SZ_1M               0x00100000

所以s3cmci_probe函数1681行，platform_get_resource(pdev, IORESOURCE_MEM, 0)函数返回的就是s3c_sdi_resource[0]。

1690-1691行，调用request_mem_region(host->mem->start,resource_size(host->mem), pdev->name)函数，该函数用于获取参数指定的内存空间。request_mem_region函数定义在include/linux/ioport.h文件中：

177#define request_mem_region(start,n,name)__request_region(&iomem_resource, (start), (n), (name), 0)

__request_region定义在kernel/resource.c文件中：

 931/**
 932* __request_region - create a new busy resource region
 933* @parent: parent resource descriptor
 934* @start: resource start address
 935* @n: resource region size
 936* @name: reserving caller's ID string
 937* @flags: IO resource flags
 938*/
 939struct resource * __request_region(structresource *parent,
 940                   resource_size_t start,resource_size_t n,
 941                   const char *name, int flags)
 942{
 943   DECLARE_WAITQUEUE(wait, current);
 944   struct resource *res = alloc_resource(GFP_KERNEL);
 945
 946   if (!res)
 947       return NULL;
 948
 949   res->name = name;
 950   res->start = start;
 951   res->end = start + n - 1;
 952   res->flags = IORESOURCE_BUSY;
 953   res->flags |= flags;
 954
 955   write_lock(&resource_lock);
 956
 957   for (;;) {
 958       struct resource *conflict;
 959
 960       conflict = __request_resource(parent, res);
 961       if (!conflict)
 962           break;
 963       if (conflict != parent) {
 964            parent = conflict;
 965           if (!(conflict->flags &IORESOURCE_BUSY))
 966                continue;
 967       }
 968       if (conflict->flags & flags & IORESOURCE_MUXED) {
 969           add_wait_queue(&muxed_resource_wait, &wait);
 970           write_unlock(&resource_lock);
 971           set_current_state(TASK_UNINTERRUPTIBLE);
 972           schedule();
 973           remove_wait_queue(&muxed_resource_wait, &wait);
 974           write_lock(&resource_lock);
 975           continue;
 976       }
 977       /* Uhhuh, that didn't work out.. */
 978       free_resource(res);
 979       res = NULL;
 980       break;
 981    }
 982   write_unlock(&resource_lock);
 983   return res;
 984}

1699行，调用ioremap(host->mem->start,resource_size(host->mem))宏，该宏完成物理内存到虚拟内存的映射。ioremap宏定义在arch/arm/include/asm/io.h文件中：

328#define ioremap(cookie,size)        __arm_ioremap((cookie), (size),MT_DEVICE)

__arm_ioremap函数定义在arch/arm/mm/ioremap.c文件中：

374void __iomem *
375__arm_ioremap(unsigned long phys_addr,size_t size, unsigned int mtype)
376{
377   return arch_ioremap_caller(phys_addr, size, mtype,
378       __builtin_return_address(0));
379}

1706行，调用platform_get_irq函数获取设备中断。platform_get_irq函数定义在drivers/base/platform.c文件中：

 

80/**
  81* platform_get_irq - get an IRQ for a device
  82* @dev: platform device
  83* @num: IRQ number index
  84*/
 85int platform_get_irq(struct platform_device *dev, unsigned int num)
  86{
 87#ifdef CONFIG_SPARC
 88    /* sparc does not have irqsrepresented as IORESOURCE_IRQ resources */
 89    if (!dev || num >=dev->archdata.num_irqs)
 90        return -ENXIO;
 91    returndev->archdata.irqs[num];
 92#else
 93    struct resource *r =platform_get_resource(dev, IORESOURCE_IRQ, num);
  94
 95    return r ? r->start :-ENXIO;
 96#endif
  97}

1713行，调用request_irq(host->irq,s3cmci_irq, 0, DRIVER_NAME, host)申请中断，中断处理函数是s3cmci_irq。

1723行，调用disable_irq禁用中断。

1726-1751行，处理SD卡探测相关内容。

1753-1761行，处理SD卡写保护相关内容。

1765-1778行，处理DMA相关内容。

1780-1794行，处理时钟相关内容。

1796-1814行，初始化mmc。

需要注意的是1796行，设置mmc->ops为s3cmci_ops，s3cmci_ops定义在drivers/mmc/host/s3cmci.c文件中：

1427static struct mmc_host_ops s3cmci_ops ={
1428   .request    = s3cmci_request,
1429   .set_ios    = s3cmci_set_ios,
1430   .get_ro     = s3cmci_get_ro,
1431   .get_cd     = s3cmci_card_present,
1432   .enable_sdio_irq = s3cmci_enable_sdio_irq,
1433};

1821行，调用s3cmci_cpufreq_register(host)，提供对变频的支持。

1827行，调用mmc_add_host(mmc)，向core层注册mmc_host。

1833行，调用s3cmci_debugfs_attach(host)创建debugfs相关节点。

至此，s3cmci_probe函数我们就分析完了。