Linux内核mmc_sdio_sd卡子系统驱动架构

MMC/SD Memory/SDIO卡mmc子系统驱动架构工作报告

2014-3-11深圳

目标：

分析整理（MMC/SD Memory/SDIO卡）mmc子系统驱动架构；

本文要点：

1、mmc子系统后端初始化相关的数据结构;

2、mmc子系统初始化驱动架构；

3、mmc请求处理；

4、基本的sd协议规范；

SDIO/SD Memory/MMC卡的区别：

●SDIO card is to provide high-speed data I/O with low power consumption for mobile

electronic devices.

●The SDIO (Secure Digital I/O) card is based on and compatible with the SD memory card. This

compatibility includes mechanical, electrical, power, signaling and software.

●SD Memory Card is a memory card that is specifically designed to meet the security,

capacity, performance, and environment requirements inherent in newly emerging audio and video consumer electronic devices.

The SD Memory Card will include a content protection mechanism.The SD Memory Card security system uses mutual authentication and a "new cipher algorithm" to protect against illegal usage of the card content.

A Non-secure access to the user's own content is also available.

●The MMC/eMMC is an universal low cost data storage and communication media. It is

designed to cover a wide area of applications as smart phones, cameras, organizers, PDAs, digital recorders, MP3 players, pagers, electronic toys, etc. Targeted features are high mobility and high performance at a low cost price.

These features include low power consumption and high data throughput at the memory card interface.

●SD Memory卡是从MMC卡发展过来的，它更注重内容保护，SD Memory卡在外形上同

MMC卡保持一致，且兼容MMC卡兼容规范.

所以就发展轨道来看，是MMC卡==>SD Memory卡==>SDIO卡，依次兼容，保持一致

硬件图：（以SD 总线为例）

注意：在默认速度下，SD 总线支持单master(application)与多slaves(cards)连接；而在高速和UHS-I(极高速)下，SD 总线只支持单master 与单slave 连接；（经分析：当前linux 版本代码针对的是单master 与单slave 连接模式）

D0-D3, CMD

VSS

VDD CLK

D0-D3, CMD

CLK VDD VSS

CLK VDD VSS D0-D3(A) CMD(A)

D0-D3(B) CMD(B)

SD Memory

Card(B)

SD Memory Card(A)

Host

数据结构

1.初始化:

mmc_card {} .dev ... ... .cid .csd *host ... ...

mmc_host {} *card

.class_dev *ops .disable .detect ... ... .ios *bus_ops

mmc_csd{} .max_dtr .cmdclass .capacity ... ...

mmc_cid{} .manfid ... ...

mmc_host_ops{} *request *set_ios *get_ro ... ...

sdhci_host {} *mmc ... ...

（前端）

gendisk {} *driverfs_dev .major .first_minor ... ...

mmc_bus_type {} *match *probe ... ...

device{} *bus ... ...

mmc_bus_match

mmc_bus_probe device_driver{} *bus ... ...

mmc_driver {} .drv .probe

... ...

mmc_blk_data {} .queue *disk ... ... mmc_queue{}

*card ... ...

（前端）

mmc_ios{} clock vdd bus_mode ... ...

delayed_work{} ... ...

mmc_sd_ops{} mmc_ops{} mmc_sdio_ops{}

其中：*ops ：表示对控制器的操作，由前端控制器驱动中设定；

*bus_ops ：表示对总线上卡的操作，不同类型总线对应的卡有不同的操作，其中mmc_sd_ops{}, 在mmc_sd_attach_bus_ops()

函数中设置; mmc_sdio_ops{} 在mmc_attach_bus()函数中设置; mmc_ops{} 在mmc_attach_bus_ops 函数中设置；

2.请求处理:

mmc_command {} *data *mrq opcode arg resp[4] flags retries ... ...

mmc_blk_data {}

queue ... ...

mmc_queue {} *data

*queue *thread *issue_fn *sg *req

mmc_data {} *mrq *stop *sg blksz blocks flags ... ...

request_queue {} queue_head *queuedata request {}

queuelist

mmc_blk_request {} mrq data cmd stop

mmc_request {} *cmd *data *stop *done ... ...

task_struct{} ... ...

scatterlist{} ... ...

