sd卡驱动分析之host

SD控制器之初始化（linux/driver/mmc/host）

这一层讲述硬件与硬件之间将要发生的故事，也是最底层驱动的核心。通常所谓的驱动程序设计的任务将落实到这一层上，所以关注host故事的发展也将成为移植整个SD类设备驱动的核心。在host目录中有各种平台下SD卡主机驱动器的实例，这里我们选择s3c2440平台作为分析的重点。参看Kconfig和Makefile即可获得相应信息，这里对应的文件即是s3cmci.c。

旧瓶装新酒，还是那个module_init，不一样的是其中的入口函数。在s3cmci.c中对应的是module_init(s3cmci_init);

[host/s3cmci.c]

1920 static int __init s3cmci_init(void)

1921 {

1922 return platform_driver_register(&s3cmci_driver);

1923 }

1922行注册了一个平台驱动，这个前面分析的串口驱动等是一样的原理。这是新版内核中引入的一个虚拟的平台总线。对应的平台设备早在内核启动时通过platform_add_devices加入到了内核，相关的具体内容前面已经分析的挺多了，这里就不在详细说明。1922行调用的结果会导致s3cmci_driver中的probe方法得以调用，由此也就把我们引入了host的世界。

首先还是来大致看一下s3cmci_driver中所对应的具体内容。

[host/s3cmci.c]

1908 static struct platform_driver s3cmci_driver = {

1909 .driver = {

1910 .name = "s3c-sdi",

1911 .owner = THIS_MODULE,

1912 .pm = s3cmci_pm_ops,

1913 },

1914 .id_table = s3cmci_driver_ids,

1915 .probe = s3cmci_probe,

1916 .remove = __devexit_p(s3cmci_remove),

1917 .shutdown = s3cmci_shutdown,

1918 };

1915行使我们关注的核心，由于host与硬件是直接相关的，probe接下来将做部分关于硬件初始化的工作，因此在分析下面一部分代码之前，最好能对s3c2440的sdi相关的内容有所了解。下面进入到probe的相关内容，整个函数洋洋洒洒三百多行，就分段说明吧。

[host/s3cmci.c]

1548 static int __devinit s3cmci_probe(struct platform_device *pdev)

1549 {

1550 struct s3cmci_host *host;

1551 struct mmc_host *mmc;

1552 int ret;

1553 int is2440;

1554 int i;

1555

1556 is2440 = platform_get_device_id(pdev)->driver_data;

/*根据设备id号判断控制器类型*/

1557

1558 mmc = mmc_alloc_host(sizeof(struct s3cmci_host), &pdev->dev);

1559 if (!mmc) {

1560 ret = -ENOMEM;

1561 goto probe_out;

1562 }

1558行分配一个mmc的控制器，同时struct s3cmci_host结构作为一个私有数据类型将添加到struct mmc_host的private域。mmc_alloc_host相应的代码如下：

[host/host.c]

58 struct mmc_host *mmc_alloc_host(int extra, struct device *dev)

59 {

60 int err;

61 struct mmc_host *host;

63 if (!idr_pre_get(&mmc_host_idr, GFP_KERNEL))

64 return NULL;

66 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);

67 if (!host)

68 return NULL;

70 spin_lock(&mmc_host_lock);

71 err = idr_get_new(&mmc_host_idr, host, &host->index);

72 spin_unlock(&mmc_host_lock);

73 if (err)

74 goto free;

76 dev_set_name(&host->class_dev, "mmc%d", host->index);

78 host->parent = dev;

79 host->class_dev.parent = dev;

80 host->class_dev.class = &mmc_host_class;

81 device_initialize(&host->class_dev);

83 spin_lock_init(&host->lock);

84 init_waitqueue_head(&host->wq);

85 INIT_DELAYED_WORK(&host->detect, mmc_rescan);

86 INIT_DELAYED_WORK_DEFERRABLE(&host->disable,mmc_host_deeper_disable);

88 /*

89 * By default, hosts do not support SGIO or large requests.

90 * They have to set these according to their abilities.

91 */

92 host->max_hw_segs = 1;

93 host->max_phys_segs = 1;

94 host->max_seg_size = PAGE_CACHE_SIZE;

96 host->max_req_size = PAGE_CACHE_SIZE;

97 host->max_blk_size = 512;

98 host->max_blk_count = PAGE_CACHE_SIZE / 512;

100 return host;

101

102 free:

103 kfree(host);

104 return NULL;

105 }

71行是内核的高效搜索树，将host->index与host结构相关联，方便以后查找。

78-81行主要是初始化host->class_dev，这个日后会通过device_register注册进系统。

84行前面已经在这个等待队列上花了不少笔墨，主要是同步对host资源的竞争的。

85-86行两行调用的函数其实没有本质上的区别，这里主要是初始化两个内核的延时工作队列。通过INIT_DELAYED_WORK或INIT_DELAYED_WORK_DEFERRABLE初始化以后，将延时执行的函数与struct delay_work结构相绑定，对于延时工作队列，日后通过调用schedule_delayed_work(),咱们只要传递struct work_struct的结构体参数即可，使得绑定的函数得以运行。关于这两个函数所做的工作，我们后面单独在说，先继续往下走。

92-98行这些个都是设置host的一些属性的，是与block.c中请求队列的设置相对应的。

重新回到s3cmci_probe....

1563

1564 for (i = S3C2410_GPE(5); i <= S3C2410_GPE(10); i++) {

1565 ret = gpio_request(i, dev_name(&pdev->dev));

1566 if (ret) {

1567 dev_err(&pdev->dev, "failed to get gpio %d\n", i);

1568

1569 for (i--; i >= S3C2410_GPE(5); i--)

1570 gpio_free(i);

1571

1572 goto probe_free_host;

1573 }

1574 }

上面这一段申请SD卡驱动器所需的GPIO资源。

1575

1576 host = mmc_priv(mmc);

1577 host->mmc = mmc;

1578 host->pdev = pdev;

1579 host->is2440 = is2440;

1580

上面这段代码就是对struct s3cmci_host *host这个私有结构的配置，对于core或block层见到的只有struct mmc_host。从另外的一个角度可以理解struct mmc_host实际上是

struct s3cmci_host的基类，有着所有控制器所必须具有的属性。struct s3cmci_host还包含了与host硬件平台相关的特征。

1581 host->pdata = pdev->dev.platform_data;

1582 if (!host->pdata) {

1583 pdev->dev.platform_data = &s3cmci_def_pdata;

1584 host->pdata = &s3cmci_def_pdata;

1585 }

1586

这是平台设备注册时platform_device所具有的属性，对于这里分析所使用的mini2440平台来说对应于math-mini2440.c文件中的

375行 s3c_device_sdi.dev.platform_data = &mini2440_mmc_cfg;

不妨关注一下mini2440_mmc_cfg中大致的一些内容。

[arch/arm/ math-mini2440.c]

334 static struct s3c24xx_mci_pdata mini2440_mmc_cfg = {

335 .gpio_detect = S3C2410_GPG(8),

336 .gpio_wprotect = S3C2410_GPH(8),

337 .set_power = NULL,

338 .ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34,

339 };

上面定义了写保护引脚、开检测以及供电范围等相关信息。

1587 spin_lock_init(&host->complete_lock);

1588 tasklet_init(&host->pio_tasklet, pio_tasklet, (unsigned long) host);

1589

tasklet就象一个内核定时器,在一个"软中断"的上下文中执行(以原子模式),常用在硬件中断处理中，使得可以使得复杂的任务安全地延后到以后的时间处理。task_init建立一个 tasklet，然后调用函数tasklet_schedule将这个tasklet放在 tasklet_vec链表的头部，并唤醒后台线程 ksoftirqd。当后台线程ksoftirqd运行调用__do_softirq时，会执行在中断向量表softirq_vec里中断号TASKLET_SOFTIRQ对应的tasklet_action函数，然后 tasklet_action遍历 tasklet_vec链表，调用每个 tasklet的函数完成软中断操作，上面例子中即是pio_tasklet函数，另外软中断处理函数只能传递一个long型变量。这里是直接使用host的地址，作为传递参数。关于这个pio_tasklet现在说他还为时过早，等时辰一到自然会对他大书特书。

1590 if (is2440) {

1591 host->sdiimsk = S3C2440_SDIIMSK;

1592 host->sdidata = S3C2440_SDIDATA;

1593 host->clk_div = 1;

1594 } else {

1595 host->sdiimsk = S3C2410_SDIIMSK;

1596 host->sdidata = S3C2410_SDIDATA;

1597 host->clk_div = 2;

1598 }

1599

host->sdiimsk、host->sdidata分别用来存放host控制器SDI中断屏蔽寄存器和SDI数据寄存器相对SDI寄存器的偏移地址。对于s3c2440根据芯片手册SDIIntMsk偏移地址为0x3C，SDIDAT偏移地址为0x40。最后host->clk_div就是指的SDI使用的时钟分频系数了。

1600 host->complete_what = COMPLETION_NONE;

1601 host->pio_active = XFER_NONE;

1602

host->complete_what是一个枚举类型变量，实际上用以标示传输完成的状态；host->pio_active标示数据传输的方向，所以在这里一起初始化为空。

关于传输完成的标示为了后面分析方便还是一起列举出来：

enum s3cmci_waitfor {

COMPLETION_NONE,

COMPLETION_FINALIZE,

COMPLETION_CMDSENT,

COMPLETION_RSPFIN,

COMPLETION_XFERFINISH,

COMPLETION_XFERFINISH_RSPFIN,

};

1603 #ifdef CONFIG_MMC_S3C_PIODMA

1604 host->dodma = host->pdata->dma;

1605 #endif

1606

上面是同时使能了PIO和DMA模式的情况，这里我们对两种传输方式都做相应的分析，所以host->dodma默认为1。

1607 host->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);

1608 if (!host->mem) {

1609 dev_err(&pdev->dev,

1610 failed to get io memory region resouce.\n);

1611

1612 ret = -ENOENT;

1613 goto probe_free_gpio;

1614 }

