Linux驱动——mmc sd card 创建块设备流程（十二）
Linux驱动——mmc sd card 创建块设备流程（十二）
备注：
1. Kernel版本：5.4
2. 使用工具：Source Insight 4.0
3. 参考博客：
（1）[sd card] sd card初始化流程
（2）[sd card] mmc_blk层为sd card创建块设备流程
文章目录
- Linux驱动——mmc sd card 创建块设备流程（十二）
-
- 块设备框架
-
- 层次说明
- 流程说明
- 结构体说明
- sd card块设备驱动层
- mmc_blk的设备驱动模型实现
-
- mmc_driver的实现
- mmc_blk层为sd card创建块设备流程（mmc_blk_probe）
-
- mmc_blk_probe()函数解析
- mmc_blk_alloc()函数解析
- mmc_add_disk()函数解析
块设备框架
层次说明
-
由通用块层(Generic Block Layer)负责维持一个I/O请求在上层文件系统与底层物理磁盘之间的关系。在通用块层中，通常用一个bio结构体来对应一个I/O请求。
-
在Linux中，驱动对块设备的输入或输出(I/O)操作，都会向块设备发出一个请求，在IO调度层中用request结构体描述。
-
但对于一些磁盘设备而言请求的速度很慢，这时候内核就提供一种队列的机制把这些I/O请求（request结构体）添加到队列中（即：请求队列），在驱动中用request_queue结构体描述。在向块设备提交这些请求前内核会先执行请求的合并和排序预操作，以提高访问的效率，然后再由内核中的I/O调度程序子系统来负责提交 I/O 请求， 调度程序将磁盘资源分配给系统中所有挂起的块 I/O 请求，其工作是管理块设备的请求队列，决定队列中的请求的排列顺序以及什么时候派发请求到设备。
-
Linux提供了一个gendisk数据结构体，用来表示一个独立的磁盘设备或分区，用于对底层物理磁盘进行访问。在gendisk中有一个类似字符设备中file_operations的硬件操作结构指针，是block_device_operations结构体。
流程说明
文件系统—>通用块层—>IO调度层—>块设备驱动层
-
文件系统会向通用块层发起块读写请求
-
通用块层将读写请求封装成bio结构体（block io），下发到IO调度层
IO调度层将bio封装成request结构体，并将request添加到对应块设备（gendisk）的请求队列（request_queue）中，并做一些预处理。 -
IO调度层对请求队列（request_queue）中的request进行预处理之后，调用请求队列（request_queue）的回调函数来对队列中的IO（request）进行处理
-
而请求队列（request_queue）以及request处理回调函数则是由块设备驱动层提供，也就是块设备驱动层会从请求队列（request_queue）提取request并且进行实质性的处理。
结构体说明
-
通用块层：struct bio
-
IO调度层：struct request（封装了struct bio）、struct request_queue
-
块设备驱动层：
各类块设备驱动层对于IO请求的封装是不一样的。以sd card的mmc块设备驱动层为例：
struct mmc_queue_req（封装了struct request）、struct mmc_queue（封装了struct request_queue）。
sd card块设备驱动层
对于sd card而言，整个数据流是：
文件系统—>通用块层—>IO调度层—>mmc_blk层—>mmc core层—>mmc host层—>mmc硬件总线—>sd card
mmc_blk的设备驱动模型实现
mmc_driver的实现
//源码：drivers/mmc/core/block.c
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 = bus_register(&mmc_rpmb_bus_type);
if (res < 0) {
pr_err("mmcblk: could not register RPMB bus type\n");
return res;
}
res = alloc_chrdev_region(&mmc_rpmb_devt, 0, MAX_DEVICES, "rpmb");
if (res < 0) {
pr_err("mmcblk: failed to allocate rpmb chrdev region\n");
goto out_bus_unreg;
}
if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
pr_info("mmcblk: using %d minors per device\n", perdev_minors);
max_devices = min(MAX_DEVICES, (1 << MINORBITS) / perdev_minors);
// 注册 mmc 块设备
res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
if (res)
goto out_chrdev_unreg;
// 注册mmc driver —— mmcblk
// mmc_driver注册到mmc_bus上，当有mmc_card注册到mmc_bus上时，其probe方法就会执行。
res = mmc_register_driver(&mmc_driver);
if (res)
goto out_blkdev_unreg;
return 0;
out_blkdev_unreg:
unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
out_chrdev_unreg:
unregister_chrdev_region(mmc_rpmb_devt, MAX_DEVICES);
out_bus_unreg:
bus_unregister(&mmc_rpmb_bus_type);
return res;
}
mmc_blk层为sd card创建块设备流程（mmc_blk_probe）
mmc_blk_probe()函数解析
//源码：drivers/mmc/core/block.c
static int mmc_blk_probe(struct mmc_card *card)
{
struct mmc_blk_data *md, *part_md;
char cap_str[10];
/*
* Check that the card supports the command class(es) we need.
*/
/** 判断card是不是一个block设备 **/
// 前面说过了，只要是mmc_card（包括SDIO card）被注册到mmc_bus上，
// 那么所有mmc_bus上的mmc_driver都会被匹配到
// 而mmc_blk只使用于存储设备（emmc、sd card、mmc card），并不能驱动于SDIO card
// 因此，这里根据是否支持块读写属性判断card是不是一个存储设备，
// 如果不是的话，说明并不能使用mmc_blk这个mmc_driver来驱动mmc_card.
if (!(card->csd.cmdclass & CCC_BLOCK_READ))
return -ENODEV;
mmc_fixup_device(card, mmc_blk_fixups);
// 申请 mmc complete 工作队列
card->complete_wq = alloc_workqueue("mmc_complete",
WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
if (unlikely(!card->complete_wq)) {
pr_err("Failed to create mmc completion workqueue");
return -ENOMEM;
}
/** 为mmc_card分配和设置mmc_blk_data **/
/** 在mmc_blk_alloc中会去分配和设置mmc_queue、request_queue、gendisk **/
// 1. 创建struct mmc_blk_data
// 2. 初始化mmc_blk_data
// 3. 初始化struct mmc_blk_data->mmc_queue
// 4. 创建struct mmc_blk_data->mmc_queue->request_queue（创建struct request_queue）
// 5. 分配和初始化struct mmc_blk_data->gendisk（创建struct gendisk & 初始化struct gendisk）
// 6. 关联struct mmc_blk_data->gendisk 和 mmc_blk_data->mmc_queue->request_queue
// （关联struct gendisk和struct request_queue）
md = mmc_blk_alloc(card);
if (IS_ERR(md))
return PTR_ERR(md);
string_get_size((u64)get_capacity(md->disk), 512, STRING_UNITS_2,
cap_str, sizeof(cap_str));
pr_info("%s: %s %s %s %s\n",
md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
cap_str, md->read_only ? "(ro)" : "");
/**
一个存储设备上（例如emmc）上可能有多个物理分区，
这里用于为这些物理分区（例如rpmb分区）分配和设置mmc_blk_data
**/
/**
SD card上只有一个物理分区，所以我们这里不care，
后面学习emmc的时候再说明
**/
if (mmc_blk_alloc_parts(card, md))
goto out;
/** 关联mmc_card和mmc_blk_data **/
dev_set_drvdata(&card->dev, md);
/** 将mmc_blk构造的gendisk注册到系统中，生成对应的块设备 **/
if (mmc_add_disk(md))
goto out;
/** 将其他物理分区的gendisk注册到系统中，生成对应的块设备。 **/
/** sd card 上只有一个分区，所以这里我们同样不关心 **/
list_for_each_entry(part_md, &md->part, part) {
if (mmc_add_disk(part_md))
goto out;
}
/* Add two debugfs entries */
mmc_blk_add_debugfs(card, md);
pm_runtime_set_autosuspend_delay(&card->dev, 3000);
pm_runtime_use_autosuspend(&card->dev);
/*
* Don't enable runtime PM for SD-combo cards here. Leave that
* decision to be taken during the SDIO init sequence instead.
*/
if (card->type != MMC_TYPE_SD_COMBO) {
pm_runtime_set_active(&card->dev);
pm_runtime_enable(&card->dev);
}
return 0;
out:
mmc_blk_remove_parts(card, md);
mmc_blk_remove_req(md);
return 0;
}
通过上述代码，可以知道对于“mmc_blk层为sd card创建块设备流程”来说，有两个核心代码来实现。
- mmc_blk_alloc
- mmc_add_disk
mmc_blk_alloc()函数解析
//源码：drivers/mmc/core/block.c
static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
{
sector_t size;
/** 以下先获取card容量，以扇区为单位 **/
if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
/*
* The EXT_CSD sector count is in number or 512 byte
* sectors.
*/
// 对于emmc设备来说，其容量是从ext_csd寄存器的sectors域获取
size = card->ext_csd.sectors;
} else {
/*
* The CSD capacity field is in units of read_blkbits.
* set_capacity takes units of 512 bytes.
*/
// 对于sd card来说，其容量是从csd的capacity域获取的
// 计算方法memory capacity = (C_SIZE+1) * 512K byte
size = (typeof(sector_t))card->csd.capacity
<< (card->csd.read_blkbits - 9);
}
/** 调用mmc_blk_alloc_req来实现前面所说的工作 **/
return mmc_blk_alloc_req(card, &card->dev, size, false, NULL,
MMC_BLK_DATA_AREA_MAIN);
}
mmc_blk_alloc_req()函数
//源码：drivers/mmc/core/block.c
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;
/** 分配一个mmcblk的从设备号 **/
devidx = ida_simple_get(&mmc_blk_ida, 0, max_devices, GFP_KERNEL);
if (devidx < 0) {
/*
* We get -ENOSPC because there are no more any available
* devidx. The reason may be that, either userspace haven't yet
* unmounted the partitions, which postpones mmc_blk_release()
* from being called, or the device has more partitions than
* what we support.
*/
if (devidx == -ENOSPC)
dev_err(mmc_dev(card->host),
"no more device IDs available\n");
return ERR_PTR(devidx);
}
/** 以下就是分配mmc_blk_data并进行设置，也是mmc_blk_alloc_req的核心工作 **/
/* 对应“1. 创建struct mmc_blk_data” */
md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
if (!md) {
ret = -ENOMEM;
goto out;
}
/* 以下对应“2. 初始化mmc_blk_data” */
//---- 设置mmc_blk_data->area_type
md->area_type = area_type;
/*
* Set the read-only status based on the supported commands
* and the write protect switch.
*/
//---- 设置mmc_blk_data->read_only
md->read_only = mmc_blk_readonly(card); // 设置只读属性
//---- 分配mmc_blk_data->disk
md->disk = alloc_disk(perdev_minors); // 调用alloc_disk分配一个gendisk结构体
if (md->disk == NULL) {
ret = -ENOMEM;
goto err_kfree;
}
//---- 设置mmc_blk_data->part、rpmbs、usage
INIT_LIST_HEAD(&md->part); // 挂载其他物理分区的链表
INIT_LIST_HEAD(&md->rpmbs); // 挂载rpmbs物理分区的链表
md->usage = 1; // 使用计数设置为1
//---- 核心：
// 设置mmc_blk_data->queue，
// 会调用mmc_init_queue来分配和设置mmc_blk_data->queue，
// 在这里面会创建对应的request_queue.
/*
以下对应“3.
初始化struct mmc_blk_data->mmc_queue”
*/
/*
以下对应“4.
创建struct mmc_blk_data->mmc_queue->request_queue（创建struct request_queue）”
*/
ret = mmc_init_queue(&md->queue, card);
if (ret)
goto err_putdisk;
md->queue.blkdata = md; // 关联mmc_queue和mmc_blk_data
/*
* Keep an extra reference to the queue so that we can shutdown the
* queue (i.e. call blk_cleanup_queue()) while there are still
* references to the 'md'. The corresponding blk_put_queue() is in
* mmc_blk_put().
*/
if (!blk_get_queue(md->queue.queue)) {
mmc_cleanup_queue(&md->queue);
ret = -ENODEV;
goto err_putdisk;
}
//---- 核心：设置mmc_blk_data->disk
/*
以下对应“5.
分配和初始化struct mmc_blk_data->gendisk（
创建struct gendisk & 初始化struct gendisk）”
*/
// 分配gendisk放在前面完成了
md->disk->major = MMC_BLOCK_MAJOR; // 设置块设备的主设备号为MMC_BLOCK_MAJOR，179
md->disk->first_minor = devidx * perdev_minors; // 设置块设备的从设备号
md->disk->fops = &mmc_bdops; // 设置块设备操作集
md->disk->private_data = md; // 关联gendisk和mmc_blk_data
/*
以下对应“6.
关联struct mmc_blk_data->gendisk
和 mmc_blk_data->mmc_queue->request_queue
关联struct gendisk和struct request_queue）”
*/
md->disk->queue = md->queue.queue; // 重要，关联gendisk和request_queue！！！
md->parent = parent;
set_disk_ro(md->disk, md->read_only || default_ro); // 设置gendisk的只读属性
md->disk->flags = GENHD_FL_EXT_DEVT; // 设置gendisk的一些标识
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;
/*
* As discussed on lkml, GENHD_FL_REMOVABLE should:
*
* - be set for removable media with permanent block devices
* - be unset for removable block devices with permanent media
*
* Since MMC block devices clearly fall under the second
* case, we do not set GENHD_FL_REMOVABLE. Userspace
* should use the block device creation/destruction hotplug
* messages to tell when the card is present.
*/
// 设置块设备的设备名，例如mmcblk0、mmcblk1，
// 而mmcblk0rpmb中的rpmb则是指subname
snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
"mmcblk%u%s", card->host->index, subname ? subname : "");
// 设置gendisk的容量，size是以扇区为单位。
set_capacity(md->disk, size);
if (mmc_host_cmd23(card->host)) {
if ((mmc_card_mmc(card) &&
card->csd.mmca_vsn >= CSD_SPEC_VER_3) ||
(mmc_card_sd(card) &&
card->scr.cmds & SD_SCR_CMD23_SUPPORT))
md->flags |= MMC_BLK_CMD23;
}
if (mmc_card_mmc(card) &&
md->flags & MMC_BLK_CMD23 &&
((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) ||
card->ext_csd.rel_sectors)) {
md->flags |= MMC_BLK_REL_WR;
blk_queue_write_cache(md->queue.queue, true, true);
}
return md;
err_putdisk:
put_disk(md->disk);
err_kfree:
kfree(md);
out:
ida_simple_remove(&mmc_blk_ida, devidx);
return ERR_PTR(ret);
}
mmc_init_queue()函数
//源码：drivers/mmc/core/queue.c
/**
* mmc_init_queue - initialise a queue structure.
* @mq: mmc queue
* @card: mmc card to attach this queue
*
* Initialise a MMC card request queue.
*/
// 两个重要的功能
// 1、创建request_queue并封装到mmc_queue中
// 2、创建IO请求（request）的提取和处理进程
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;
/*
* The queue depth for CQE must match the hardware because the request
* tag is used to index the hardware queue.
*/
if (mq->use_cqe)
mq->tag_set.queue_depth =
min_t(int, card->ext_csd.cmdq_depth, host->cqe_qdepth);
else
mq->tag_set.queue_depth = MMC_QUEUE_DEPTH;
mq->tag_set.numa_node = NUMA_NO_NODE;
mq->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
mq->tag_set.nr_hw_queues = 1;
mq->tag_set.cmd_size = sizeof(struct mmc_queue_req);
mq->tag_set.driver_data = mq;
/*
* Since blk_mq_alloc_tag_set() calls .init_request() of mmc_mq_ops,
* the host->can_dma_map_merge should be set before to get max_segs
* from mmc_get_max_segments().
*/
if (mmc_merge_capable(host) &&
host->max_segs < MMC_DMA_MAP_MERGE_SEGMENTS &&
dma_get_merge_boundary(mmc_dev(host)))
host->can_dma_map_merge = 1;
else
host->can_dma_map_merge = 0;
ret = blk_mq_alloc_tag_set(&mq->tag_set);
if (ret)
return ret;
/**
创建struct mmc_blk_data->mmc_queue->request_queue
（创建struct request_queue）
**/
mq->queue = blk_mq_init_queue(&mq->tag_set);
if (IS_ERR(mq->queue)) {
ret = PTR_ERR(mq->queue);
goto free_tag_set;
}
if (mmc_host_is_spi(host) && host->use_spi_crc)
mq->queue->backing_dev_info->capabilities |=
BDI_CAP_STABLE_WRITES;
mq->queue->queuedata = mq;
blk_queue_rq_timeout(mq->queue, 60 * HZ);
mmc_setup_queue(mq, card);
return 0;
free_tag_set:
blk_mq_free_tag_set(&mq->tag_set);
return ret;
}
- mmc_mq_ops的实现
具体实现稍后补上。
//源码：drivers/mmc/core/queue.c
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,
};
mmc_add_disk()函数解析
//源码：drivers/mmc/core/block.c
static int mmc_add_disk(struct mmc_blk_data *md)
{
int ret;
struct mmc_card *card = md->queue.card;
/** 注册mmc_blk_data->gendisk到系统中 （注册块设备） **/
device_add_disk(md->parent, md->disk, NULL);
md->force_ro.show = force_ro_show;
md->force_ro.store = force_ro_store;
sysfs_attr_init(&md->force_ro.attr);
md->force_ro.attr.name = "force_ro";
md->force_ro.attr.mode = S_IRUGO | S_IWUSR;
ret = device_create_file(disk_to_dev(md->disk), &md->force_ro);
if (ret)
goto force_ro_fail;
if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
card->ext_csd.boot_ro_lockable) {
umode_t mode;
if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_DIS)
mode = S_IRUGO;
else
mode = S_IRUGO | S_IWUSR;
md->power_ro_lock.show = power_ro_lock_show;
md->power_ro_lock.store = power_ro_lock_store;
sysfs_attr_init(&md->power_ro_lock.attr);
md->power_ro_lock.attr.mode = mode;
md->power_ro_lock.attr.name =
"ro_lock_until_next_power_on";
ret = device_create_file(disk_to_dev(md->disk),
&md->power_ro_lock);
if (ret)
goto power_ro_lock_fail;
}
return ret;
power_ro_lock_fail:
device_remove_file(disk_to_dev(md->disk), &md->force_ro);
force_ro_fail:
del_gendisk(md->disk);
return ret;
}