core层作为整个MMC 的核心，这部分完成了不同协议和规范的实现，并为HOST 层的驱动提供了接口函数。
CORE 部分: 这是整个MMC 的核心存，这部分完成了不同协议和规范的实现，并为HOST 层的驱动提供了接口函数。
HOST 部分是针对不同主机的驱动程序，这一部是驱动程序工程师需要根据自己的特点平台来完成的。
CARD 部分：因为这些记忆卡都是块设备，当然需要提供块设备的驱动程序，这部分就是实现了将你的SD 卡如何实现为块设备的。
它们分布于下面的文件夹中 Linux/drivers/mmc中：
1 数据结构
1.1 mmc_host
定义位于：linux-3.10.73\include\linux\mmc\host.h
1 struct mmc_host {
2 struct device *parent;
3 struct device class_dev;
4 int index;
5 const struct mmc_host_ops *ops;
6 unsigned int f_min;
7 unsigned int f_max;
8 unsigned int f_init;
9 u32 ocr_avail;
10 u32 ocr_avail_sdio; /* SDIO-specific OCR */
11 u32 ocr_avail_sd; /* SD-specific OCR */
12 u32 ocr_avail_mmc; /* MMC-specific OCR */
13 struct notifier_block pm_notify;
14 u32 max_current_330;
15 u32 max_current_300;
16 u32 max_current_180;
17
18 ...
19
20 unsigned long private[0] ____cacheline_aligned;
21 }1.2 总线
platform bus //MMC host controller 作为一种 platform device, 它是需要注册到 platform bus上 的 。
1 struct bus_type platform_bus_type = {
2 .name = "platform",
3 .dev_attrs = platform_dev_attrs,
4 .match = platform_match,
5 .uevent = platform_uevent,
6 .pm = &platform_dev_pm_ops,
7 };mmc bus type ，在mmc_init()中被创建的.通过调用 mmc_register_bus() 来注册 MMC 总线 。定义位于：drivers\mmc\core\bus.c
1 static struct bus_type mmc_bus_type = {
2 .name = "mmc",
3 .dev_attrs = mmc_dev_attrs,
4 .match = mmc_bus_match,
5 .uevent = mmc_bus_uevent,
6 .probe = mmc_bus_probe,
7 .remove = mmc_bus_remove,
8 .pm = &mmc_bus_pm_ops,
9 };sdio bus type，在mmc_init()中被创建的.通过调用sdio_register_bus() 来注册 SDIO 总线 。定义位于：drivers\mmc\core\sdio_bus.c。
1 static struct bus_type sdio_bus_type = {
2 .name = "sdio",
3 .dev_attrs = sdio_dev_attrs,
4 .match = sdio_bus_match,
5 .uevent = sdio_bus_uevent,
6 .probe = sdio_bus_probe,
7 .remove = sdio_bus_remove,
8 .pm = SDIO_PM_OPS_PTR,
9 };1.3 操作结构体
其中mmc总线操作相关函数，由于mmc卡支持多种总数据线，如SPI、SDIO、8LineMMC而不同的总线的操作控制方式不尽相同，所以通过此结构与相应的总线回调函数相关联。
sdio的总线操作 core/sdio.c
1 static const struct mmc_bus_ops mmc_sdio_ops = {
2 .remove = mmc_sdio_remove,
3 .detect = mmc_sdio_detect,
4 .suspend = mmc_sdio_suspend,
5 .resume = mmc_sdio_resume,
6 .power_restore = mmc_sdio_power_restore,
7 .alive = mmc_sdio_alive,
8 };mmc卡的总线操作 core/mmc.c
1 static const struct mmc_bus_ops mmc_ops = {
2 .awake = mmc_awake,
3 .sleep = mmc_sleep,
4 .remove = mmc_remove,
5 .detect = mmc_detect,
6 .suspend = NULL,
7 .resume = NULL,
8 .power_restore = mmc_power_restore,
9 .alive = mmc_alive,
10 };sd卡的总线操作 core/sd.c
1 static const struct mmc_bus_ops mmc_sd_ops = {
2 .remove = mmc_sd_remove,
3 .detect = mmc_sd_detect,
4 .suspend = NULL,
5 .resume = NULL,
6 .power_restore = mmc_sd_power_restore,
7 .alive = mmc_sd_alive,
8 };.detect操作函数：驱动程序经常需要调用此函数去检测mmc卡的状态，具体实现是发送CMD13命令，并读回响应，如果响应错误，则依次调用.remove、detach_bus来移除卡及释放总线。
2 core的flow
内核启动时，首先执行core/core.c的mmc_init，注册mmc、sd总线，以及一个host class设备。接着执行card/block.c中mmc_blk_init()，申请一个块设备。
2.1 初始化
2.1.1 mmc_init
定义位于：linux-3.10.73\drivers\mmc\core\core.c
1 static int __init mmc_init(void)
2 {
3 int ret;
4
5 workqueue = alloc_ordered_workqueue("kmmcd", 0);//建立队列，主要用来支持热插热拔
6 if (!workqueue)
7 return -ENOMEM;
8
9 ret = mmc_register_bus();//注册mmc总线
10 if (ret)
11 goto destroy_workqueue;
12
13 ret = mmc_register_host_class();//注册mmc host class
14 if (ret)
15 goto unregister_bus;
16
17 ret = sdio_register_bus();//注册SDIO总线
18 if (ret)
19 goto unregister_host_class;
20
21 return 0;
22
23 unregister_host_class:
24 mmc_unregister_host_class();
25 unregister_bus:
26 mmc_unregister_bus();
27 destroy_workqueue:
28 destroy_workqueue(workqueue);
29
30 return ret;
31 }2.1.2 函数mmc_blk_init
定义位于：mmc/card/block.c
1 static int __init mmc_blk_init(void)
2 {
3 int res;
4
5 if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
6 pr_info("mmcblk: using %d minors per device\n", perdev_minors);
7
8 max_devices = 256 / perdev_minors;
9
10 res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");//注册一个块设备
11 if (res)
12 goto out;
13
14 res = mmc_register_driver(&mmc_driver);//注册一个mmc设备驱动
15 if (res)
16 goto out2;
17
18 return 0;
19 out2:
20 unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
21 out:
22 return res;
23 }mmc_driver
1 static struct mmc_driver mmc_driver = {
2 .drv = {
3 .name = "mmcblk",
4 },
5 .probe = mmc_blk_probe,
6 .remove = mmc_blk_remove,
7 .suspend = mmc_blk_suspend,
8 .resume = mmc_blk_resume,
9 };mmc_driver probe函数
1 static int mmc_blk_probe(struct mmc_card *card)
2 {
3 struct mmc_blk_data *md, *part_md;
4 char cap_str[10];
5
6 /*
7 * Check that the card supports the command class(es) we need.
8 */
9 if (!(card->csd.cmdclass & CCC_BLOCK_READ))
10 return -ENODEV;
11
12 md = mmc_blk_alloc(card);
13 if (IS_ERR(md))
14 return PTR_ERR(md);
15
16 string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
17 cap_str, sizeof(cap_str));
18 pr_info("%s: %s %s %s %s\n",
19 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
20 cap_str, md->read_only ? "(ro)" : "");
21
22 if (mmc_blk_alloc_parts(card, md))
23 goto out;
24
25 mmc_set_drvdata(card, md);
26 mmc_fixup_device(card, blk_fixups);
27
28 if (mmc_add_disk(md))
29 goto out;
30
31 list_for_each_entry(part_md, &md->part, part) {
32 if (mmc_add_disk(part_md))
33 goto out;
34 }
35 return 0;
36
37 out:
38 mmc_blk_remove_parts(card, md);
39 mmc_blk_remove_req(md);
40 return 0;
41 }2.2 注册mmc总线
定义位于：drivers\mmc\core\bus.c
1 int mmc_register_bus(void)
2 {
3 return bus_register(&mmc_bus_type);//注册bus
4 }
5
6 static struct bus_type mmc_bus_type = {
7 .name = "mmc",
8 .dev_attrs = mmc_dev_attrs,
9 .match = mmc_bus_match,
10 .uevent = mmc_bus_uevent,
11 .probe = mmc_bus_probe,
12 .remove = mmc_bus_remove,
13 .pm = &mmc_bus_pm_ops,
14 };2.3 注册host class
定义位于：drivers\mmc\core\host.c
1 static struct class mmc_host_class = {
2 .name = "mmc_host",
3 .dev_release = mmc_host_classdev_release,
4 };
5
6 int mmc_register_host_class(void)
7 {
8 return class_register(&mmc_host_class);
9 }2.4 注册sdio总线
定义位于：drivers\mmc\core\sdio_bus.c
1 static struct bus_type sdio_bus_type = {
2 .name = "sdio",
3 .dev_attrs = sdio_dev_attrs,
4 .match = sdio_bus_match,
5 .uevent = sdio_bus_uevent,
6 .probe = sdio_bus_probe,
7 .remove = sdio_bus_remove,
8 .pm = SDIO_PM_OPS_PTR,
9 };
10
11 int sdio_register_bus(void)
12 {
13 return bus_register(&sdio_bus_type);
14 }2.5 mmc_rescan函数
mmc_rescan 函数是需要重点关注的,因为SD卡协议中的检测，以及卡识别等都是在此函数中实现。
插入SD卡，主控制器产生中断，进入中断处理函数s3cmci_irq_cd，其中调用的函数 mmc_detect_change，它将最终调用queue_delayed_work执行工作队列里的mmc_rescan函数。
mmc_rescan扫描SD总线上是否存在SD卡，是mmc host的detect work的功能函数，用于探测目标卡的类型并且根据mmc/sd/sdio协议进行comm的初始化。
1 void mmc_rescan(struct work_struct *work)
2 {
3 struct mmc_host *host =
4 container_of(work, struct mmc_host, detect.work);//
5 int i;
6
7 if (host->rescan_disable)
8 return;
9
10 /* If there is a non-removable card registered, only scan once */
11 if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
12 return;
13 host->rescan_entered = 1;
14
15 mmc_bus_get(host);//
16
17 /*
18 * if there is a _removable_ card registered, check whether it is
19 * still present
20 */
21 if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
22 && !(host->caps & MMC_CAP_NONREMOVABLE))
23 host->bus_ops->detect(host);//
24
25 host->detect_change = 0;//
26
27 /*
28 * Let mmc_bus_put() free the bus/bus_ops if we've found that
29 * the card is no longer present.
30 */
31 mmc_bus_put(host);//减少引用计数，即释放
32 mmc_bus_get(host);//增加bus引用计数
33
34 /* if there still is a card present, stop here */
35 if (host->bus_ops != NULL) {
36 mmc_bus_put(host);//如果卡仍然存在，减少引用计数，不必探测了
37 goto out;
38 }
39
40 /*
41 * Only we can add a new handler, so it's safe to
42 * release the lock here.
43 */
44 mmc_bus_put(host);//
45
46 if (host->ops->get_cd && host->ops->get_cd(host) == 0) {//有卡，退出
47 mmc_claim_host(host);//
48 mmc_power_off(host);//
49 mmc_release_host(host);//
50 goto out;
51 }
52
53 mmc_claim_host(host);//
54 for (i = 0; i < ARRAY_SIZE(freqs); i++) {
55 if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))//
56 break;
57 if (freqs[i] <= host->f_min)
58 break;
59 }
60 mmc_release_host(host);//
61
62 out:
63 if (host->caps & MMC_CAP_NEEDS_POLL)
64 mmc_schedule_delayed_work(&host->detect, HZ);//
65 }初始化卡接以下流程初始化：
发送CMD0使卡进入IDLE状态
发送CMD8，检查卡是否SD2.0。SD1.1是不支持CMD8的，因此在SD2.0 Spec中提出了先发送CMD8，如响应为无效命令，则卡为SD1.1，否则就是SD2.0（请参考SD2.0 Spec）。
发送CMD5读取OCR寄存器。
发送ACMD55、CMD41，使卡进入工作状态。MMC卡并不支持ACMD55、CMD41，如果这步通过了，则证明这张卡是SD卡。
如果d步骤错误，则发送CMD1判断卡是否为MMC。SD卡不支持CMD1，而MMC卡支持，这就是SD和MMC类型的判断依据。
如果ACMD41和CMD1都不能通过，那这张卡恐怕就是无效卡了，初始化失败。假如扫描到总线上挂有有效的设备，就调用相对应的函数把设备装到系统中，mmc_attach_sdio()、mmc_attach_sd()、mmc_attach_mmc()这三个函数分别是装载sdio设备，sd卡和mmc卡的。
在 sd卡中，驱动循环发送ACMD41、CMD55给卡，读取OCR寄存器，成功后，依次发送CMD2(读CID)、CMD3(得到RCA)、CMD9(读 CSD)、CMD7(选择卡)。后面还有几个命令分别是ACMD41&CMD51，使用CMD6切换一些功能，如切换到高速模式。
经过上述步骤，已经确定当前插入的卡是一张有效、可识别的存储卡。然后调用mmc_add_card()把存储卡加到系统中。正式与系统驱动连接在一起。
2.6 函数mmc_rescan_try_freq
1 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
2 {
3 host->f_init = freq; //根据mmc_recan函数传进来的参数知道，首先传进来的是400kHZ.一般mmc/sd/sdio的初始化时钟采用的是400kHZ
4
5 #ifdef CONFIG_MMC_DEBUG
6 pr_info("%s: %s: trying to init card at %u Hz\n",
7 mmc_hostname(host), __func__, host->f_init);
8 #endif
9 mmc_power_up(host);//上电，我们知道，在mmc_add_host时，会调用mmc_start_host,而那里首先是将host掉电的。这里上电
10
11 /*
12 * Some eMMCs (with VCCQ always on) may not be reset after power up, so
13 * do a hardware reset if possible.
14 */
15 mmc_hw_reset_for_init(host);//复位硬件，可以选择性实现。
16
17 /*
18 * sdio_reset sends CMD52 to reset card. Since we do not know
19 * if the card is being re-initialized, just send it. CMD52
20 * should be ignored by SD/eMMC cards.
21 */
22 sdio_reset(host);
23 mmc_go_idle(host);//发送CMD0 复位SD卡
24
25 mmc_send_if_cond(host, host->ocr_avail);
26 /*Linux 卡的探测顺序是：先辨别卡是否是sdio功能卡或者是sdio与sd卡的组合卡，然后辨别是否是SD卡，最后才会辨别是否是mmc卡*/27 /* Order's important: probe SDIO, then SD, then MMC */
28 if (!mmc_attach_sdio(host))//匹配sdio接口
29 return 0;
30 if (!mmc_attach_sd(host))
31 return 0;
32 if (!mmc_attach_mmc(host))
33 return 0;
34
35 mmc_power_off(host);
36 return -EIO;
37 }函数sdio_reset(host);/的作用：
（1）如果目标卡是纯SD卡（对MMC卡不了解，所以不加评论），则目标卡不会应答,一般主机host的寄存器会报错，但是这个无关紧要，可以不理它。
（2）如果目标卡是纯SDIO卡，那么这里就是复位SDIO卡，通过命令CMD52来实现的。
（3）如果目标卡是SD卡和SDIO卡的组合卡，则需要先发送CMD52来复位SDIO卡，再复位SD卡，因为CMD52要先于CMD0发送。
函数mmc_send_if_cond(host, host->ocr_avail);的作用 ：
为了支持sd version 2.0以上的sd卡，在初始化的过程中必须在发送ACMD41之前，先发送CMD8,CMD8一般是用于检测SD卡是否能运行在host提供的电压范围内。大家可能发现，这个调用过程没有检查是否出错，其实一般CMD8是用来辨别目标卡是否是高容量SD卡，如果是，CMD8 会有R7应答，R7应答中会有目标SD卡支持的电压范围以及CMD8中发送过去的“check pattern(一般是0xAA)”,否则，目标卡不会应答，在Linux 内核代码中，判断是这样的，如果应答，目标卡就是SD高容量卡，否则出现应答超时错误，就是标准SD卡！这里的调用，主要作用是为了在发送ACMD41之前发送CMD8，这是version 2.0及以上的规定顺序，后面还会有发送CMD8的地方，那里才是真正检测目标卡的类型的地方。
2.6.1 函数mmc_go_idle
1 int mmc_go_idle(struct mmc_host *host)
2 struct mmc_command cmd = {0};
3 cmd.opcode = MMC_GO_IDLE_STATE; //即CMD0
4 cmd.arg = 0; //此命令无参数
5 err = mmc_wait_for_cmd(host, &cmd, 0)
6
7 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
8 memset(cmd->resp, 0, sizeof(cmd->resp)); //调用了 mmc_start_request,
9 cmd->retries = retries;
10 mrq.cmd = cmd;
11 mmc_wait_for_req(host, &mrq);
12
13 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) ----重要函数
14 __mmc_start_req(host, mrq);
15
16 static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
17 mmc_start_request(host, mrq);
18
19 static void mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
20 host->ops->request(host, mrq); //即 msmsdcc_request， MMC 核心与核HOST 层握手了host即struct mmc_host类型，在drivers\mmc\host\s3cmci.c的probe函数中定义赋值：
1 static int s3cmci_probe(struct platform_device *pdev)
2 {
3 ...
4 mmc->ops = &s3cmci_ops;
5 ...
6 }
7
8 static struct mmc_host_ops s3cmci_ops = {
9 .request = s3cmci_request,
10 .set_ios = s3cmci_set_ios,
11 .get_ro = s3cmci_get_ro,
12 .get_cd = s3cmci_card_present,
13 .enable_sdio_irq = s3cmci_enable_sdio_irq,
14 };request函数分析见linux设备驱动-SD卡驱动详解3 host层。
2.7 sdio的挂载
2.7.1 函数mmc_attach_sdio
定义位于：drivers\mmc\core\sdio.c
1 int mmc_attach_sdio(struct mmc_host *host)
2 {
3 int err, i, funcs;
4 u32 ocr;
5 struct mmc_card *card;
6
7 BUG_ON(!host);
8 WARN_ON(!host->claimed);
9
10 err = mmc_send_io_op_cond(host, 0, &ocr);//
11 if (err)
12 return err;
13
14 mmc_attach_bus(host, &mmc_sdio_ops);//
15 if (host->ocr_avail_sdio)
16 host->ocr_avail = host->ocr_avail_sdio;
17
18 /*
19 * Sanity check the voltages that the card claims to
20 * support.
21 */
22 if (ocr & 0x7F) {
23 pr_warning("%s: card claims to support voltages "
24 "below the defined range. These will be ignored.\n",
25 mmc_hostname(host));
26 ocr &= ~0x7F;
27 }
28
29 host->ocr = mmc_select_voltage(host, ocr);//设置时钟和总线 ---------------- 详解1
30
31 /*
32 * Can we support the voltage(s) of the card(s)?
33 */
34 if (!host->ocr) {
35 err = -EINVAL;
36 goto err;
37 }
38
39 /*
40 * Detect and init the card.
41 */
42 if (mmc_host_uhs(host))
43 /* to query card if 1.8V signalling is supported */
44 host->ocr |= R4_18V_PRESENT;
45
46 err = mmc_sdio_init_card(host, host->ocr, NULL, 0);//
47 if (err) {
48 if (err == -EAGAIN) {
49 /*
50 * Retry initialization with S18R set to 0.
51 */
52 host->ocr &= ~R4_18V_PRESENT;
53 err = mmc_sdio_init_card(host, host->ocr, NULL, 0);//
54 }
55 if (err)
56 goto err;
57 }
58 card = host->card;
59
60 /*
61 * Enable runtime PM only if supported by host+card+board
62 */
63 if (host->caps & MMC_CAP_POWER_OFF_CARD) {
64 /*
65 * Let runtime PM core know our card is active
66 */
67 err = pm_runtime_set_active(&card->dev);//
68 if (err)
69 goto remove;
70
71 /*
72 * Enable runtime PM for this card
73 */
74 pm_runtime_enable(&card->dev);//
75 }
76
77 /*
78 * The number of functions on the card is encoded inside
79 * the ocr.
80 */
81 funcs = (ocr & 0x70000000) >> 28;
82 card->sdio_funcs = 0;
83
84 /*
85 * Initialize (but don't add) all present functions.
86 */
87 for (i = 0; i < funcs; i++, card->sdio_funcs++) {
88 err = sdio_init_func(host->card, i + 1);
89 if (err)
90 goto remove;
91
92 /*
93 * Enable Runtime PM for this func (if supported)
94 */
95 if (host->caps & MMC_CAP_POWER_OFF_CARD)
96 pm_runtime_enable(&card->sdio_func[i]->dev);
97 }
98
99 /*
100 * First add the card to the driver model...
101 */
102 mmc_release_host(host);
103 err = mmc_add_card(host->card);//注册一个mmc card
104 if (err)
105 goto remove_added;
106
107 /*
108 * ...then the SDIO functions.
109 */
110 for (i = 0;i < funcs;i++) {
111 err = sdio_add_func(host->card->sdio_func[i]);//注册一个sdio func
112 if (err)
113 goto remove_added;
114 }
115
116 mmc_claim_host(host);//
117 return 0;
118
119
120 remove_added:
121 /* Remove without lock if the device has been added. */
122 mmc_sdio_remove(host);
123 mmc_claim_host(host);//
124 remove:
125 /* And with lock if it hasn't been added. */
126 mmc_release_host(host);//
127 if (host->card)
128 mmc_sdio_remove(host);
129 mmc_claim_host(host);
130 err:
131 mmc_detach_bus(host);//
132
133 pr_err("%s: error %d whilst initialising SDIO card\n",
134 mmc_hostname(host), err);
135
136 return err;
137 }详解1：mmc_select_voltage函数设置时钟和总线，协议层里利用回调函数为所有满足该协议的设备提供统一的接口，而具体实现由底层不同的设备驱动各自完成。注意到，之所以要定义一些放之四海而皆准的公用的类，比如struct mmc_host，就是需要通过struct mmc_host *host指针作为形参传到协议层所提供的接口函数中，从而得以调用。
1 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
2 {
3 mmc_set_ios(host);
4
5 ... ...
6 }
7
8 static inline void mmc_set_ios(struct mmc_host *host)
9 {
10 struct mmc_ios *ios = &host->ios;
11
12 host->ops->set_ios(host, ios); // 设置主控制器时钟和总线的回调函数，具体实现由主控制器驱动完成
13 }2.7.2 函数mmc_add_card
定义位于：drivers\mmc\core\bus.c
最终call device_add，就是将card注册进linux设备模型 ，注册结果就是可以在/sys/bus/mmc/devices目录下见到card 的名字，如mmc2:0001
1 /*
2 * Register a new MMC card with the driver model.
3 */
4 int mmc_add_card(struct mmc_card *card)
5 {
6 int ret;
7 const char *type;
8 const char *uhs_bus_speed_mode = "";
9 static const char *const uhs_speeds[] = {
10 [UHS_SDR12_BUS_SPEED] = "SDR12 ",
11 [UHS_SDR25_BUS_SPEED] = "SDR25 ",
12 [UHS_SDR50_BUS_SPEED] = "SDR50 ",
13 [UHS_SDR104_BUS_SPEED] = "SDR104 ",
14 [UHS_DDR50_BUS_SPEED] = "DDR50 ",
15 };
16
17
18 dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);//设置device 名字
19
20 switch (card->type) {
21 case MMC_TYPE_MMC:
22 type = "MMC";
23 break;
24 case MMC_TYPE_SD:
25 type = "SD";
26 if (mmc_card_blockaddr(card)) {
27 if (mmc_card_ext_capacity(card))
28 type = "SDXC";
29 else
30 type = "SDHC";
31 }
32 break;
33 case MMC_TYPE_SDIO:
34 type = "SDIO";
35 break;
36 case MMC_TYPE_SD_COMBO:
37 type = "SD-combo";
38 if (mmc_card_blockaddr(card))
39 type = "SDHC-combo";
40 break;
41 default:
42 type = "?";
43 break;
44 }
45
46 if (mmc_sd_card_uhs(card) &&
47 (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
48 uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
49
50 if (mmc_host_is_spi(card->host)) {
51 pr_info("%s: new %s%s%s card on SPI\n",
52 mmc_hostname(card->host),
53 mmc_card_highspeed(card) ? "high speed " : "",
54 mmc_card_ddr_mode(card) ? "DDR " : "",
55 type);
56 } else {
57 pr_info("%s: new %s%s%s%s%s card at address %04x\n",
58 mmc_hostname(card->host),
59 mmc_card_uhs(card) ? "ultra high speed " :
60 (mmc_card_highspeed(card) ? "high speed " : ""),
61 (mmc_card_hs200(card) ? "HS200 " : ""),
62 mmc_card_ddr_mode(card) ? "DDR " : "",
63 uhs_bus_speed_mode, type, card->rca);
64 }
65
66 #ifdef CONFIG_DEBUG_FS
67 mmc_add_card_debugfs(card);
68 #endif
69 mmc_init_context_info(card->host);
70
71 ret = device_add(&card->dev);//添加设备device
72 if (ret)
73 return ret;
74
75 mmc_card_set_present(card);
76
77 return 0;
78 }2.7.3 sdio总线上driver
以上已向系统添加设备device。以TIdrivers\net\wireless\ti\wlcore\sdio.c的wlan为例：
1 static struct sdio_driver wl1271_sdio_driver = {
2 .name = "wl1271_sdio",
3 .id_table = wl1271_devices,
4 .probe = wl1271_probe,
5 .remove = wl1271_remove,
6 #ifdef CONFIG_PM
7 .drv = {
8 .pm = &wl1271_sdio_pm_ops,
9 },
10 #endif
11 };
12
13 static int __init wl1271_init(void)
14 {
15 return sdio_register_driver(&wl1271_sdio_driver);//向sdio总线注册driver
16 }函数sdio_register_driver，定义位于：drivers\mmc\core\sdio_bus.c
1 /**
2 * sdio_register_driver - register a function driver
3 * @drv: SDIO function driver
4 */
5 int sdio_register_driver(struct sdio_driver *drv)
6 {
7 drv->drv.name = drv->name;
8 drv->drv.bus = &sdio_bus_type;
9 return driver_register(&drv->drv);
10 }总结：（1）以上device和driver是挂在sdio总线上的，sdio总线在kernel启动时加载的；
（2）以drivers\mmc\host\s3cmci.c为例作为host，sdio设备插入时产生中断，调用mmc_resan建立host等工作，最终添加sdio总线上的设备device；
（3）以下的mmc总线和sd卡也是类似。
2.8 sd卡的挂载
2.8.1 函数mmc_attach_sd
完成匹配，和初始化卡的功能 。定义位于：drivers\mmc\core\sd.c
1 /*
2 * Starting point for SD card init.
3 */
4 int mmc_attach_sd(struct mmc_host *host)
5 {
6 int err;
7 u32 ocr;
8
9 BUG_ON(!host);
10 WARN_ON(!host->claimed);
11
12 err = mmc_send_app_op_cond(host, 0, &ocr);//检测是否是支持SD卡
13 if (err)
14 return err;
15
16 mmc_sd_attach_bus_ops(host);
17 if (host->ocr_avail_sd)
18 host->ocr_avail = host->ocr_avail_sd;
19
20 /*
21 * We need to get OCR a different way for SPI.
22 */
23 if (mmc_host_is_spi(host)) {
24 mmc_go_idle(host);
25
26 err = mmc_spi_read_ocr(host, 0, &ocr);
27 if (err)
28 goto err;
29 }
30
31 /*
32 * Sanity check the voltages that the card claims to
33 * support.
34 */
35 if (ocr & 0x7F) {
36 pr_warning("%s: card claims to support voltages "
37 "below the defined range. These will be ignored.\n",
38 mmc_hostname(host));
39 ocr &= ~0x7F;
40 }
41
42 if ((ocr & MMC_VDD_165_195) &&
43 !(host->ocr_avail_sd & MMC_VDD_165_195)) {
44 pr_warning("%s: SD card claims to support the "
45 "incompletely defined 'low voltage range'. This "
46 "will be ignored.\n", mmc_hostname(host));
47 ocr &= ~MMC_VDD_165_195;
48 }
49
50 host->ocr = mmc_select_voltage(host, ocr);//设置MMC电压
51
52 /*
53 * Can we support the voltage(s) of the card(s)?
54 */
55 if (!host->ocr) {
56 err = -EINVAL;
57 goto err;
58 }
59
60 /*
61 * Detect and init the card.
62 */
63 err = mmc_sd_init_card(host, host->ocr, NULL);//对mmc卡进行初始化，主要是读取mmc卡里的一些寄存器信息，且对这些寄存器的值进行设置
64 if (err)
65 goto err;
66
67 mmc_release_host(host);
68 err = mmc_add_card(host->card);//调用 mmc_add_card 来把 mmc_card 挂载到 mmc_bus_type 总线去
69 mmc_claim_host(host);
70 if (err)
71 goto remove_card;
72
73 return 0;
74
75 remove_card:
76 mmc_release_host(host);
77 mmc_remove_card(host->card);
78 host->card = NULL;
79 mmc_claim_host(host);
80 err:
81 mmc_detach_bus(host);
82
83 pr_err("%s: error %d whilst initialising SD card\n",
84 mmc_hostname(host), err);
85
86 return err;
87 }2.8.2 函数mmc_send_app_op_cond
定义位于：drivers\mmc\core\sd_ops.c
1 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
2 {
3 ...
4 cmd.opcode = SD_APP_OP_COND; //ACMD41,获取 SDcard 的允许电压范围值,保存在 ocr 中. 所有发送它之前需要发送 CMD_55 命令。执行完后 card 状态变为 READY
5 ...
6 }2.8.3 函数mmc_sd_init_card
1 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,struct mmc_card *oldcard)
2 {
3 ...
4 err = mmc_sd_get_cid(host, ocr, cid, &rocr); //发送 CMD2 ，获取卡的身份信息，进入到身份状态
5 ...
6 card = mmc_alloc_card(host, &sd_type); //分配一张 SD 类型的 card 结构
7 ...
8 err = mmc_send_relative_addr(host, &card->rca); //获取卡的相对地址，注意一前卡和主机通信都采用默认地址，现在有了自己的地址了，进入到 stand_by 状态
9 ...
10 err = mmc_sd_get_csd(host, card); ----mmc_send_csd(card, card->raw_csd);//CMD9, 获取 CSD 寄存器的信息，包括 block 长度，卡容量等信息
11 ...
12 err = mmc_select_card(card); //发送 CMD7, 选中目前 RADD 地址上的卡，任何时候总线上只有一张卡被选中，进入了传输状态
13 ...
14 err = mmc_sd_setup_card(host, card, oldcard != NULL);
15 ...
16 }函数mmc_sd_setup_card
1 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,bool reinit)
2 {
3 ...
4 mmc_app_send_scr(card, card->raw_scr); //发送命令 ACMD51 获取 SRC 寄存器的内容，进入到 SENDING-DATA 状态
5 ...
6 if (host->ops->get_ro(host) > 0 ) // get_ro(host) 即是 msmsdcc_get_ro
7 mmc_card_set_readonly(card); //是否写保护，如果是的，将 card 状态设置为只读状态
8 ...
9 }卡设备加到系统中后，对于块设备来说，会通知mmc块设备驱动。块设备驱动此时调用probe函数，即mmc_blk_probe()函数，mmc_blk_probe()首 先分配一个新的mmc_blk_data结构变量，然后调用mmc_init_queue，初始化blk队列。然后建立一个线程 mmc_queue_thread()。
3 sdio core总结
mmc_rescan函数总结
行胜于言，自强不息。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
