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

本文主要是介绍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卡全称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文件中，有如下内容：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 155#define S3C24XX_PA_SDI      S3C2410_PA_SDI  

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

[cpp]  view plain copy  
 105#define S3C2410_PA_SDI     (0x5A000000)  

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

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

[cpp]  view plain copy  
 61#define S3C24XX_SZ_SDI      SZ_1M  

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

[cpp]  view plain copy  
 33#define SZ_1M               0x00100000  

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

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 622static void __init mini2440_init(void)  
 {  
           ……  
 678  platform_add_devices(mini2440_devices,ARRAY_SIZE(mini2440_devices));  
           ……  
 }  

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

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 1992module_platform_driver(s3cmci_driver);  

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

[cpp]  view plain copy  
 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文件中，其内容如下：

[cpp]  view plain copy  
 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文件中，其内容如下：

[cpp]  view plain copy  
 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文件中，其内容如下：

[cpp]  view plain copy  
 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文件中，其内容如下：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中，其内容如下：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
  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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 155#define S3C24XX_PA_SDI      S3C2410_PA_SDI  

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

[cpp]  view plain copy  
 105#define S3C2410_PA_SDI     (0x5A000000)  

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

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

[cpp]  view plain copy  
 61#define S3C24XX_SZ_SDI      SZ_1M  

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

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 328#define ioremap(cookie,size)        __arm_ioremap((cookie), (size),MT_DEVICE)  

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

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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文件中：

[cpp]  view plain copy  
 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};  