1615

1616 host->mem = request_mem_region(host->mem->start,

1617 resource_size(host->mem), pdev->name);

1618

1619 if (!host->mem) {

1620 dev_err(&pdev->dev, "failed to request io memory region.\n");

1621 ret = -ENOENT;

1622 goto probe_free_gpio;

1623 }

1624

1625 host->base = ioremap(host->mem->start, resource_size(host->mem));

1626 if (!host->base) {

1627 dev_err(&pdev->dev, "failed to ioremap() io memory region.\n");

1628 ret = -EINVAL;

1629 goto probe_free_mem_region;

1630 }

1631

上面的一段代码相对比较简单，都是平台驱动设计过程中常用的几个处理函数，就不一一展开了。首先是获取IO资源，这当然即使mach-mini2440.c中所注册的IORESOURCE_MEM,

1616行会申请这个资源并检查是否可用，当然只要之前没有使用过SDI寄存器空间，这里都会申请成功。最后就是IO映射，将实地址映射为内核虚拟地址使用。最后，host->base将保持SDI寄存器基地址所对应的内核虚拟地址。

1632 host->irq = platform_get_irq(pdev, 0);

1633 if (host->irq == 0) {

1634 dev_err(&pdev->dev, "failed to get interrupt resouce.\n");

1635 ret = -EINVAL;

1636 goto probe_iounmap;

1637 }

1638

1639 if (request_irq(host->irq, s3cmci_irq, 0, DRIVER_NAME, host)) {

1640 dev_err(&pdev->dev, "failed to request mci interrupt.\n");

1641 ret = -ENOENT;

1642 goto probe_iounmap;

1643 }

1644

上面一段是对中断资源的申请，并通过request_irq安装了中断处理函数，使能了SDI中断。在上段最为关心的是s3cmci_irq 中断处理函数及其传入的dev_id 。关于这个处理函数的分析后面讲述数据传输的时候会进行细致分析。接着向下....

1645 /* We get spurious interrupts even when we have set the IMSK

1646 * register to ignore everything, so use disable_irq() to make

1647 * ensure we don't lock the system with un-serviceable requests. */

1648

1649 disable_irq(host->irq);

1650 host->irq_state = false;

1651

前面我们强调了request_irq调用的结果会使能 host->irq，但此时系统初始化尚未完成这时候出现的中断可能将处理器带入一个异常状态，所以1649行屏蔽中断1650行将中断状态置位无效都是有必要的。

1652 if (!host->pdata->no_detect) {

1653 ret = gpio_request(host->pdata->gpio_detect, "s3cmci detect");

1654 if (ret) {

1655 dev_err(&pdev->dev, "failed to get detect gpio\n");

1656 goto probe_free_irq;

1657 }

1658

如果SD卡存在的检查一般是通过读取专用引脚状态来实现的，这里如果需要做detect相关的工作的话就必须重新分配一个管脚，在当前系统中前面定义了以GPG8作为检测引脚。

1659 host->irq_cd = s3c2410_gpio_getirq(host->pdata->gpio_detect);

1660

s3c2410_gpio_getirq是获取这个GPIO的外部中断向量号，可见后面的SD卡的检测可能会用到这个引脚的外部中断。

1661 if (host->irq_cd >= 0) {

1662 if (request_irq(host->irq_cd, s3cmci_irq_cd,

1663 IRQF_TRIGGER_RISING |

1664 IRQF_TRIGGER_FALLING,

1665 DRIVER_NAME, host)) {

1666 dev_err(&pdev->dev,

1667 can't get card detect irq.\n);

1668 ret = -ENOENT;

1669 goto probe_free_gpio_cd;

1670 }

1671 } else {

1672 dev_warn(&pdev->dev,

1673 "host detect has no irq available\n");

1674 gpio_direction_input(host->pdata->gpio_detect);

1675 }

1676 } else

1677 host->irq_cd = -1;

1678

上面的这段代码意图很明显就是要申请这个中断了，s3cmci_irq_cd是其处理函数。对像SD卡这种可移出设备来作为块设备存储介质的话，大多会涉及到媒体切换，具体这方面的内容后面用到的时候也会有个详细分析。

1679 if (!host->pdata->no_wprotect) {

1680 ret = gpio_request(host->pdata->gpio_wprotect, "s3cmci wp");

1681 if (ret) {

1682 dev_err(&pdev->dev, "failed to get writeprotect\n");

1683 goto probe_free_irq_cd;

1684 }

1685

1686 gpio_direction_input(host->pdata->gpio_wprotect);

1687 }

1688

与检测的管脚类似，这里就不详说了

1689 /* depending on the dma state, get a dma channel to use. */

1690

1691 if (s3cmci_host_usedma(host)) {

1692 host->dma = s3c2410_dma_request(DMACH_SDI, &s3cmci_dma_client,

1693 host);

1694 if (host->dma < 0) {

1695 dev_err(&pdev->dev, "cannot get DMA channel.\n");

1696 if (!s3cmci_host_canpio()) {

1697 ret = -EBUSY;

1698 goto probe_free_gpio_wp;

1699 } else {

1700 dev_warn(&pdev->dev, "falling back to PIO.\n");

1701 host->dodma = 0;

1702 }

1703 }

1704 }

1705

1691行这个我们之前就默认为TURE了，所以接下来的几行代码是免不了。

1692行s3c2410_dma_request申请DMA通道，对s3c2440平台有4通道的DMA。而DMACH_SDI是一个虚拟的通道号，由于这部分代码是和硬件紧密相关的，而且整个DMA的管理相对来讲比较复杂，所以这里只是粗略了解一下。

[plat-s3c24xx/dma.c]

715 int s3c2410_dma_request(unsigned int channel,

716 struct s3c2410_dma_client *client,

717 void *dev)

718 {

719 struct s3c2410_dma_chan *chan;

720 unsigned long flags;

721 int err;

722

723 pr_debug("dma%d: s3c2410_request_dma: client=%s, dev=%p\n",

724 channel, client->name, dev);

725

726 local_irq_save(flags);

727

728 chan = s3c2410_dma_map_channel(channel);

729 if (chan == NULL) {

730 local_irq_restore(flags);

731 return -EBUSY;

732 }

733

734 dbg_showchan(chan);

735

736 chan->client = client;

737 chan->in_use = 1;

738

739 if (!chan->irq_claimed) {

740 pr_debug("dma%d: %s : requesting irq %d\n",

741 channel, __func__, chan->irq);

742

743 chan->irq_claimed = 1;

744 local_irq_restore(flags);

745

746 err = request_irq(chan->irq, s3c2410_dma_irq, IRQF_DISABLED,

747 client->name, (void *)chan);

748

749 local_irq_save(flags);

750

751 if (err) {

752 chan->in_use = 0;

753 chan->irq_claimed = 0;

754 local_irq_restore(flags);

755

756 printk(KERN_ERR "%s: cannot get IRQ %d for DMA %d\n",

757 client->name, chan->irq, chan->number);

758 return err;

760

761 chan->irq_enabled = 1;

762 }

763

764 local_irq_restore(flags);

765

766 /* need to setup */

767

768 pr_debug("%s: channel initialised, %p\n", __func__, chan);

769

770 return chan->number | DMACH_LOW_LEVEL;

771 }

728行是问题的关键，调用s3c2410_dma_map_channel为虚拟的DMA通道寻找一个物理的空闲通道。相应的代码如下：

1388 static struct s3c2410_dma_chan *s3c2410_dma_map_channel(int channel)

1389 {

1390 struct s3c24xx_dma_order_ch *ord = NULL;

1391 struct s3c24xx_dma_map *ch_map;

1392 struct s3c2410_dma_chan *dmach;

1393 int ch;

1394

1395 if (dma_sel.map == NULL || channel > dma_sel.map_size)

1396 return NULL;

1397

1398 ch_map = dma_sel.map + channel;

1399

1400 /* first, try the board mapping */

1401

1402 if (dma_order) {

1403 ord = &dma_order->channels[channel];

1404

1405 for (ch = 0; ch < dma_channels; ch++) {

1406 if (!is_channel_valid(ord->list[ch]))

1407 continue;

1408

1409 if (s3c2410_chans[ord->list[ch]].in_use == 0) {

1410 ch = ord->list[ch] & ~DMA_CH_VALID;

1411 goto found;

1412 }

1413 }

1414

1415 if (ord->flags & DMA_CH_NEVER)

1416 return NULL;

1417 }

1418

1419 /* second, search the channel map for first free */

1420

1421 for (ch = 0; ch < dma_channels; ch++) {

1422 if (!is_channel_valid(ch_map->channels[ch]))

1423 continue;

1424

1425 if (s3c2410_chans[ch].in_use == 0) {

1426 printk("mapped channel %d to %d\n", channel, ch);

1427 break;

1428 }

1429 }

1430

1431 if (ch >= dma_channels)

1432 return NULL;

1433

1434 /* update our channel mapping */

1435

1436 found:

1437 dmach = &s3c2410_chans[ch];

1438 dmach->map = ch_map;

1439 dmach->req_ch = channel;

1440 s3c_dma_chan_map[channel] = dmach;

1441

1442 /* select the channel */

1443

1444 (dma_sel.select)(dmach, ch_map);

1445

1446 return dmach;

1447 }

从上面的代码可以看到有两种策略来寻找一个空闲的通道，找到以后就走到了found以后的代码了，1444行就是对这个找的通道进行适当的初始化。

1706 host->clk = clk_get(&pdev->dev, "sdi");

1707 if (IS_ERR(host->clk)) {

1708 dev_err(&pdev->dev, "failed to find clock source.\n");

1709 ret = PTR_ERR(host->clk);

1710 host->clk = NULL;

1711 goto probe_free_dma;

1712 }

1713

1714 ret = clk_enable(host->clk);

1715 if (ret) {

1716 dev_err(&pdev->dev, "failed to enable clock source.\n");

1717 goto clk_free;

1718 }

1719

1720 host->clk_rate = clk_get_rate(host->clk);

1721

以上是关于sdi时钟和波特率的有关设置，都是内核提供的一些简单的函数调用，相关的内容不是现在研究的重点就不再详细分析了。

1722 mmc->ops = &s3cmci_ops;

1723 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;

1724 #ifdef CONFIG_MMC_S3C_HW_SDIO_IRQ

1725 mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;

1726 #else

1727 mmc->caps = MMC_CAP_4_BIT_DATA;

1728 #endif

1729 mmc->f_min = host->clk_rate / (host->clk_div * 256);

1730 mmc->f_max = host->clk_rate / host->clk_div;

1731

1732 if (host->pdata->ocr_avail)

1733 mmc->ocr_avail = host->pdata->ocr_avail;

1734

1735 mmc->max_blk_count = 4095;

1736 mmc->max_blk_size = 4095;

1737 mmc->max_req_size = 4095 * 512;

1738 mmc->max_seg_size = mmc->max_req_size;

1739

1740 mmc->max_phys_segs = 128;

1741 mmc->max_hw_segs = 128;

1742

1743 dbg(host, dbg_debug,

1744 "probe: mode:%s mapped mci_base:%p irq:%u irq_cd:%u dma:%u.\n",

1745 (host->is2440?"2440":""),

1746 host->base, host->irq, host->irq_cd, host->dma);

1747

上面就是对这个将要出嫁的mmc_host进行最后的设置，mmc->ops = &s3cmci_ops;就是一直以来向core层提供的接口函数集。后面的分析可能部分是围绕它其中的函数展开的。

1748 ret = s3cmci_cpufreq_register(host);

1749 if (ret) {

1750 dev_err(&pdev->dev, "failed to register cpufreq\n");

1751 goto free_dmabuf;

1752 }

1753

这里使用的是Linux的通告机制，s3cmci_cpufreq_register相对应的代码如下：

1398 static inline int s3cmci_cpufreq_register(struct s3cmci_host *host)

1399 {

1400 host->freq_transition.notifier_call = s3cmci_cpufreq_transition;

1401

1402 return cpufreq_register_notifier(&host->freq_transition,

1403 CPUFREQ_TRANSITION_NOTIFIER);

1404 }

cpufreq_register_notifier cpu是将host->freq_transition注册到CPU频率通告链上，这个是由内核维护的，当cpu频率改变时将会调用上面注册的s3cmci_cpufreq_transition的内容。

1754 ret = mmc_add_host(mmc);

1755 if (ret) {

1756 dev_err(&pdev->dev, "failed to add mmc host.\n");

1757 goto free_cpufreq;

1758 }

1759

mmc_add_host这是core层的函数，他保存了所有平台通用的代码。同时看上去简简单单的一个mmc_add_host，可能蕴藏着天大的玄机。为此我们将为mmc_add_host另分一章，作为core层的续集，专门讲述mmc_add_host过程中发生的点点滴滴....

在开始分析mmc_add_host之前，让我们还是结束SD主机控制器的probe函数，接下来到了1760行....

1760 s3cmci_debugfs_attach(host);

1761

1762 platform_set_drvdata(pdev, mmc);

1763 dev_info(&pdev->dev, "%s - using %s, %s SDIO IRQ\n", mmc_hostname(mmc),

1764 s3cmci_host_usedma(host) ? "dma" : "pio",

1765 mmc->caps & MMC_CAP_SDIO_IRQ ? "hw" : "sw");

1766

1767 return 0;

1768

1769 free_cpufreq:

1770 s3cmci_cpufreq_deregister(host);

1771

1772 free_dmabuf:

1773 clk_disable(host->clk);

1774

1775 clk_free:

1776 clk_put(host->clk);

1777

1778 probe_free_dma:

1779 if (s3cmci_host_usedma(host))

1780 s3c2410_dma_free(host->dma, &s3cmci_dma_client);

1781

1782 probe_free_gpio_wp:

1783 if (!host->pdata->no_wprotect)

1784 gpio_free(host->pdata->gpio_wprotect);

1785

1786 probe_free_gpio_cd:

1787 if (!host->pdata->no_detect)

1788 gpio_free(host->pdata->gpio_detect);

1789

1790 probe_free_irq_cd:

1791 if (host->irq_cd >= 0)

1792 free_irq(host->irq_cd, host);

1793

1794 probe_free_irq:

1795 free_irq(host->irq, host);

1796

1797 probe_iounmap:

1798 iounmap(host->base);

1799

1800 probe_free_mem_region:

1801 release_mem_region(host->mem->start, resource_size(host->mem));

1802

1803 probe_free_gpio:

1804 for (i = S3C2410_GPE(5); i <= S3C2410_GPE(10); i++)

1805 gpio_free(i);

1806

1807 probe_free_host:

1808 mmc_free_host(mmc);

1809

1810 probe_out:

1811 return ret;

1812 }

上面的一段除了1760行是debugefs相关的，其他都是出错的处理了，那么也就没有必要纠结于此了，赶快开启新的生活吧....

core层续集之mmc_add_host

[core/host.c]

117 int mmc_add_host(struct mmc_host *host)

118 {

119 int err;

120

121 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&

122 !host->ops->enable_sdio_irq);

123

124 led_trigger_register_simple(dev_name(&host->class_dev), &host->led);

125

126 err = device_add(&host->class_dev);

127 if (err)

128 return err;

129

130 #ifdef CONFIG_DEBUG_FS

131 mmc_add_host_debugfs(host);

132 #endif

133

134 mmc_start_host(host);

135

136 return 0;

137 }