（块层构建的请求）

request {} queuelist 注1

（当前取出的请求）

（mmc 构建的请求）

（mmc 构建的命令）

注1：不论是块层下发的读写请求，还是源自mmc 核心层要发出的命令，都使用mmc_request {}进行发送 （原因：保存了所需资源的指针）； 注2：有两种命令来源，一种是mmc 核心需要发的命令，一种是块层下发的请求也需要由mmc 为其生成命令。两个都是在mmc 子系统中构建；

注3：mmc 核心需要发的命令，以初始化为目的，不传输数据；由块层下发的请求所生成的命令，以数据读写为目的，要用到mmc_data {}；

注2 注3 mmc_request()

数据结构成员：

struct mmc_card {

struct mmc_host *host; /* 隶属的MMC控制器*/

struct device dev; /* 当前设备*/

unsigned int rca; /* 卡地址*/

unsigned int type; /* 卡的类型: 0=MMC 1=SD 2=SDIO*/

unsigned int state; /* 卡状态*/

u32 raw_cid[4]; /* 卡cid，未解码*/

u32 raw_csd[4]; /* 卡csd，未解码*/

u32 raw_scr[2]; /* 卡scr，未解码*/

... ...;

struct mmc_cid cid; /* 卡身份，已解码*/

struct mmc_csd csd; /* 卡的特殊数据，已解码*/

struct sd_scr scr; /* 额外的SD数据，已解码*/

... ...;

};

mmc_card{}代表了一张MMC卡

struct mmc_cid {

unsigned int manfid; /* 制造商id*/

char prod_name[8]; /* 产品名*/

unsigned int serial; /* 产品序列号*/

unsigned short oemid; /* 产品OID*/

... ...

};

struct mmc_csd {

unsigned char mmca_vsn; /*卡版本号*/

unsigned short cmdclass; /* card支持的命令子集*/

unsigned short tacc_clks; /*用于计算读命令的末位和所读数据的首位间的最大时值Nac*/

unsigned int tacc_ns; /*用于计算读命令的末位和所读数据的首位间的最大时值Nac*/

unsigned int max_dtr; /*最大传输速率*/

unsigned int read_blkbits; /*最大的读数据块长度*/

unsigned int write_blkbits; /*最大的写数据块长度*/

unsigned int capacity; /*卡的存储容量*/

unsigned int read_partial:1, /*读小块尺寸数据（最小1byte）是否允许，SD卡恒为1*/

... ...

};

mmc_cid{},mmc_csd{}是MMC卡的CID寄存器与CSD寄存器相关的结构

struct sd_scr {

unsigned char sda_vsn; /*physical layer specification版本号*/

unsigned char bus_widths; /*数据线的宽度*/

};

struct mmc_blk_data {

struct gendisk *disk; /*通用磁盘*/

struct mmc_queue queue; /*磁盘设备的请求队列数据结构*/

unsigned int read_only; /*只读标志*/

... ...;

};

struct gendisk {

int major; /* 磁盘的主设备号*/

int first_minor; /* 磁盘的第一个次设备号*/

int minors; /* 次设备号数目，即分区个数, 至少为1*/ struct disk_part_tbl *part_tbl; /* 指向磁盘分区表*/

struct hd_struct part0; /* 第一个分区：0分区*/

struct block_device_operations *fops; /* 磁盘块设备操作方法*/

struct request_queue *queue; /* 指向磁盘设备的请求队列*/

void *private_data; /* 磁盘的私有数据*/

int flags; /* 磁盘类别标志*/

char disk_name[DISK_NAME_LEN]; /* 磁盘名*/

struct device *driverfs_dev; /* 对应的当前设备*/

... ...;

};

struct mmc_queue {

struct mmc_card *card; /* 对应的卡设备*/

struct task_struct *thread; /* 请求队列关联的处理线程*/

struct request *req; /* 取出的一个请求*/

int (*issue_fn)(struct mmc_queue *, struct request *); /* 发送请求的函数*/

void *data; /*这里用来保存mmc_blk_data{}的指针*/ struct request_queue *queue; /* 磁盘设备的请求队列*/

struct scatterlist *sg; /* 磁盘设备的散列表*/

... ...;

};

