1.mmc的概念
1.MMC
MultiMedia Card，多媒体存储卡， 但后续泛指一个接口协定（一种卡式），能符合这接口的内存器都可称作mmc储存体,工作电压：高电压为2.7～3.6 V，低电压为1.65～1.95 V，可选.
2.MMC总线
mmc总线是和I2C总线、SPI总线类似的一种总线结构。
卡与主控制器间串行传送，工作时钟频率范围为0～200 MHz,mmc总线上最多可识别64 K个mmc设备，在总线上不超过10个卡时，可运行到最高频率。
3.mmc设备
使用mmc接口规范（MCI, Multimedia Card Interface）的设备都可以称之为mmc设备。分为以下三种:
1.mmc type card:
1.标准mmc卡：闪存卡的一种，使用mmc标准;
2.emmc：Embedded MultiMediaCard，是MMC协会所制定的内嵌式存储器标准规格，带有mmc接口，是具备mmc协议的芯片。
2.sd type card
sd卡：SD卡为Secure Digital Memory Card, 即安全数码卡。它在MMC的基础上发展而来，增加了两个主要特色：SD卡强调数据的安全安全，可以设定所储存的使用权限，防止数据被他人复制。兼容mmc接口规范。
3.sdio type card
sdio设备：SDIO是在SD标准上定义了一种外设接口，它和SD卡规范间的一个重要区别是增加了低速标准。在SDIO卡只需要SPI和1位SD传输模式。低速卡的目标应用是以最小的硬件开销支持低速IO能力。常见的sdio设备有Wi-Fi card、Bluetooth card等等。
这几种类型的card统称为mmc card
4.mmc协议
类似i2c协议、spi协议，mmc总线上也有一套自己的通讯规范。通信规范后续在说明。而上述mmc设备基于上mmc总线通讯规范上由自身硬件特性设置了自己的一套协议。
1.标准mmc卡协议
2.emmc协议（主要区别在于读写速度上）
3.sd协议
5.mmc subsystem
kernel中的mmc subsystem用于管理所有mmc总线控制器以及mmc设备，包括mmc type card（标准mmc卡、emmc）、sd type card（sd卡）、sdio type card。
也就是说只要使用MCI的设备都交由mmc subsystem统一管理。
2.MMC framework的软件架构
MMC framework分别有“从左到右”和“从下到上”两种层次结构:
1.从左到右
MMC协议是一个总线协议，因此包括Host controller、Bus、Card三类实体（从左到右）。相应的，MMC framework抽象出了host、bus、card三个软件实体，以便和硬件一一对应：
host:负责驱动Host controller，提供诸如访问card的寄存器、检测card的插拔、读写card等操作方法。从设备模型的角度看，host会检测卡的插入，并向bus注册MMC card设备；
bus:是MMC bus的虚拟抽象，以标准设备模型的方式，收纳MMC card（device）以及对应的MMC driver（driver）;
card:抽象具体的MMC卡，由对应的MMC driver驱动（从这个角度看，可以忽略MMC的技术细节，只需关心一个个具有特定功能的卡设备，如存储卡、WIFI卡、GPS卡等等）.
2.从左到右
MMC host controller driver位于底层，基于MMC core提供的框架，驱动具体的硬件（MMC controller）；
MMC core位于中间，是MMC framework的核心实现，负责抽象host、bus、card等软件实体，负责向底层提供统一、便利的编写Host controller driver的API；
MMC card driver位于最上面，负责驱动MMC core抽象出来的虚拟的card设备，并对接内核其它的framework（例如块设备、TTY、wireless等），实现具体的功能。
3.工作流程
Linux MMC framework的工作流程如下
4.数据结构
1.host相关
1.struct mmc_host
struct mmc_host是mmc core由host controller抽象出来的结构体，用于代表一个mmc host控制器。
struct mmc_host {
struct device *parent; // 对应的host controller的device
struct device class_dev; // mmc_host的device结构体，会挂在class/mmc_host下
int index; // 该host的索引号
const struct mmc_host_ops *ops; // 该host的操作集，由host controller设置，后面说明
unsigned int f_min; // 该host支持的最低频率
unsigned int f_max; // 该host支持的最大频率
unsigned int f_init; // 该host使用的初始化频率
u32 ocr_avail; // 该host可用的ocr值（电压相关）
u32 ocr_avail_sdio; /* SDIO-specific OCR */
u32 ocr_avail_sd; /* SD-specific OCR */
u32 ocr_avail_mmc; /* MMC-specific OCR */
struct notifier_block pm_notify;
u32 max_current_330; // 3.3V时的最大电流
u32 max_current_300; // 3.0V时的最大电流
u32 max_current_180; // 1.8V时的最大电流
u32 caps; /* Host capabilities */ // host属性
u32 caps2; /* More host capabilities */ // host属性2
mmc_pm_flag_t pm_caps; /* supported pm features */ // 电源管理属性
/// 以下是和clock相关的成员
int clk_requests; /* internal reference counter */
unsigned int clk_delay; /* number of MCI clk hold cycles */
bool clk_gated; /* clock gated */
struct delayed_work clk_gate_work; /* delayed clock gate */
unsigned int clk_old; /* old clock value cache */
spinlock_t clk_lock; /* lock for clk fields */
struct mutex clk_gate_mutex; /* mutex for clock gating */
struct device_attribute clkgate_delay_attr;
unsigned long clkgate_delay;
/* host specific block data */
// 和块相关的成员
unsigned int max_seg_size; /* see blk_queue_max_segment_size */
unsigned short max_segs; /* see blk_queue_max_segments */
unsigned short unused;
unsigned int max_req_size; /* maximum number of bytes in one req */
unsigned int max_blk_size; /* maximum size of one mmc block */
unsigned int max_blk_count; /* maximum number of blocks in one req */
unsigned int max_discard_to; /* max. discard timeout in ms */
/* private data */
spinlock_t lock; /* lock for claim and bus ops */ // host的bus使用的锁
struct mmc_ios ios; /* current io bus settings */ // io setting，后续说明
u32 ocr; /* the current OCR setting */ // 当前使用的ocr的值
/* group bitfields together to minimize padding */
unsigned int use_spi_crc:1;
unsigned int claimed:1; /* host exclusively claimed */ // host是否已经被占用
unsigned int bus_dead:1; /* bus has been released */ // host的bus是否处于激活状态
int rescan_disable; /* disable card detection */ // 禁止rescan的标识，禁止搜索card
int rescan_entered; /* used with nonremovable devices */ // 是否已经rescan过的标识，对应不可移除的设备只能rescan一次
struct mmc_card *card; /* device attached to this host */ // 和该host绑定在一起的card
wait_queue_head_t wq;
struct task_struct *claimer; /* task that has host claimed */ // 该host的占有者进程
struct task_struct *suspend_task;
int claim_cnt; /* "claim" nesting count */ // 占有者进程对该host的占用计数
struct delayed_work detect; // 检测卡槽变化的工作
struct wake_lock detect_wake_lock; // 检测卡槽变化的工作使用的锁
const char *wlock_name; // 锁名称
int detect_change; /* card detect flag */ // 需要检测卡槽变化的标识
struct mmc_slot slot; // 卡槽的结构体
const struct mmc_bus_ops *bus_ops; /* current bus driver */ // host的mmc总线的操作集，后面说明
unsigned int bus_refs; /* reference counter */ // host的mmc总线的使用计数
unsigned int bus_resume_flags; // host的mmc总线的resume标识
mmc_pm_flag_t pm_flags; /* requested pm features */
#ifdef CONFIG_REGULATOR
bool regulator_enabled; /* regulator state */ // 代表regulator（LDO）的状态
#endif
struct mmc_supply supply;
struct dentry *debugfs_root; // 对应的debug目录结构体
struct mmc_async_req *areq; /* active async req */ // 当前正在处理的异步请求
struct mmc_context_info context_info; /* async synchronization info */ // 异步请求的信息
unsigned int actual_clock; /* Actual HC clock rate */ // 实际的时钟频率
};
ocr值各个位代表的电压意义如下：
#define MMC_VDD_165_195 0x00000080 /* VDD voltage 1.65 - 1.95 */
#define MMC_VDD_20_21 0x00000100 /* VDD voltage 2.0 ~ 2.1 */
#define MMC_VDD_21_22 0x00000200 /* VDD voltage 2.1 ~ 2.2 */
#define MMC_VDD_22_23 0x00000400 /* VDD voltage 2.2 ~ 2.3 */
#define MMC_VDD_23_24 0x00000800 /* VDD voltage 2.3 ~ 2.4 */
#define MMC_VDD_24_25 0x00001000 /* VDD voltage 2.4 ~ 2.5 */
#define MMC_VDD_25_26 0x00002000 /* VDD voltage 2.5 ~ 2.6 */
#define MMC_VDD_26_27 0x00004000 /* VDD voltage 2.6 ~ 2.7 */
#define MMC_VDD_27_28 0x00008000 /* VDD voltage 2.7 ~ 2.8 */
#define MMC_VDD_28_29 0x00010000 /* VDD voltage 2.8 ~ 2.9 */
#define MMC_VDD_29_30 0x00020000 /* VDD voltage 2.9 ~ 3.0 */
#define MMC_VDD_30_31 0x00040000 /* VDD voltage 3.0 ~ 3.1 */
#define MMC_VDD_31_32 0x00080000 /* VDD voltage 3.1 ~ 3.2 */
#define MMC_VDD_32_33 0x00100000 /* VDD voltage 3.2 ~ 3.3 */
#define MMC_VDD_33_34 0x00200000 /* VDD voltage 3.3 ~ 3.4 */
#define MMC_VDD_34_35 0x00400000 /* VDD voltage 3.4 ~ 3.5 */
#define MMC_VDD_35_36 0x00800000 /* VDD voltage 3.5 ~ 3.6 */
host属性（mmc_host->caps）支持的属性如下
#define MMC_CAP_4_BIT_DATA (1 << 0) /* Can the host do 4 bit transfers */
#define MMC_CAP_MMC_HIGHSPEED (1 << 1) /* Can do MMC high-speed timing */
#define MMC_CAP_SD_HIGHSPEED (1 << 2) /* Can do SD high-speed timing */
#define MMC_CAP_SDIO_IRQ (1 << 3) /* Can signal pending SDIO IRQs */
#define MMC_CAP_SPI (1 << 4) /* Talks only SPI protocols */
#define MMC_CAP_NEEDS_POLL (1 << 5) /* Needs polling for card-detection */
#define MMC_CAP_8_BIT_DATA (1 << 6) /* Can the host do 8 bit transfers */
#define MMC_CAP_NONREMOVABLE (1 << 8) /* Nonremovable e.g. eMMC */
#define MMC_CAP_WAIT_WHILE_BUSY (1 << 9) /* Waits while card is busy */
#define MMC_CAP_ERASE (1 << 10) /* Allow erase/trim commands */
#define MMC_CAP_1_8V_DDR (1 << 11) /* can support */
/* DDR mode at 1.8V */
#define MMC_CAP_1_2V_DDR (1 << 12) /* can support */
/* DDR mode at 1.2V */
#define MMC_CAP_HSDDR (MMC_CAP_1_8V_DDR | MMC_CAP_1_2V_DDR)
#define MMC_CAP_POWER_OFF_CARD (1 << 13) /* Can power off after boot */
#define MMC_CAP_BUS_WIDTH_TEST (1 << 14) /* CMD14/CMD19 bus width ok */
#define MMC_CAP_UHS_SDR12 (1 << 15) /* Host supports UHS SDR12 mode */
#define MMC_CAP_UHS_SDR25 (1 << 16) /* Host supports UHS SDR25 mode */
#define MMC_CAP_UHS_SDR50 (1 << 17) /* Host supports UHS SDR50 mode */
#define MMC_CAP_UHS_SDR104 (1 << 18) /* Host supports UHS SDR104 mode */
#define MMC_CAP_UHS_DDR50 (1 << 19) /* Host supports UHS DDR50 mode */
#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */
#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */
#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */
#define MMC_CAP_CMD23 (1 << 30) /* CMD23 supported. */
#define MMC_CAP_HW_RESET (1 << 31) /* Hardware reset */
host属性2（mmc_host->caps2）支持的属性如下
#define MMC_CAP2_BOOTPART_NOACC (1 << 0) /* Boot partition no access */
#define MMC_CAP2_CACHE_CTRL (1 << 1) /* Allow cache control */
#define MMC_CAP2_POWEROFF_NOTIFY (1 << 2) /* Notify poweroff supported */
#define MMC_CAP2_NO_MULTI_READ (1 << 3) /* Multiblock reads don't work */
#define MMC_CAP2_NO_SLEEP_CMD (1 << 4) /* Don't allow sleep command */
#define MMC_CAP2_HS200_1_8V_SDR (1 << 5) /* can support */
#define MMC_CAP2_HS200_1_2V_SDR (1 << 6) /* can support */
#define MMC_CAP2_HS200 (MMC_CAP2_HS200_1_8V_SDR | \
MMC_CAP2_HS200_1_2V_SDR)
#define MMC_CAP2_BROKEN_VOLTAGE (1 << 7) /* Use the broken voltage */
#define MMC_CAP2_DETECT_ON_ERR (1 << 8) /* On I/O err check card removal */
#define MMC_CAP2_HC_ERASE_SZ (1 << 9) /* High-capacity erase size */
#define MMC_CAP2_CD_ACTIVE_HIGH (1 << 10) /* Card-detect signal active high */
#define MMC_CAP2_RO_ACTIVE_HIGH (1 << 11) /* Write-protect signal active high */
#define MMC_CAP2_PACKED_RD (1 << 12) /* Allow packed read */
#define MMC_CAP2_PACKED_WR (1 << 13) /* Allow packed write */
#define MMC_CAP2_PACKED_CMD (MMC_CAP2_PACKED_RD | \
MMC_CAP2_PACKED_WR)
#define MMC_CAP2_NO_PRESCAN_POWERUP (1 << 14) /* Don't power up before scan */
#define MMC_CAP2_INIT_BKOPS (1 << 15) /* Need to set BKOPS_EN */
#define MMC_CAP2_PACKED_WR_CONTROL (1 << 16) /* Allow write packing control */
#define MMC_CAP2_CLK_SCALE (1 << 17) /* Allow dynamic clk scaling */
#define MMC_CAP2_STOP_REQUEST (1 << 18) /* Allow stop ongoing request */
/* Use runtime PM framework provided by MMC core */
#define MMC_CAP2_CORE_RUNTIME_PM (1 << 19)
#define MMC_CAP2_SANITIZE (1 << 20) /* Support Sanitize */
/* Allows Asynchronous SDIO irq while card is in 4-bit mode */
#define MMC_CAP2_ASYNC_SDIO_IRQ_4BIT_MODE (1 << 21)
#define MMC_CAP2_HS400_1_8V (1 << 22) /* can support */
#define MMC_CAP2_HS400_1_2V (1 << 23) /* can support */
#define MMC_CAP2_CORE_PM (1 << 24) /* use PM framework */
#define MMC_CAP2_HS400 (MMC_CAP2_HS400_1_8V | \
MMC_CAP2_HS400_1_2V)
#define MMC_CAP2_NONHOTPLUG (1 << 25) /*Don't support hotplug*/
2.struct mmc_host_ops
mmc core将host需要提供的一些操作方法封装成struct mmc_host_ops。mmc core主模块的很多接口都是基于这里面的操作方法来实现的，通过这些方法来操作host硬件达到对应的目的。所以struct mmc_host_ops也是host controller driver需要实现的核心部分。
struct mmc_host_ops {
/*
* 'enable' is called when the host is claimed and 'disable' is called
* when the host is released. 'enable' and 'disable' are deprecated.
*/
int (*enable)(struct mmc_host *host); // 使能host，当host被占用时（第一次调用mmc_claim_host）调用
int (*disable)(struct mmc_host *host); // 禁用host，当host被释放时（第一次调用mmc_release_host）调用
/*
* It is optional for the host to implement pre_req and post_req in
* order to support double buffering of requests (prepare one
* request while another request is active).
* pre_req() must always be followed by a post_req().
* To undo a call made to pre_req(), call post_req() with
* a nonzero err condition.
*/
// post_req和pre_req是为了实现异步请求处理而设置的
// 异步请求处理就是指，当另外一个异步请求还没有处理完成的时候，可以先准备另外一个异步请求而不必等待
// 具体参考《mmc core主模块》
void (*post_req)(struct mmc_host *host, struct mmc_request *req,
int err);
void (*pre_req)(struct mmc_host *host, struct mmc_request *req,
bool is_first_req);
void (*request)(struct mmc_host *host, struct mmc_request *req); // host处理mmc请求的方法，在mmc_start_request中会调用
void (*set_ios)(struct mmc_host *host, struct mmc_ios *ios); // 设置host的总线的io setting
int (*get_ro)(struct mmc_host *host); // 获取host上的card的读写属性
int (*get_cd)(struct mmc_host *host); // 检测host的卡槽中card的插入状态
/* optional callback for HC quirks */
void (*init_card)(struct mmc_host *host, struct mmc_card *card); // 初始化card的方法
int (*start_signal_voltage_switch)(struct mmc_host *host, struct mmc_ios *ios); // 切换信号电压的方法
/* Check if the card is pulling dat[0:3] low */
int (*card_busy)(struct mmc_host *host); // 用于检测card是否处于busy状态
/* The tuning command opcode value is different for SD and eMMC cards */
int (*execute_tuning)(struct mmc_host *host, u32 opcode); // 执行tuning操作，为card选择一个合适的采样点
int (*select_drive_strength)(unsigned int max_dtr, int host_drv, int card_drv); // 选择信号的驱动强度
void (*hw_reset)(struct mmc_host *host); // 硬件复位
void (*card_event)(struct mmc_host *host); //
unsigned long (*get_max_frequency)(struct mmc_host *host); // 获取host支持的最大频率的方法
unsigned long (*get_min_frequency)(struct mmc_host *host); // 获取host支持的最小频率的方法
int (*notify_load)(struct mmc_host *, enum mmc_load);
int (*stop_request)(struct mmc_host *host); // 停止请求处理的方法
unsigned int (*get_xfer_remain)(struct mmc_host *host);
};
2.core相关
1.struct mmc_card
struct mmc_card是mmc core由mmc设备抽象出来的card设备的结构体，用于代表一个mmc设备。
struct mmc_card {
struct mmc_host *host; /* the host this device belongs to */ // 该mmc_card所属host
struct device dev; /* the device */ // 对应的device
unsigned int rca; /* relative card address of device */ // 该card的RCA地址
unsigned int type; /* card type */ // card类型，后面说明
unsigned int state; /* (our) card state */ // card的当前状态，后面说明
unsigned int quirks; /* card quirks */ // 该card的一些特点
unsigned int erase_size; /* erase size in sectors */
unsigned int erase_shift; /* if erase unit is power 2 */
unsigned int pref_erase; /* in sectors */
u8 erased_byte; /* value of erased bytes */
u32 raw_cid[4]; /* raw card CID */ // 原始的cid寄存器的值
u32 raw_csd[4]; /* raw card CSD */ // 原始的csd寄存器的值
u32 raw_scr[2]; /* raw card SCR */ // 原始的scr寄存器的值
struct mmc_cid cid; /* card identification */ // 从cid寄存器的值解析出来的信息
struct mmc_csd csd; /* card specific */ // 从csd寄存器的值解析出来的信息
struct mmc_ext_csd ext_csd; /* mmc v4 extended card specific */ // 从ext_csd寄存器的值解析出来的信息
struct sd_scr scr; /* extra SD information */ // 外部sdcard的信息
struct sd_ssr ssr; /* yet more SD information */ // 更多关于sd card的信息
struct sd_switch_caps sw_caps; /* switch (CMD6) caps */ // sd的切换属性
unsigned int sd_bus_speed; /* Bus Speed Mode set for the card */
struct dentry *debugfs_root; // 对应debug目录的结构体
struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical partitions */ // 物理分区
unsigned int nr_parts; // 分区数量
unsigned int part_curr; // 当前分区
struct mmc_wr_pack_stats wr_pack_stats; /* packed commands stats*/
struct mmc_bkops_info bkops_info;
struct device_attribute rpm_attrib; // rpm属性
unsigned int idle_timeout;
struct notifier_block reboot_notify;
bool issue_long_pon;
u8 *cached_ext_csd;
};
mmc card类型（mmc_card->type）如下：
#define MMC_TYPE_MMC 0 /* MMC card */
#define MMC_TYPE_SD 1 /* SD card */
#define MMC_TYPE_SDIO 2 /* SDIO card */
#define MMC_TYPE_SD_COMBO 3 /* SD combo (IO+mem) card */
mmc card状态（mmc_card->state）如下：
#define MMC_STATE_PRESENT (1<<0) /* present in sysfs */
#define MMC_STATE_READONLY (1<<1) /* card is read-only */
#define MMC_STATE_HIGHSPEED (1<<2) /* card is in high speed mode */
#define MMC_STATE_BLOCKADDR (1<<3) /* card uses block-addressing */
#define MMC_STATE_HIGHSPEED_DDR (1<<4) /* card is in high speed mode */
#define MMC_STATE_ULTRAHIGHSPEED (1<<5) /* card is in ultra high speed mode */
#define MMC_CARD_SDXC (1<<6) /* card is SDXC */
#define MMC_CARD_REMOVED (1<<7) /* card has been removed */
#define MMC_STATE_HIGHSPEED_200 (1<<8) /* card is in HS200 mode */
#define MMC_STATE_HIGHSPEED_400 (1<<9) /* card is in HS400 mode */
#define MMC_STATE_DOING_BKOPS (1<<10) /* card is doing BKOPS */
#define MMC_STATE_NEED_BKOPS (1<<11) /* card needs to do BKOPS */
mmc card的一些特写标识（mmc_card->quirks）如下：
#define MMC_QUIRK_LENIENT_FN0 (1<<0) /* allow SDIO FN0 writes outside of the VS CCCR range */
#define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1) /* use func->cur_blksize */
/* for byte mode */
#define MMC_QUIRK_NONSTD_SDIO (1<<2) /* non-standard SDIO card attached */
/* (missing CIA registers) */
#define MMC_QUIRK_BROKEN_CLK_GATING (1<<3) /* clock gating the sdio bus will make card fail */
#define MMC_QUIRK_NONSTD_FUNC_IF (1<<4) /* SDIO card has nonstd function interfaces */
#define MMC_QUIRK_DISABLE_CD (1<<5) /* disconnect CD/DAT[3] resistor */
#define MMC_QUIRK_INAND_CMD38 (1<<6) /* iNAND devices have broken CMD38 */
#define MMC_QUIRK_BLK_NO_CMD23 (1<<7) /* Avoid CMD23 for regular multiblock */
#define MMC_QUIRK_BROKEN_BYTE_MODE_512 (1<<8) /* Avoid sending 512 bytes in */
#define MMC_QUIRK_LONG_READ_TIME (1<<9) /* Data read time > CSD says */
#define MMC_QUIRK_SEC_ERASE_TRIM_BROKEN (1<<10) /* Skip secure for erase/trim */
/* byte mode */
#define MMC_QUIRK_INAND_DATA_TIMEOUT (1<<11) /* For incorrect data timeout */
/* To avoid eMMC device getting broken permanently due to HPI feature */
#define MMC_QUIRK_BROKEN_HPI (1 << 12)
/* Skip data-timeout advertised by card */
#define MMC_QUIRK_BROKEN_DATA_TIMEOUT (1<<13)
#define MMC_QUIRK_CACHE_DISABLE (1 << 14) /* prevent cache enable */
3.host的总线相关
1.struct mmc_bus_ops
host的mmc总线的操作集，由host插入的card决定,不同类型的card对mmc总线的操作有所不同。
struct mmc_bus_ops {
int (*awake)(struct mmc_host *); // 唤醒mmc总线上的card
int (*sleep)(struct mmc_host *); // 休眠mmc总线上的card
void (*remove)(struct mmc_host *); // 从软件上注销mmc总线上的card
void (*detect)(struct mmc_host *); // 检测mmc总线上的card是否被移除
int (*suspend)(struct mmc_host *); // 对应mmc总线的suspend操作
int (*resume)(struct mmc_host *); // 对应mmc总线的resume操作
int (*power_save)(struct mmc_host *); // 存储电源状态
int (*power_restore)(struct mmc_host *); // 恢复电源状态
int (*alive)(struct mmc_host *); // 检测mmc总线上的card的激活状态
int (*change_bus_speed)(struct mmc_host *, unsigned long *); // 修改mmc总线的工作时钟
};
2.struct mmc_ios
struct mmc_ios 由mmc core定义的规范的结构，用来维护mmc总线相关的一些io setting。如下：
struct mmc_ios {
unsigned int clock; /* clock rate */ // 当前工作频率
unsigned int old_rate; /* saved clock rate */ // 上一次的工作频率
unsigned long clk_ts; /* time stamp of last updated clock */ // 上一次更新工作频率的时间戳
unsigned short vdd;/* vdd stores the bit number of the selected voltage range from below. */ // 支持的电压表
unsigned char bus_mode; /* command output mode */ // 总线输出模式，包括开漏模式和上拉模式
unsigned char chip_select; /* SPI chip select */ // spi片选
unsigned char power_mode; /* power supply mode */ // 电源状态模式
unsigned char bus_width; /* data bus width */ // 总线宽度
unsigned char timing; /* timing specification used */ // 时序类型
unsigned char signal_voltage; /* signalling voltage (1.8V or 3.3V) */ // 信号的工作电压
unsigned char drv_type; /* driver type (A, B, C, D) */ // 驱动类型
};
4.请求相关
1.struct mmc_command
mmc core用struct mmc_command来表示一个命令包，其中包括命令码、命令类型、response、response类型
struct mmc_command {
u32 opcode; // 命令的操作码，如MMC_GO_IDLE_STATE、MMC_SEND_OP_COND等等
u32 arg; // 命令的参数
u32 resp[4]; // response值
unsigned int flags; /* expected response type */ // 期待的response的类型，具体参考后面的命令类型和response类型
#define mmc_resp_type(cmd) ((cmd)->flags & (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC|MMC_RSP_BUSY|MMC_RSP_OPCODE))
#define mmc_cmd_type(cmd) ((cmd)->flags & MMC_CMD_MASK)
unsigned int retries; /* max number of retries */ // 失败时的重复尝试次数
unsigned int error; /* command error */ // 命令的错误码
unsigned int cmd_timeout_ms; /* in milliseconds */ // 命令执行的等待超时事件
struct mmc_data *data; /* data segment associated with cmd */ // 和该命令关联在一起的数据段
struct mmc_request *mrq; /* associated request */ // 该命令关联到哪个request
};
命令类型如下（和协议相关）：
#define MMC_CMD_MASK (3 << 5) /* non-SPI command type */
#define MMC_CMD_AC (0 << 5)
#define MMC_CMD_ADTC (1 << 5)
#define MMC_CMD_BC (2 << 5)
#define MMC_CMD_BCR (3 << 5)
response类型如下（和协议相关）：
#define MMC_RSP_PRESENT (1 << 0)
#define MMC_RSP_136 (1 << 1) /* 136 bit response */
#define MMC_RSP_CRC (1 << 2) /* expect valid crc */
#define MMC_RSP_BUSY (1 << 3) /* card may send busy */
#define MMC_RSP_OPCODE (1 << 4) /* response contains opcode */
#define MMC_RSP_NONE (0)
#define MMC_RSP_R1 (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
#define MMC_RSP_R1B (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE|MMC_RSP_BUSY)
#define MMC_RSP_R2 (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC)
#define MMC_RSP_R3 (MMC_RSP_PRESENT)
#define MMC_RSP_R4 (MMC_RSP_PRESENT)
#define MMC_RSP_R5 (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
#define MMC_RSP_R6 (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
#define MMC_RSP_R7 (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
2.struct mmc_data
mmc core用struct mmc_data来表示一个命令包
struct mmc_data {
unsigned int timeout_ns; /* data timeout (in ns, max 80ms) */ // 超时时间，以ns为单位
unsigned int timeout_clks; /* data timeout (in clocks) */ // 超时时间，以clock为单位
unsigned int blksz; /* data block size */ // 块大小
unsigned int blocks; /* number of blocks */ // 块数量
unsigned int error; /* data error */ // 传输的错误码
unsigned int flags; // 传输标识
unsigned int bytes_xfered;
struct mmc_command *stop; /* stop command */ // 结束传输的命令
struct mmc_request *mrq; /* associated request */ // 该命令关联到哪个request
unsigned int sg_len; /* size of scatter list */
struct scatterlist *sg; /* I/O scatter list */
s32 host_cookie; /* host private data */
bool fault_injected; /* fault injected */
};
3.struct mmc_request
struct mmc_request是mmc core向host controller发起命令请求的处理单位,其包含了要传输的命令和数据。
struct mmc_request {
struct mmc_command *sbc; /* SET_BLOCK_COUNT for multiblock */ // 设置块数量的命令，怎么用的后续再补充
struct mmc_command *cmd; // 要传输的命令
struct mmc_data *data; // 要传输的数据
struct mmc_command *stop; // 结束命令，怎么用的后续再补充
struct completion completion; // 完成量
void (*done)(struct mmc_request *);/* completion function */ // 传输结束后的回调函数
struct mmc_host *host; // 所属host
};
4.struct mmc_async_req
异步请求的结构体。封装了struct mmc_request请求结构体。
struct mmc_async_req {
/* active mmc request */
struct mmc_request *mrq; // mmc请求
unsigned int cmd_flags; /* copied from struct request */ // 命令标识
/*
* Check error status of completed mmc request.
* Returns 0 if success otherwise non zero.
*/
int (*err_check) (struct mmc_card *, struct mmc_async_req *);
/* Reinserts request back to the block layer */
void (*reinsert_req) (struct mmc_async_req *);
/* update what part of request is not done (packed_fail_idx) */
int (*update_interrupted_req) (struct mmc_card *,
struct mmc_async_req *);
};
5.bus模块
对应代码drivers/mmc/core/bus.c。
抽象出虚拟mmc bus，实现mmc bus的操作。
1.API总览
1.mmc bus相关
mmc_register_bus & mmc_unregister_bus
用于注册和卸载mmc bus（虚拟mmc总线）到设备驱动模型中。
int mmc_register_bus(void)
{
return bus_register(&mmc_bus_type); // 以mmc_bus_type为bus_type注册一条虚拟bus
}
相关节点：/sys/bus/mmc
2.mmc driver相关
mmc_register_driver & mmc_unregister_driver,用于注册和卸载struct mmc_driver *drv到mmc_bus上。mmc_driver就是mmc core抽象出来的card设备driver。
int mmc_register_driver(struct mmc_driver *drv)
{
drv->drv.bus = &mmc_bus_type; // 通过设置mmc_driver——》device_driver——》bus_type来设置mmc_driver所属bus为mmc_bus
return driver_register(&drv->drv); // 这样就将mmc_driver挂在了mmc_bus上了。
}
相关节点：/sys/bus/mmc/drivers.
3.mmc card相关
mmc_alloc_card & mmc_release_card,用于分配或者释放一个struct mmc_card结构体，创建其与mmc host以及mmc bus之间的关联。
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); // 分配一个mmc_card
if (!card)
return ERR_PTR(-ENOMEM);
card->host = host; // 关联mmc_card与mmc_host
device_initialize(&card->dev);
card->dev.parent = mmc_classdev(host);
// 设置card的device的parent device为mmc_host的classdev，
// 注册到设备驱动模型中之后，会在/sys/class/mmc_host/mmc0目录下生成相应card的节点，如mmc0:0001
card->dev.bus = &mmc_bus_type;
// 设置card的bus为mmc_bus_type，这样，mmc_card注册到设备驱动模型中之后就会挂在mmc_bus下。
// 会在/sys/bus/mmc/devices/目录下生成相应card的节点，如mmc0:0001
card->dev.release = mmc_release_card;
card->dev.type = type; // 设置device type
spin_lock_init(&card->bkops_info.bkops_stats.lock); // 初始化spin_lock
spin_lock_init(&card->wr_pack_stats.lock); // 初始化spin_lock
return card;
}
参数说明：host——》要分配的card所属的mmc_host，type——》对应的device type。
mmc_add_card & mmc_remove_card,用于注册或者卸载struct mmc_card到mmc_bus上。
/*
* Register a new MMC card with the driver model.
*/
int mmc_add_card(struct mmc_card *card)
{
int ret;
/* 以下用于打印card的注册信息 */
const char *type;
const char *uhs_bus_speed_mode = "";
// 设置速度模式的字符串，为了后面打印出card信息
//......
if (mmc_host_is_spi(card->host)) {
pr_info("%s: new %s%s%s card on SPI\n",
mmc_hostname(card->host),
mmc_card_highspeed(card) ? "high speed " : "",
mmc_card_ddr_mode(card) ? "DDR " : "",
type);
} else {
pr_info("%s: new %s%s%s%s%s%s card at address %04x\n",
mmc_hostname(card->host),
mmc_card_uhs(card) ? "ultra high speed " :
(mmc_card_highspeed(card) ? "high speed " : ""),
(mmc_card_hs400(card) ? "HS400 " : ""),
(mmc_card_hs200(card) ? "HS200 " : ""),
mmc_card_ddr_mode(card) ? "DDR " : "",
uhs_bus_speed_mode, type, card->rca);
}
// 在这里会打印出card信息的字符串
// eg:mmc0: new HS200 MMC card at address 0001
/* 设置card的debug节点 */
#ifdef CONFIG_DEBUG_FS
mmc_add_card_debugfs(card);
// 创建card对应的debug节点，对应路径例如：/sys/kernel/debug/mmc0/mmc0:0001
#endif
mmc_init_context_info(card->host); // 初始化同步的文本信息
/* 以下使能card device的pm runtime的功能 */
ret = pm_runtime_set_active(&card->dev);
if (ret)
pr_err("%s: %s: failed setting runtime active: ret: %d\n",
mmc_hostname(card->host), __func__, ret);
else if (!mmc_card_sdio(card) && mmc_use_core_runtime_pm(card->host))
pm_runtime_enable(&card->dev);
/* 添加到设备驱动模型中 */
ret = device_add(&card->dev);
// 会创建/sys/bus/mmc/devices/mmc0:0001节点和/sys/class/mmc_host/mmc0/mmc0:0001节点
/* 使能异步device suspend，初始化runtime_pm_timeout属性 */
device_enable_async_suspend(&card->dev);
if (mmc_use_core_runtime_pm(card->host) && !mmc_card_sdio(card)) {
card->rpm_attrib.show = show_rpm_delay;
card->rpm_attrib.store = store_rpm_delay;
sysfs_attr_init(&card->rpm_attrib.attr);
card->rpm_attrib.attr.name = "runtime_pm_timeout";
card->rpm_attrib.attr.mode = S_IRUGO | S_IWUSR;
ret = device_create_file(&card->dev, &card->rpm_attrib);
if (ret)
pr_err("%s: %s: creating runtime pm sysfs entry: failed: %d\n",
mmc_hostname(card->host), __func__, ret);
/* Default timeout is 10 seconds */
card->idle_timeout = RUNTIME_SUSPEND_DELAY_MS;
}
/* 设置mmc card的state标识 */
mmc_card_set_present(card);
// 设置card的MMC_STATE_PRESENT状态
// #define MMC_STATE_PRESENT (1<<0) /* present in sysfs */
// 表示card已经合入到sysfs中了
return 0;
}
相关节点：
/sys/bus/mmc/devices/mmc0:0001
/sys/class/mmc_host/mmc0/mmc0:0001
/sys/kernel/debug/mmc0/mmc0:0001
2.数据结构
mmc_bus_type
mmc_bus_type代表了mmc虚拟总线。其内容如下：
static struct bus_type mmc_bus_type = {
.name = "mmc", // 相应会在/sys/bus下生成mmc目录
.dev_attrs = mmc_dev_attrs, // bus下的device下继承的属性，可以看到/sys/bus/mmc/devices/mmc0:0001/type属性就是这里来的
.match = mmc_bus_match, // 用于mmc bus上device和driver的匹配
.uevent = mmc_bus_uevent,
.probe = mmc_bus_probe, // 当match成功的时候，执行的probe操作
.remove = mmc_bus_remove,
.shutdown = mmc_bus_shutdown,
.pm = &mmc_bus_pm_ops, // 挂在mmc bus上的device的电源管理操作集合
};
/***************************match方法***************************/
static int mmc_bus_match(struct device *dev, struct device_driver *drv)
{
return 1; // 无条件返回1，说明挂载mmc bus上的device（mmc_card）和driver（mmc_driver）是无条件匹配的。
}
/****************************probe方法***************************/
static int mmc_bus_probe(struct device *dev)
{
struct mmc_driver *drv = to_mmc_driver(dev->driver);
struct mmc_card *card = mmc_dev_to_card(dev);
return drv->probe(card); // 直接调用mmc_driver中的probe操作，对于block.c来说就是mmc_blk_probe
}
通过上述mmc_bus的match方法实现，我们可以知道挂载mmc bus上的mmc_card和mmc_driver是无条件匹配的。
6.host模块
对应代码drivers/mmc/core/host.c，drivers/mmc/core/host.h。
为底层host controller driver实现mmc host的申请以及注册的API等等，以及host相关属性的实现。
1.API总览
1.mmc host分配、注册相关
mmc_alloc_host & mmc_free_host,底层host controller驱动调用，用来分配或者释放一个struct mmc_host结构体，将其于mmc_host_class关联，并且做部分初始化操作。具体为:分配内存空间,初始化其class device（对应/sys/class/mmc0节点）,clock gate、锁、工作队列、wakelock、detect工作的初始化,初始化detect成员（也就是检测工作）为mmc_rescan.
参数说明：extra——》mmc_host的私有数据的长度，会和mmc_host结构体一起分配， dev——》底层host controller的device结构体，用于作为mmc_host的device的父设备
/**
* mmc_alloc_host - initialise the per-host structure.
* @extra: sizeof private data structure
* @dev: pointer to host device model structure
*
* Initialise the per-host structure.
*/
struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
{
// 参数说明：extra——》mmc_host的私有数据的长度，会和mmc_host结构体一起分配，
// dev——》底层host controller的device结构体，用于作为mmc_host的device的父设备
int err;
struct mmc_host *host;
/* 分配内存空间，其中多分配了extra字节作为私有数据 */
host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
if (!host)
return NULL;
/* scanning will be enabled when we're ready */
/* 因为只是分配了一个mmc_host，host还没有准备好，所以这里禁用rescan，也就是设置mmc_host->rescan_disable
host->rescan_disable = 1; // 在在mmc_start_host中会去使能
/* 为该mmc_host分配一个唯一的id号，设置到host->index */
idr_preload(GFP_KERNEL);
spin_lock(&mmc_host_lock);
err = idr_alloc(&mmc_host_idr, host, 0, 0, GFP_NOWAIT);
if (err >= 0)
host->index = err;
spin_unlock(&mmc_host_lock);
idr_preload_end();
if (err < 0)
goto free;
/* 设置mmc_host name */
dev_set_name(&host->class_dev, "mmc%d", host->index); // 以mmc_host的id号构成mmc_host的name，例如mmc0、mmc1
/* 关联mmc_host class_dev并进行初始化 */
/* class_dev就代表了mmc_host 的device结构体，是其在设备驱动模型中的体现 */
host->parent = dev; // 将mmc_host的parent设置成对应host controller节点转化出来的device
host->class_dev.parent = dev;
// 将mmc_host的device(class_dev)的parent设置成对应host controller节点转化出来的device
// 注册到sysfs之后，会相应生成/sys/bus/platform/devices/7824900.sdhci/mmc_host/mmc0
// 其中7824900.sdhci表示qcom的host controller节点转化出来的device
host->class_dev.class = &mmc_host_class;
// 将mmc_device(class_dev)的类设置为mmc_host_class
// 注册到sysfs之后，会相应生成/sys/class/mmc_host/mmc0
device_initialize(&host->class_dev); // 初始化mmc_host->class_dev
/* clock gate、锁、工作队列、wakelock、detect工作的初始化 */
mmc_host_clk_init(host);
mutex_init(&host->slot.lock);
host->slot.cd_irq = -EINVAL;
spin_lock_init(&host->lock);
init_waitqueue_head(&host->wq);
host->wlock_name = kasprintf(GFP_KERNEL, "%s_detect", mmc_hostname(host)); // 设置detect_wake_lock的名称为mmc0_detect，在card检测的时候会使用
wake_lock_init(&host->detect_wake_lock, WAKE_LOCK_SUSPEND, host->wlock_name); // // 初始化detect_wake_lock
// 可以通过/sys/kernel/debug/wakeup_sources，相应生成了mmc0_detect和mmc1_detect两个wakelock
INIT_DELAYED_WORK(&host->detect, mmc_rescan);
// ！！！！这个很重要！！！！初始化detect工作为mmc_rescan，后续调度host->detect来检测是否有card插入时，就会调用到mmc_rescan。
#ifdef CONFIG_PM
host->pm_notify.notifier_call = mmc_pm_notify;
#endif
/* 一些size的初始化 */
host->max_segs = 1; // 初始化最大支持段（由host自己根据硬件进行修改），可以通过/sys/block/mmcblk0/queue/max_segments进行修改
host->max_seg_size = PAGE_CACHE_SIZE; // 初始化段大小，（由host自己根据硬件进行修改）
host->max_req_size = PAGE_CACHE_SIZE; // 一次MMC请求的最大字节数
host->max_blk_size = 512; // 一个块的最大字节数
host->max_blk_count = PAGE_CACHE_SIZE / 512; // 一次MMC请求的最大块数量
return host;
free:
kfree(host);
return NULL;
}
这边重点强调一个mmc_host->detect=mmc_rescan，当mmc_host的detect work被执行时，就会调用到mmc_rescan中。
相关节点，以mmc_host0为例：
/sys/bus/platform/devices/7824900.sdhci/mmc_host/mmc0
/sys/class/mmc_host/mmc0
mmc_add_host & mmc_remove_host,底层host controller驱动调用，注册或者卸载mmc_host到设备驱动中，添加到sys类下面，并设置相应的debug目录。然后启动mmc_host。主要工作：使能pm runtime功能,将mmc_host的class_dev添加到设备驱动模型中，在sysfs中生成相应的节点,初始化mmc_host相关的debug目录,设置mmc_host的class_dev的属性,调用mmc_start_host启动host（进入mmc core主模块的部分）.
/**
* mmc_add_host - initialise host hardware
* @host: mmc host
*
* Register the host with the driver model. The host must be
* prepared to start servicing requests before this function
* completes.
*/
int mmc_add_host(struct mmc_host *host)
{
int err;
/* 使能mmc host的class_dev的pm runtime功能 */
err = pm_runtime_set_active(&host->class_dev);
if (err)
pr_err("%s: %s: failed setting runtime active: err: %d\n",
mmc_hostname(host), __func__, err);
else if (mmc_use_core_runtime_pm(host))
pm_runtime_enable(&host->class_dev);
/* 通过device_add将mmc_host->class_dev添加到设备驱动模型中，在sys下生成相应节点 */
err = device_add(&host->class_dev);
// 通过mmc_alloc_host中关于mmc_host的class_dev的关联，可以生成如下两个节点
// /sys/bus/platform/devices/7824900.sdhci/mmc_host/mmc0
// /sys/class/mmc_host/mmc0
/* 使能mmc host的class_dev的异步suspend的功能 */
device_enable_async_suspend(&host->class_dev);
led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
/* 设置mmc_host的debug节点 */
#ifdef CONFIG_DEBUG_FS
mmc_add_host_debugfs(host);
#endif
// 对应sys节点为/sys/kernel/debug/mmc0
/* 以下设置mmc host的class_dev的属性 */
mmc_host_clk_sysfs_init(host);
// 对应/sys/class/mmc_host/mmc0/clkgate_delay属性
host->clk_scaling.up_threshold = 35;
host->clk_scaling.down_threshold = 5;
host->clk_scaling.polling_delay_ms = 100;
err = sysfs_create_group(&host->class_dev.kobj, &clk_scaling_attr_grp);
// 对应/sys/class/mmc_host/mmc0/clk_scaling目录下的四个属性，clk_scaling_attr_grp前面已经说明过了
err = sysfs_create_group(&host->class_dev.kobj, &dev_attr_grp);
// 对应/sys/class/mmc_host/mmc0/perf属性，dev_attr_grp前面已经说明过了
/* 调用mmc_start_host，也就调用到了mmc core主模块的启动host部分，在mmc core主模块的时候说明 */
mmc_start_host(host);
if (!(host->pm_flags & MMC_PM_IGNORE_PM_NOTIFY))
register_pm_notifier(&host->pm_notify);
return 0;
}
注意，最后调用了mmc_start_host来启动host。关于mmc_start_host会在mmc core主模块的部分里面说明。也就是说，关于host的初始化工作，需要在调用mmc_add_host之前就要完成了。
相关节点：
/sys/bus/platform/devices/7824900.sdhci/mmc_host/mmc0
/sys/class/mmc_host/mmc0
/sys/kernel/debug/mmc0
2.mmc host class相关
mmc_register_host_class & mmc_unregister_host_class,注册或者卸载mmc_host类。
int mmc_register_host_class(void)
{
return class_register(&mmc_host_class); // 以mmc_host_class为class创建一个class，关于mmc_host_class在上述数据结构已经说明过了
}
相关节点：/sys/class/mmc_host
3.mmc host属性解析相关
mmc_of_parse,底层host controller驱动调用，解析mmc_host的dtsi节点的部分属性。mmc_of_parse提供了通用的、解析host controller dtsi节点的属性的方法，这就要依赖于dtsi的属性是否符合规范。但是host controller driver并不一定要使用这个，也可以使用自己一套解析的方法。
void mmc_of_parse(struct mmc_host *host)
{
struct device_node *np;
u32 bus_width;
bool explicit_inv_wp, gpio_inv_wp = false;
enum of_gpio_flags flags;
int len, ret, gpio;
if (!host->parent || !host->parent->of_node)
return;
/* 获取到mmc_host对应的host controller的dts节点 */
np = host->parent->of_node;
// host->parent指向了mmc_host的对应host controller的device，获取其of_node就获取到了对应的dtsi节点
/* 以下就是解析属性，并设置到mmc_host的属性标识caps和caps2 中 */
/* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
if (of_property_read_u32(np, "bus-width", &bus_width) < 0) {
dev_dbg(host->parent,
"\"bus-width\" property is missing, assuming 1 bit.\n");
bus_width = 1;
}
switch (bus_width) {
case 8:
host->caps |= MMC_CAP_8_BIT_DATA; // "bus-width"——》MMC_CAP_8_BIT_DATA
/* Hosts capable of 8-bit transfers can also do 4 bits */
case 4:
host->caps |= MMC_CAP_4_BIT_DATA; // "bus-width"——》MMC_CAP_4_BIT_DATA
break;
case 1:
break;
default:
dev_err(host->parent,
"Invalid \"bus-width\" value %ud!\n", bus_width);
}
/* f_max is obtained from the optional "max-frequency" property */
of_property_read_u32(np, "max-frequency", &host->f_max);
//................后面的代码都类似，直接略过了
}
4.mmc host时钟相关
mmc_host_clk_hold & mmc_host_clk_release,mmc core主模块调用，用于获取host时钟和释放host时钟.
2.数据结构
1.mmc_host_class
mmc_host_class代表了mmc_host这个类。其内容如下：
static struct class mmc_host_class = {
.name = "mmc_host", // 添加到sys文件系统之后，会生成/sys/class/mmc_host这个目录
.dev_release = mmc_host_classdev_release, // 从mmc_host这个class下release掉某个设备之后要做的对应操作
.pm = &mmc_host_pm_ops, // 该class下的host的pm电源管理操作
};
static const struct dev_pm_ops mmc_host_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(mmc_host_suspend, mmc_host_resume)
SET_RUNTIME_PM_OPS(mmc_host_runtime_suspend, mmc_host_runtime_resume,
pm_generic_runtime_idle)
};
2.clk_scaling_attr_grp
一些和时钟缩放（clk_scaling）相关的属性组
static struct attribute *clk_scaling_attrs[] = {
&dev_attr_enable.attr,
&dev_attr_up_threshold.attr,
&dev_attr_down_threshold.attr,
&dev_attr_polling_interval.attr,
NULL,
};
static struct attribute_group clk_scaling_attr_grp = {
.name = "clk_scaling",
.attrs = clk_scaling_attrs,
};
对应/sys/class/mmc_host/mmc0/clk_scaling目录下的属性
3.dev_attr_grp
和设备相关的属性组，只定义了perf属性
static struct attribute *dev_attrs[] = {
#ifdef CONFIG_MMC_PERF_PROFILING
&dev_attr_perf.attr,
#endif
NULL,
};
static struct attribute_group dev_attr_grp = {
.attrs = dev_attrs,
};
对应/sys/class/mmc_host/mmc0/perf属性
7.card模块
1.API总览
1.mmc type card匹配相关
mmc_attach_mmc提供给mmc core主模块使用，用于绑定card到host bus上（也就是card和host的绑定）。通过mmc_host获取mmc type card信息，初始化mmc_card，并进行部分驱动，最后将其注册到mmc_bus上。主要工作：设置总线模式;选择一个card和host都支持的最低工作电压,对于不同type的card，相应mmc总线上的操作协议也可能有所不同,所以需要设置相应的总线操作集合（mmc_host->bus_ops;初始化card使其进入工作状态（mmc_init_card）为card构造对应的mmc_card并且注册到mmc_bus中（mmc_add_card，具体参考bus模块说明）.
int mmc_attach_mmc(struct mmc_host *host)
{
int err;
u32 ocr;
BUG_ON(!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);
/* 获取card的ocr寄存器 */
err = mmc_send_op_cond(host, 0, &ocr);
// 发送CMD1命令（MMC_SEND_OP_COND），并且参数为0
// 这里获取OCR（Operation condition register）32位的OCR包含卡设备支持的工作电压表，存储到ocr变量中
// 如果Host的IO电压可调整，那调整前需要读取OCR。为了不使卡误进入Inactive State，可以给MMC卡发送不带参数的CMD1，这样可以仅获取OCR寄存器，而不会改变卡的状态。
/* 对于不同type的card，相应mmc总线上的操作协议也可能有所不同 */
/* 所以这里设置mmc_host的总线操作集合，为mmc_ops_unsafe或者mmc_ops，上述已经说明 */
mmc_attach_bus_ops(host);
// 设置host->bus_ops，也就是会为host的bus选择一个操作集，对于non-removable的host来说，这里对应应该为mmc_ops_unsafe
/* 为card选择一个HOST和card都支持的最低电压 */
if (host->ocr_avail_mmc)
host->ocr_avail = host->ocr_avail_mmc; // 选择mmc的可用ocr值作为host的ocr_avail值
if (ocr & 0x7F) {
ocr &= ~0x7F; // 在标准MMC协议中，OCR寄存器的bit6-0位是属于保留位，并不会使用，所以这里对应将其清零
}
host->ocr = mmc_select_voltage(host, ocr); // 通过OCR寄存器选择一个HOST和card都支持的最低电压
/* 调用mmc_init_card初始化该mmc type card，这里是核心函数，后续会继续说明 */
err = mmc_init_card(host, host->ocr, NULL); // 初始化该mmc type card，并为其分配和初始化一个对应的mmc_card
if (err)
goto err;
/* 将分配到的mmc_card注册到mmc_bus中 */
mmc_release_host(host); // 先释放掉host，可能是在mmc_add_card中会获取这个host
err = mmc_add_card(host->card);
// 调用到mmc_add_card，将card注册到设备驱动模型中。
// 这时候该mmc_card就挂在了mmc_bus上，会和mmc_bus上的block这类mmc driver匹配起来。具体再学习mmc card driver的时候再说明。
mmc_claim_host(host); // 再次申请host
if (err)
goto remove_card;
/* clock scaling相关的东西，这里暂时先不关心 */
mmc_init_clk_scaling(host);
register_reboot_notifier(&host->card->reboot_notify);
return 0;
remove_card:
mmc_release_host(host);
mmc_remove_card(host->card);
mmc_claim_host(host);
host->card = NULL;
err:
mmc_detach_bus(host);
pr_err("%s: error %d whilst initialising MMC card\n",
mmc_hostname(host), err);
return err;
}
重点说明
（1）在attach过程中，有一个很重要的函数mmc_init_card;
（2）调用了mmc_add_card之后mmc_card就挂在了mmc_bus上，会和mmc_bus上的block（mmc_driver）匹配起来。相应block（mmc_driver）就会进行probe，驱动card，实现card的实际功能（也就是存储设备的功能）。会对接到块设备子系统中。
2.mmc_init_card
mmc_attach_mmc中的一个核心函数就是mmc_init_card，用于对mmc type card进行实质性的初始化，并为其分配和初始化一个对应的mmc_card。这部分和协议相关，需要先学习一下mmc协议。主要工作:根据协议初始化mmc type card，使其进入相应状态（standby state）;为mmc type card构造对应mmc_card并进行设置;从card的csd寄存器以及ext_csd寄存器获取card信息并设置到mmc_card的相应成员中;根据host属性以及一些需求修改ext_csd寄存器的值;设置mmc总线时钟频率以及位宽.
static int mmc_init_card(struct mmc_host *host, u32 ocr,
struct mmc_card *oldcard)
{
// struct mmc_host *host：该mmc card使用的host
// ocr：表示了host要使用的电压，在mmc_attach_mmc中，已经得到了一个HOST和card都支持的最低电压 struct mmc_card *card;
int err = 0;
u32 cid[4];
u32 rocr;
u8 *ext_csd = NULL;
BUG_ON(!host);
WARN_ON(!host->claimed);
/* Set correct bus mode for MMC before attempting init */
if (!mmc_host_is_spi(host))
mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); // 设置总线模式为开漏模式
/* 根据mmc协议从mmc总线上选中一张card（协议的初始化流程） */
mmc_go_idle(host);
// 发送CMD0指令，GO_IDLE_STATE
// 使mmc card进入idle state。
// 虽然进入到了Idle State，但是上电复位过程并不一定完成了，这主要靠读取OCR的busy位来判断，而流程归结为下一步。
/* The extra bit indicates that we support high capacity */
err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
// 发送CMD1指令，SEND_OP_COND
// 这里会设置card的工作电压寄存器OCR，并且通过busy位（bit31）来判断card的上电复位过程是否完成，如果没有完成的话需要重复发送。
// 完成之后，mmc card进入ready state。
/*
* Fetch CID from card.
*/
if (mmc_host_is_spi(host))
err = mmc_send_cid(host, cid);
else
err = mmc_all_send_cid(host, cid);
// 这里会发送CMD2指令，ALL_SEND_CID
// 广播指令，使card回复对应的CID寄存器的值。在这里就相应获得了CID寄存器的值了，存储在cid中。
// 完成之后，MMC card会进入Identification State。
if (oldcard) {
。。。
} else {
/* 调用mmc_alloc_card分配一个mmc_card并进行部分设置 */
card = mmc_alloc_card(host, &mmc_type);
// 为card配分一个struct mmc_card结构体并进行初始化，在mmc_type中为mmc定义了大量的属性。
// 具体参考“《mmc core——bus模块说明》——》mmc_alloc_card”
card->type = MMC_TYPE_MMC; // 设置card的type为MMC_TYPE_MMC
card->rca = 1; // 设置card的RCA地址为1
memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); // 将读到的CID存储到card->raw_cid，也就是原始CID值中
card->reboot_notify.notifier_call = mmc_reboot_notify;
host->card = card; // 将mmc_card和mmc_host 进行关联
}
/* 设置card RCA地址 */
if (!mmc_host_is_spi(host)) {
err = mmc_set_relative_addr(card);
// 发送CMD3指令，SET_RELATIVE_ADDR
// 设置该mmc card的关联地址为card->rca，也就是0x0001
// 完成之后，该MMC card进入standby模式。
mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
// 设置总线模式为MMC_BUSMODE_PUSHPULL
}
/* 从card的csd寄存器以及ext_csd寄存器获取信息并设置到mmc_card的相应成员中 */
if (!oldcard) {
/*
* Fetch CSD from card.
*/
err = mmc_send_csd(card, card->raw_csd);
// 发送CMD9指令，MMC_SEND_CSD
// 要求mmc card发送csd寄存器，存储到card->raw_csd中，也就是原始的csd寄存器的值。
// 此时mmc card还是处于standby state
err = mmc_decode_csd(card);
// 解析raw_csd，获取到各个bit的值并设置到card->csd中的相应成员上
err = mmc_decode_cid(card);
// 解析raw_cid，获取到各个bit的值并设置到card->cid中的相应成员上
}
/*
* Select card, as all following commands rely on that.
*/
if (!mmc_host_is_spi(host)) {
err = mmc_select_card(card);
// 发送CMD7指令，SELECT/DESELECT CARD
// 选择或者断开指定的card
// 这时卡进入transfer state。后续可以通过各种指令进入到receive-data state或者sending-data state依次来进行数据的传输
}
if (!oldcard) {
err = mmc_get_ext_csd(card, &ext_csd);
// 发送CMD8指令，SEND_EXT_CSD
// 这里要求处于transfer state的card发送ext_csd寄存器，这里获取之后存放在ext_csd寄存器中
// 这里会使card进入sending-data state，完成之后又退出到transfer state。
card->cached_ext_csd = ext_csd; // 将ext_csd原始值存储到card->cached_ext_csd，表示用来保存ext_csd的一块缓存，可能还没有和card的ext_csd同步
err = mmc_read_ext_csd(card, ext_csd); // 解析ext_csd的值，获取到各个bit的值并设置到card->ext_csd中的相应成员上
if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
mmc_card_set_blockaddr(card);
/* Erase size depends on CSD and Extended CSD */
mmc_set_erase_size(card); // 设置card的erase_size，扇区里面的擦除字节数，读出来是512K
if (card->ext_csd.sectors && (rocr & MMC_CARD_SECTOR_ADDR))
mmc_card_set_blockaddr(card);
}
/* 根据host属性以及一些需求修改ext_csd寄存器的值 */
/*
* If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
* bit. This bit will be lost every time after a reset or power off.
*/
if (card->ext_csd.enhanced_area_en ||
(card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
EXT_CSD_ERASE_GROUP_DEF, 1,
card->ext_csd.generic_cmd6_time);
// 发送CMD6命令，MMC_SWITCH
// 用于设置ext_csd寄存器的某些bit
// 当enhanced_area_en 被设置的时候，host需要去设置ext_csd寄存器中的EXT_CSD_ERASE_GROUP_DEF位为1
}
if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
card->ext_csd.part_config,
card->ext_csd.part_time);
// 发送CMD6命令，MMC_SWITCH
// 用于设置ext_csd寄存器的某些bit
// 设置ext_csd寄存器中的EXT_CSD_CMD_SET_NORMAL位为EXT_CSD_PART_CONFIG
card->part_curr = card->ext_csd.part_config &
EXT_CSD_PART_CONFIG_ACC_MASK;
}
if ((host->caps2 & MMC_CAP2_POWEROFF_NOTIFY) &&
(card->ext_csd.rev >= 6)) {
err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
EXT_CSD_POWER_OFF_NOTIFICATION,
EXT_CSD_POWER_ON,
card->ext_csd.generic_cmd6_time);
// 发送CMD6命令，MMC_SWITCH
// 用于设置ext_csd寄存器的某些bit
// 设置ext_csd寄存器中的EXT_CSD_POWER_OFF_NOTIFICATION位为EXT_CSD_POWER_ON
}
/* 设置mmc总线时钟频率以及位宽 */
err = mmc_select_bus_speed(card, ext_csd); // 激活host和card都支持的最大总线速度
//.........这里过滤掉一些设置ext_csd的代码
if (!oldcard) {
if (card->ext_csd.bkops_en) {
INIT_DELAYED_WORK(&card->bkops_info.dw,
mmc_start_idle_time_bkops);
// 如果emmc支持bkops的话，就初始化card->bkops_info.dw工作为mmc_start_idle_time_bkops
}
}
return 0;
}
3.mmc_ops_unsafe相关函数
static const struct mmc_bus_ops mmc_ops_unsafe = {
.awake = mmc_awake, // 使mmc总线上的mmc type card退出sleep state
.sleep = mmc_sleep, // 使mmc总线的mmc type card进入sleep state
.remove = mmc_remove, // 释放mmc type card
.detect = mmc_detect, // 检测mmc总线的mmc type card是否拔出
.suspend = mmc_suspend, // suspend掉mmc总线上的mmc type card，注意不仅仅会使card进入sleep state，还会对clock以及mmc cache进行操作
.resume = mmc_resume, // resume上mmc总线上的mmc type card
.power_restore = mmc_power_restore, // 恢复mmc总线上的mmc type card的电源状态
.alive = mmc_alive, // 检测mmc总线上的mmc type card状态是否正常
.change_bus_speed = mmc_change_bus_speed, // 修改mmc总线时钟频率
};
/**********************使mmc总线上的mmc type card退出sleep state************************/
static int mmc_awake(struct mmc_host *host)
{
//...
if (card && card->ext_csd.rev >= 3) { // 判断版本是否大于3
err = mmc_card_sleepawake(host, 0);
// 发送CMD5指令，MMC_SLEEP_AWAKE，参数为0，表示退出sleep state.（如果参数为1就是进入sleep state）
// 完成之后，该MMC card从sleep state进入standby模式。
}
//...
}
/**********************检测mmc总线的mmc type card是否拔出************************/
static void mmc_detect(struct mmc_host *host)
{
int err;
mmc_rpm_hold(host, &host->card->dev);
mmc_claim_host(host);
/* 检测card是否被拔出 */
err = _mmc_detect_card_removed(host);
mmc_release_host(host);
/*
* if detect fails, the device would be removed anyway;
* the rpm framework would mark the device state suspended.
*/
/* card并没有被拔出，说明出现异常了，标记card的rpm状态为suspend */
if (!err)
mmc_rpm_release(host, &host->card->dev);
/* card确实被拔出，正常释放card */
if (err) {
mmc_remove(host);
mmc_claim_host(host);
mmc_detach_bus(host);
mmc_power_off(host);
mmc_release_host(host);
}
}
/********************** 修改mmc总线时钟频率************************/
/**
* mmc_change_bus_speed() - Change MMC card bus frequency at runtime
* @host: pointer to mmc host structure
* @freq: pointer to desired frequency to be set
*
* Change the MMC card bus frequency at runtime after the card is
* initialized. Callers are expected to make sure of the card's
* state (DATA/RCV/TRANSFER) beforing changing the frequency at runtime.
*/
static int mmc_change_bus_speed(struct mmc_host *host, unsigned long *freq)
{
int err = 0;
struct mmc_card *card;
mmc_claim_host(host);
/*
* Assign card pointer after claiming host to avoid race
* conditions that may arise during removal of the card.
*/
card = host->card;
if (!card || !freq) {
err = -EINVAL;
goto out;
}
/* 确定出一个可用频率 */
if (mmc_card_highspeed(card) || mmc_card_hs200(card)
|| mmc_card_ddr_mode(card)
|| mmc_card_hs400(card)) {
if (*freq > card->ext_csd.hs_max_dtr)
*freq = card->ext_csd.hs_max_dtr;
} else if (*freq > card->csd.max_dtr) {
*freq = card->csd.max_dtr;
}
if (*freq < host->f_min)
*freq = host->f_min;
/* 根据实际要设置的频率值来设置时钟 */
if (mmc_card_hs400(card)) {
err = mmc_set_clock_bus_speed(card, *freq);
if (err)
goto out;
} else {
mmc_set_clock(host, (unsigned int) (*freq));
}
/* 对于hs200来说，修改完频率之后需要执行execute_tuning来选择一个合适的采样点 */
if (mmc_card_hs200(card) && card->host->ops->execute_tuning) {
/*
* We try to probe host driver for tuning for any
* frequency, it is host driver responsibility to
* perform actual tuning only when required.
*/
mmc_host_clk_hold(card->host);
err = card->host->ops->execute_tuning(card->host,
MMC_SEND_TUNING_BLOCK_HS200);
mmc_host_clk_release(card->host);
if (err) {
pr_warn("%s: %s: tuning execution failed %d. Restoring to previous clock %lu\n",
mmc_hostname(card->host), __func__, err,
host->clk_scaling.curr_freq);
mmc_set_clock(host, host->clk_scaling.curr_freq); // 采样失败，设置回原来的时钟频率
}
}
out:
mmc_release_host(host);
return err;
}
4.mmc ops接口说明
mmc_ops提供了部分和mmc type card协议相关操作，这些操作会在mmc.c中mmc的初始化过程中被使用到,这些操作都会发起mmc请求，因此会调用mmc core主模块的mmc请求API.
1.mmc_send_status（典型）
发送CMD13命令，MMC_SEND_STATUS,要求card发送自己当前的状态寄存器.
int mmc_send_status(struct mmc_card *card, u32 *status)
{
int err;
struct mmc_command cmd = {0};
BUG_ON(!card);
BUG_ON(!card->host);
/* 主要是根据对应命令构造struct mmc_command */
cmd.opcode = MMC_SEND_STATUS; // 设置命令操作码opcode，这里设置为MMC_SEND_STATUS，也就是CMD13
if (!mmc_host_is_spi(card->host))
cmd.arg = card->rca << 16; // 设置命令的对应参数，这里设置为card的RCA地址
cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; // 设置请求的一些标识，包括命令类型，response类型等等
/* 调用mmc_wait_for_cmd发送命令请求并且等待命令处理完成。 */
err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
if (err)
return err;
/* NOTE: callers are required to understand the difference
* between "native" and SPI format status words!
*/
/* 对response的处理 */
if (status)
*status = cmd.resp[0]; // 依照协议，response[0]存储了status，因此这里提取cmd.resp[0]
return 0;
}
mmc_go_idle、mmc_select_card、mmc_all_send_cid、mmc_set_relative_addr、mmc_send_cxd_native等等的实现方法和其类似。主要差异在于命令的构造区别以及对response的数据的处理。
2.mmc_send_op_cond（特殊）
发送CMD1指令，SEND_OP_COND.在idle状态时，向卡传送Host支持的电压范围，卡回复OCR的值以及上电复位的状态。如果发送的电压参数为0，则卡仅传回OCR的值，并不进行判断。如果发送的电压参数存在，则和卡本身的OCR对比，若不符合，则卡进入Inactive State，符合，则返回OCR寄存器的值。其实和典型的接口类似，但是其特殊之处在于需要通过busy位（bit31）来判断card的上电复位过程是否完成，如果没有完成的话需要重复发送。
int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
{
struct mmc_command cmd = {0};
int i, err = 0;
BUG_ON(!host);
/* 主要是根据对应命令构造struct mmc_command */
cmd.opcode = MMC_SEND_OP_COND;
cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
/* 需要判断status的busy（bit31）来判断上电复位是否完成，如果没有完成的话需要重复发送。 */
for (i = 100; i; i--) {
err = mmc_wait_for_cmd(host, &cmd, 0);
if (err)
break;
/* if we're just probing, do a single pass */
if (ocr == 0) // ocr为0，说明只是读取ocr寄存器的值，不进行判断
break;
/* otherwise wait until reset completes */
if (mmc_host_is_spi(host)) {
if (!(cmd.resp[0] & R1_SPI_IDLE))
break;
} else {
if (cmd.resp[0] & MMC_CARD_BUSY)
break;
// 如果发送的电压参数存在，则和卡本身的OCR对比，若不符合，则卡进入Inactive State，符合，则返回OCR寄存器的值。
// 同时，需要判断OCR寄存器的busy位来判断上电复位是否完成。
}
err = -ETIMEDOUT;
mmc_delay(10);
}
if (rocr && !mmc_host_is_spi(host))
*rocr = cmd.resp[0];
return err;
}
3.mmc_send_ext_csd
发送CMD8指令，SEND_EXT_CSD.这里要求处于transfer state的card发送ext_csd寄存器，这里获取之后存放在ext_csd寄存器中.这里会使card进入sending-data state，完成之后又退出到transfer state。特殊之处在于涉及到了DATA线上的数据传输，会调用到内部接口mmc_send_cxd_data。
int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
{
return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD,
ext_csd, 512);
}
static int
mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
u32 opcode, void *buf, unsigned len)
{
struct mmc_request mrq = {NULL};
struct mmc_command cmd = {0};
struct mmc_data data = {0};
struct scatterlist sg;
void *data_buf;
int is_on_stack;
is_on_stack = object_is_on_stack(buf);
if (is_on_stack) {
/*
* dma onto stack is unsafe/nonportable, but callers to this
* routine normally provide temporary on-stack buffers ...
*/
data_buf = kmalloc(len, GFP_KERNEL);
if (!data_buf)
return -ENOMEM;
} else
data_buf = buf;
/* 因为涉及到了data线上的数据传输，需要构造mmc_request请求 */
mrq.cmd = &cmd; // 设置mmc_request请求中的命令包
mrq.data = &data; // 设置mmc_request请求中的数据包
/* 主要是根据对应命令构造struct mmc_command */
cmd.opcode = opcode;
cmd.arg = 0;
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
/* 主要是根据对应命令的数据包来构造struct mmc_data */
data.blksz = len;
data.blocks = 1;
data.flags = MMC_DATA_READ;
data.sg = &sg;
data.sg_len = 1;
sg_init_one(&sg, data_buf, len);
if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
data.timeout_ns = 0;
data.timeout_clks = 64;
} else
mmc_set_data_timeout(&data, card);
/* 发起mmc请求并且等待mmc_request处理完成 */
mmc_wait_for_req(host, &mrq);
if (is_on_stack) {
memcpy(buf, data_buf, len);
kfree(data_buf);
}
if (cmd.error)
return cmd.error;
if (data.error)
return data.error;
return 0;
}
4.mmc_switch
发送CMD6命令，MMC_SWITCH.用于设置ext_csd寄存器的某些bit。特殊之处在于：在__mmc_switch中会发起CMD6命令，会导致card进入programming state，因此，在__mmc_switch中必须去获取card的status，直到card退出programming state。这部分就是通过CMD13来实现的。
int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
unsigned int timeout_ms)
{
return __mmc_switch(card, set, index, value, timeout_ms, true, false);
}
int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
unsigned int timeout_ms, bool use_busy_signal,
bool ignore_timeout)
{
int err;
struct mmc_command cmd = {0};
unsigned long timeout;
u32 status;
BUG_ON(!card);
BUG_ON(!card->host);
/* 主要是根据对应命令构造struct mmc_command */
cmd.opcode = MMC_SWITCH;
cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
(index << 16) |
(value << 8) |
set;
cmd.flags = MMC_CMD_AC;
if (use_busy_signal)
cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B;
else
cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1;
cmd.cmd_timeout_ms = timeout_ms;
cmd.ignore_timeout = ignore_timeout;
/* 调用mmc_wait_for_cmd发送命令请求并且等待命令处理完成。 */
err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
if (err)
return err;
/* No need to check card status in case of unblocking command */
if (!use_busy_signal)
return 0;
/* 调用mmc_send_status发送CMD13获取card status，等待card退出programming state。 */
timeout = jiffies + msecs_to_jiffies(MMC_OPS_TIMEOUT_MS);
do {
err = mmc_send_status(card, &status);
if (err)
return err;
if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
break;
if (mmc_host_is_spi(card->host))
break;
/* Timeout if the device never leaves the program state. */
if (time_after(jiffies, timeout)) {
pr_err("%s: Card stuck in programming state! %s\n",
mmc_hostname(card->host), __func__);
return -ETIMEDOUT;
}
} while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
if (mmc_host_is_spi(card->host)) {
if (status & R1_SPI_ILLEGAL_COMMAND)
return -EBADMSG;
} else {
if (status & 0xFDFFA000)
pr_warning("%s: unexpected status %#x after "
"switch", mmc_hostname(card->host), status);
if (status & R1_SWITCH_ERROR)
return -EBADMSG;
}
return 0;
}
2.数据结构
1.mmc_ops & mmc_ops_unsafe
struct mmc_bus_ops表示mmc host在总线上的操作集合，由host的card 设备来决定，mmc type card、sd type card相应的操作集合是不一样的。mmc_ops和mmc_ops_unsafe则表示mmc type card所属的host对于总线的操作集合。
static const struct mmc_bus_ops mmc_ops = {
.awake = mmc_awake,
.sleep = mmc_sleep,
.remove = mmc_remove,
.detect = mmc_detect,
.suspend = NULL,
.resume = NULL,
.power_restore = mmc_power_restore,
.alive = mmc_alive,
.change_bus_speed = mmc_change_bus_speed,
};
static const struct mmc_bus_ops mmc_ops_unsafe = {
.awake = mmc_awake, // 使mmc总线上的mmc type card退出sleep state
.sleep = mmc_sleep, // 使mmc总线的mmc type card进入sleep state
.remove = mmc_remove, // 释放mmc type card
.detect = mmc_detect, // 检测mmc总线的mmc type card是否拔出
.suspend = mmc_suspend, // suspend掉mmc总线上的mmc type card，注意不仅仅会使card进入sleep state，还会对clock以及mmc cache进行操作
.resume = mmc_resume, // resume上mmc总线上的mmc type card
.power_restore = mmc_power_restore, // 恢复mmc总线上的mmc type card的电源状态
.alive = mmc_alive, // 检测mmc总线上的mmc type card状态是否正常
.change_bus_speed = mmc_change_bus_speed, // 修改mmc总线时钟频率
};
mmc_ops_unsafe和mmc_ops的区别在于是否实现suspend和resume方法。对于card不可移除的host来说，需要使用mmc_ops_unsafe这个mmc_bus_ops来支持suspend和resume。之所以在上述注释中不断说明mmc总线，是为了强调应该和mmc_bus虚拟总线区分开来，这里的mmc总线是物理概念、是和host controller直接相关联的。
2.mmc_type
struct device_type mmc_type中为mmc_card定义了很多属性，可以在sysfs中进行查看
/sys/class/mmc_host/mmc0/mmc0:0001
或者/sys/bus/mmc/devices/mmc0:0001下可以查看到如下属性
block cid csd date driver enhanced_area_offset enhanced_area_size erase_size fwrev hwrev
manfid name oemid power preferred_erase_size prv raw_rpmb_size_mult rel_sectors
runtime_pm_timeout serial subsystem type uevent
mmc_type对应实现如下：
static struct device_type mmc_type = {
.groups = mmc_attr_groups,
};
static const struct attribute_group *mmc_attr_groups[] = {
&mmc_std_attr_group,
NULL,
};
static struct attribute_group mmc_std_attr_group = {
.attrs = mmc_std_attrs,
};
MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
card->raw_cid[2], card->raw_cid[3]);
MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
card->raw_csd[2], card->raw_csd[3]);
//...................略过一些
MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
static struct attribute *mmc_std_attrs[] = {
&dev_attr_cid.attr,
&dev_attr_csd.attr,
&dev_attr_date.attr,
&dev_attr_erase_size.attr,
&dev_attr_preferred_erase_size.attr,
&dev_attr_fwrev.attr,
&dev_attr_hwrev.attr,
//.....................略过一些
&dev_attr_rel_sectors.attr,
NULL,
};
8.core模块
mmc core主模块是mmc core的实现核心,对应代码位置drivers/mmc/core/core.c
其主要负责如下功能：
-
mmc core初始化，包括注册mmc bus、mm host class等等
-
mmc host的管理和维护，包括为其他模块提供mmc_host的操作接口，如下
- host的启动和停止
- host的占用和释放
- host电源状态的保存和恢复
- host总线操作集的绑定和解绑
- host上卡状态检测
-
为其他模块提供mmc_card的操作接口，如下
- card的唤醒和休眠
- card擦除
- card属性的获取
-
为其他模块提供总线io setting的接口
-
为其他模块提供mmc请求接口
-
card检测接口
-
bkops操作接口
-
regulator操作接口
-
clock操作接口
-
mmc core电源管理操作接口
1.API总览
1.mmc core初始化相关
- mmc_init & mmc_exit (模块内使用)
2.mmc host的管理和维护相关
mmc_claim_host & mmc_try_claim_host & mmc_release_host （模块内使用）
mmc_power_up & mmc_power_off
mmc_start_host & mmc_stop_host
mmc_power_save_host & mmc_power_restore_host
mmc_resume_host & mmc_suspend_host
mmc_pm_notify
3.mmc card的操作相关（包括card状态的获取）
mmc_hw_reset & mmc_hw_reset_check &
mmc_card_awake & mmc_card_sleep
mmc_card_is_prog_state
mmc_can_erase
mmc_can_trim
mmc_can_discard
mmc_can_sanitize
mmc_can_secure_erase_trim
mmc_erase_group_aligned
4.总线io setting相关
mmc_set_ios
mmc_set_chip_select
mmc_set_clock
mmc_set_bus_mode
mmc_set_bus_width
mmc_select_voltage
mmc_set_signal_voltage（特殊）
mmc_set_timing
mmc_set_driver_typemmc_get_max_frequency & mmc_get_min_frequency
5.host的mmc总线相关
- mmc_resume_bus
- mmc_attach_bus & mmc_detach_bus
6.mmc请求相关
- mmc_request_done
- mmc_wait_for_req
- mmc_wait_for_cmd
- mmc_set_data_timeout
- mmc_align_data_size
7.card检测相关
- mmc_detect_change
- mmc_rescan
- mmc_detect_card_removed
8.bkops操作相关
- mmc_blk_init_bkops_statistics
- mmc_start_delayed_bkops
- mmc_start_bkops & mmc_stop_bkops
- mmc_start_idle_time_bkops
- mmc_read_bkops_status
9.regulator操作相关
- mmc_regulator_get_ocrmask
- mmc_regulator_set_ocr
- mmc_regulator_get_supply
10.card擦除操作相关
- mmc_init_erase
- mmc_erase
11.clock操作接口
- mmc_init_clk_scaling & mmc_exit_clk_scaling
- mmc_can_scale_clk
- mmc_disable_clk_scaling
12.mmc core电源管理操作
- mmc_rpm_hold & mmc_rpm_release
2.函数详解
1.mmc core初始化相关
1.mmc_init实现
负责初始化整个mmc core。
- 主要工作：
- 分配一个workqueue，用于专门处理mmc core的执行的工作
- 注册mmc bus
- 注册mmc host class
static int __init mmc_init(void)
{
int ret;
/* 分配一个workqueue，用于专门处理mmc core的执行的工作 */
workqueue = alloc_ordered_workqueue("kmmcd", 0);
/* 注册mmc bus */
ret = mmc_register_bus(); // 调用mmc_register_bus注册mmc bus，具体参考《mmc core——bus模块说明》
// 会生成/sys/bus/mmc目录
/* 注册mmc host class */
ret = mmc_register_host_class(); // 调用mmc_register_host_class注册mmc host class，具体参考《mmc core——host模块说明》
// 会生成/sys/class/mmc_host目录
/* 注册sdio bus */
ret = sdio_register_bus();
return 0;
}
subsys_initcall(mmc_init);
2.mmc host的管理和维护相关
1.mmc_claim_host & mmc_try_claim_host & mmc_release_host
host被使能之后就不能再次被使能，并且只能被某个进程独自占用。可以简单地将host理解为一种资源，同时只能被一个进程获取，但是在占用进程里面可以重复占用。在对host进行操作之前（包括发起mmc请求），必须使用mmc_claim_host和mmc_release_host来进行获取和释放。
- 变量说明
- mmc_host->claimed用来表示host是否被占用
- mmc_host->claimer用来表示host的占用者（进程）
- mmc_host->claim_cnt用来表示host的占用者的占用计数，为0时则会释放这个host
static inline void mmc_claim_host(struct mmc_host *host)
{
__mmc_claim_host(host, NULL);·// 调用__mmc_claim_host来获取host
}
int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
{
/只考虑abort为NULL的情况，在mmc core中的mmc_claim_host也是将其设置为NULL
DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
int stop;
might_sleep(); // 说明这个函数可能导致进程休眠
add_wait_queue(&host->wq, &wait); // 把当前进程加入到等待队列中
spin_lock_irqsave(&host->lock, flags);
while (1) { // 以下尝试获取host，如果host正在被占用，会进入休眠
set_current_state(TASK_UNINTERRUPTIBLE); // 设置进程状态为TASK_UNINTERRUPTIBLE状态
stop = abort ? atomic_read(abort) : 0;
if (stop || !host->claimed || host->claimer == current) // 当host的占用标志claimed为0，或者占用者是当前进程的时候，说明可以占用了，退出
break;
spin_unlock_irqrestore(&host->lock, flags);
schedule(); // 否则，进行调度进入休眠
spin_lock_irqsave(&host->lock, flags);
}
set_current_state(TASK_RUNNING); // 设置进程为运行状态
if (!stop) {
host->claimed = 1; // 设置占用标志claimed
host->claimer = current; // 设置占用者为当前进程
host->claim_cnt += 1; // 占用计数加1
} else
wake_up(&host->wq);
spin_unlock_irqrestore(&host->lock, flags);
remove_wait_queue(&host->wq, &wait); // 将当前进程从等待队列中退出
if (host->ops->enable && !stop && host->claim_cnt == 1)
host->ops->enable(host); // 调用host操作集中的enable方法来占用该host，对应sdhci类host即为sdhci_enable
return stop;
}
void mmc_release_host(struct mmc_host *host)
{
unsigned long flags;
WARN_ON(!host->claimed);
if (host->ops->disable && host->claim_cnt == 1) // 当前claim_cnt为1（马上要变为0），调用释放host了
host->ops->disable(host); // 调用host操作集中的disable方法来释放该host，对应sdhci类host即为sdhci_disable
spin_lock_irqsave(&host->lock, flags);
if (--host->claim_cnt) {
/* Release for nested claim */
spin_unlock_irqrestore(&host->lock, flags); // 如果减一之后计数还不为0，说明当前进程需要继续占用该host，不做其他操作
} else { // 以下需要释放该host
host->claimed = 0; // 设置占用标志claimed为0
host->claimer = NULL; // 清空占用者（进程）
spin_unlock_irqrestore(&host->lock, flags);
wake_up(&host->wq); // 唤醒host的等待队列，让那些调用mmc_claim_host睡眠等待host资源的进程被唤醒
}
}
int mmc_try_claim_host(struct mmc_host *host)
{
// 和mmc_claim_host的主要区别在于进程不会休眠，获取失败直接返回
int claimed_host = 0;
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
if (!host->claimed || host->claimer == current) {
host->claimed = 1;
host->claimer = current;
host->claim_cnt += 1;
claimed_host = 1;
}
spin_unlock_irqrestore(&host->lock, flags);
if (host->ops->enable && claimed_host && host->claim_cnt == 1)
host->ops->enable(host);
return claimed_host;
}
会调用mmc_host->struct mmc_host_ops->enable和mmc_host->struct mmc_host_ops->disable来使能和禁用host。对于sdhci类的host，相应就是sdhci_enable和sdhci_disable。
2.mmc_power_up & mmc_power_off
mmc host的上电操作和关电操作。
-
mmc的power状态
- MMC_POWER_OFF：掉电状态
- MMC_POWER_UP：正在上电的状态
- MMC_POWER_ON：供电正常的状态
-
主要工作
主要工作就是初始化host的总线设置、总线时钟以及工作电压、信号电压。
void mmc_power_up(struct mmc_host *host)
{
int bit;
/* 判断是否已经处于MMC_POWER_ON，是的话不进行后续操作 */
if (host->ios.power_mode == MMC_POWER_ON)
return;
/* 第一阶段，先设置对应的io setting使host处于MMC_POWER_UP的状态（总线工作频率没有设置） */
mmc_host_clk_hold(host); // 先获取host时钟
/* If ocr is set, we use it */
if (host->ocr)
bit = ffs(host->ocr) - 1; // 选择一个ocr配置设置为host的工作电压
else
bit = fls(host->ocr_avail) - 1;
host->ios.vdd = bit;
if (mmc_host_is_spi(host))
host->ios.chip_select = MMC_CS_HIGH;
else {
host->ios.chip_select = MMC_CS_DONTCARE;
host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; // 设置总线模式
}
host->ios.power_mode = MMC_POWER_UP;
host->ios.bus_width = MMC_BUS_WIDTH_1; // 设置总线宽度为1
host->ios.timing = MMC_TIMING_LEGACY; // 串口时序
mmc_set_ios(host); // 调用mmc_set_ios设置总线的io setting，后面会说明
/*
* This delay should be sufficient to allow the power supply
* to reach the minimum voltage.
*/
mmc_delay(10);
/* 第二阶段，以host的初始化工作频率再次设置io setting，使host处于MMC_POWER_ON状态 */
host->ios.clock = host->f_init; // 设置总线的时钟频率
host->ios.power_mode = MMC_POWER_ON;
mmc_set_ios(host); // 调用mmc_set_ios设置总线的io setting，后面会说明
/*
* This delay must be at least 74 clock sizes, or 1 ms, or the
* time required to reach a stable voltage.
*/
mmc_delay(10);
/* 设置信号的电压 */
/* Set signal voltage to 3.3V */
__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
mmc_host_clk_release(host); // 释放host时钟
}
3.mmc_start_host & mmc_stop_host
mmc_start_host 用来启动一个host，mmc_stop_host用来停止一个host。当底层host controller调用mmc_add_host来注册host时，在mmc_add_host中就会调用mmc_start_host来启动一个host了.相对应的，会在mmc_remove_host中调用mmc_stop_host停止host。
void mmc_start_host(struct mmc_host *host)
{
mmc_claim_host(host); // 因为上电操作涉及到对host的使用和设置，需要先占用host
host->f_init = max(freqs[0], host->f_min); // 通过最小频率要设置初始化频率
host->rescan_disable = 0; // 设置rescan_disable标志为0，说明已经可以进行card检测了
if (host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP) // 如果mmc属性设置了MMC_CAP2_NO_PRESCAN_POWERUP，也就是在rescan前不需要进行power up操作时，则进行关电
mmc_power_off(host);
else
mmc_power_up(host); // 否则，调用mmc_power_up对host进行上电操作。这里也是mmc core中启动host的核心函数。
mmc_release_host(host); // 完成上电操作，释放host
/* 到这里host已经可以工作了，可以开始进行后续的card操作了 */
mmc_detect_change(host, 0); // 调用mmc_detect_change检测card变化，后续会继续说明
}
3.card检测相关
1.mmc_detect_change
在上述中我们知道在启动host的函数mmc_start_host 中最后调用了mmc_detect_change来开始检测card（也就是检测mmc卡槽的状态变化情况）。其实mmc_detect_change是在driver发现mmc卡槽状态发生变化时，调用mmc_detect_change来进行确认和处理。
void mmc_detect_change(struct mmc_host *host, unsigned long delay)
{
#ifdef CONFIG_MMC_DEBUG
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
WARN_ON(host->removed);
spin_unlock_irqrestore(&host->lock, flags);
#endif
host->detect_change = 1; // 检测到card状态发生变化的标识
mmc_schedule_delayed_work(&host->detect, delay); // 间隔delay jiffies之后调用host->detect的工作
}
在《host模块说明》已经知道了在mmc_alloc_host中默认将host->detect工作设置为mmc_rescan（card重新扫描）函数，INIT_DELAYED_WORK(&host->detect, mmc_rescan)。当然，host也可以自己另外设置，但是一般都是使用mmc core提供的mmc_rescan作为detect工作来搜索card。下面说明。
2.mmc_rescan
用于检测host的卡槽状态，并对状态变化做相应的操作。有card插入时，重新扫描mmc card。
void mmc_rescan(struct work_struct *work)
{
struct mmc_host *host =
container_of(work, struct mmc_host, detect.work);
bool extend_wakelock = false;
/* 如果rescan_disable被设置，说明host此时还禁止rescan */
if (host->rescan_disable)
return;
/* 对于设备不可移除的host来说，只能rescan一次 */
/* If there is a non-removable card registered, only scan once */
if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
return;
host->rescan_entered = 1;
mmc_bus_get(host); // 获取host对应的bus
mmc_rpm_hold(host, &host->class_dev); // 使host处于rpm resume的状态
/* 以下判断原来的card是否已经被移除，移除了则需要做相应的操作 */
/*
* if there is a _removable_ card registered, check whether it is
* still present
*/
if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
&& !(host->caps & MMC_CAP_NONREMOVABLE))
host->bus_ops->detect(host);
// host->bus_ops存在的话说明之前是有card插入的状态
// 需要调用host->bus_ops->detect检测card是否被移除，是的话在host->bus_ops->detect中做相应的处理
// 对于mmc type card来说，对应就是mmc_detect，具体参考《card相关模块》
host->detect_change = 0;
/* If the card was removed the bus will be marked
* as dead - extend the wakelock so userspace
* can respond */
if (host->bus_dead)
extend_wakelock = 1; // 需要设置一个wakelock锁，使用户空间可以及时做出相应
/*
* Let mmc_bus_put() free the bus/bus_ops if we've found that
* the card is no longer present.
*/
mmc_bus_put(host);
// 因为在这个函数的前面已经获取了一次host，可能导致host->bus_ops->detect中检测到card拔出之后，没有真正释放到host的bus，所以这里先put一次
// host bus的计数（bus_refs）为0的时候，会调用__mmc_release_bus清空host bus的信息
mmc_bus_get(host);
// 再获取host bus
/* if there still is a card present, stop here */
if (host->bus_ops != NULL) { // 说明此时还有card插入，退出后续的操作
mmc_rpm_release(host, &host->class_dev);
mmc_bus_put(host);
goto out;
}
mmc_rpm_release(host, &host->class_dev);
/*
* Only we can add a new handler, so it's safe to
* release the lock here.
*/
mmc_bus_put(host);
/* 检测当前卡槽状态，根据卡槽状态做相应的操作 */
if (host->ops->get_cd && host->ops->get_cd(host) == 0) {
// 调用host->ops->get_cd来判断host的卡槽的当前card插入状态
// 对应sdhci类型的host来说，就是sdhci_get_cd
// 为0的时候，表示没有card插入，对应host进行power off操作之后进行退出
// 为1的时候，表示当前有card插入，跳到后续的操作
mmc_claim_host(host);
mmc_power_off(host);
mmc_release_host(host);
goto out;
}
mmc_rpm_hold(host, &host->class_dev);
mmc_claim_host(host);
if (!mmc_rescan_try_freq(host, host->f_min)) // 调用mmc_rescan_try_freq，以支持的最低频率作为工作频率尝试搜索card，后续继续说明
extend_wakelock = true;
mmc_release_host(host);
mmc_rpm_release(host, &host->class_dev);
out:
/* only extend the wakelock, if suspend has not started yet */
if (extend_wakelock && !host->rescan_disable)
wake_lock_timeout(&host->detect_wake_lock, HZ / 2); // 占用wakelock，使系统在HZ/2的时间内不会休眠
if (host->caps & MMC_CAP_NEEDS_POLL)
mmc_schedule_delayed_work(&host->detect, HZ);
// 当host设置了MMC_CAP_NEEDS_POLL属性时，需要每隔HZ的时间轮询检测host的卡槽状态，
// 调度了host->detect工作，对应就是mmc_rescan
}
会调用host->ops->get_cd来判断host的卡槽的当前card插入状态，对应sdhci类型的host就是sdhci_get_cd。会调用host->bus_ops->detect检测card是否被移除，是的话在host->bus_ops->detect中做相应的处理。对于mmc type card，就是mmc_detect。
3.mmc_rescan_try_freq
以一定频率搜索host bus上的card
static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
{
host->f_init = freq;
mmc_power_up(host); // 给host做上电操作
mmc_hw_reset_for_init(host); // 硬件复位和初始化
mmc_go_idle(host);
mmc_send_if_cond(host, host->ocr_avail); // 获取card的可用频率，存储到host->ocr_avail中
/* Order's important: probe SDIO, then SD, then MMC */
/* 用于绑定card到host bus上（也就是card和host的绑定）。 */
if (!mmc_attach_sdio(host)) // 先假设card是sdio type card，尝试绑定到host bus上，失败则说明不是sdio type card，继续后面的操作，否则返回
return 0;
if (!mmc_attach_sd(host)) // 先假设card是sd type card，尝试绑定到host bus上，失败则说明不是sd type card，继续后面的操作，否则返回
return 0;
if (!mmc_attach_mmc(host)) // 先假设card是mmc type card，尝试绑定到host bus上，失败则说明不是mmc type card，继续后面的操作，否则返回
// mmc_attach_mmc通过mmc_host获取mmc type card信息，初始化mmc_card，并进行部分驱动，最后将其注册到mmc_bus上。
// 具体参考《card相关模块说明》
return 0;
mmc_power_off(host);
return -EIO;
}
4.总线io setting相关
0.mmc_ios说明
struct mmc_ios 由mmc core定义的规范的结构，用来维护mmc总线相关的一些io setting。如下：
struct mmc_ios {
unsigned int clock; /* clock rate */ // 当前工作频率
unsigned int old_rate; /* saved clock rate */ // 上一次的工作频率
unsigned long clk_ts; /* time stamp of last updated clock */ // 上一次更新工作频率的时间戳
unsigned short vdd;/* vdd stores the bit number of the selected voltage range from below. */ // 支持的电压表
unsigned char bus_mode; /* command output mode */ // 总线输出模式，包括开漏模式和上拉模式
unsigned char chip_select; /* SPI chip select */ // spi片选
unsigned char power_mode; /* power supply mode */ // 电源状态模式
unsigned char bus_width; /* data bus width */ // 总线宽度
unsigned char timing; /* timing specification used */ // 时序类型
unsigned char signal_voltage; /* signalling voltage (1.8V or 3.3V) */ // 信号的工作电压
unsigned char drv_type; /* driver type (A, B, C, D) */ // 驱动类型
};
在设置总线io setting的过程中，就是要设置mmc_host->mmc_ios中的这些成员。然后通过调用mmc_set_ios进行统一设置.
1.mmc_set_ios
统一设置mmc总线的io设置（io setting）。
void mmc_set_ios(struct mmc_host *host)
{
struct mmc_ios *ios = &host->ios;
if (ios->clock > 0)
mmc_set_ungated(host); // 关闭clock的门控
host->ops->set_ios(host, ios); // 调用host->ops->set_ios来对mmc总线的io setting进行设置，核心函数
// 对于sdhci类型的host，对应就是sdhci_set_ios
}
会调用host->ops->set_ios来对mmc总线的io setting进行设置，核心函数。对于sdhci类型的host，对应就是sdhci_set_ios.
2.mmc_set_bus_mode & mmc_set_bus_width
mmc_set_bus_mode:
用于设置总线模式，有如下模式:MMC_BUSMODE_OPENDRAIN（开漏模式）,MMC_BUSMODE_PUSHPULL（上拉模式）
mmc_set_bus_width:
用于设置总线宽度，有如下模式:MMC_BUS_WIDTH_1,MMC_BUS_WIDTH_4,MMC_BUS_WIDTH_8
void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
{
mmc_host_clk_hold(host);
host->ios.bus_mode = mode;
mmc_set_ios(host);
mmc_host_clk_release(host);
}
void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
{
mmc_host_clk_hold(host);
host->ios.bus_width = width;
mmc_set_ios(host);
mmc_host_clk_release(host);
5.host的mmc总线相关
1.mmc_attach_bus & mmc_detach_bus
-
主要功能
- mmc_attach_bus用于将分配一个mmc总线操作集给host。
- mmc_detach_bus用于释放和host相关联的mmc总线操作集。
-
一些变量
- mmc_host->bus_ops，表示host的mmc总线操作集
- mmc_host->bus_refs，表示host的mmc总线的使用者计数
- mmc_host->bus_dead，表示host的mmc总线是否被激活，如果设置了bus_ops，那么就会被激活了
oid mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
{
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
BUG_ON(host->bus_ops); // 不允许重复设置host的mmc总线操作集
BUG_ON(host->bus_refs); // 当mmc总线的使用者计数还存在时，不允许设置host的mmc总线操作集
host->bus_ops = ops; // 设置host的mmc总线操作集
host->bus_refs = 1; // host的mmc总线的使用者计数设置为1，相当于调用了mmc_bus_get
host->bus_dead = 0; // 总线被激活了
spin_unlock_irqrestore(&host->lock, flags);
}
void mmc_detach_bus(struct mmc_host *host)
{
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
host->bus_dead = 1; // host的mmc总线设置为dead状态
spin_unlock_irqrestore(&host->lock, flags);
mmc_bus_put(host); // 调用mmc_bus_put释放host的mmc总线，也就是对host的mmc总线的使用者计数-1
}
在card模块中可以看到mmc_attach_mmc->mmc_attach_bus_ops调用mmc_attach_bus来绑定了host的mmc总线操作集为mmc_ops_unsafe或者mmc_ops
2.mmc_bus_get & mmc_bus_put
static inline void mmc_bus_get(struct mmc_host *host)
{
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
host->bus_refs++; // 对host的mmc总线的使用者计数+1
spin_unlock_irqrestore(&host->lock, flags);
}
static inline void mmc_bus_put(struct mmc_host *host)
{
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
host->bus_refs--; // 对host的mmc总线的使用者计数-1
if ((host->bus_refs == 0) && host->bus_ops) // 说明host的mmc总线当前并没有使用，调用__mmc_release_bus进行实际的释放操作
__mmc_release_bus(host);
spin_unlock_irqrestore(&host->lock, flags);
}
static void __mmc_release_bus(struct mmc_host *host)
{
host->bus_ops = NULL; // 清空host的mmc总线操作集
}
6.mmc请求相关
分成同步的mmc请求和异步的mmc请求。差别如下：
1、流程上的差别：
（1）会阻塞的处理流程：
mmc_wait_for_req
——》__mmc_start_req // 发起请求
————》init_completion(&mrq->completion);
————》mrq->done = mmc_wait_done
————》mmc_start_request(host, mrq); // 实际发起请求的操作
——》mmc_wait_for_req_done // 阻塞等待请求处理完成
——》返回
（2）不阻塞等待该命令的处理流程：
（注意：并不是说调用这个接口并不会阻塞，而是不会为了等待当前请求处理完成而阻塞，但是可能会等待上一次请求处理完成而阻塞）
mmc_start_req
——》mmc_wait_for_data_req_done // 阻塞等待上一次的请求处理
——》__mmc_start_data_req // 发起异步请求
————》mrq->done = mmc_wait_data_done
————》mmc_start_request // 实际发起请求的操作
——》返回
最后都是调用了mmc_start_request使host向MMC发起请求。
0.数据结构说明
一个mmc请求分成两部分内容，分别是命令部分和数据部分。
- mmc_command
struct mmc_command {
u32 opcode; // 命令的操作码，如MMC_GO_IDLE_STATE、MMC_SEND_OP_COND等等
u32 arg; // 命令的参数
u32 resp[4]; // response值
unsigned int flags; /* expected response type */ // 期待的response的类型
#define mmc_resp_type(cmd) ((cmd)->flags & (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC|MMC_RSP_BUSY|MMC_RSP_OPCODE))
/*
* These are the command types.
*/
#define mmc_cmd_type(cmd) ((cmd)->flags & MMC_CMD_MASK)
unsigned int retries; /* max number of retries */ // 失败时的重复尝试次数
unsigned int error; /* command error */ // 命令的错误码
/*
* Standard errno values are used for errors, but some have specific
* meaning in the MMC layer:
*
* ETIMEDOUT Card took too long to respond
* EILSEQ Basic format problem with the received or sent data
* (e.g. CRC check failed, incorrect opcode in response
* or bad end bit)
* EINVAL Request cannot be performed because of restrictions
* in hardware and/or the driver
* ENOMEDIUM Host can determine that the slot is empty and is
* actively failing requests
*/
unsigned int cmd_timeout_ms; /* in milliseconds */ // 命令执行的等待超时事件
struct mmc_data *data; /* data segment associated with cmd */ // 和该命令关联在一起的数据段
struct mmc_request *mrq; /* associated request */ // 该命令关联到哪个request
};
- mmc_data
struct mmc_data {
unsigned int timeout_ns; /* data timeout (in ns, max 80ms) */ // 超时时间，以ns为单位
unsigned int timeout_clks; /* data timeout (in clocks) */ // 超时时间，以clock为单位
unsigned int blksz; /* data block size */ // 块大小
unsigned int blocks; /* number of blocks */ // 块数量
unsigned int error; /* data error */ // 传输的错误码
unsigned int flags; // 传输标识
#define MMC_DATA_WRITE (1 << 8)
#define MMC_DATA_READ (1 << 9)
#define MMC_DATA_STREAM (1 << 10)
unsigned int bytes_xfered;
struct mmc_command *stop; /* stop command */ // 结束传输的命令
struct mmc_request *mrq; /* associated request */ // 该命令关联到哪个request
unsigned int sg_len; /* size of scatter list */
struct scatterlist *sg; /* I/O scatter list */
s32 host_cookie; /* host private data */
bool fault_injected; /* fault injected */
};
- mmc_request
struct mmc_request是mmc core向host controller发起命令请求的处理单位。
struct mmc_request {
struct mmc_command *sbc; /* SET_BLOCK_COUNT for multiblock */ // 设置块数量的命令，怎么用的后续再补充
struct mmc_command *cmd; // 要传输的命令
struct mmc_data *data; // 要传输的数据
struct mmc_command *stop; // 结束命令，怎么用的后续再补充
struct completion completion; // 完成量
void (*done)(struct mmc_request *);/* completion function */ // 传输结束后的回调函数
struct mmc_host *host; // 所属host
};
- mmc_async_req
struct mmc_async_req {
/* active mmc request */
struct mmc_request *mrq;
unsigned int cmd_flags; /* copied from struct request */
/*
* Check error status of completed mmc request.
* Returns 0 if success otherwise non zero.
*/
int (*err_check) (struct mmc_card *, struct mmc_async_req *);
/* Reinserts request back to the block layer */
void (*reinsert_req) (struct mmc_async_req *);
/* update what part of request is not done (packed_fail_idx) */
int (*update_interrupted_req) (struct mmc_card *,
struct mmc_async_req *);
};
1.mmc_wait_for_req
发起mmc_request请求并且等待其处理完成。由其他需要发起mmc请求的模块调用。可以结合后面的mmc_request_done来看。
void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
{
#ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
if (mmc_bus_needs_resume(host))
mmc_resume_bus(host);
#endif
__mmc_start_req(host, mrq); // 开始发起mmc_request请求
mmc_wait_for_req_done(host, mrq); // 等待mmc_request处理完成
}
//-----------------------------------__mmc_start_req说明，开始发起mmc_request请求
static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
{
/* 发起mmc_request前的一些初始化工作，包括完成量和处理完成的回调函数的设置 */
init_completion(&mrq->completion); // 初始化完成量，在mmc_wait_for_req_done中会去等待这个完成量
mrq->done = mmc_wait_done;
// 设置mmc_request处理完成的回调函数，会调用complete(&mrq->completion);来设置完成量
// host controller会调用mmc_request_done来执行这个回调函数，具体在后面分析
if (mmc_card_removed(host->card)) { // 检测card是否存在
mrq->cmd->error = -ENOMEDIUM;
complete(&mrq->completion);
return -ENOMEDIUM;
}
/* 调用mmc_start_request发起mmc请求 */
mmc_start_request(host, mrq); // 开始处理mmc_request请求
return 0;
}
static void
mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{
WARN_ON(!host->claimed);
/* 以下对mmc_request的各个成员，包括cmd、data、stop做验证操作和关联操作 */
mrq->cmd->error = 0;
mrq->cmd->mrq = mrq;
if (mrq->data) {
BUG_ON(mrq->data->blksz > host->max_blk_size);
BUG_ON(mrq->data->blocks > host->max_blk_count);
BUG_ON(mrq->data->blocks * mrq->data->blksz >
host->max_req_size);
mrq->cmd->data = mrq->data; // 也就是说mmc_request的data和其cmd中的data是一一样的
mrq->data->error = 0;
mrq->data->mrq = mrq;
if (mrq->stop) {
mrq->data->stop = mrq->stop;
mrq->stop->error = 0;
mrq->stop->mrq = mrq;
}
#ifdef CONFIG_MMC_PERF_PROFILING
if (host->perf_enable)
host->perf.start = ktime_get();
#endif
}
/* 获取时钟 */
mmc_host_clk_hold(host);
/* 调用host controller的request方法来处理mmc_request请求 */
host->ops->request(host, mrq);
// host->ops->request也就是host controller的request方法，对于sdhci类型的host来说，就是sdhci_request
}
//-----------------------------------mmc_wait_for_req_done说明，等待mmc_request处理完成
static void mmc_wait_for_req_done(struct mmc_host *host,
struct mmc_request *mrq)
{
struct mmc_command *cmd;
while (1) {
wait_for_completion_io(&mrq->completion); // 在这里休眠，等待mrq->completion完成量，在__mmc_start_req中初始化的
cmd = mrq->cmd; // 获取对应的command
/*
* If host has timed out waiting for the commands which can be
* HPIed then let the caller handle the timeout error as it may
* want to send the HPI command to bring the card out of
* programming state.
*/
if (cmd->ignore_timeout && cmd->error == -ETIMEDOUT)
break;
if (!cmd->error || !cmd->retries || mmc_card_removed(host->card))
// 如果command正常处理完成，或者失败重复尝试次数为0，或者card被移除了，直接退出循环返回
break;
// 以下处理失败重复尝试的情况
pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
mmc_hostname(host), cmd->opcode, cmd->error);
cmd->retries--;
cmd->error = 0;
host->ops->request(host, mrq);
}
}
会调用host->ops->request来对mmc_request进行处理，对于sdhci类型的host，对应就是sdhci_request。这个方法就是mmc_request实际被处理的核心。
2.mmc_request_done
通知mmc core某个mmc_request已经处理完成，由host controller调用。以sdhci类型的host为例，处理完一个mmc_request之后，会执行sdhci_tasklet_finish，而在sdhci_tasklet_finish中会调用mmc_request_done来通知host某个mmc_request已经处理完成了。
void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
{
struct mmc_command *cmd = mrq->cmd;
int err = cmd->error;
if (host->card)
mmc_update_clk_scaling(host);
if (err && cmd->retries && !mmc_card_removed(host->card)) {
// command执行出错，如果还需要重复尝试的话，这里不释放clock，只是通知mmc core
if (mrq->done)
mrq->done(mrq);
// 执行mmc_request的回调函数来通知mmc core，
// 对于__mmc_start_req发起的request来说，就是mmc_wait_done，上面已经说明过了
// 对于__mmc_start_data_req发起的request来说，就是mmc_wait_data_done，后面会说明
} else {
mmc_should_fail_request(host, mrq);
// 用于模拟data传输概率出错的情况
// 具体参考http://blog.csdn.net/luckywang1103/article/details/52224160
if (mrq->done)
mrq->done(mrq);
// 执行mmc_request的回调函数来通知mmc core，对于__mmc_start_req发起的request来说，就是mmc_wait_done，上面已经说明过了
mmc_host_clk_release(host);
}
}
通过上述，mrq->done被调度，mmc_wait_done被执行，mrq->completion被设置。然后等待mrq->completion的mmc_wait_for_req_done就会继续往下执行。
3.mmc_wait_for_cmd
mmc_wait_for_cmd用于处理一个不带数据请求的命令。会被封装到mmc_request中，通过调用mmc_wait_for_req来发起请求。
int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
{
struct mmc_request mrq = {NULL};
WARN_ON(!host->claimed);
memset(cmd->resp, 0, sizeof(cmd->resp)); // 清空command的response
cmd->retries = retries; // 失败时的重复尝试次数
mrq.cmd = cmd; // 封装到mmc_request中
cmd->data = NULL; // 不带数据包的命令，故清空data
mmc_wait_for_req(host, &mrq); // 调用mmc_wait_for_req发起mmc请求并且等待其处理完成
return cmd->error; // 返回错误码
}
4.mmc_start_req（重要）
机制说明如下：mmc_start_req会先判断上一次的asycn_req是否处理完成，如果没有处理完成，则会等待其处理完成。如果处理完成了，为当前要处理的asycn_req发起请求，但是并不会等待，而是直接返回。
注意：并不是说调用这个接口并不会阻塞，而是不会为了等待当前请求处理完成而阻塞，但是可能会等待上一次请求处理完成而阻塞。这样，可以利用等待的一部分时间来做其他操作。
/**
* mmc_start_req - start a non-blocking request // 该函数用来发起一个不阻塞的请求
* @host: MMC host to start command // 要发起对应请求的host
* @areq: async request to start // 要发起的异步请求
* @error: out parameter returns 0 for success, otherwise non zero // 返回值，返回0表示成功，返回非零表示失败
*
* Start a new MMC custom command request for a host. // 为host发起的一个新的mmc命令请求
* If there is on ongoing async request wait for completion // 如果host已经有一个正在处理、等待完成的异步请求，那么会等待这个请求完成！！！
* of that request and start the new one and return. // 然后发起新的请求，然后返回！！！
* Does not wait for the new request to complete. // 并不会等待这个新的请求完成！！！
*
* Returns the completed request, NULL in case of none completed. // 会返回被完成的mmc请求（而不是新的mmc请求。）空表示没有mmc请求被完成。
* Wait for the an ongoing request (previoulsy started) to complete and
* return the completed request. If there is no ongoing request, NULL
* is returned without waiting. NULL is not an error condition.
// 等待上一次发起的mmc请求完成，然后把这个mmc请求返回。如果没有mmc请求正在处理，那么就直接返回而不会等待。空并不是错误条件。
*/
struct mmc_async_req *mmc_start_req(struct mmc_host *host,
struct mmc_async_req *areq, int *error)
{
int err = 0;
int start_err = 0;
struct mmc_async_req *data = host->areq;
unsigned long flags;
bool is_urgent;
/* Prepare a new request */
/* 为新的异步请求做准备处理 */
if (areq) {
/*
* start waiting here for possible interrupt
* because mmc_pre_req() taking long time
*/
mmc_pre_req(host, areq->mrq, !host->areq);
}
/* 对上一次发起的、正在处理、等待完成的异步请求进行处理、等待操作 */
if (host->areq) {
err = mmc_wait_for_data_req_done(host, host->areq->mrq, areq); // 在这里等待正在处理的异步请求处理完成
//.......以下过滤了错误处理的部分
}
/* 对新的异步请求进行发起操作 */
if (!err && areq) {
/* urgent notification may come again */
spin_lock_irqsave(&host->context_info.lock, flags);
is_urgent = host->context_info.is_urgent;
host->context_info.is_urgent = false;
spin_unlock_irqrestore(&host->context_info.lock, flags);
if (!is_urgent || (areq->cmd_flags & REQ_URGENT)) {
start_err = __mmc_start_data_req(host, areq->mrq); // 调用__mmc_start_data_req发起新的异步请求
} else {
/* previous request was done */
err = MMC_BLK_URGENT_DONE;
if (host->areq) {
mmc_post_req(host, host->areq->mrq, 0);
host->areq = NULL;
}
areq->reinsert_req(areq);
mmc_post_req(host, areq->mrq, 0);
goto exit;
}
}
if (host->areq)
mmc_post_req(host, host->areq->mrq, 0);
/* Cancel a prepared request if it was not started. */
if ((err || start_err) && areq)
mmc_post_req(host, areq->mrq, -EINVAL);
if (err)
host->areq = NULL;
else
host->areq = areq;
exit:
if (error)
*error = err;
return data; // 反正上一次正常处理的异步请求
}
//-----------------------------------------------------------------------------------------------------------------------------
static int __mmc_start_data_req(struct mmc_host *host, struct mmc_request *mrq)
{
mrq->done = mmc_wait_data_done;
// 设置mmc_request处理完成的回调函数，会唤醒正在等待请求被完成的进程，后面说明
// host controller会调用mmc_request_done来执行这个回调函数，具体前面分析过了
mrq->host = host;
mmc_start_request(host, mrq); // 开始处理mmc_request请求，前面已经说明过了
return 0;
}
static void mmc_wait_data_done(struct mmc_request *mrq)
{
unsigned long flags;
struct mmc_context_info *context_info = &mrq->host->context_info;
spin_lock_irqsave(&context_info->lock, flags);
mrq->host->context_info.is_done_rcv = true; // 设置is_done_rcv标识
wake_up_interruptible(&mrq->host->context_info.wait); // 唤醒context_info上的等待进程
spin_unlock_irqrestore(&context_info->lock, flags);
}
//-----------------------------------------------------------------------------------------------------------------------------
static int mmc_wait_for_data_req_done(struct mmc_host *host,
struct mmc_request *mrq,
struct mmc_async_req *next_req)
{
// struct mmc_request *mrq：表示正在等待完成的请求
// struct mmc_async_req *next_req：表示下一次要执行的异步请求
struct mmc_command *cmd;
struct mmc_context_info *context_info = &host->context_info;
bool pending_is_urgent = false;
bool is_urgent = false;
bool is_done_rcv = false;
int err, ret;
unsigned long flags;
while (1) {
/* 在这里等待正在进行的请求完成，会在mmc_wait_data_done中被唤醒 */
/* 有几种情况会唤醒等待进程 */
ret = wait_io_event_interruptible(context_info->wait,(context_info->is_done_rcv || context_info->is_new_req || context_info->is_urgent));
spin_lock_irqsave(&context_info->lock, flags);
is_urgent = context_info->is_urgent;
is_done_rcv = context_info->is_done_rcv;
context_info->is_waiting_last_req = false;
spin_unlock_irqrestore(&context_info->lock, flags);
/* 对请求处理完成的处理 */
if (is_done_rcv) {
context_info->is_done_rcv = false;
context_info->is_new_req = false;
cmd = mrq->cmd;
if (!cmd->error || !cmd->retries || mmc_card_removed(host->card)) {
/* 请求正常处理完成，或者失败但是不需要重复尝试的情况的处理 */
err = host->areq->err_check(host->card, host->areq);
//.......
break; /* return err */
} else {
/* 对请求处理出错并且需要重复尝试的情况的处理 */
//.......
}
}
}
return err;
}
参考:
https://blog.csdn.net/ooonebook/article/details/55001201
9.wowotech.net
Linux MMC framework(2)_host controller driver
1. 前言
本文是Linux MMC framework的第二篇，将从驱动工程师的角度，介绍MMC host controller driver有关的知识，学习并掌握如何在MMC framework的框架下，编写MMC控制器的驱动程序。同时，通过本篇文章，我们会进一步的理解MMC、SD、SDIO等有关的基础知识。
2. MMC host驱动介绍
MMC的host driver，是用于驱动MMC host控制器的程序，位于“drivers/mmc/host”目录。从大的流程上看，编写一个这样的驱动非常简单，只需要三步：
1）调用mmc_alloc_host，分配一个struct mmc_host类型的变量，用于描述某一个具体的MMC host控制器。
2）根据MMC host控制器的硬件特性，填充struct mmc_host变量的各个字段，例如MMC类型、电压范围、操作函数集等等。
3）调用mmc_add_host接口，将正确填充的MMC host注册到MMC core中。
当然，看着简单，一牵涉到实现细节，还是很麻烦的，后面我们会慢慢分析。
注1：分析MMC host driver的时候，Linux kernel中有大把大把的例子（例如drivers/mmc/host/pxamci.c），大家可尽情参考、学习，不必谦虚（这是学习Linux的最佳方法）。
注2：由于MMC host driver牵涉到具体的硬件controller，分析的过程中需要一些具体的硬件辅助理解，本文将以“X Project”所使用Bubblegum-96平台为例，具体的硬件spec可参考[1]。
3. 主要数据结构
3.1 struct mmc_host
MMC core使用struct mmc_host结构抽象具体的MMC host controller，该结构的定义位于“include/linux/mmc/host.h”中，它既可以用来描述MMC控制器所具有的特性、能力（host driver关心的内容），也保存了host driver运行过程中的一些状态、参数（MMC core关心的内容）。需要host driver关心的部分的具体的介绍如下：
parent，一个struct device类型的指针，指向该MMC host的父设备，一般是注册该host的那个platform设备；
class_dev，一个struct device类型的变量，是该MMC host在设备模型中作为一个“设备”的体现。当然，人如其名，该设备从属于某一个class（mmc_host_class）；
ops，一个struct mmc_host_ops类型的指针，保存了该MMC host有关的操作函数集，具体可参考3.2小节的介绍；
pwrseq，一个struct mmc_pwrseq类型的指针，保存了该MMC host电源管理有关的操作函数集，具体可参考3.2小节的介绍；
f_min、f_max、f_init，该MMC host支持的时钟频率范围，最小频率、最大频率以及初始频率；
ocr_avail，该MMC host可支持的操作电压范围（具体可参考include/linux/mmc/host.h中MMC_VDD_开头的定义）；
注3：OCR（Operating Conditions Register）是MMC/SD/SDIO卡的一个32-bit的寄存器，其中有些bit指明了该卡的操作电压。MMC host在驱动这些卡的时候，需要和Host自身所支持的电压范围匹配之后，才能正常操作，这就是ocr_avail的存在意义。ocr_avail_sdio、ocr_avail_sd、ocr_avail_mmc，如果MMC host针对SDIO、SD、MMC等不同类型的卡，所支持的电压范围不同的话，需要通过这几个字段特别指定。否则，不需要赋值（初始化为0）；
pm_notify，一个struct notifier_block类型的变量，用于支持power management有关的notify实现；
max_current_330、max_current_300、max_current_180，当工作电压分别是3.3v、3v以及1.8v的时候，所支持的最大操作电流（如果MMC host没有特别的限制，可以不赋值）；
caps、caps2，指示该MMC host所支持的功能特性，具体可参考3.4小节的介绍；
pm_caps，mmc_pm_flag_t类型的变量，指示该MMC host所支持的电源管理特性；
max_seg_size、max_segs、max_req_size、max_blk_size、max_blk_count、max_busy_timeout，和块设备（如MMC、SD、eMMC等）有关的参数，在古老的磁盘时代，这些参数比较重要。对基于MMC技术的块设备来说，硬件的性能大大提升，这些参数就没有太大的意义了。具体可参考5.2章节有关MMC数据传输的介绍；
lock，一个spin lock，是MMC host driver的私有变量，可用于保护host driver的临界资源；
ios，一个struct mmc_ios类型的变量，用于保存MMC bus的当前配置，具体可参考3.5小节的介绍；
supply，一个struct mmc_supply类型的变量，用于描述MMC系统中的供电信息，具体可参考3.6小节的介绍；
……
private，一个0长度的数组，可以在mmc_alloc_host时指定长度，由host controller driver自行支配。
3.2 struct mmc_host_ops
struct mmc_host_ops抽象并集合了MMC host controller所有的操作函数集，包括：
1）数据传输有关的函数
/*
* It is optional for the host to implement pre_req and post_req in
* order to support double buffering of requests (prepare one
* request while another request is active).
* pre_req() must always be followed by a post_req().
* To undo a call made to pre_req(), call post_req() with
* a nonzero err condition.
*/
void (*post_req)(struct mmc_host *host, struct mmc_request *req,
int err);
void (*pre_req)(struct mmc_host *host, struct mmc_request *req,
bool is_first_req);
void (*request)(struct mmc_host *host, struct mmc_request *req);
pre_req和post_req是非必需的，host driver可以利用它们实现诸如双buffer之类的高级功能。
数据传输的主题是struct mmc_request类型的指针，具体可参考3.7小节的介绍。
2）总线参数的配置以及卡状态的获取函数
/*
* Avoid calling these three functions too often or in a “fast path”,
* since underlaying controller might implement them in an expensive
* and/or slow way.
*
* Also note that these functions might sleep, so don’t call them
* in the atomic contexts!
*
* Return values for the get_ro callback should be:
* 0 for a read/write card
* 1 for a read-only card
* -ENOSYS when not supported (equal to NULL callback)
* or a negative errno value when something bad happened
*
* Return values for the get_cd callback should be:
* 0 for a absent card
* 1 for a present card
* -ENOSYS when not supported (equal to NULL callback)
* or a negative errno value when something bad happened
*/
void (*set_ios)(struct mmc_host *host, struct mmc_ios *ios);
int (*get_ro)(struct mmc_host *host);
int (*get_cd)(struct mmc_host *host);
set_ios用于设置bus的参数（ios，可参考3.5小节的介绍）；get_ro可获取card的读写状态（具体可参考上面的注释）；get_cd用于检测卡的存在状态。
注4：注释中特别说明了，这几个函数可以sleep，耗时较长，没事别乱用。
3）其它一些非主流函数，都是optional的，用到的时候再去细看即可。
3.3 struct mmc_pwrseq
MMC framework的power sequence是一个比较有意思的功能，它提供一个名称为struct mmc_pwrseq_ops的操作函数集，集合了power on、power off等操作函数，用于控制MMC系统的供电，如下：
struct mmc_pwrseq_ops {
void (*pre_power_on)(struct mmc_host *host);
void (*post_power_on)(struct mmc_host *host);
void (*power_off)(struct mmc_host *host);
void (*free)(struct mmc_host *host);
};struct mmc_pwrseq {
const struct mmc_pwrseq_ops *ops;
};
与此同时，MMC core提供了一个通用的pwrseq的管理模块（drivers/mmc/core/pwrseq.c），以及一些简单的pwrseq策略（如drivers/mmc/core/pwrseq_simple.c、drivers/mmc/core/pwrseq_emmc.c），最终的目的是，通过一些简单的dts配置，即可正确配置MMC的供电，例如：
/* arch/arm/boot/dts/omap3-igep0020.dts /
mmc2_pwrseq: mmc2_pwrseq {
compatible = “mmc-pwrseq-simple”;
reset-gpios = <&gpio5 11 GPIO_ACTIVE_LOW>, / gpio_139 - RESET_N_W /
<&gpio5 10 GPIO_ACTIVE_LOW>; / gpio_138 - WIFI_PDN */
};/* arch/arm/boot/dts/rk3288-veyron.dtsi */
emmc_pwrseq: emmc-pwrseq {
compatible = “mmc-pwrseq-emmc”;
pinctrl-0 = <&emmc_reset>;
pinctrl-names = “default”;
reset-gpios = <&gpio2 9 GPIO_ACTIVE_HIGH>;
};
具体的细节，在需要的时候，阅读代码即可，这里不再赘述。
3.4 Host capabilities
通过的caps和caps2两个字段，MMC host driver可以告诉MMC core控制器的一些特性、能力，包括（具体可参考include/linux/mmc/host.h中相关的宏定义，更为细致的使用场景和指南，需要结合实际的硬件，具体分析）：
MMC_CAP_4_BIT_DATA，支持4-bit的总线传输；
MMC_CAP_MMC_HIGHSPEED，支持“高速MMC时序”；
MMC_CAP_SD_HIGHSPEED，支持“高速SD时序”；
MMC_CAP_SDIO_IRQ，可以产生SDIO有关的中断；
MMC_CAP_SPI，仅仅支持SPI协议（可参考“drivers/mmc/host/mmc_spi.c”中有关的实现）；
MMC_CAP_NEEDS_POLL，表明需要不停的查询卡的插入状态（如果需要支持热拔插的卡，则需要设置该feature）；
MMC_CAP_8_BIT_DATA，支持8-bit的总线传输；
MMC_CAP_AGGRESSIVE_PM，支持比较积极的电源管理策略（kernel的注释为“Suspend (e)MMC/SD at idle”）；
MMC_CAP_NONREMOVABLE，表明该MMC控制器所连接的卡是不可拆卸的，例如eMMC；
MMC_CAP_WAIT_WHILE_BUSY，表面Host controller在向卡发送命令时，如果卡处于busy状态，是否等待。如果不等待，MMC core在一些流程中（如查询busy状态），需要额外做一些处理；
MMC_CAP_ERASE，表明该MMC控制器允许执行擦除命令；
MMC_CAP_1_8V_DDR，支持工作电压为1.8v的DDR（Double Data Rate）mode[3]；
MMC_CAP_1_2V_DDR，支持工作电压为1.2v的DDR（Double Data Rate）mode[3]；
MMC_CAP_POWER_OFF_CARD，可以在启动之后，关闭卡的供电（一般只有在SDIO的应用场景中才可能用到，因为SDIO所连接的设备可能是一个独立的设备）；
MMC_CAP_BUS_WIDTH_TEST，支持通过CMD14和CMD19进行总线宽度的测试，以便选择一个合适的总线宽度进行通信；
MMC_CAP_UHS_SDR12、MMC_CAP_UHS_SDR25、MMC_CAP_UHS_SDR50、MMC_CAP_UHS_SDR104，它们是SD3.0的速率模式，分别表示支持25MHz、50MHz、100MHz和208MHz的SDR（Single Data Rate，相对[3]中的DDR）模式；
MMC_CAP_UHS_DDR50，它也是SD3.0的速率模式，表示支持50MHz的DDR（Double Data Rate[3]）模式；
MMC_CAP_DRIVER_TYPE_A、MMC_CAP_DRIVER_TYPE_C、MMC_CAP_DRIVER_TYPE_D，分别表示支持A/C/D类型的driver strength（驱动能力，具体可参考相应的spec）；
MMC_CAP_CMD23，表示该controller支持multiblock transfers（通过CMD23）；
MMC_CAP_HW_RESET，支持硬件reset；MMC_CAP2_FULL_PWR_CYCLE，表示该controller支持从power off到power on的完整的power cycle；
MMC_CAP2_HS200_1_8V_SDR、MMC_CAP2_HS200_1_2V_SDR，HS200是eMMC5.0支持的一种速率模式，200是200MHz的缩写，分别表示支持1.8v和1.2v的SDR模式；
MMC_CAP2_HS200，表示同时支持MMC_CAP2_HS200_1_8V_SDR和MMC_CAP2_HS200_1_2V_SDR；
MMC_CAP2_HC_ERASE_SZ，支持High-capacity erase size；
MMC_CAP2_CD_ACTIVE_HIGH，CD（Card-detect）信号高有效；
MMC_CAP2_RO_ACTIVE_HIGH，RO（Write-protect）信号高有效；
MMC_CAP2_PACKED_RD、MMC_CAP2_PACKED_WR，允许packed read、packed write；
MMC_CAP2_PACKED_CMD，同时支持DMMC_CAP2_PACKED_RD和MMC_CAP2_PACKED_WR；
MMC_CAP2_NO_PRESCAN_POWERUP，在scan之前不要上电；
MMC_CAP2_HS400_1_8V、MMC_CAP2_HS400_1_2V，HS400是eMMC5.0支持的一种速率模式，400是400MHz的缩写，分别表示支持1.8v和1.2v的HS400模式；
MMC_CAP2_HS400，同时支持MMC_CAP2_HS400_1_8V和MMC_CAP2_HS400_1_2V；
MMC_CAP2_HSX00_1_2V，同时支持MMC_CAP2_HS200_1_2V_SDR和MMC_CAP2_HS400_1_2V；
MMC_CAP2_SDIO_IRQ_NOTHREAD，SDIO的IRQ的处理函数，不能在线程里面执行；
MMC_CAP2_NO_WRITE_PROTECT，没有物理的RO管脚，意味着任何时候都是可以读写的；
MMC_CAP2_NO_SDIO，在初始化的时候，不会发送SDIO相关的命令（也就是说不支持SDIO模式）。
3.5 struct mmc_ios
struct mmc_ios中保存了MMC总线当前的配置情况，包括如下信息：
1）clock，时钟频率。
2）vdd，卡的供电电压，通过“1 << vdd”可以得到MMC_VDD_x_x（具体可参考include/linux/mmc/host.h中MMC_VDD_开头的定义），进而得到电压信息。
3）bus_mode，两种信号模式，open-drain（MMC_BUSMODE_OPENDRAIN）和push-pull（MMC_BUSMODE_PUSHPULL），对应不同的高低电平（可参考相应的spec，例如[2]）。
4）chip_select，只针对SPI模式，指定片选信号的有效模式，包括没有片选信号（MMC_CS_DONTCARE）、高电平有效（MMC_CS_HIGH）、低电平有效（MMC_CS_LOW）。
5）power_mode，当前的电源状态，包括MMC_POWER_OFF、MMC_POWER_UP、MMC_POWER_ON和MMC_POWER_UNDEFINED。
6）bus_width，总线的宽度，包括1-bit（MMC_BUS_WIDTH_1）、4-bit（MMC_BUS_WIDTH_4）和8-bit（MMC_BUS_WIDTH_8）。
7）timing，符合哪一种总线时序（大多对应某一类MMC规范），包括：
MMC_TIMING_LEGACY，旧的、不再使用的规范；
MMC_TIMING_MMC_HS，High speed MMC规范（具体可参考相应的spec，这里不再详细介绍，下同）；
MMC_TIMING_SD_HS，High speed SD；
MMC_TIMING_UHS_SDR12；
MMC_TIMING_UHS_SDR25
MMC_TIMING_UHS_SDR50
MMC_TIMING_UHS_SDR104
MMC_TIMING_UHS_DDR50
MMC_TIMING_MMC_DDR52
MMC_TIMING_MMC_HS200
MMC_TIMING_MMC_HS400
8）signal_voltage，总线信号使用哪一种电压，3.3v（MMC_SIGNAL_VOLTAGE_330）、1.8v（MMC_SIGNAL_VOLTAGE_180）或者1.2v（MMC_SIGNAL_VOLTAGE_120）。
9）drv_type，驱动能力，包括：
MMC_SET_DRIVER_TYPE_B
MMC_SET_DRIVER_TYPE_A
MMC_SET_DRIVER_TYPE_C
MMC_SET_DRIVER_TYPE_D
3.6 struct mmc_supply
struct mmc_supply中保存了两个struct regulator指针（如下），用于控制MMC子系统有关的供电（vmmc和vqmmc）。
struct mmc_supply {
struct regulator vmmc; / Card power supply */
struct regulator vqmmc; / Optional Vccq supply */
};
关于vmmc和vqmmc，说明如下：
vmmc是卡的供电电压，一般连接到卡的VDD管脚上。而vqmmc则用于上拉信号线（CMD、CLK和DATA[6]）。
通常情况下vqmmc使用和vmmc相同的regulator，同时供电即可。
后来，一些高速卡（例如UHS SD）要求在高速模式下，vmmc为3.3v，vqmmc为1.8v，这就需要两个不同的regulator独立控制。
3.7 struct mmc_request
struct mmc_request封装了一次传输请求，定义如下：
/* include/linux/mmc/core.h */
struct mmc_request {
struct mmc_command sbc; / SET_BLOCK_COUNT for multiblock */
struct mmc_command *cmd;
struct mmc_data *data;
struct mmc_command *stop; struct completion completion;
void (*done)(struct mmc_request );/ completion function */
struct mmc_host *host;
};
要理解这个数据结构，需要先了解MMC的总线协议（bus protocol），这里以eMMC[2]为例进行简单的介绍（更为详细的解释，可参考相应的spec以及本站的文章–“eMMC 原理 4 ：总线协议[7]”）。
3.7.1 MMC bus protocol
在eMMC的spec中，称总线协议为“message-based MultiMediaCard bus protocol”，这里的message由三种信标（token）组成：
Command，用于启动（或者停止）一次传输，由Host通过CMD line向Card发送；
Response，用于应答上一次的Command，由Card通过CMD line想Host发送；
Data，传输数据，由Host（或者Card）通过DATA lines向Card（或者Host发送）。
以上token除了Command之外，剩余的两个（Response和Data）都是非必需的，也就是说，一次传输可以是：不需要应答、不需要数据传输的Command；需要应答、不需要数据传输的Command；不需要应答、需要数据传输的Command；不需要应答、不需要数据传输的Command。
Command token的格式只有一种（具体可参考[2]中“Command token format”有关的表述），长度为48bits，包括Start bit(0)、Transmitter bit(1, host command)、Content(38bits)、CRC checksum(7bits)、Stop bit(1)。
根据内容的不同，Response token的格式有5中，分别简称为R1/R3/R4/R5/R2，其中R1/R3/R4/R5的长度为48bits，R2为136bits（具体可参考[2]中“Response token format”有关的表述）。
对于包含了Data token的Command，有两种类型：
Sequential commands，发送Start command之后，数据以stream的形式传输，直到Stop command为止。这种方式只支持1-bit总线模式，主要为了兼容旧的技术，一般不使用；
Block-oriented commands，发送Start command之后，数据以block的形式传输（每个block的大小是固定的，且都由CRC保护）。
最后，以block为单位的传输，大体上也分为两类：
在传输开始的时候（Start command），没有指定需要传输的block数目，直到发送Stop command为止。这种方法在spec中称作“Open-ended”；
在传输开始的时候（Start command），指定需要传输的block数据，当达到数据之后，Card会自动停止传输，这样可以省略Stop command。这种方法在spec中称作pre-defined block count。
3.7.2 struct mmc_request
了解MMC bus protocol之后，再来看一次MMC传输请求（struct mmc_request ）所包含的内容：
cmd，Start command，为struct mmc_command类型（具体请参考3.7.3中的介绍）的指针，在一次传输的过程中是必须的；
data，传输的数据，为struct mmc_data类型（具体请参考3.7.4中的介绍）的指针，不是必须要的；
stop、sbc，如果需要进行数据传输，根据数据传输的方式（参考3.7.1中的介绍）：如果是“Open-ended”，则需要stop命令（stop指针，或者data->stop指针）；如果是pre-defined block count，则需要sbc指针（用于发送SET_BLOCK_COUNT–CMD23命令）；
completion，一个struct completion变量，用于等待此次传输完成，host controller driver可以根据需要使用；
done，传输完成时的回调，用于通知传输请求的发起者；
host，对应的mmc host controller指针。
3.7.3 struct mmc_command
struct mmc_command结构抽象了一个MMC command，包括如下内容：
/* include/linux/mmc/core.h */
opcode，Command的操作码，用于标识该命令是哪一个命令，具体可参考相应的spec（例如[2]）；
arg，一个Command可能会携带参数，具体可参考相应的spec（例如[2]）；
resp[4]，Command发出后，如果需要应答，结果保存在resp数组中，该数组是32-bit的，因此最多可以保存128bits的应答；
flags，是一个bitmap，保存该命令所期望的应答类型，例如：
MMC_RSP_PRESENT（1 << 0)，是否需要应答，如果该bit为0，则表示该命令不需要应答，否则，需要应答；
MMC_RSP_136（1 << 1），如果为1，表示需要136bits的应答；
MMC_RSP_CRC（1 << 2），如果为1，表示需要对该命令进行CRC校验；
等等，具体可参考include/linux/mmc/core.h中“MMC_RSP_”开头的定义；retries，如果命令发送出错，可以重新发送，该字段向host driver指明最多可重发的次数；
error，如果最终还是出错，host driver需要通过该字段返回错误的原因，kernel定义了一些标准错误，例如ETIMEDOUT、EILSEQ、EINVAL、ENOMEDIUM等，具体含义可参考include/linux/mmc/core.h中注释；
busy_timeout，如果card具有busy检测的功能，该字段指定等待card返回busy状态的超时时间，单位为ms；
data，和该命令对应的struct mmc_data指针；
mrq，和该命令对应的struct mmc_request指针。
3.7.4 struct mmc_data
struct mmc_data结构包含了数据传输有关的内容：
/* include/linux/mmc/core.h */
timeout_ns、timeout_clks，这一笔数据传输的超时时间（单位分别为ns和clks），如果超过这个时间host driver还无法成功发送，则要将状态返回给mmc core；
blksz、blocks，该笔数据包含多少block（blocks），每个block的size多大（blksz），这两个值不会大于struct mmc_host中上报的max_blk_size和max_blk_count；
error，如果数据传输出错，错误值保存在该字段，具体意义和struct mmc_command中的一致；
flags，一个bitmap，指明该笔传说的方向（MMC_DATA_WRITE或者MMC_DATA_READ）；
sg，一个struct scatterlist类型的数组，保存了需要传输的数据（可以通过dma_相关的接口，获得相应的物理地址）；
sg_len，sg数组的size；
sg_count，通过sg map出来的实际的entry的个数（可能由于物理地址的连续、IOMMU的干涉等，map出来的entry的个数，可能会小于sg的size）；
注5：有关scatterlist的介绍，可参考本站另外的文章（TODO）。有关struct mmc_data的使用场景，可参考5.2小节的介绍；host_cookie，host driver的私有数据，怎么用由host driver自行决定。
4. 主要API
第3章花了很大的篇幅介绍了用于抽象MMC host的数据结构----struct mmc_host，并详细说明了和mmc_host相关的mmc request、mmc command、mmc data等结构。基于这些知识，本章将介绍MMC core提供的和struct mmc_host有关的操作函数，主要包括如下几类。
4.1 向MMC host controller driver提供的用于操作struct mmc_host的API
包括：
struct mmc_host *mmc_alloc_host(int extra, struct device *); int mmc_add_host(struct mmc_host *); void mmc_remove_host(struct mmc_host *); void mmc_free_host(struct mmc_host *); int mmc_of_parse(struct mmc_host *host); static inline void *mmc_priv(struct mmc_host *host) { return (void *)host->private; }
mmc_alloc_host，动态分配一个struct mmc_host变量。extra是私有数据的大小，可通过host->private指针访问（也可通过mmc_priv接口直接获取）。mmc_free_host执行相反动作。
mmc_add_host，将已初始化好的host变量注册到kernel中。mmc_remove_host执行相反动作。
为了方便，host controller driver可以在dts中定义host的各种特性，然后在代码中调用mmc_of_parse解析并填充到struct mmc_host变量中。dts属性关键字可参考mmc_of_parse的source code（drivers/mmc/core/host.c），并结合第三章的内容自行理解。
int mmc_power_save_host(struct mmc_host *host); int mmc_power_restore_host(struct mmc_host *host);
从mmc host的角度进行电源管理，进入/退出power save状态。
void mmc_detect_change(struct mmc_host *, unsigned long delay);
当host driver检测到总线上的设备有变动的话（例如卡的插入和拔出等），需要调用这个接口，让MMC core帮忙做后续的工作，例如检测新插入的卡到底是个什么东东……
另外，可以通过delay参数告诉MMC core延时多久（单位为jiffies）开始处理，通常可以用来对卡的拔插进行去抖动。
void mmc_request_done(struct mmc_host *, struct mmc_request *);
当host driver处理完成一个mmc request之后,需要调用该函数通知MMC core，MMC core会进行一些善后的操作，例如校验结果、调用mmc request的.done回调等等。
static inline void mmc_signal_sdio_irq(struct mmc_host *host) void sdio_run_irqs(struct mmc_host *host);
对于SDIO类型的总线，这两个函数用于操作SDIO irqs，后面用到的时候再分析。
int mmc_regulator_get_ocrmask(struct regulator *supply); int mmc_regulator_set_ocr(struct mmc_host *mmc, struct regulator *supply, unsigned short vdd_bit); int mmc_regulator_set_vqmmc(struct mmc_host *mmc, struct mmc_ios *ios); int mmc_regulator_get_supply(struct mmc_host *mmc);
regulator有关的辅助函数：
mmc_regulator_get_ocrmask可根据传入的regulator指针，获取该regulator支持的所有电压值，并以此推导出对应的ocr mask（可参考3.1中的介绍）。
mmc_regulator_set_ocr用于设置host controller为某一个操作电压（vdd_bit），该接口会调用regulator framework的API，进行具体的电压切换。
mmc_regulator_set_vqmmc可根据struct mmc_ios信息，自行调用regulator framework的接口，设置vqmmc的电压。
最后，mmc_regulator_get_supply可以帮忙从dts的vmmc、vqmmc属性值中，解析出对应的regulator指针，以便后面使用。
4.2 用于判断MMC host controller所具备的能力的API
比较简单，可结合第3章的介绍理解：
#define mmc_host_is_spi(host) ((host)->caps & MMC_CAP_SPI) static inline int mmc_card_is_removable(struct mmc_host *host) static inline int mmc_card_keep_power(struct mmc_host *host) static inline int mmc_card_wake_sdio_irq(struct mmc_host *host) static inline int mmc_host_cmd23(struct mmc_host *host) static inline int mmc_boot_partition_access(struct mmc_host *host) static inline int mmc_host_uhs(struct mmc_host *host) static inline int mmc_host_packed_wr(struct mmc_host *host) static inline int mmc_card_hs(struct mmc_card *card) static inline int mmc_card_uhs(struct mmc_card *card) static inline bool mmc_card_hs200(struct mmc_card *card) static inline bool mmc_card_ddr52(struct mmc_card *card) static inline bool mmc_card_hs400(struct mmc_card *card) static inline void mmc_retune_needed(struct mmc_host *host) static inline void mmc_retune_recheck(struct mmc_host *host)
5. MMC host驱动的编写步骤
经过上面章节的描述，相信大家对MMC controller driver有了比较深的理解，接下来驱动的编写就是一件水到渠成的事情了。这里简要描述一下驱动编写步骤，也顺便为本文做一个总结。
5.1 struct mmc_host的填充和注册
编写MMC host驱动的所有工作，都是围绕struct mmc_host结构展开的。在对应的platform driver的probe函数中，通过mmc_alloc_host分配一个mmc host后，我们需要根据controller的实际情况，填充对应的字段。
mmc host中大部分和controller能力/特性有关的字段，可以通过dts配置（然后在代码中调用mmc_of_parse自动解析并填充），举例如下（注意其中红色的部分，都是MMC framework的标准字段）：
/* arch/arm/boot/dts/exynos5420-peach-pit.dts */
&mmc_1 {
status = “okay”;
num-slots = <1>;
non-removable;
cap-sdio-irq;
keep-power-in-suspend;
clock-frequency = <400000000>;
samsung,dw-mshc-ciu-div = <1>;
samsung,dw-mshc-sdr-timing = <0 1>;
samsung,dw-mshc-ddr-timing = <0 2>;
pinctrl-names = “default”;
pinctrl-0 = <&sd1_clk>, <&sd1_cmd>, <&sd1_int>, <&sd1_bus1>,
<&sd1_bus4>, <&sd1_bus8>, <&wifi_en>;
bus-width = <4>;
cap-sd-highspeed;
mmc-pwrseq = <&mmc1_pwrseq>;
vqmmc-supply = <&buck10_reg>;
};
5.2 数据传输的实现
填充struct mmc_host变量的过程中，工作量最大的，就是对struct mmc_host_ops的实现（毫无疑问！所有MMC host的操作逻辑都封在这里呢！！）。这里简单介绍一下相关的概念，具体的驱动编写步骤，后面文章会结合“X Project”详细描述。
5.2.1 Sectors（扇区）、Blocks（块）以及Segments（段）的理解
我们在3.1小节介绍struct mmc_host的时候，提到了max_seg_size、max_segs、max_req_size、max_blk_size、max_blk_count等参数。这和磁盘设备（块设备）中Sectors、Blocks、Segments等概念有关，下面简单介绍一下：
1）Sectors
Sectors是存储设备访问的基本单位。
对磁盘、NAND等块设备来说，Sector的size是固定的，例如512、2048等。
对存储类的MMC设备来说，按理说也应有固定size的sector。但因为有MMC协议的封装，host驱动以及上面的块设备驱动，不需要关注物理的size。它们需要关注的就是bus上的数据传输单位（具体可参考MMC protocol的介绍[7]）。
最后，对那些非存储类的MMC设备来说，完全没有sector的概念了。
2） Blocks
Blocks是数据传输的基本单位，是VFS（虚拟文件系统）抽象出来的概念，是纯软件的概念，和硬件无关。它必须是2的整数倍、不能大于Sectors的单位、不能大于page的长度，一般为512B、2048B或者4096B。
对MMC设备来说，由于协议的封装，淡化了Sector的概念，或者说，MMC设备可以支持一定范围内的任意的Block size。Block size的范围，由两个因素决定：
a）host controller的能力，这反映在struct mmc_host结构的max_blk_size字段上。
b）卡的能力，这可以通过MMC command从卡的CSD（Card-Specific Data）寄存器中读出。
3）Segments[8]
块设备的数据传输，本质上是设备上相邻扇区与内存之间的数据传输。通常情况下，为了提升性能，数据传输通过DMA方式。
在磁盘控制器的旧时代，DMA操作都比较简单，每次传输，数据在内存中必须是连续的。现在则不同，很多SOC都支持“分散/聚合”（scatter-gather）DMA操作，这种操作模式下，数据传输可以在多个非连续的内存区域中进行。
对于每个“分散/聚合”DMA操作，块设备驱动需要向控制器发送：
a）初始扇区号和传输的总共扇区数
b）内存区域的描述链表，每个描述都包含一个地址和长度。不同的描述之间，可以在物理上连续，也可以不连续。控制器来管理整个数据传输，例如：在读操作中，控制器从块设备相邻的扇区上读取数据，然后将数据分散存储在内存的不同区域。
这里的每个内存区域描述（物理连续的一段内存，可以是一个page，也可以是page的一部分），就称作Segment。一个Segment包含多个相邻扇区。
最后，利用“分散/聚合”的DMA操作，一次数据传输可以会涉及多个segments。
理解了Segment的概念之后，max_seg_size和max_segs两个字段就好理解了：
虽然控制器支持“分散/聚合”的DMA操作，但物理硬件总有限制，例如最大的Segment size（也即一个内存描述的最大长度），最多支持的segment个数（max_segs）等。
5.2.2 struct mmc_data中的sg
我们在3.7.4小节介绍struct mmc_data时，提到了scatterlist的概念。结合上面Segment的解释，就很好理解了：
MMC core提交给MMC host driver的数据传输请求，是一个struct scatterlist链表（也即内存区域的描述链表），也可以理解为是一个个的Segment（Segment的个数保存在sg_len变量中了）。
每个Segment是一段物理地址连续的内存区域，所有的Segments对应了MMC设备中连续的Sector（或者说Block，初始扇区号和传输的总共扇区数已经在之前的MMC command中指定了。
host driver在接收到这样的数据传输请求之后，需要调用dma_map_sg将这些Segment映射出来（获得相应的物理地址），以便交给MMC controller传输。
当然，相邻两个Segment的物理地址可能是连续（或者其它原因），map的时候可能会将两个Segment合成一个。因此可供MMC controller传输的内存片可能少于sg_len（具体要看dma_map_sg的返回值，可将结果保存在sg_count中）。
最后，如何实施传输，则要看具体的MMC controller的硬件实现（可能涉及DMA操作），后面文章再详细介绍。
扫卡流程(或许错误):
sdhci_s3c_probe->sdhci_add_host->mmc_start->_mmc_detect_change
10.函数调用过程
1.rk3308b函数调用过程
dw_mci_init
dw_mci_probe
dw_mci_init_slot
mmc_alloc_host
INIT_DELAYED_WORK(&host->detect, mmc_rescan);//这里绑定mmc_rescan
mmc_add_host //(rk将host导出了primary_sdio_host)
mmc_start_host
mmc_detect_change
_mmc_detect_change
mmc_schedule_delayed_work(&host->detect, delay);(mmc_alloc_host中默认将host->detect工作设置为mmc_rescan)
电源管理：
mmc_power_up
mmc_pwrseq_pre_power_on
pwrseq->ops->pre_power_on(host);
.pre_power_on = mmc_pwrseq_simple_pre_power_on
mmc_pwrseq_simple_pre_power_on
mmc_pwrseq_post_power_on
pwrseq->ops->post_power_on(host);
.post_power_on = mmc_pwrseq_simple_post_power_on
mmc_pwrseq_simple_post_power_on
mmc_power_off
mmc_pwrseq_power_off
pwrseq->ops->power_off(host);
.power_off = mmc_pwrseq_simple_power_off
mmc_pwrseq_simple_power_off
698
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