124行还是前面所说的那个LED，这里不做研究。

126行设备注册，这个host->class_dev在很早以前我们就对他进行过初始化了，其中并没有给他关联到某某总线或是驱动上，所以实际上这段代码产生的效果就是在sysfs中留下自己走过的痕迹。

130-132行debug相关的可以跳过了。

134行是时候开启主机控制器了，这也是core层的函数具体的方法如下：

[core/core.c]

1118 void mmc_start_host(struct mmc_host *host)

1119 {

1120 mmc_power_off(host);

1121 mmc_detect_change(host, 0);

1122 }

代码精炼到了极致，首先来看一下mmc_power_off，内容如下：

[core/core.c]

911 static void mmc_power_off(struct mmc_host *host)

912 {

913 host->ios.clock = 0;

914 host->ios.vdd = 0;

915 if (!mmc_host_is_spi(host)) {

916 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;

917 host->ios.chip_select = MMC_CS_DONTCARE;

918 }

919 host->ios.power_mode = MMC_POWER_OFF;

920 host->ios.bus_width = MMC_BUS_WIDTH_1;

921 host->ios.timing = MMC_TIMING_LEGACY;

922 mmc_set_ios(host);

923 }

关心最多的就是host->ios当中的内容，前段的赋值真正作用在硬件上是调用host层向上提供的struct mmc_host_ops接口。这里922行实际上就是完成了这个工作。

回到mmc_start_host，1121行这一行的作用显然是意义重大，看名字就知道是用来检测SD卡的，内容如下：

[core/core.c]

1023 void mmc_detect_change(struct mmc_host *host, unsigned long delay)

1024 {

1025 #ifdef CONFIG_MMC_DEBUG

1026 unsigned long flags;

1027 spin_lock_irqsave(&host->lock, flags);

1028 WARN_ON(host->removed);

1029 spin_unlock_irqrestore(&host->lock, flags);

1030 #endif

1031

1032 mmc_schedule_delayed_work(&host->detect, delay);

1033 }

除了1032行说了句人话，其他的百分之九十九的都是废话。曾几何时我们说过内核有个延时工作队列，没错就是他了。当然这可不是随便拿来玩的，与之对应的初始化前面已经说过即INIT_DELAYED_WORK(&host->detect, mmc_rescan);

好了1032行作用的结果估计大家都能猜到了，就是延时delay时间后就会去调用mmc_rescan了。前面我们传递的delay=0，那么这里就没有延时了，既然驱动都等不及要rescan了，我们也就不再卖关子了，直接mmc_rescan。

[core/core.c]

1038 void mmc_rescan(struct work_struct *work)

1039 {

1040 struct mmc_host *host =

1041 container_of(work, struct mmc_host, detect.work);

1042 u32 ocr;

1043 int err;

1044

1045 mmc_bus_get(host);

1046

1047 /* if there is a card registered, check whether it is still present */

1048 if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead)

1049 host->bus_ops->detect(host);

1050

1051 mmc_bus_put(host);

1052

1053

1054 mmc_bus_get(host);

1055

1056 /* if there still is a card present, stop here */

1057 if (host->bus_ops != NULL) {

1058 mmc_bus_put(host);

1059 goto out;

1060 }

1061

1062 /* detect a newly inserted card */

1063

1064 /*

1065 * Only we can add a new handler, so it's safe to

1066 * release the lock here.

1067 */

1068 mmc_bus_put(host);

1069

1070 if (host->ops->get_cd && host->ops->get_cd(host) == 0)

1071 goto out;

1072

1073 mmc_claim_host(host);

1074

1075 mmc_power_up(host);

1076 mmc_go_idle(host);

1077

1078 mmc_send_if_cond(host, host->ocr_avail);

1079

1080 /*

1081 * First we search for SDIO...

1082 */

1083 err = mmc_send_io_op_cond(host, 0, &ocr);