struct mmc_host {

struct device class_dev; /* 当前mmc控制器设备*/

const struct mmc_host_ops *ops; /* 控制器的操作方法*/

u32 ocr_avail; /* 控制器支持的运行电压*/

unsigned long caps; /* 控制器支持的传输能力*/

unsigned int max_seg_size; /* 最大的数据段尺寸（bytes）*/

unsigned short max_hw_segs; /* 一条请求的硬件扇区数上限（通常以512b为单位）*/

unsigned short max_phys_segs;

unsigned int max_req_size; /* 一条请求的最大字节数（bytes）*/

unsigned int max_blk_size; /* 一个mmc数据块的最大尺寸（bytes）*/

unsigned int max_blk_count; /* 一条请求中的数据块数目上限*/

struct mmc_ios ios; /* 当前的总线设置*/

struct delayed_work disable; /* 延迟的事物，用于关闭控制器*/

struct mmc_card *card; /* 与控制器关联的卡*/

unsigned int claimed:1; /* 控制器占用声明*/

unsigned int bus_dead:1; /* 控制器总线被释放*/

wait_queue_head_t wq; /* 声明占用控制器的等待队列头结点*/

struct task_struct *claimer; /* 占用控制器的进/线程*/

int claim_cnt; /* 计数*/

struct delayed_work detect; /* 延迟的事务，用于探测*/

const struct mmc_bus_ops *bus_ops; /* 当前绑定的总线操作*/

unsigned int bus_refs; /* 引用计数*/

... ...;

unsigned long private[0] ;

};

mmc_host{}代表一个MMC控制器

struct mmc_host_ops {

int (*enable)(struct mmc_host *host); /* 使控制器进入省电状态*/

int (*disable)(struct mmc_host *host, int lazy); /* 使控制器退出省电状态*/

void(*request)(struct mmc_host *host, struct mmc_request *req); /* 控制器处理请求的接口*/

void(*set_ios)(struct mmc_host *host, struct mmc_ios *ios); /* 控制器总线设置的接口*/

... ...;

};

struct mmc_bus_ops {

void (*remove)(struct mmc_host *); /* 释放卡*/

void (*detect)(struct mmc_host *); /* 查询卡的状态*/

int (*suspend)(struct mmc_host *); /* 使卡退出传输状态*/

int (*resume)(struct mmc_host *); /* 使已存在的卡恢复状态*/

void (*power_restore)(struct mmc_host *); /* 使已存在的卡恢复状态（不使用高速模式）*/

};

struct mmc_ios {

unsigned int clock; /* 时钟*/

unsigned short vdd; /* 电压*/

unsigned char bus_mode; /* 命令输出采用的模式*/ unsigned char chip_select; /* SPI芯片片选*/

... ...;

unsigned char bus_width; /* 总线宽度(1,4,8)*/

unsigned char timing; /*时序模式*/

};

mmc_ios{}存储MMC卡的状态信息

struct bus_type mmc_bus_type = {

.name = "mmc", /* bus type 名*/

.match = mmc_bus_match, /* bus type 匹配函数*/

.probe = mmc_bus_probe, /* bus type 匹配处理*/

... ...,

};

struct mmc_driver {

struct device_driver drv; /* 当前驱动*/

int (*probe)(struct mmc_card *); /* 驱动的匹配处理函数*/

... ...

};

struct mmc_command {

u32 opcode; /* 命令操作码*/

u32 arg; /* 命令参数*/

u32 resp[4]; /* 反馈信息*/

unsigned int flags; /* 期待的反馈类型*/

unsigned int retries; /* 重发次数*/

unsigned int error; /* 命令出错*/

struct mmc_data *data; /* 命令关联的数据段*/

struct mmc_request *mrq; /* 关联的请求*/

};

struct mmc_data {

unsigned int timeout_ns; /* 超时时间ns (max 80ms) */ unsigned int timeout_clks; /* 超时时钟数(in clocks) */ unsigned int blksz; /* 块尺寸*/

unsigned int blocks; /* 块数目*/

unsigned int error; /* 数据错误*/

unsigned int flags; /* 读写标志*/

unsigned int bytes_xfered; /* 待传输的字节数*/

struct mmc_command *stop; /* stop命令*/

struct mmc_request *mrq; /* 关联的请求*/

unsigned int sg_len; /* 散列表的尺寸*/

struct scatterlist *sg; /* 散列表指针*/

};

