Linux MMC 驱动子系统简述（源码剖析）
1. Linux MMC 驱动子系统
块设备是Linux系统中的基础外设之一，而 MMC/SD 存储设备是一种典型的块设备。Linux内核设计了 MMC子系统，用于管理 MMC/SD 设备。html
MMC 子系统的框架结构以下图所示，其中core layer根据MMC/SD设备协议标准实现了协议。card layer与Linux的块设备子系统对接，实现块设备驱动以及完成请求，具体协议通过core layer的接口，最终经过host layer完成传输，对 MMC设备进行实际的操做。和 MMC设备硬件相对应，host和card能够分别理解为 MMC device的两个子设备：MMC主设备和MMC从设备，其中host为集成于MMC设备内部的MMC controller，card为MMC设备内部实际的存储设备。node
Linux系统中，使用两个结构体 struct mmc_host 和 struct mmc_card 分别描述host和card，其中host设备被封装成 platform_device 注册到Linux驱动模型中。总体而言，（Linux驱动模型框架下）MMC驱动子系统包括三个部分：linux
- MMC总线（ mmc_bus ）
- 封装在 platform_device下的host设备
- 依附于MMC总线的MMC驱动（ mmc_driver ）
下文将经过内核源码（Linux Kernel 5.2）对MMC驱动子系统进行简述，并经过MMC驱动的实际案例说明MMC驱动编写的通常步骤，同时分析驱动模型下完成驱动、设备绑定的过程。如对Linux设备驱动模型不熟悉，能够参考另外一篇博文：Linux设备驱动模型简述（源码剖析）。ios
2. MMC 总线的注册
MMC总线的注册和 platform 总线的注册方法相同，均是调用 bus_register() 函数。函数的调用入口位于 mmc/core/core.c ，经过 mmc_init() 实现，此处主要关注MMC的部分。git
/* drivers/mmc/core/core.c */ subsys_initcall(mmc_init); static int __init mmc_init(void) { int ret; ret = mmc_register_bus(); if (ret) return ret; ret = mmc_register_host_class(); if (ret) goto unregister_bus; ret = sdio_register_bus(); if (ret) goto unregister_host_class; return 0; unregister_host_class: mmc_unregister_host_class(); unregister_bus: mmc_unregister_bus(); return ret; }
/*********************************************************** * mmc bus 总线注册 ***********************************************************/ static struct bus_type mmc_bus_type = { .name = "mmc", .dev_groups = mmc_dev_groups, .match = mmc_bus_match, .uevent = mmc_bus_uevent, .probe = mmc_bus_probe, .remove = mmc_bus_remove, .shutdown = mmc_bus_shutdown, .pm = &mmc_bus_pm_ops, }; int mmc_register_bus(void) { return bus_register(&mmc_bus_type); }
/*********************************************************** * mmc_host class 类注册 ***********************************************************/ static struct class mmc_host_class = { .name = "mmc_host", .dev_release = mmc_host_classdev_release, }; int mmc_register_host_class(void) { return class_register(&mmc_host_class); }
主要包括两个方面：github
- 利用 bus_register() 注册 mmc_bus 。对应sysfs下的 /sys/bus/mmc/ 目录。
- 利用 class_register() 注册 mmc_host_class 。对应sysfs下的 /sys/class/mmc_host 目录。
3. MMC 驱动（mmc_driver）的注册
drivers/mmc/core/block.c 中将 mmc_driver 注册到 mmc_bus 对应的总线系统里。主要步骤包括：cookie
- 经过 register_blkdev() 向内核注册块设备。
- 调用 driver_register() 将 mmc_driver 注册到 mmc_bus 总线系统。和其余驱动注册方式一致。
mmc_driver 注册完成以后，会在sysfs中创建目录 /sys/bus/mmc/drivers/mmcblk 。框架
/* drivers/mmc/core/block.c */ module_init(mmc_blk_init); static struct mmc_driver mmc_driver = { .drv = { .name = "mmcblk", .pm = &mmc_blk_pm_ops, }, .probe = mmc_blk_probe, .remove = mmc_blk_remove, .shutdown = mmc_blk_shutdown, }; static int __init mmc_blk_init(void) { int res; ... ... res = register_blkdev(MMC_BLOCK_MAJOR, "mmc"); ... res = mmc_register_driver(&mmc_driver); ... return 0; ... ... } /** * mmc_register_driver - register a media driver * @drv: MMC media driver */ int mmc_register_driver(struct mmc_driver *drv) { drv->drv.bus = &mmc_bus_type; return driver_register(&drv->drv); }
4. MMC 设备的注册
前文已经简单描述过，MMC设备主要包括主设备host和从设备card两部分，而主设备host将被封装在 platform_device 中注册到驱动模型中。
为了更加清晰地描述此部分的注册过程，下文将以一个驱动为例分析（此驱动源码只包含关键步骤代码，只为描述MMC驱动的编写基本框架，demo mmc driver)。async
module_init(xxx_mmc_init); #define DRIVER_NAME "xxx_mmc" /* platform driver definition */ static struct platform_driver xxx_mmc_driver = { .probe = xxx_mmc_probe, .remove = xxx_mmc_remove, .driver = { .name = DRIVER_NAME, }, }; static struct platform_device *pdev; static __init int xxx_mmc_init(void) { int err = 0; /* * Register platform driver into driver model */ // 将xxx_mmc_driver注册到驱动模型中 err = platform_driver_register(&xxx_mmc_driver); /* * Allocate platform device and register into driver model * This will call driver->probe() */ // 动态分配platform_device，并将其注册到驱动模型中 // 此过程会回调driver->probe()函数 pdev = platform_device_alloc(DRIVER_NAME, 0); err = platform_device_add(pdev); return err; }
从代码中看到，驱动入口函数中将注册 platform_driver 和 platform_device ， name 均定义为 xxx_mmc 。根据驱动模型，最终会回调 xxx_mmc_driver 中的 probe() 函数： xxx_mmc_probe() 。ide
4.1 xxx_mmc_probe(pdev)
// 自定义的mmc_host_ops，用于host作实际操做时回调 static const struct mmc_host_ops xxx_mmc_ops = { .request = xxx_mmc_request, .set_ios = xxx_mmc_set_ios, }; /* platform driver probe function */ static int xxx_mmc_probe(struct platform_device *pdev) { struct mmc_host *mmc; struct xxx_mmc_host *host = NULL; int ret = 0; /* Step 1: Allocate host structure */ // 第1步：动态分配mmc_host结构 mmc = mmc_alloc_host(sizeof(struct xxx_mmc_host), &pdev->dev); if (mmc == NULL) { pr_err("alloc host failed\n"); ret = -ENOMEM; goto err_alloc_host; } // pointer initialization host = mmc_priv(mmc); host->mmc = mmc; host->id = pdev->id; /* Step 2: Initialize struct mmc_host */ // 第2步：初始化mmc_host的结构成员 mmc->ops = &xxx_mmc_ops; mmc->f_min = 400000; mmc->f_max = 52000000; mmc->ocr_avail = MMC_VDD_32_33; mmc->caps = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE | MMC_CAP_MMC_HIGHSPEED; mmc->caps2 = MMC_CAP2_BOOTPART_NOACC | MMC_CAP_PANIC_WRITE; mmc->max_segs = 1; mmc->max_blk_size = 512; mmc->max_req_size = 65536; // Maximum number of bytes in one req mmc->max_blk_count = mmc->max_req_size/mmc->max_blk_size; // Maximum number of blocks in one req mmc->max_seg_size = mmc->max_req_size; // Segment size in one req, in bytes host->dev = &pdev->dev; platform_set_drvdata(pdev, host); // pdev->dev->driver_data = host /* Step 3: Register the host with driver model */ // 第3步：将mmc_host注册到驱动模型中 mmc_add_host(mmc); return 0; err_alloc_host: return ret; }
xxx_mmc_probe(pdev) 主要工做以下：
- 调用 mmc_alloc_host() 分配一个 struct mmc_host 结构。
- 对 struct mmc_host 结构体成员初始化。
- 调用 mmc_add_host()
将 struct mmc_host加入到驱动模型中。
4.2 mmc_alloc_host(sizeof(struct xxx_mmc_host), &pdev->dev)
/* drivers/mmc/core/host.c */ static DEFINE_IDA(mmc_host_ida); /* mmc_alloc_host - initialise the per-host structure. */ struct mmc_host *mmc_alloc_host(int extra, struct device *dev) { int err; struct mmc_host *host; host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); if (!host) return NULL; /* scanning will be enabled when we're ready */ host->rescan_disable = 1; // Allocate an unused ID err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL); if (err < 0) { kfree(host); return NULL; } host->index = err; dev_set_name(&host->class_dev, "mmc%d", host->index); // 此处能够稍微注意一下，host->class_dev的类class设置为mmc_host_class // 而且host->class_dev的parent指向了pdev->dev (platform_device) // 这些许的差别会改变device_add后在sysfs中表现出来的层次结构 host->parent = dev; // host->parent = &pdev->dev host->class_dev.parent = dev; // host->class_dev.parent = &pdev->dev host->class_dev.class = &mmc_host_class; // Initialize host->class_dev device_initialize(&host->class_dev); device_enable_async_suspend(&host->class_dev); if (mmc_gpio_alloc(host)) { put_device(&host->class_dev); return NULL; } // 初始化自旋锁 spin_lock_init(&host->lock); // 初始化等待队列头 init_waitqueue_head(&host->wq); // 初始化延迟的工做队列`host->detect`和`host->sdio_irq_work` INIT_DELAYED_WORK(&host->detect, mmc_rescan); INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work); timer_setup(&host->retune_timer, mmc_retune_timer, 0); host->max_segs = 1; host->max_seg_size = PAGE_SIZE; host->max_req_size = PAGE_SIZE; host->max_blk_size = 512; host->max_blk_count = PAGE_SIZE / 512; host->fixed_drv_type = -EINVAL; host->ios.power_delay_ms = 10; return host; }
主要工做以下：
- 动态分配内存给 struct mmc_host 结构体，并对结构体成员初始化。
- 调用 device_initialize() 对 host->class_dev 进行初始化，包括 kobject 、 mutex 等。
- 初始化自旋锁、等待队列 (waitqueue)和延迟的工做队列 (Delayed Work)，其中，用处理函数 mmc_rescan() 来初始化延迟的工做队列 host->detect ，后文会再次提到。
- 初始化定时器 host->retune_timer ，处理函数为 mmc_retune_timer() 。
4.3 mmc_add_host(mmc)
在上述对host进行初始化后，调用 mmc_add_host() 将host注册到驱动模型中。
/* drivers/mmc/core/host.c */ /* mmc_add_host - initialise host hardware */ int mmc_add_host(struct mmc_host *host) { int err; WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) && !host->ops->enable_sdio_irq); err = device_add(&host->class_dev); if (err) return err; led_trigger_register_simple(dev_name(&host->class_dev), &host->led); #ifdef CONFIG_DEBUG_FS mmc_add_host_debugfs(host); #endif mmc_start_host(host); mmc_register_pm_notifier(host); return 0; }
主要的工做包括两个部分：
- device_add() 将 host->class_dev 加入到sysfs中device层次结构中。
- 调用 mmc_start_host() 启动主设备，也即MMC设备开始正常工做。
在介绍 mmc_start_host() 以前，先简单介绍下此处将 host->class_dev 加入到驱动模型后sysfs中表现出来的层次结构。 4.2一节中介绍 mmc_alloc_host() 时注意到 host->class_dev 的 class 被设置为 mmc_host_class ， parent 指向 pdev->dev 。 device_add()-->get_device_parent()/device_add_class_symlinks() 调用过程当中将在 platform_device 的目录下多创建一个名称和 class name 相同的子文件夹，同时在class类目录下也会有指向实际设备的目录项。sysfs此时的结构以下：
/sys/devices/platform/xxx_mmc.0/mmc_host/mmc0$ ll total 0 ... ... root root 0 Sep 17 11:21 ./ ... ... root root 0 Sep 17 11:21 ../ ... ... root root 0 Sep 17 11:23 device -> ../../../xxx_mmc.0/ ... ... root root 0 Sep 17 11:23 power/ ... ... root root 0 Sep 17 11:23 subsystem -> ../../../../../class/mmc_host/ ... ... root root 4096 Sep 17 11:23 uevent /sys/class/mmc_host$ ll /sys/class/mmc_host total 0 ... ... root root 0 Sep 17 11:21 ./ ... ... root root 0 Sep 17 11:09 ../ ... ... root root 0 Sep 17 11:26 mmc0 -> ../../devices/platform/xxx_mmc.0/mmc_host/mmc0/
此时 mmc_host 结构体成员初始化状态简要列举以下（详细能够按照驱动模型中device注册步骤推导）：
struct mmc_host mmc { .rescan_disable = 1 // set to 0 in mmc_start_host() .index = id (allocated) .class_dev (struct dev)= { .p = { .device = &mmc.class_dev .klist_children = .deferred_probe = } . kobj = { .name = (“mmc%d”, .index) // name = “mmc0” .kset = devices_kset .ktype = &device_ktype INIT_LIST_HEAD(.dma_pools); mutex_init(.mutex); spin_lock_init(.devres_lock); INIT_LIST_HEAD(.devres_head); .parent = dir->kobject; /* /sys/devices/platform/xxx_mmc.0/mmc_host/mmc0 */ //struct class_dir dir = { // .class = &mmc_host_class // .kobj = { // .ktype = &class_dir_ktype // .kset = & mmc_host_class->p->glue_dirs // .parent = &pdev->dev->kobj // /* /sys/devices/platform/xxx_mmc.0/ */ // .name = “mmc_host” // } //} } .parent = &pdev->dev .class = &mmc_host_class = { .name = "mmc_host", .dev_release = mmc_host_classdev_release, .dev_kobj = sysfs_dev_char_kobj .p (struct subsys_private) = { .class = &mmc_host_class . glue_dirs (kset) = { .kobj = .list = .list_lock = } . subsys (struct kset) = { .kobj = { .name = “mmc_host” .parent = & class_kset->kobj .kset = class_kset; .ktype = &class_ktype; // create_dir(kobj) } } } }; } .parent = &pdev->dev spin_lock_init(&.lock); init_waitqueue_head(&.wq); INIT_DELAYED_WORK(&.detect, mmc_rescan); INIT_DELAYED_WORK(&.sdio_irq_work, sdio_irq_work); timer_setup(&.retune_timer, mmc_retune_timer, 0); .max_segs = 1 .max_seg_size = PAGE_SIZE //max segment size 8K .max_req_size = PAGE_SIZE .max_blk_size = 512 .max_blk_count = PAGE_SIZE / 512 .fixed_drv_type = -EINVAL .ios = { .power_delay_ms = 10 .power_mode = MMC_POWER_UP // mmc_start_host() .vdd = fls(ocr) – 1 // mmc_power_up(host, host->ocr_avail); .clock = .f_init } . ops = { .request = xxx_mmc_request, .set_ios = xxx_mmc_set_ios, } .f_min = 400000 .f_max = 52000000 .ocr_avail = MMC_VDD_32_33 = 0x00100000 .caps = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE | MMC_CAP_MMC_HIGHSPEED; .caps2 = MMC_CAP2_BOOTPART_NOACC | MMC_CAP_PANIC_WRITE; .pm_notify.notifier_call = mmc_pm_notify };
4.4 mmc_add_host(mmc)
/* drivers/mmc/core/core.c */ void mmc_start_host(struct mmc_host *host) { host->f_init = max(freqs[0], host->f_min); host->rescan_disable = 0; host->ios.power_mode = MMC_POWER_UNDEFINED; if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) { mmc_claim_host(host); mmc_power_up(host, host->ocr_avail); mmc_release_host(host); } mmc_gpiod_request_cd_irq(host); _mmc_detect_change(host, 0, false); }
- host->rescan_disable = 0 使能主设备的从新检测。
- 未使能 MMC_CAP2_NO_PRESCAN_POWERU
P时，将完成 claim_host() 、 power_up() 、 release_host() 等一系列工做。 - mmc_gpiod_request_cd_irq() 用于为host申请中断号（和GPIO口对应），并绑定中断服务函数。
- _mmc_detect_change(host, 0, false) 用于检测MMC槽位上的变更。
mmc_claim_host(host) 函数用于申请得到host（主控制器）的使用权，进程将进入休眠等待状态，直至能够得到主控制器的使用权。该函数结合 mmc_release_host(host) ，利用等待队列实现，原理细节能够参考：Linux等待队列（Wait Queue）。
4.5 _mmc_detect_change(host, 0, false)
static void _mmc_detect_change(struct mmc_host *host, unsigned long delay, bool cd_irq) { if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL) && device_can_wakeup(mmc_dev(host))) pm_wakeup_event(mmc_dev(host), 5000); host->detect_change = 1; mmc_schedule_delayed_work(&host->detect, delay); } static int mmc_schedule_delayed_work(struct delayed_work *work, unsigned long delay) { return queue_delayed_work(system_freezable_wq, work, delay); }
_mmc_detect_change() 函数用来检测MMC状态的改变，具体是经过调度工做队列实现，如4.2一节介绍， mmc_rescan() 做为处理函数被绑定在延迟工做队列 host->detect 上。所以，此处其实是启动 mmc_rescan() 的执行过程。
4.6 mmc_rescan(&host->detect)
void mmc_rescan(struct work_struct *work) { // 经过host->detect指针获得mmc_host结构体指针 struct mmc_host *host = container_of(work, struct mmc_host, detect.work); // 若是rescan被禁止，函数提早返回 if (host->rescan_disable) return; // 对于不可移除(non-removable)的host，若是其正在作rescan工做时，函数提早返回（scan只作一次） if (!mmc_card_is_removable(host) && host->rescan_entered) return; // 基本检查经过，进入rescan流程，标记rescan_entered host->rescan_entered = 1; ... ... // 检查可移除(removable) host是否还存在 if (host->bus_ops && !host->bus_dead && mmc_card_is_removable(host)) host->bus_ops->detect(host); host->detect_change = 0; ... ... // 尝试得到host的使用权，实现原理在4.4小节中有说起 mmc_claim_host(host); ... ... // rescan流程的关键步骤，依次尝试四个给定频率，直至检测到mmc card的存在 // static const unsigned freqs[] = { 400000, 300000, 200000, 100000 } for (i = 0; i < ARRAY_SIZE(freqs); i++) { if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min))) break; if (freqs[i] <= host->f_min) break; } mmc_release_host(host); ... ... }
static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq) { host->f_init = freq; // 完成一系列初始化步骤，保证设备在合适的运行状态，为后面实际探测作准备 mmc_power_up(host, host->ocr_avail); mmc_hw_reset_for_init(host); ... ... mmc_go_idle(host); if (!(host->caps2 & MMC_CAP2_NO_SD)) mmc_send_if_cond(host, host->ocr_avail); /* Order's important: probe SDIO, then SD, then MMC */ // 依次探测设备：SDIO，SD，MMC // 对于MMC设备，尝试调用mmc_attach_mmc(host) if (!(host->caps2 & MMC_CAP2_NO_SDIO)) if (!mmc_attach_sdio(host)) return 0; if (!(host->caps2 & MMC_CAP2_NO_SD)) if (!mmc_attach_sd(host)) return 0; if (!(host->caps2 & MMC_CAP2_NO_MMC)) if (!mmc_attach_mmc(host)) return 0; mmc_power_off(host); return -EIO; }
mmc_rescan(&host->detect) 会调用 mmc_rescan_try_freq(host, max(freqs[i], host->f_min)) ，进一步调用重要的 mmc_attach_mmc(host) 函数，将MMC设备加入到驱动模型中。
4.7 mmc_attach_mmc(&host)
// mmc_bus相关的一系列operations函数 static const struct mmc_bus_ops mmc_ops = { .remove = mmc_remove, .detect = mmc_detect, .suspend = mmc_suspend, .resume = mmc_resume, .runtime_suspend = mmc_runtime_suspend, .runtime_resume = mmc_runtime_resume, .alive = mmc_alive, .shutdown = mmc_shutdown, .hw_reset = _mmc_hw_reset, }; // MMC card初始化的入口函数 int mmc_attach_mmc(struct mmc_host *host) { int err; u32 ocr, rocr; // 首先检查host的使用权是否已经得到 WARN_ON(!host->claimed); /* Set correct bus mode for MMC before attempting attach */ if (!mmc_host_is_spi(host)) mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); // OCR register得到，可参考MMC设备操做规范 err = mmc_send_op_cond(host, 0, &ocr); // 将host结构成员bus_ops设置为mmc_ops mmc_attach_bus(host, &mmc_ops); ... ... // 为host选择合适的工做电压 rocr = mmc_select_voltage(host, ocr); ... ... // 关键步骤1：开始初始化MMC card的流程 err = mmc_init_card(host, rocr, NULL); // MMC card初始化后释放host的使用权，起初在mmc_rescan()函数中得到 mmc_release_host(host); // 关键步骤2：将MMC card注册进设备驱动模型中 err = mmc_add_card(host->card); mmc_claim_host(host); return 0; ... ... }
mmc_attach_mmc(&host) 做为MMC card检测和初始化的关键函数，执行的步骤可归纳为：
- 获取MMC基本硬件初始化信息，例如OCR register （工做电压相关）
- 初始化host->bus_ops成员， host->bus_ops = &mmc_ops
- mmc_init_card(host, rocr, NULL) ：MMC card初始化，下文详细介绍
- mmc_add_card(host->card) ：将MMC card加入到设备驱动模型中，下文将详细介绍
4.8 mmc_init_mmc(&host, rocr, NULL)
static struct device_type mmc_type = { .groups = mmc_std_groups, }; static int mmc_init_card(struct mmc_host *host, u32 ocr, struct mmc_card *oldcard) { struct mmc_card *card; int err; u32 cid[4]; u32 rocr; WARN_ON(!host->claimed); ... ... mmc_go_idle(host); /* The extra bit indicates that we support high capacity */ err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr); ... ... err = mmc_send_cid(host, cid); if (oldcard) { ... card = oldcard; } else { // 动态分配mmc_card结构 card = mmc_alloc_card(host, &mmc_type); card->ocr = ocr; card->type = MMC_TYPE_MMC; card->rca = 1; memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); } ... ... ... ... }
struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type) { struct mmc_card *card; card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL); if (!card) return ERR_PTR(-ENOMEM); card->host = host; device_initialize(&card->dev); card->dev.parent = mmc_classdev(host); card->dev.bus = &mmc_bus_type; card->dev.release = mmc_release_card; card->dev.type = type; return card; }
mmc_init_mmc(&host, rocr, NULL) 会调用 mmc_alloc_card(host, &mmc_type) 动态分配一个 struct mmc_card 结构，并初始化其内部的 struct device 结构。此外， mmc_init_mmc() 中还完成了许多初始化工做，这些工做大可能是依据MMC操做规范定义的，在此不详细介绍。
struct mmc_card 结构成员大体列举以下，以方便分析。
struct mmc_card card = { .host = &mmc; .dev = { .parent = mmc_classdev(mmc) = &(mmc.class_dev); .bus = &mmc_bus_type = { .name = "mmc", .dev_groups = mmc_dev_groups, .match = mmc_bus_match, .uevent = mmc_bus_uevent, .probe = mmc_bus_probe, .remove = mmc_bus_remove, .shutdown = mmc_bus_shutdown, .pm = &mmc_bus_pm_ops, }; .release = mmc_release_card; .type = &mmc_type = { .groups = mmc_std_groups, }; } .ocr = rocr; .type = MMC_TYPE_MMC; .rca = 1; // relative card address of device };
4.9 mmc_add_card(host->card)
int mmc_add_card(struct mmc_card *card) { int ret; ... ... // #define mmc_hostname(x) (dev_name(&(x)->class_dev)) // 为card->dev设置名称“mmc0:0001”，实际上设置了card->dev->kobj.name = “mmc0:0001” dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca); ... ... card->dev.of_node = mmc_of_find_child_device(card->host, 0); device_enable_async_suspend(&card->dev); // 关键步骤：经过device_add() 将mmc card注册到设备驱动模型中 ret = device_add(&card->dev); // 标记mmc card状态为PRESENT，card->state = MMC_STATE_PRESENT mmc_card_set_present(card); return 0; }
这里最关键的一步是熟悉的 device_add(&card->dev) 函数，它将mmc card添加到驱动模型中。注意到 card.dev 的 parent 被设置为 mmc.class_dev ，因此将在前述host的目录层次下创建新的名为 mmc0:0001 的 card 子目录，而在调用 bus_add_device() 时，在mmc bus目录下子目录 devices 创建相应的连接，连接到上述 mmc0:0001 的设备目录上。sysfs的总体目录层次表现以下：
/sys/devices/platform/xxx_mmc.0/mmc_host/mmc0/mmc0:0001$ ll total 0 ... ... block/ ... ... ... ... driver -> ../../../../../../bus/mmc/drivers/mmcblk/ ... ... ... ... subsystem -> ../../../../../../bus/mmc/ ... ... ... ... uevent /sys/bus/mmc/devices$ ll ... ... mmc0:0001 -> ../../../devices/platform/xxx_mmc.0/mmc_host/mmc0/mmc0:0001/ /sys/bus/mmc/drivers/mmcblk$ ll ... ... mmc0:0001 -> ../../../../devices/platform/xxx_mmc.0/mmc_host/mmc0/mmc0:0001/ /sys/class/mmc_host$ ll ... ... mmc0 -> ../../devices/platform/klm_emmc.0/mmc_host/mmc0/
按照Linux驱动模型，接下来要完成的是设备和驱动在总线上的匹配工做，最终调用驱动的probe()函数。调用的函数依次是：
mmc_bus_probe(&card.dev) --> mmc_blk_probe(&card)
5. 块设备设备驱动
Linux块设备驱动初始化通常包括以下几个方面：
- 申请设备号，并将块设备驱动注册到内核。 register_blkdev()
- 初始化请求队列。 blk_init_queue() / blk_alloc_queue()
- 分配gendisk结构，并进行初始化。 alloc_disk()
- 添加gendisk。 add_disk()
第3节MMC驱动注册中，函数 mmc_blk_init() 调用 register_blkdev(MMC_BLOCK_MAJOR, "mmc") 完成了设备号的申请，将块设备注册到内核中。下文将从 mmc_blk_probe(card)入手分析其余几个步骤的实现。
5.1 mmc_blk_probe(card)
struct mmc_blk_data { struct device *parent; struct gendisk *disk; struct mmc_queue queue; struct list_head part; struct list_head rpmbs; unsigned int flags; unsigned int usage; unsigned int read_only; unsigned int part_type; unsigned int reset_done; ... ... };
static int mmc_blk_probe(struct mmc_card *card) { struct mmc_blk_data *md, *part_md; char cap_str[10]; ... ... card->complete_wq = alloc_workqueue("mmc_complete", WQ_MEM_RECLAIM | WQ_HIGHPRI, 0); // 分配和初始化gendisk结构，初始化请求队列 md = mmc_blk_alloc(card); string_get_size((u64)get_capacity(md->disk), 512, STRING_UNITS_2, cap_str, sizeof(cap_str)); if (mmc_blk_alloc_parts(card, md)) goto out; dev_set_drvdata(&card->dev, md); // 添加gendisk if (mmc_add_disk(md)) goto out; list_for_each_entry(part_md, &md->part, part) { if (mmc_add_disk(part_md)) goto out; } ... return 0; ... }
mmc_blk_probe(card) 为MMC card完成全部块设备驱动有关的工做，主要调用了两个重要的函数：
- mmc_blk_alloc(card)
mmc_add_disk(md)
5.2 mmc_blk_alloc(card)
mmc_blk_alloc(card) 为MMC card初始化请求队列，函数调用过程为：
mmc_blk_alloc(card) --> mmc_blk_alloc_req() --> mmc_init_queue(&md->queue, card) --> blk_mq_init_queue()
static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card) { sector_t size; if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) { size = card->ext_csd.sectors; } else { size = (typeof(sector_t))card->csd.capacity << (card->csd.read_blkbits - 9); } return mmc_blk_alloc_req(card, &card->dev, size, false, NULL, MMC_BLK_DATA_AREA_MAIN); }
static const struct block_device_operations mmc_bdops = { .open = mmc_blk_open, .release = mmc_blk_release, .getgeo = mmc_blk_getgeo, .owner = THIS_MODULE, .ioctl = mmc_blk_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = mmc_blk_compat_ioctl, #endif }; static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card, struct device *parent, sector_t size, bool default_ro, const char *subname, int area_type) { struct mmc_blk_data *md; int devidx, ret; devidx = ida_simple_get(&mmc_blk_ida, 0, max_devices, GFP_KERNEL); ... ... md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL); md->area_type = area_type; md->read_only = mmc_blk_readonly(card); // 分配gendisk结构 md->disk = alloc_disk(perdev_minors); INIT_LIST_HEAD(&md->part); INIT_LIST_HEAD(&md->rpmbs); md->usage = 1; // 初始化请求队列 ret = mmc_init_queue(&md->queue, card); md->queue.blkdata = md; // 初始化gendisk结构成员 md->disk->major = MMC_BLOCK_MAJOR; md->disk->first_minor = devidx * perdev_minors; // 为MMC card定义了block_device_operations结构体 md->disk->fops = &mmc_bdops; md->disk->private_data = md; md->disk->queue = md->queue.queue; md->parent = parent; set_disk_ro(md->disk, md->read_only || default_ro); md->disk->flags = GENHD_FL_EXT_DEVT; if (area_type & (MMC_BLK_DATA_AREA_RPMB | MMC_BLK_DATA_AREA_BOOT)) md->disk->flags |= GENHD_FL_NO_PART_SCAN | GENHD_FL_SUPPRESS_PARTITION_INFO; snprintf(md->disk->disk_name, sizeof(md->disk->disk_name), "mmcblk%u%s", card->host->index, subname ? subname : ""); set_capacity(md->disk, size); ... ... return md; ... ... }
值得注意的是， mmc_blk_alloc_req() 函数中为将MMC card gendisk结构体的fops赋值为 mmc_bdops ，即为MMC card定义了 open ， release ， getgeo ， ioctl 等操做的回调函数。
5.3 mmc_init_queue(&md->queue, card)
static const struct blk_mq_ops mmc_mq_ops = { .queue_rq = mmc_mq_queue_rq, .init_request = mmc_mq_init_request, .exit_request = mmc_mq_exit_request, .complete = mmc_blk_mq_complete, .timeout = mmc_mq_timed_out, }; int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card) { struct mmc_host *host = card->host; int ret; mq->card = card; mq->use_cqe = host->cqe_enabled; spin_lock_init(&mq->lock); memset(&mq->tag_set, 0, sizeof(mq->tag_set)); // mq->tag_set.ops设置为mmc_mq_ops mq->tag_set.ops = &mmc_mq_ops; ... ... mq->tag_set.driver_data = mq; ret = blk_mq_alloc_tag_set(&mq->tag_set); if (ret) return ret; // 初始化请求队列 mq->queue = blk_mq_init_queue(&mq->tag_set); ... ... mq->queue->queuedata = mq; blk_queue_rq_timeout(mq->queue, 60 * HZ); mmc_setup_queue(mq, card); return 0; ... ... }
struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *set) { struct request_queue *uninit_q, *q; uninit_q = blk_alloc_queue_node(GFP_KERNEL, set->numa_node); q = blk_mq_init_allocated_queue(set, uninit_q); return q; }
struct request_queue *blk_mq_init_allocated_queue(struct blk_mq_tag_set *set, struct request_queue *q) { // 用set->ops (mmc_mq_ops)来初始化request_queue的mq_ops成员 q->mq_ops = set->ops; ... ... blk_queue_make_request(q, blk_mq_make_request); ... ... }
mmc_init_queue(&md->queue, card) 最终调用 blk_queue_make_request(q, blk_mq_make_request) 初始化了请求队列（制造请求函数）。
另外，也使用 mmc_mq_ops 初始化了 request_queue 的 mq_ops 成员，下文会提到。
至此，块设备驱动注册工做基本完成。
6. 请求队列的工做流程梳理
4.1节介绍MMX设备初始化时提到，驱动编写过程当中特别地为host编写了 mmc_host_ops ，而至目前仍未介绍到其被使用的地方，本节将从请求队列入手，经过一个简单的情形，分析 mmc_host_ops 操做函数的回调过程。
当对mmc card发起块设备I/O动做时，内核会首先调用到以前初始化的 blk_mq_make_request() 函数（定义在 block/blk-mq.c ），在特定状况下调用 blk_mq_try_issue_directly() ，最终一步步调用到 __blk_mq_issue_directly() 。
static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio) { ... blk_mq_try_issue_directly(data.hctx, rq, &cookie); .. }
static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, struct request *rq, blk_qc_t *cookie) { ... ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false, true); if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE) blk_mq_request_bypass_insert(rq, true); else if (ret != BLK_STS_OK) blk_mq_end_request(rq, ret); ... }
static blk_status_t __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, struct request *rq, blk_qc_t *cookie, bool bypass_insert, bool last) { ... return __blk_mq_issue_directly(hctx, rq, cookie, last); ... }
static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx, struct request *rq, blk_qc_t *cookie, bool last) { struct request_queue *q = rq->q; ... ret = q->mq_ops->queue_rq(hctx, &bd); ... return ret; }
5.3一节中提到 q->mq_ops 指向 mmc_mq_ops ，所以此处最终会回调函数 mmc_mq_ops->queue_rq() ，即 mmc_mq_queue_rq() ，最终回调至 mmc_host_ops->request(host, mrq) 。
mmc_mq_queue_rq() --> mmc_blk_mq_issue_rq() --> mmc_blk_mq_issue_rw_rq() --> mmc_start_request() --> __mmc_start_request() --> host->ops->request(host, mrq)
static blk_status_t mmc_mq_queue_rq(struct blk_mq_hw_ctx *hctx, const struct blk_mq_queue_data *bd) { ... issued = mmc_blk_mq_issue_rq(mq, req); ... }
enum mmc_issued mmc_blk_mq_issue_rq(struct mmc_queue *mq, struct request *req) { ... ret = mmc_blk_mq_issue_rw_rq(mq, req); ... }
static int mmc_blk_mq_issue_rw_rq(struct mmc_queue *mq, struct request *req) { struct mmc_queue_req *mqrq = req_to_mmc_queue_req(req); struct mmc_host *host = mq->card->host; ... ... err = mmc_start_request(host, &mqrq->brq.mrq); ... ... return err; }
int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) { int err; init_completion(&mrq->cmd_completion); mmc_retune_hold(host); ... WARN_ON(!host->claimed); err = mmc_mrq_prep(host, mrq); ... __mmc_start_request(host, mrq); return 0; }
static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) { int err; ... err = mmc_retune(host); ... host->ops->request(host, mrq); }
7. 总结
综合上述分析，能够将MMC驱动子系统流程分析归纳为下图。从驱动编写的角度，只需关注MMC card设备注册相关代码，主要包含以下几个方面：
- 将mmc host封装进一个 platform device ，同时定义一 platform driver ，并将它们注册到驱动模型中
- platform driver 的 probe() 函数中调用 mmc_alloc_host() 和 mmc_add_host() ，将mmc card注册到驱动模型中
参考资料
[1] Linux设备驱动开发详解（基于最新的Linux4.0内核），宋宝华编著，2016年
[2] Linux SD/MMC/SDIO驱动分析：http://www.javashuo.com/article/p-rslduppo-mp.html