1084 if (!err) {

1085 if (mmc_attach_sdio(host, ocr))

1086 mmc_power_off(host);

1091 * ...then normal SD...

1092 */

1093 err = mmc_send_app_op_cond(host, 0, &ocr);

1094 if (!err) {

1095 if (mmc_attach_sd(host, ocr))

1096 mmc_power_off(host);

1101 * ...and finally MMC.

1102 */

1103 err = mmc_send_op_cond(host, 0, &ocr);

1104 if (!err) {

1105 if (mmc_attach_mmc(host, ocr))

1106 mmc_power_off(host);

1107 goto out;

1108 }

1109

1110 mmc_release_host(host);

1111 mmc_power_off(host);

1112

1113 out:

1114 if (host->caps & MMC_CAP_NEEDS_POLL)

1115 mmc_schedule_delayed_work(&host->detect, HZ);

1116 }

又是一个core层的函数，这可不好host表示“host很生气，后果很严重”。但是这也没办法阿，现实就是这么残酷，谁叫人家是core呢。这里又出现了个新名词bus_ops，不过我可以相当负责任的告诉你，现在我们还用不到。那么我们就直接跳到了1070行检测SD卡是否存在。那么host->ops->get_cd(host)将是我们关注的重点，他依然是那个宝刀未老的struct mmc_host_ops结构。get_cd方法正好对应函数.get_cd= s3cmci_card_present。既然都走到这来了就干脆先看完源码再说。

[host/s3cmci.c]

1177 static int s3cmci_card_present(struct mmc_host *mmc)

1178 {

1179 struct s3cmci_host *host = mmc_priv(mmc);

1180 struct s3c24xx_mci_pdata *pdata = host->pdata;

1181 int ret;

1182

1183 if (pdata->gpio_detect == 0)

1184 return -ENOSYS;

1185

1186 ret = gpio_get_value(pdata->gpio_detect) ? 0 : 1;

1187 return ret ^ pdata->detect_invert;

1188 }

这是利用了SD卡座的一个机械检测方法，当SD插入以后SD卡的11脚会连接到低电平，从而得到卡插入的状态。对SD卡本身来说只能利用SD3引脚来做相应的判断。1186行就是读取检测引脚的值。

回到mmc_rescan中，继续往下....

1073行获得主机控制权，这个函数的实现前面已经详细分析过了。

1075行设置并开启主机控制器。

[core/core.c]

865 static void mmc_power_up(struct mmc_host *host)

866 {

867 int bit;

868

869 /* If ocr is set, we use it */

870 if (host->ocr)

871 bit = ffs(host->ocr) - 1;

872 else

873 bit = fls(host->ocr_avail) - 1;

874

875 host->ios.vdd = bit;

876 if (mmc_host_is_spi(host)) {

877 host->ios.chip_select = MMC_CS_HIGH;

878 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;

879 } else {

880 host->ios.chip_select = MMC_CS_DONTCARE;

881 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;

882 }

883 host->ios.power_mode = MMC_POWER_UP;

884 host->ios.bus_width = MMC_BUS_WIDTH_1;

885 host->ios.timing = MMC_TIMING_LEGACY;

886 mmc_set_ios(host);

887

888 /*

889 * This delay should be sufficient to allow the power supply

890 * to reach the minimum voltage.

891 */

892 mmc_delay(10);

893

894 if (host->f_min > 400000) {

895 pr_warning("%s: Minimum clock frequency too high for "

896

897 host->ios.clock = host->f_min;

898 } else

899 host->ios.clock = 400000;

900

901 host->ios.power_mode = MMC_POWER_ON;

902 mmc_set_ios(host);

903

904 /*

905 * This delay must be at least 74 clock sizes, or 1 ms, or the

906 * time required to reach a stable voltage.

907 */

908 mmc_delay(10);

909 }

上面代码比较简单，894行这里是对初始化阶段的时钟进行相应的控制，不能高于400K，否则有初始化失败的风险。其他的就是mmc_set_ios的工作了，这个我们后面分析mmc_host_ops的时候再来一起说。

另外，SD卡的初始化一般分为几个阶段如下所示：

1076行使SD卡进入idle状态。

[core/mmc_ops.c]

96 int mmc_go_idle(struct mmc_host *host)

97 {

98 int err;

99 struct mmc_command cmd;

100

101 /*

102 * Non-SPI hosts need to prevent chipselect going active during

103 * GO_IDLE; that would put chips into SPI mode. Remind them of

104 * that in case of hardware that won't pull up DAT3/nCS otherwise.

105 *

106 * SPI hosts ignore ios.chip_select; it's managed according to

107 * rules that must accomodate non-MMC slaves which this layer

108 * won't even know about.

109 */

110 if (!mmc_host_is_spi(host)) {

111 mmc_set_chip_select(host, MMC_CS_HIGH);

112 mmc_delay(1);

113 }

114

115 memset(&cmd, 0, sizeof(struct mmc_command));

116

117 cmd.opcode = MMC_GO_IDLE_STATE;

118 cmd.arg = 0;

119 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;

120

121 err = mmc_wait_for_cmd(host, &cmd, 0);

122

123 mmc_delay(1);

124

125 if (!mmc_host_is_spi(host)) {

126 mmc_set_chip_select(host, MMC_CS_DONTCARE);

127 mmc_delay(1);

128 }

129

130 host->use_spi_crc = 0;

131

132 return err;

133 }

110-112行由于SD卡会根据初始化过程中CS引脚的状态来判断所采用的传输模式，这里如果不使用SPI传输，那么一定要就CS引脚置位高电平。SD卡不同传输模式下引脚的定义如下所示：

117-119行设置命令格式，MMC_GO_IDLE_STATE对应CMD0，然后调用121行的函数mmc_wait_for_cmd来执行命令。

125-128行将110-112行置位的引脚复位到输入状态，因为在硬件上不确定输入输出关系的引脚都应将其设置为输入，以免引起冲突。

下面就到了mmc_rescan的1078行....

[core/sd_ops.c]

196 int mmc_send_if_cond(struct mmc_host *host, u32 ocr)

197 {

198 struct mmc_command cmd;

199 int err;

200 static const u8 test_pattern = 0xAA;

201 u8 result_pattern;

202

203 /*

204 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND

205 * before SD_APP_OP_COND. This command will harmlessly fail for

206 * SD 1.0 cards.

207 */

208 cmd.opcode = SD_SEND_IF_COND;

209 cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;

210 cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;

211

212 err = mmc_wait_for_cmd(host, &cmd, 0);

213 if (err)

214 return err;

215

216 if (mmc_host_is_spi(host))

217 result_pattern = cmd.resp[1] & 0xFF;

218 else

219 result_pattern = cmd.resp[0] & 0xFF;

220

221 if (result_pattern != test_pattern)

这是为了实现对SD 2.0的支持，因为SD 2.0在发送设置SD卡的工作电压之前必须先发送CMD8命令，对于SD1.1来说，这个命令式得不到响应的。SD 2.0版和1.1版在很多地方都有很大的不同的，相关的内容可以参考spece。具体实现的代码与mmc_go_idle类似这里就不再分析了。

mmc_rescan的1083-1088行，这小段是搜索SDIO设备....

1093行是对SD卡的设置，跟踪源码：

[core/sd_ops.c]

151 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)

152 {

153 struct mmc_command cmd;

158 memset(&cmd, 0, sizeof(struct mmc_command));

159

160 cmd.opcode = SD_APP_OP_COND;

161 if (mmc_host_is_spi(host))

162 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */

163 else

164 cmd.arg = ocr;

165 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;

166

167 for (i = 100; i; i--) {

168 err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);

169 if (err)

170 break;

171

172 /* if we're just probing, do a single pass */

173 if (ocr == 0)

174 break;

175

176 /* otherwise wait until reset completes */

177 if (mmc_host_is_spi(host)) {

178 if (!(cmd.resp[0] & R1_SPI_IDLE))

179 break;

180 } else {

181 if (cmd.resp[0] & MMC_CARD_BUSY)

182 break;

183 }

184

185 err = -ETIMEDOUT;

190 if (rocr && !mmc_host_is_spi(host))

191 *rocr = cmd.resp[0];

192

193 return err;

194 }

160-165行还是设置cmd结构，根据我们前面所说的SD卡初始化过程，这里应该是设置目标的工作电压也就是ACMD41。

167行表示mmc_wait_for_app_cmd最多重复做一百次，下面来分析一下她所做的具体工作。

[core/sd-ops.c]

65 int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,

66 struct mmc_command *cmd, int retries)

67 {

68 struct mmc_request mrq;

70 int i, err;

72 BUG_ON(!cmd);

73 BUG_ON(retries < 0);

75 err = -EIO;

77 /*

78 * We have to resend MMC_APP_CMD for each attempt so

79 * we cannot use the retries field in mmc_command.

80 */

81 for (i = 0;i <= retries;i++) {

82 memset(&mrq, 0, sizeof(struct mmc_request));

84 err = mmc_app_cmd(host, card);

85 if (err) {

86 /* no point in retrying; no APP commands allowed */

87 if (mmc_host_is_spi(host)) {

88 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)

94 memset(&mrq, 0, sizeof(struct mmc_request));

96 memset(cmd->resp, 0, sizeof(cmd->resp));

97 cmd->retries = 0;

99 mrq.cmd = cmd;

100 cmd->data = NULL;

101

102 mmc_wait_for_req(host, &mrq);

103

104 err = cmd->error;

105 if (!cmd->error)

106 break;

107

108 /* no point in retrying illegal APP commands */

109 if (mmc_host_is_spi(host)) {

110 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)

上面的代码我们分为两部分来看，81-92行为第一部分，94-113行为第二部分。同样mmc_app_cmd被重复了retries次。不妨看下84行的代码：

[core/sd-ops.c]

23 static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)

24 {

25 int err;

26 struct mmc_command cmd;

28 BUG_ON(!host);

29 BUG_ON(card && (card->host != host));

31 cmd.opcode = MMC_APP_CMD;

33 if (card) {

34 cmd.arg = card->rca << 16;

35 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;

36 } else {

37 cmd.arg = 0;

38 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;

39 }

41 err = mmc_wait_for_cmd(host, &cmd, 0);

42 if (err)

43 return err;

45 /* Check that card supported application commands */

46 if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))

47 return -EOPNOTSUPP;

49 return 0;

50 }

和前面所分析的情况一致，这里最后还是在调用mmc_wait_for_cmd实现MMC_APP_CM（ACMD55）命令,根据前面的流程图我们知道在非SPI模式下设置ACMD41命令之前，必须先发送ACMD55命令进入AMD模式。因此这里的处理时为了保证ACMD41命令的成功执行。回到mmc_wait_for_app_cmd函数中来....

94-112行前面传递过来的ACMD41命令这里就会重新组装成struct mmc_request结构，然后调用mmc_wait_for_cmd(host, &cmd, 0);来执行。

109-112行作为SPI传输来讲这些个命令式被忽略的，所以出现了错误，只要状态指明了R1_SPI_ILLEGAL_COMMAND就不用在重试了。回到mmc_send_app_op_cond函数....

177-183行对于非SPI模式，通过判断返回的状态寄存器rSDIRSP0的第三十一位是否为1，来决定SD卡进入了ready状态。1：ready0：busy。

190-191行这是返回的电压范围。如果一切正常认为初始化的第二阶段已经完成了，就该回到mmc_rescan的1095行mmc_attach_sd函数了。

[core/sd.c]

658 int mmc_attach_sd(struct mmc_host *host, u32 ocr)

663 WARN_ON(!host->claimed);

664

665 mmc_sd_attach_bus_ops(host);

666

667 /*

668 * We need to get OCR a different way for SPI.

669 */

670 if (mmc_host_is_spi(host)) {

671 mmc_go_idle(host);

672

673 err = mmc_spi_read_ocr(host, 0, &ocr);

679 * Sanity check the voltages that the card claims to

680 * support.

681 */

682 if (ocr & 0x7F) {

683 printk(KERN_WARNING "%s: card claims to support voltages "

684 "below the defined range. These will be ignored.\n",

685 mmc_hostname(host));

686 ocr &= ~0x7F;

687 }

688

689 if (ocr & MMC_VDD_165_195) {

690 printk(KERN_WARNING "%s: SD card claims to support the "

691 "incompletely defined 'low voltage range'. This "

692 "will be ignored.\n", mmc_hostname(host));

693 ocr &= ~MMC_VDD_165_195;

694 }

695

696 host->ocr = mmc_select_voltage(host, ocr);

697

698 /*

699 * Can we support the voltage(s) of the card(s)?

700 */

701 if (!host->ocr) {

707 * Detect and init the card.

708 */

709 err = mmc_sd_init_card(host, host->ocr, NULL);

710 if (err)

711 goto err;

712

713 mmc_release_host(host);

714

715 err = mmc_add_card(host->card);

716 if (err)

717 goto remove_card;

722 mmc_remove_card(host->card);

723 host->card = NULL;

724 mmc_claim_host(host);

725 err:

726 mmc_detach_bus(host);

727 mmc_release_host(host);

728

729 printk(KERN_ERR "%s: error %d whilst initialising SD card\n",

730 mmc_hostname(host), err);

731

732 return err;

733 }

这个函数开始对SD的初始化，下面我们来详细分析。

665行完成bus_ops与SD卡的绑定，这也就是我们之间所见到的内容，其对应的实现如下：

[core/sd.c]

642 static void mmc_sd_attach_bus_ops(struct mmc_host *host)

643 {

644 const struct mmc_bus_ops *bus_ops;

645

646 if (host->caps & MMC_CAP_NONREMOVABLE)

647 bus_ops = &mmc_sd_ops_unsafe;

648 else

649 bus_ops = &mmc_sd_ops;

650 mmc_attach_bus(host, bus_ops);

651 }

646-649行设置了bus_ops对应的方法，这里我们选择mmc_sd_ops，里面对应的具体内容我们用到的时候在去分析。

650行是总线方法和host绑定的过程，中间的内容比较简单就是将bus_ops关联到host->bus_ops上，同时对总线的引用计数进行初始化。相应的代码如下：

[core/core.c]

968 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)

969 {

970 unsigned long flags;

975 WARN_ON(!host->claimed);

976

977 spin_lock_irqsave(&host->lock, flags);

978

979 BUG_ON(host->bus_ops);

980 BUG_ON(host->bus_refs);

981

982 host->bus_ops = ops;

983 host->bus_refs = 1;

984 host->bus_dead = 0;

985

986 spin_unlock_irqrestore(&host->lock, flags);

987 }

这个总线绑定的过程一旦完成就又重新回到了mmc_attach_sd。

670-676行我们前面分析获取工作电压范围的过程是针对非SPI模式的，这里对于SPI模式我们需要重新获取。

671行首先重新进入idle状态，这个无论哪种工作模式都是一样的。

673行是获取ocr的区别，对于spi使用的命令字为ACMD58，其他的就和一般的命令发送大相径庭了。

[core/mmc_ops.c]

355 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)