struct mmc_blk_request {

struct mmc_request mrq; /* 当前请求*/

struct mmc_command cmd; /* 请求对应的命令*/

struct mmc_command stop; /* 请求的stop命令*/

struct mmc_data data; /* 请求对应的数据*/

};

struct mmc_request {

struct mmc_command *cmd; /* 请求对应的命令的指针*/

struct mmc_data *data; /* 请求对应的数据的指针*/

struct mmc_command *stop; /* 请求对应的stop命令的指针*/ void *done_data; /* completion参数*/

void (*done)(struct mmc_request *); /* completion函数*/

};

第一篇：初始化架构：

mmc 子系统就初始化而言，主要有三条线、五个环节

说明：

1、最首先进行的是mmc 子系统核心初始化，下面的初始化整体框架图只是为了排版的需要位置滞后；

2、第二、三条线的先后顺序无需固定；

初始化整体框架：

第一条线 1. mmc 子系统核心初始化

subsys_initcall 3. mmc 控制器设备注册

4.探测、分配和注册card 设备

第二条线 2. mmc 控制器驱动平台注册

module_init 5.磁盘设备驱动注册

第三条线 module_init

11/44

//work : &host->detect

mmc_sd_init_card

mmc_init

workqueue = create_singlethread_workqueue("kmmcd") sdhci_probe_slot

mmc_detect_change

mmc_schedule_delayed_work(&host->detect , ...) queue_delayed_work (workqueue , work , ...) mmc_rescan ... ....（详见下文）

mmc_sd_attach_bus_ops

2. mmc 控制器

平台驱动注册 3.mmc 控制器设备注册 1. mmc 子系统

核心初始化 5.磁盘设备驱动注册

struct mmc_driver mmc_driver = {

.drv = {

.name = "mmcblk",

},

.probe

= mmc_blk_probe ,

}

add_disk

module_init sdhci_drv_init platform_driver_registe struct bus_type mmc_bus_type = { .match= mmc_bus_match,

... ...,

.probe = mmc_bus_probe , }

4.2分配和注册 card 设备

mmc_attach_sd

module_init mmc_blk_init

mmc_register_driver (&mmc_driver ) register_blkdev driver_register

device_add

mmc_add_card

mmc_alloc_host

mmc_add_host device_add mmc_start_host

queue_delayed_work

sdhci_probe 平台驱动机制流程

（见下行）

INIT_DELAYED_WORK(&host->detect , mmc_rescan ) 驱动注册并挂入总线

设备注册并挂入总线

subsys_initcall bus_register(&mmc_bus_type )

mmc_register_bus （见下行）

4.1探测

（以SD 为例）

12/44

一、mmc 子系统核心初始化：

struct workqueue_struct *workqueue ;

struct wake_lock mmc_delayed_work_wake_lock ; struct bus_type mmc_bus_type = { .name = "mmc",

.match = mmc_bus_match, .probe

= mmc_bus_probe,

... ...,

};

struct class mmc_host_class = { .name

= "mmc_host",

.dev_release = mmc_host_classdev_release,

};

struct bus_type sdio_bus_type = { .name = "sdio", .dev_attrs = sdio_dev_attrs, .match = sdio_bus_match,

.uevent

= sdio_bus_uevent,

mmc_init

总线类型mmc_bus_type 注册（SD/mmc ）

workqueue= create_singlethread_workqueue("kmmcd") 为控制器设备注册一个类mmc_host_class

总线类型sdio_bus_type 注册（SDIO ）

subsys_initcall

13/44

.probe = sdio_bus_probe, .remove

= sdio_bus_remove,

};

static int __init mmc_init (void) { wake_lock_init(&mmc_delayed_work_wake_lock , WAKE_LOCK_SUSPEND, "mmc_delayed_work"); workqueue = create_singlethread_workqueue("kmmcd"); mmc_register_bus (); mmc_register_host_class(); sdio_register_bus();

}

int mmc_register_bus (void) { return bus_register (&mmc_bus_type );

}