356 {

357 struct mmc_command cmd;

358 int err;

359

360 memset(&cmd, 0, sizeof(struct mmc_command));

361

362 cmd.opcode = MMC_SPI_READ_OCR;

363 cmd.arg = highcap ? (1 << 30) : 0;

364 cmd.flags = MMC_RSP_SPI_R3;

365

366 err = mmc_wait_for_cmd(host, &cmd, 0);

367

368 *ocrp = cmd.resp[1];

369 return err;

370 }

上面一段代码注意368行获取ocr的差异。

回到mmc_attach_sd的696行mmc_select_voltage(host, ocr)，这是根据host的电压范围和读取到的SD卡工作电压，来判断工作电压是否匹配。函数内容如下：

[core/core.c]

822 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)

823 {

824 int bit;

825

826 ocr &= host->ocr_avail;

834 host->ios.vdd = bit;

835 mmc_set_ios(host);

836 } else {

837 pr_warning("%s: host doesn't support card's voltages\n",

838 mmc_hostname(host));

host->ocr_avail前面我们已经进行了相应的初始化。

.ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34。

回到mmc_attach_sd函数中，下面就到了整个mmc_rescan的高潮部分了，也就是一直在说的初始化SD卡，对应709行err = mmc_sd_init_card(host, host->ocr, NULL);这个函数完成了整个SD卡初始化的全动作，下面来看代码：

[core/sd.c]

332 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,

333 struct mmc_card *oldcard)

334 {

335 struct mmc_card *card;

336 int err;

337 u32 cid[4];

338 unsigned int max_dtr;

339

340 BUG_ON(!host);

341 WARN_ON(!host->claimed);

342

343 /*

344 * Since we're changing the OCR value, we seem to

345 * need to tell some cards to go back to the idle

346 * state. We wait 1ms to give cards time to

347 * respond.

348 */

349 mmc_go_idle(host);

350

351 /*

352 * If SD_SEND_IF_COND indicates an SD 2.0

353 * compliant card and we should set bit 30

354 * of the ocr to indicate that we can handle

355 * block-addressed SDHC cards.

356 */

357 err = mmc_send_if_cond(host, ocr);

358 if (!err)

359 ocr |= 1 << 30;

360

361 err = mmc_send_app_op_cond(host, ocr, NULL);

366 *Fetch CID from card.

367 */

368 if (mmc_host_is_spi(host))

369 err = mmc_send_cid(host, cid);

370 else

371 err =mmc_all_send_cid(host, cid);

376 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {

384 * Allocate card structure.

385 */

386 card =mmc_alloc_card(host, &sd_type);

387 if (IS_ERR(card)) {

388 err = PTR_ERR(card);

389 goto err;

390 }

391

392 card->type = MMC_TYPE_SD;

393 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));

394 }

395

396 /*

397 * For native busses: get card RCA and quit open drain mode.

398 */

399 if (!mmc_host_is_spi(host)) {

400 err = mmc_send_relative_addr(host, &card->rca);

401 if (err)

402 goto free_card;

403

404 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);

409 * Fetch CSD from card.

410 */

411 err = mmc_send_csd(card, card->raw_csd);

412 if (err)

413 goto free_card;

414

415 err = mmc_decode_csd(card);

416 if (err)

417 goto free_card;

418

419 mmc_decode_cid(card);

420 }

421

422 /*

423 * Select card, as all following commands rely on that.

424 */

425 if (!mmc_host_is_spi(host)) {

426 err = mmc_select_card(card);

433 * Fetch SCR from card.

434 */

435 err = mmc_app_send_scr(card, card->raw_scr);

436 if (err)

437 goto free_card;

438

439 err = mmc_decode_scr(card);

444 * Fetch switch information from card.

445 */

446 err = mmc_read_switch(card);

452 * For SPI, enable CRC as appropriate.

453 * This CRC enable is located AFTER the reading of the

454 * card registers because some SDHC cards are not able

455 * to provide valid CRCs for non-512-byte blocks.

456 */

457 if (mmc_host_is_spi(host)) {

458 err = mmc_spi_set_crc(host, use_spi_crc);

464 * Attempt to change to high-speed (if supported)

465 */

466 err = mmc_switch_hs(card);

471 * Compute bus speed.

472 */

473 max_dtr = (unsigned int)-1;

474

475 if (mmc_card_highspeed(card)) {

476 if (max_dtr > card->sw_caps.hs_max_dtr)

477 max_dtr = card->sw_caps.hs_max_dtr;

478 } else if (max_dtr > card->csd.max_dtr) {

479 max_dtr = card->csd.max_dtr;

480 }

481

482 mmc_set_clock(host, max_dtr);

483

484 /*

485 * Switch to wider bus (if supported).

486 */

487 if ((host->caps & MMC_CAP_4_BIT_DATA) &&

488 (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {

489 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);

490 if (err)

491 goto free_card;

492

493 mmc_set_bus_width(host, MMC_BUS_WIDTH_4);

494 }

495

496 /*

497 * Check if read-only switch is active.

498 */

499 if (!oldcard) {

500 if (!host->ops->get_ro || host->ops->get_ro(host) < 0) {

501 printk(KERN_WARNING "%s: host does not "

502 support reading read-only

503 switch. assuming write-enable.\n,

504 mmc_hostname(host));

505 } else {

506 if (host->ops->get_ro(host) > 0)

507 mmc_card_set_readonly(card);

512 host->card = card;

518 mmc_remove_card(card);

这段代码洋洋洒洒二百余行，着实有点难看。但是没关系，深呼吸一下继续来看代码...

349行再见了mmc_go_idle(host)，话可以乱说但是代码可不能乱写。这个函数在这里不为别的，只因前面修改了ocr的值。所以必须让大家都回到idle状态。

357行还是那个熟悉的背影，依旧是为SD 2.0而生。

361行还是前面花了大力气分析过的函数，这里就不必要重申了。

再继续向前之前还是要去瞅瞅我们之前贴出来的那张初始化流程图，下面的时间该到获取卡的身份信息了，由此SD卡将步入identification时代，使用的命令是CMD2。

368-371行我们选择err = mmc_all_send_cid(host, cid)，跟踪源码：

[/core/mmc_ops.c]

177 int mmc_all_send_cid(struct mmc_host *host, u32 *cid)

178 {

179 int err;

180 struct mmc_command cmd;

185 memset(&cmd, 0, sizeof(struct mmc_command));

186

187 cmd.opcode = MMC_ALL_SEND_CID;

188 cmd.arg = 0;

189 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;

190

191 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);

192 if (err)

193 return err;

194

195 memcpy(cid, cmd.resp, sizeof(u32) * 4);

196

197 return 0;

198 }

187行跟据#define MMC_ALL_SEND_CID 2可以确定，此刻的SD卡即将进入激动人心的时刻identification。

195行回复的就是我们一直想得到的身份信息了。

函数的其他内容就是炒剩饭了，所有的罪就让mmc_wait_for_cmd来背吧。

飘啊飘，总算是飘到了386行mmc_alloc_card，这个函数就是为了分配一个struct mmc_card结构，相信读过card部分的朋友对她应该是不再陌生了。打个比方来说这个函数就好比领身份证，SD卡都已经走到了identification这一步了，却还没有一个东西能证明他的身份的，您说她冤不冤。好了，就发个证件给她吧，于是乎聪明的内核开发者就想到了mmc_alloc_card。具体是怎么工作的就只能看源码啦！

[core/bus.c]

199 struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)

200 {

201 struct mmc_card *card;

202

203 card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);

204 if (!card)

205 return ERR_PTR(-ENOMEM);

206

207 card->host = host;

208

209 device_initialize(&card->dev);

210

211 card->dev.parent = mmc_classdev(host);

212 card->dev.bus = &mmc_bus_type;

213 card->dev.release = mmc_release_card;

214 card->dev.type = type;

215

216 return card;

217 }

207行吃水不忘挖井人，辛辛苦苦为SD卡操劳了N久的host总算还是被struct mmc_host第一个给记下了。当然后面对这个SD卡的所有操作也就顺理成章的交给了card->host。

209-214行您是否还依稀记得早在分析card目录的时候，讲到一个driver的注册，却始终未见他命中注定的那个device。那么现在我以一种极其负责任的态度来告诉您，在不久以后的某个黄道吉日，您眼前的这个device将和前面那位苦苦等待他的driver一起步入婚姻的殿堂。当然为这对新人牵线搭桥的还有mmc_bus_type这条总线。这一切过后是时候返回了。

392-393行是对这个新生的card做对应的初始化。

始终不忘的是那张动情的SD卡初始化流程图，indentification过后就到了设置RCA阶段了，mmc_send_relative_addr最终将不辱使命，内容如下：

[core/sd_ops.c]

227 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)

228 {

229 int err;

230 struct mmc_command cmd;

235 memset(&cmd, 0, sizeof(struct mmc_command));

236

237 cmd.opcode = SD_SEND_RELATIVE_ADDR;

238 cmd.arg = 0;

239 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;

240

241 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);

242 if (err)

243 return err;

244

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

246

247 return 0;

248 }

237行设置的正是CMD3，这个函数过后SD卡将转入stand-by状态。SD卡最终要到的西方极乐世界是transfer，现在距离他也就真的只有一步之遥了。好了，回到mmc_sd_init_card再接再厉...

404行mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);其实总线就两种模式要么open drain也就是漏极开路或者push-pull上拉。现在都开始要传输数据了，您说该是哪种模式呢。对于host总线的设置还是利用host->ops->set_ios实现的，具体代码如下：

[core/core.c]

630 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)

631 {

632 host->ios.bus_mode = mode;

633 mmc_set_ios(host);

634 }

上面所做的工作全部完成以后，接下来就是通过CMD9读取卡的CSD寄存器。从CSD寄存器中，获知卡容量，支持的命令集等重要参数了。411-419为您解决了一切后顾之忧，显然mmc_send_csd是来发送csd命令的。

[core/mmc_ops.c]

310 int mmc_send_csd(struct mmc_card *card, u32 *csd)

311 {

312 int ret, i;

313

314 if (!mmc_host_is_spi(card->host))

315 return mmc_send_cxd_native(card->host, card->rca << 16,

316 csd, MMC_SEND_CSD);

317

318 ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16);

319 if (ret)

320 return ret;

321

322 for (i = 0;i < 4;i++)

323 csd[i] = be32_to_cpu(csd[i]);

324

325 return 0;

326 }

对于我们一直跟踪的非SPI模式，315行成了整个函数的焦点。MMC_SEND_CSD对应的是CMD9，mmc_send_cxd_native的内容如下：

[core/mmc_ops.c]

222 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)

223 {

224 int err;

225 struct mmc_command cmd;

230 memset(&cmd, 0, sizeof(struct mmc_command));

231

232 cmd.opcode = opcode;

233 cmd.arg = arg;

234 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;

235

236 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);

237 if (err)

238 return err;

239

240 memcpy(cxd, cmd.resp, sizeof(u32) * 4);

241

242 return 0;

243 }

与其他设置命令类的函数一样mmc_send_cxd_native依然具有着足够清晰地脉络，有着永远不变的调用顺序。这个函数返回以后整个获取CSD的工作就做完了，结果保存在传递的cxd变量中。回到mmc_init_card...

416行取出了CSD的参数，但是哪些个字段表示什么意思就得decode了，下面来看mmc_decode_csd。

[core/sd.c]

90 static int mmc_decode_csd(struct mmc_card *card)

91 {

92 struct mmc_csd *csd = &card->csd;

93 unsigned int e, m, csd_struct;

94 u32 *resp = card->raw_csd;

96 csd_struct = UNSTUFF_BITS(resp, 126, 2);

98 switch (csd_struct) {

99 case 0:

100 m = UNSTUFF_BITS(resp, 115, 4);

101 e = UNSTUFF_BITS(resp, 112, 3);

102 csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10;

103 csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100;

104

105 m = UNSTUFF_BITS(resp, 99, 4);

106 e = UNSTUFF_BITS(resp, 96, 3);

107 csd->max_dtr = tran_exp[e] * tran_mant[m];

108 csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);

109

110 e = UNSTUFF_BITS(resp, 47, 3);

111 m = UNSTUFF_BITS(resp, 62, 12);

112 csd->capacity = (1 + m) << (e + 2);

113

114 csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);

115 csd->read_partial = UNSTUFF_BITS(resp, 79, 1);

116 csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);

117 csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);

118 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);

119 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);

120 csd->write_partial = UNSTUFF_BITS(resp, 21, 1);

121 break;

122 case 1:

123 /*

124 * This is a block-addressed SDHC card. Most

125 * interesting fields are unused and have fixed

126 * values. To avoid getting tripped by buggy cards,

127 * we assume those fixed values ourselves.

128 */

129 mmc_card_set_blockaddr(card);

130

131 csd->tacc_ns = 0; /* Unused */

132 csd->tacc_clks = 0; /* Unused */

133

134 m = UNSTUFF_BITS(resp, 99, 4);

135 e = UNSTUFF_BITS(resp, 96, 3);

136 csd->max_dtr = tran_exp[e] * tran_mant[m];

137 csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);

138

139 m = UNSTUFF_BITS(resp, 48, 22);

140 csd->capacity = (1 + m) << 10;

141

142 csd->read_blkbits = 9;

143 csd->read_partial = 0;

144 csd->write_misalign = 0;

145 csd->read_misalign = 0;

146 csd->r2w_factor = 4; /* Unused */

147 csd->write_blkbits = 9;

148 csd->write_partial = 0;

149 break;

150 default:

151 printk(KERN_ERR "%s: unrecognised CSD structure version %d\n",

152 mmc_hostname(card->host), csd_struct);

在分析上面的函数之前，首先还是来给出一张寄存器表，如下：

首先来看一下96行频频出现的UNSTUFF_BITS，其实他是个宏定义，具体的形式如下：

[core/sd.c]

44 #define UNSTUFF_BITS(resp,start,size) \

45 ({ \

46 const int __size = size; \

47 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \

48 const int __off = 3 - ((start) / 32); \

49 const int __shft = (start) & 31; \

50 u32 __res; \

51 \

52 __res = resp[__off] >> __shft; \

53 if (__size + __shft > 32) \

54 __res |= resp[__off-1] << ((32 - __shft) % 32); \

55 __res & __mask; \

56 })

上面一段代码纠结于C语言各种运算符，但是总的来说还是比较清晰地。为了对应背景我们就以resp[4]为例来说明。首先明确这个宏中resp[4]是当做一个4*32bit的数据来对待的，高位地址resp数组的第四个数据占据最高位，start指的是4*32bit中从哪一位起始，size是指提取几位的数据。UNSTUFF_BITS(resp, 126, 2);就是指提取resp数组中的126和127位。对照上面的表可以看出取出的正是csd struct。

接下来就是根据csd_struct的情况来决定是SD1.1还是SD2.0标准。这里我们关注SD2.0的情况。

129行设置了设备的状态为MMC_STATE_BLOCKADDR，这是SD卡版本所决定的。记性好的朋友可能还记得在card中有一个叫做mmc_blk_set_blksize的函数，里面会使用