int mmc_register_host_class(void) {

return class_register(&mmc_host_class ); }

int sdio_register_bus(void) { return bus_register(&sdio_bus_type); }

subsys_initcall (mmc_init )===> android 休眠锁:在android 机制中，只有有进程拿到wake_lock 锁且未释放，则系统不能进入休眠. 在之后的mmc_rescan()中完成mmc 卡的探测，注册之后，即释放该锁

14/44

二、mmc 控制器驱动与设备注册：

架构设计思想:

说明：sdhci_host{}是对mmc_host{} 的外封装；

函数调用图:

module_init (sdhci_drv_init)

sdhci_driver 平台驱动注册

sdhci_probe_slot() mmc_host{}

mmc->ops = &sdhci_ops

host->class_dev.class = &mmc_host_class ;

INIT_DELAYED_WORK(&host->detect, mmc_rescan ) mmc_detect_change (host, 0)

mmc_power_off(host) 探测设备的具体处理例程 断电的处理例程 启动时第一次探测设备

命令发送超时的相关处理

分配数据结构内存

mmc_host{}、sdhci_host{}内存分配

INIT_WORK(&host->finish_wq, sdhci_finish_worker )

setup_timer(&host->timer, sdhci_timeout_timer,... ... )

sdhci_host{}

命令发送完成的相关处理

request_irq(host->irq,sdhci_irq , ... ... );

命令数据收发中断的处理

15/44

代码骨架：

（属前端驱动部分，以mx_sdhci.c 为例） struct mmc_host_ops sdhci_ops = {

.request = sdhci_request, //展开见后文 .set_ios = sdhci_set_ios,//展开见后文 ... ..., };

struct platform_driver sdhci_driver = { .driver = { .name = "mxsdhci", }, .probe = sdhci_probe ,

... ..., };

//前端：

int __init sdhci_drv_init (void)

request_irq(host->detect_irq, sdhci_cd_irq ) sdhci_probe_slot device_add

mmc_power_off

mmc_add_host

mmc_start_host

mmc_detect_change

module_init (sdhci_drv_init)===> mmc_alloc_host

INIT_DELAYED_WORK(&host->detect, mmc_rescan , …)

device_initialize

16/44

{ return platform_driver_register (&sdhci_driver );

}

static int sdhci_probe (struct platform_device *pdev)

{ ... ...;

sdhci_probe_slot (pdev, ...); }

static int __devinit sdhci_probe_slot (struct platform_device *pdev, ...) { struct mmc_host *mmc;

struct sdhci_host *host; ... ...; mmc = mmc_alloc_host (sizeof(struct sdhci_host), &pdev->dev);

host = mmc_priv(mmc);//return (void *)host->private ... ...;

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

host->detect_irq = platform_get_irq(pdev, 1);

mmc->index =pdev->id;

dev_set_name(&mmc->class_dev, "mmc%d", mmc->index); //如mmc0 mmc->ops = &sdhci_ops ; ……

//Q:在什么地方执行这个tasklet //A:在sdhci_irq 中断处理程序中

tasklet_init(&host->card_tasklet, sdhci_tasklet_card, (unsigned long)host); host->workqueue = create_workqueue("esdhc_wq"); INIT_WORK(&host->cd_wq, esdhc_cd_callback);

INIT_WORK(&host->finish_wq, sdhci_finish_worker); //sdhci_finish_worker 见第二篇

setup_timer(&host->timer, sdhci_timeout_timer, (unsigned long)host); //sdhci_timeout_timer 见第二篇 setup_timer(&host->cd_timer, sdhci_cd_timer, (unsigned long)host); ... ...;

struct platform_device mxcsdhc1_device = { .name = "mxsdhci", .id = 0,

... ...,

} 平台驱动机制流程

匹配资源调用probe 传入设备资源

17/44

//这个中断是通过GPIO 引脚检测SD 卡拔插的中断

ret = request_irq(host->detect_irq, sdhci_cd_irq, 0,pdev->name, host); //这个中断是用来检测 SD write/read CMD 错误的中断

ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED, pdev->name, host); mmc_add_host (mmc);

}

struct mmc_host *mmc_alloc_host (int extra, struct device *dev) { struct mmc_host *host ;

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

host->class_dev.class = &mmc_host_class ;

... ...; INIT_DELAYED_WORK(&host->detect , mmc_rescan ); device_initialize (&host->class_dev ); return host; }

int mmc_add_host (struct mmc_host *host) { device_add (&host->class_dev ); mmc_start_host (host); }

void mmc_start_host (struct mmc_host *host) { mmc_power_off (host);

//这里以控制器启动为契机，引出“三、card 设备的探测、分配和注册”（见后） mmc_detect_change (host, 0); }

static void mmc_power_off (struct mmc_host *host) { host->ios.clock = 0;

名为class_dev ，实为mmc/sd memory/sdio 卡的

mmc_host{}设备 mmc_rescan 接口,主要承担card 的探测、分配和注册。展开见后文:

由mmc_detect_change/mmc_start_host 发起调用

host->ios.vdd = 0;

host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;

host->ios.chip_select = MMC_CS_DONTCARE;

host->ios.power_mode = MMC_POWER_OFF;

host->ios.bus_width = MMC_BUS_WIDTH_1;

host->ios.timing = MMC_TIMING_LEGACY;

mmc_set_ios(host);

}

static inline void mmc_set_ios(struct mmc_host *host)

{

struct mmc_ios *ios = &host->ios;

host->ops->set_ios(host, ios); //进入控制器前端驱动完成具体设置,

//.set_ios = sdhci_set_ios

}

void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)

{

//具体的前端寄存器操作。将设置的数据写入imx51 esdhc控制器使其生效}

mmc_set_timing mmc_power_up mmc_select_voltage mmc_set_bus_width mmc_set_bus_mode

mmc_set_clock

mmc_set_chip_select mmc_power_down

mmc_set_ios

host->ops->set_ios sdhci_set_ios

struct mmc_host_ops sdhci_ops = {

.........,

.set_ios = sdhci_set_ios, }

前端驱动中:

mmc_host{}->ops = &sdhci_ops;

18/44

三、card设备的探测、分配和注册：

1) 探测card设备：

探测时机：

1、mmc控制器启动时；

函数链：

module_init==>sdhci_drv_init==>platform_driver_register==>... ...（控制器平台驱动注册，获取设备资源）

==>sdhci_probe==>sdhci_probe_slot==>mmc_add_host==>mmc_start_host==>mmc_detect_change ;

2、mmc控制器启动后，某时刻插入或拔出card设备时，这里涉及到mmc控制器前端驱动的两种处理：

1）、采用中断机制，经过简单的中断转调后，将调用到这里的mmc_detect_change()函数；

准备工作：（以mx_sdhci.c为例）

request_irq(host->detect_irq, sdhci_cd_irq, 0, pdev->name, host);

INIT_WORK(&host->cd_wq, esdhc_cd_callback);

函数链：

插卡/拔卡触发中断==>sdhci_cd_irq==>schedule_work(&host->cd_wq)==>esdhc_cd_callback==>

mmc_detect_change;

使用poll方式轮询探测，也将调用mmc_schedule_delayed_work()函数。

准备工作：前端开启MMC_CAP_NEEDS_POLL

如struct mmc_host host_for_instance;

host_for_instance.cap |= MMC_CAP_NEEDS_POLL;

（说明：mx_sdhci.c并没有使用轮询方式，这里对MMC_CAP_NEEDS_POLL的设置仅仅是个示意）

函数链：见后面rescan()函数内部即可；

3、mmc控制器从suspend转为resume时(电源管理)

说明：这里为电源管理服务考虑，在进入suspend之前如果已有卡处于插入态，当控制器resume返回时，需要重新进行确认并进行恢复；

准备工作：（仍以mx_sdhci.c为例）

struct platform_driver sdhci_driver = {

... ...,

.resume = sdhci_resume,

};

platform_driver_register(&sdhci_driver);

函数链：

19/44

电源管理模块==>sdhci_resume（控制器先）==>mmc_resume_host==>

host->bus_ops->resume (card后)

mmc_detect_change (待控制器和card设备依次resume后，才执行确认性探测工作) （本部分为了前后连贯突出主干，承接上文，以时机1来引起探测过程，并解析。）

20/44