#define mmc_card_blockaddr(c) ((c)->state & MMC_STATE_BLOCKADDR)判断是否设置块大小，这个依据出现在这里。

136行max. data transfer rate最大数据传输率定义在96-106bit，这里也就能够简单地得到了。

137行card command classes指明SD卡所属的指令集，它使用的是84位以后的12bit来表示。

其他的内容就比较明确了，这里就不一一列出了。

回到mmc_init_card中接下来就该解码CID了，所用的函数即mmc_decode_cid。代码如下：

[core/sd.c]

61 static void mmc_decode_cid(struct mmc_card *card)

62 {

63 u32 *resp = card->raw_cid;

65 memset(&card->cid, 0, sizeof(struct mmc_cid));

67 /*

68 * SD doesn't currently have a version field so we will

69 * have to assume we can parse this.

70 */

71 card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);

72 card->cid.oemid = UNSTUFF_BITS(resp, 104, 16);

73 card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);

74 card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);

75 card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);

76 card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);

77 card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);

78 card->cid.hwrev = UNSTUFF_BITS(resp, 60, 4);

79 card->cid.fwrev = UNSTUFF_BITS(resp, 56, 4);

80 card->cid.serial = UNSTUFF_BITS(resp, 24, 32);

81 card->cid.year = UNSTUFF_BITS(resp, 12, 8);

82 card->cid.month = UNSTUFF_BITS(resp, 8, 4);

84 card->cid.year += 2000; /* SD cards year offset */

85 }

与CSD一样，首先来看看它的家谱图如下：

里面始终使用的是UNSTUFF_BITS这个宏定义，具体的内容参照上面的图应该比较清晰就不下详述了。

清醒一下重新回到我们一直讨论的主旋律——SD卡初始化。依旧是那张唠叨了千遍地流程图，好了下一步我们该大步迈进选择SD卡阶段了，这个黑暗的时刻过后，SD卡将走上新的人生轨道，transfer。397行判断传输模式，对于SPI而言，有一个大名鼎鼎的CS信号，所以做法就稍微有点不一样了。我们只谈if (!mmc_host_is_spi(host))成立的时候，那么走进mmc_select_card是必然的趋势了。

[core/mmc_ops.c]

48 int mmc_select_card(struct mmc_card *card)

49 {

50 BUG_ON(!card);

52 return _mmc_select_card(card->host, card);

53 }

目光投向_mmc_select_card，其实聪明的你早就应该猜到这个函数是怎么做的了，还是来看看源码：

[core/mmc_ops.c]

22 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)

23 {

24 int err;

25 struct mmc_command cmd;

27 BUG_ON(!host);

29 memset(&cmd, 0, sizeof(struct mmc_command));

31 cmd.opcode = MMC_SELECT_CARD;

33 if (card) {

34 cmd.arg = card->rca << 16;

35 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

36 } else {

37 cmd.arg = 0;

38 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;

39 }

41 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);

依旧是那张熟悉的脸，前面见多了，这里就不想在分析了。

回到mmc_sd_init_card，436行开始就要获取SD卡的SCR寄存器了，SCR寄存器共64位，是关于这个SD卡的特殊功能的特性信息。关于这个用的比较少我们就不进去研究了，有兴趣的朋友可以自己看看源码。

447行是用来切换SD卡至高速模式，使用命令CMD6，CMD6是SD卡用来扩展功能的一条重要命令。在SD协议1.00和2.00的版本是，该命令主要用于切换卡进入高速模式。CMD6命令共有查询模式和设置模式两种。查询模式主要用于查询是否支持该功能，而设置模式主要用于对该功能的设置。我们采取的流程是先查询，后设置。根据SPEC，因此，我们第一次发送的命令参数应该为：0x00, 0xff, 0xff, 0xf1。该命令的作用是查询AccessMode是否支持High-Speed。命令发送完毕，这里需要注意的是，CMD6并不是用命令总线，而是用数据总线来进行应答。在命令发送完毕时，我们会从数据总线上接收到64Byte的数据。根据SPEC，我们判断第17Byte的低4Bit（是否等于1。是则继续，否则表示不支持高速模式。

有了这个背景下面分析一下它相关的源码:

[core/sd.c]

188 static int mmc_read_switch(struct mmc_card *card)

193 if (card->scr.sda_vsn < SCR_SPEC_VER_1)

194 return 0;

195

196 if (!(card->csd.cmdclass & CCC_SWITCH)) {

197 printk(KERN_WARNING "%s: card lacks mandatory switch "

198 function, performance might suffer.\n,

199 mmc_hostname(card->host));

205 status = kmalloc(64, GFP_KERNEL);

206 if (!status) {

207 printk(KERN_ERR "%s: could not allocate a buffer for "

208 switch capabilities.\n, mmc_hostname(card->host));

209 return -ENOMEM;

210 }

211

212 err = mmc_sd_switch(card, 0, 0, 1, status);

213 if (err) {

214 /* If the host or the card can't do the switch,

215 * fail more gracefully. */

216 if ((err != -EINVAL)

217 && (err != -ENOSYS)

218 && (err != -EFAULT))

219 goto out;

220

221 printk(KERN_WARNING "%s: problem reading switch "

222 capabilities, performance might suffer.\n,

223 mmc_hostname(card->host));

229 if (status[13] & 0x02)

230 card->sw_caps.hs_max_dtr = 50000000;

193行如果通过scr判断是ver1.1版，那么这里就没有必要继续做后面的工作了。

205行根据前面的描述，cmd6会利用数据线返回64个字节的信息，这个就是为了存放读取的状态值的。

212行是整个命令设置的重点，源码如下：

[core/sd_ops.c]

302 int mmc_sd_switch(struct mmc_card *card, int mode, int group,

303 u8 value, u8 *resp)

304 {

305 struct mmc_request mrq;

306 struct mmc_command cmd;

307 struct mmc_data data;

308 struct scatterlist sg;

309

310 BUG_ON(!card);

311 BUG_ON(!card->host);

312

313 /* NOTE: caller guarantees resp is heap-allocated */

318 memset(&mrq, 0, sizeof(struct mmc_request));

319 memset(&cmd, 0, sizeof(struct mmc_command));

320 memset(&data, 0, sizeof(struct mmc_data));

321

322 mrq.cmd = &cmd;

323 mrq.data = &data;

324

325 cmd.opcode = SD_SWITCH;

326 cmd.arg = mode << 31 | 0x00FFFFFF;

327 cmd.arg &= ~(0xF << (group * 4));

328 cmd.arg |= value << (group * 4);

329 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;

330

331 data.blksz = 64;

332 data.blocks = 1;

333 data.flags = MMC_DATA_READ;

334 data.sg = &sg;

335 data.sg_len = 1;

336

337 sg_init_one(&sg, resp, 64);

338

339 mmc_set_data_timeout(&data, card);

340

341 mmc_wait_for_req(card->host, &mrq);

342

343 if (cmd.error)

344 return cmd.error;

345 if (data.error)

346 return data.error;

347

348 return 0;

349 }

这条命令由于有数据的返回所以设计上较设置命令稍稍复杂一些，并由 mmc_wait_for_req来完成整个命令请求的。前面在分析card目录过程当中我们对数据的传输请求做了详细的分析，这里请求与之前见到的一致需要一个struct mmc_request结构，并初始化正确的struct mmc_data。同时struct scatterlist散列结构也是必须的，并利用337 sg_init_one(&sg, resp, 64);初始化了一个散列入口。

339行mmc_set_data_timeout(&data, card); 设置底层处理超时的参数，这个后面在分析host_ops中会提到。

341行mmc_wait_for_req就是整个函数期待的核心了。如果没有错误mmc_sd_switch就带着返回的数据高高兴兴的返回到mmc_read_switch的怀抱。

还剩下最后要说的两行229-230，根据返回设置卡允许的最大数据传输速率。

继续向下，mmc_sd_init_card 467行，前面我们说过一旦支持高速模式，那么就会利用CMD6来设置高速模式。

[core/sd.c]

241 static int mmc_switch_hs(struct mmc_card *card)

246 if (card->scr.sda_vsn < SCR_SPEC_VER_1)

247 return 0;

248

249 if (!(card->csd.cmdclass & CCC_SWITCH))

250 return 0;

251

252 if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))

253 return 0;

254

255 if (card->sw_caps.hs_max_dtr == 0)

260 status = kmalloc(64, GFP_KERNEL);

261 if (!status) {

262 printk(KERN_ERR "%s: could not allocate a buffer for "

263 switch capabilities.\n, mmc_hostname(card->host));

264 return -ENOMEM;

265 }

266

267 err = mmc_sd_switch(card, 1, 0, 1, status);

268 if (err)

269 goto out;

270

271 if ((status[16] & 0xF) != 1) {

272 printk(KERN_WARNING "%s: Problem switching card "

273 into high-speed mode!\n,

274 mmc_hostname(card->host));

275 } else {

276 mmc_card_set_highspeed(card);

277 mmc_set_timing(card->host, MMC_TIMING_SD_HS);

前面已经说过，第二个设置阶段所做的事情还是一样，所以仍然调用了mmc_sd_switch，但是请注意传递的参数是有区别的。

271行根据返回的statue决定判断是否转化状态。

276行mmc_card_set_highspeed(card);就是将这个好消息，记录在card当中。

#define mmc_card_set_highspeed(c) ((c)->state |= MMC_STATE_HIGHSPEED)

277行就是对SD控制器进行设置了。

[core/core.c]

848 void mmc_set_timing(struct mmc_host *host, unsigned int timing)

849 {

850 host->ios.timing = timing;

851 mmc_set_ios(host);

852 }

回到mmc_sd_init_card中来，476-481行最终会得到一个合适的max_dtr。然后调用mmc_set_clock对主机控制器的时钟进行设置。

[core/core.c]

616 void mmc_set_clock(struct mmc_host *host, unsigned int hz)

617 {

618 WARN_ON(hz < host->f_min);

619

620 if (hz > host->f_max)

621 hz = host->f_max;

622

623 host->ios.clock = hz;

624 mmc_set_ios(host);

625 }

最后一段将会设置DATA的总线宽度。这个依然使用我们前面所说的CMD6命令，调用的函数是mmc_app_set_bus_width，源码如下：

[core/sd_ops.c]

120 int mmc_app_set_bus_width(struct mmc_card *card, int width)

121 {

122 int err;

123 struct mmc_command cmd;

124

125 BUG_ON(!card);

126 BUG_ON(!card->host);

127

128 memset(&cmd, 0, sizeof(struct mmc_command));

129

130 cmd.opcode = SD_APP_SET_BUS_WIDTH;

131 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

132

133 switch (width) {

134 case MMC_BUS_WIDTH_1:

135 cmd.arg = SD_BUS_WIDTH_1;

136 break;

137 case MMC_BUS_WIDTH_4:

138 cmd.arg = SD_BUS_WIDTH_4;

144 err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);

130行的命令正是CMD6，同样144行的代码也是我们讲过N次的老朋友了。设置完SD卡，接下来该到SD控制器了，不然两边对不上，岂不就麻烦大了....

一旦SD卡接受了这个宽总线的命运，那么SD控制器也将不得不支持，因此497行将是对SD控制器的数据宽度进行设置，调用mmc_set_bus_width如下：

[core/core.c]

639 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)

640 {

641 host->ios.bus_width = width;

642 mmc_set_ios(host);

643 }

最后一点细节，所有准备工作都做好了，对于SD卡是否还应该检测一下有没有写保护，不然折腾了半天，最后被保护起来了那就丢大了。好了，500-508行通过调用host_ops中的检测只读函数，获取了卡的写保护状态并设置到card->state中以便日后使用。

#define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY)

回头对照一下SD卡初始化的流程图，总线宽度设置结束以后，初始化的过程就完成了。SD卡也就真正进入了数据传输的时代。同时mmc_sd_init_card也就走到了他生命的尽头....

在mmc_sd_init_card中走了很久很久，已经记不清来时的路了。也许好像大概，我们回到了mmc_attach_sd....

714行对于SD卡而言，主机为我们做了初始化中他所有能做的事情，该放他回家休息了，一句 mmc_release_host(host);带着无限的感激释放了SD卡控制器。

716行对于SD卡驱动来说有着特殊的意义.....

[core/bus.c]

222 int mmc_add_card(struct mmc_card *card)

223 {

224 int ret;

225 const char *type;

226

227 dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);

228

229 switch (card->type) {

230 case MMC_TYPE_MMC:

231 type = "MMC";

232 break;

233 case MMC_TYPE_SD:

234 type = "SD";

235 if (mmc_card_blockaddr(card))

236 type = "SDHC";

237 break;

238 case MMC_TYPE_SDIO:

246 if (mmc_host_is_spi(card->host)) {

247 printk(KERN_INFO "%s: new %s%s card on SPI\n",

248 mmc_hostname(card->host),

249 mmc_card_highspeed(card) ? "high speed " : "",

250 type);

251 } else {

252 printk(KERN_INFO "%s: new %s%s card at address %04x\n",

253 mmc_hostname(card->host),

254 mmc_card_highspeed(card) ? "high speed " : "",

255 type, card->rca);

256 }

257

258 ret = device_add(&card->dev);

259 if (ret)

260 return ret;

261

262 #ifdef CONFIG_DEBUG_FS

263 mmc_add_card_debugfs(card);

264 #endif

265

266 mmc_card_set_present(card);

267

268 return 0;

269 }

如果让我选出SD卡子系统中最美丽的一个函数的话，我愿意说是mmc_add_card，但时也是最八卦的一个函数。整个函数一共50余行，却单单只说了一句有意义的话：

258 ret = device_add(&card->dev);

还记得申请这个card时我说过的话吗？我说card->dev早晚得和他命中注定的那个她步入婚礼的殿堂，今天便是我说的那个黄道吉日。也就是因为这句话才让我们早在card中所说的res = mmc_register_driver(&mmc_driver);有了probe成功的那一天，然后才进一步加深了SD卡与块设备驱动的联系。

好了，再美丽的函数我们也只能欣赏到这了，循着来时的路我们走到了mmc_attach_sd的尽头，等着我们的依旧是哪个不老的传说——mmc_rescan。

一旦mmc_attach_sd成功走出，我们的目光将跳转到1113行....

我们知道像SD卡的这种设备，永远是个风流的主。他也许不会永远守护在你的身边，那么就需要你时时刻刻去关心一下，他是否还在你身边停留。没办法那就没隔1S钟检测一次吧。好了，这下子问题就上来了。我们知道每当调用

mmc_schedule_delayed_work(&host->detect, HZ);的时候，每过后1秒钟都会去执行mmc_rescan，那么是否每隔1S正常工作的SD卡都要被初始化一次呢？要是SD卡一旦拔出，那么谁又将为这种不负责任的行为埋单呢？

为了找到这个幕后的真凶，看来我们又不得不重入mmc_rescan的代码了。代码就不贴了，用到了再说，只要您不是太健忘，估计还是能找到他的出生地的。

1045行，第一次看这个函数的时候，我们说还用不上，但是现在情况可就不一样了，谁叫我们都是经历了初始化的人啊。在mmc_rescan调用mmc_attach_sd的过程中曾经出现了这么一个函数的身影，那便是mmc_sd_attach_bus_ops。对就是他使得我们的host与bus_ops有染，为了找出这个关联的对象我们不惜再次贴出mmc_sd_attach_bus_ops的代码。

[core/sd.c]

642 static void mmc_sd_attach_bus_ops(struct mmc_host *host)

643 {

644 const struct mmc_bus_ops *bus_ops;

645

646 if (host->caps & MMC_CAP_NONREMOVABLE)

647 bus_ops = &mmc_sd_ops_unsafe;

648 else

649 bus_ops = &mmc_sd_ops;

650 mmc_attach_bus(host, bus_ops);

651 }

bus_ops = &mmc_sd_ops;立即吸引了我们的眼球，那么干脆坚持到底，看看他是些什么东西。

[core/sd.c]

627 static const struct mmc_bus_ops mmc_sd_ops = {

628 .remove = mmc_sd_remove,

629 .detect = mmc_sd_detect,

630 .suspend = NULL,

631 .resume = NULL,

632 .power_restore = mmc_sd_power_restore,

633 };

好了，有了这个基础我们继续回到mmc_rescan，那么1045行也就是增加这条总线的引用计数了。

1048-1049行这时候这两行的内容就不容轻易飘过了，host->bus_ops意味这这个SD卡已经注册在案了，那么是否他还依然守候着卡槽呢？那可不一定调用host->bus_ops->detect(host);检查一下，结果就到了上面的.detect = mmc_sd_detect,进入mmc_sd_detect。

[core/sd.c]

540 static void mmc_sd_detect(struct mmc_host *host)

545 BUG_ON(!host->card);

546

547 mmc_claim_host(host);

548

549 /*

550 * Just check if our card has been removed.

551 */

552 err = mmc_send_status(host->card, NULL);

553

554 mmc_release_host(host);

555

556 if (err) {

557 mmc_sd_remove(host);

558

559 mmc_claim_host(host);

560 mmc_detach_bus(host);

561 mmc_release_host(host);

562 }

563 }

这里检测SD卡是否存在的方法很简单，直接查询状态，如果出错，那对不起接下来发生的一切就让人难以接受了。之前初始化的一切都将付之一炬….

556行会令这张风光一时的SD卡彻底消失，代码如下：

[core/sd.c]

528 static void mmc_sd_remove(struct mmc_host *host)

529 {

530 BUG_ON(!host);

531 BUG_ON(!host->card);

532

533 mmc_remove_card(host->card);

534 host->card = NULL;

535 }

重点来看532行mmc_remove_card….

[core/bus.c]

275 void mmc_remove_card(struct mmc_card *card)

276 {

277 #ifdef CONFIG_DEBUG_FS

278 mmc_remove_card_debugfs(card);

279 #endif

280

281 if (mmc_card_present(card)) {

282 if (mmc_host_is_spi(card->host)) {

283 printk(KERN_INFO "%s: SPI card removed\n",

284 mmc_hostname(card->host));

285 } else {

286 printk(KERN_INFO "%s: card %04x removed\n",

287 mmc_hostname(card->host), card->rca);

288 }

289 device_del(&card->dev);

290 }

291

292 put_device(&card->dev);

293 }

289和292行将SD卡在设备模型的中的所有记录将全部销毁，同时card目录下驱动对应的remove函数也将做相应的清理工作，这里就不详细诉了。回到mmc_sd_remove…

最后，host解除了与card之间的约定，使得host->card = NULL;。那么悲剧的mmc_sd_remove函数也就悄悄谢幕了…

接下来就是对这条bus_ops的操作了，mmc_detach_bus相关内容如下：

[core/core.c]

993 void mmc_detach_bus(struct mmc_host *host)

994 {

995 unsigned long flags;

996

997 BUG_ON(!host);

998

999 WARN_ON(!host->claimed);

1000 WARN_ON(!host->bus_ops);

1001

1002 spin_lock_irqsave(&host->lock, flags);

1003

1004 host->bus_dead = 1;

1005

1006 spin_unlock_irqrestore(&host->lock, flags);

1007

1008 mmc_power_off(host);

1009

1010 mmc_bus_put(host);

1011 }

1004和1010行使得bus_ops与card彻底绝交，伤心的card从新回到mmc_rescan….

1057行这时候如果成立说明卡依然存在，初始化的过程就直接跳过，进入下一轮的mmc_schedule_delayed_work(&host->detect, HZ);否则就必须开始新一轮的检测了，后面的内容就和我们之前分析的一致了。所以到这里您到可放心，只要卡不离槽，驱动是决计不会实施第二轮的初始化的。

http://m.blog.csdn.net/blog/rain0993/8476755