当前位置:   article > 正文

LINUX之MMC子系统分析_linux mmc子系统

linux mmc子系统

目录

1. 概念

MMC(Multi-Media Card)子系统是Linux内核中的一个模块,主要用于管理SD卡和eMMC等可移动存储设备。使用MMC子系统可以使得SD卡等存储设备在Linux内核中被识别为一个块设备,并可以使用标准的块设备驱动程序进行管理。同时,MMC子系统也为SDIO卡提供了标准的接口,便于开发各种不同类型的SDIO卡设备驱动。

对与MMC,主要包括几个部分:MMC控制器、MMC总线、card

对于卡而言,包括MMC卡(7pin,支持MMC和spi两种通信模式)、SD卡(9pin,支持sd和spi两种通信模式)、TF卡(8pin,支持sd和spi两种通信模式),这些卡其总线规范类似,都是从MMC总线规范演化过来的

基于MMC这种通信方式,又演化了SDIO,SDIO强调的是IO一种总线,可以链接任何支持SDIO的外设(包括蓝牙设备、wifi设备等)。

CPU、MMC controller、存储设备之间的关联如下图所示,主要包括了MMC controller、总线、存储卡等内容的连接,针对控制器与设备的总线连接,主要包括时钟、数据、命令三种类型的引脚,而这些引脚中的cd引脚主要用于卡的在位检测,当mmc controller检测到该位的变化后,则会进行mmc card的注册或注销操作
在这里插入图片描述
MMC从本质上看,是一种用于固态非易失性存储的内存卡(memory card)规范,定义了诸如卡的形态、尺寸、容量、电气信号、和主机之间的通信协议等方方面面的内容。

从1997年MMC规范发布至今,基于不同的考量(物理尺寸、电压范围、管脚数量、最大容量、数据位宽、clock频率、安全特性、是否支持SPI mode、是否支持DDR[DDR: Dual data rate] mode、等等),进化出了MMC、SD、microSD、SDIO、eMMC等不同的规范。

在这里插入图片描述
下面是不同接口规范的封装引脚和大小对比图,当SD接口要和MMC兼容时,8和9脚留空即可
在这里插入图片描述
MMC、SD、SDIO的技术本质是一样的(使用相同的总线规范,等等),都是从MMC规范演化而来;

MMC强调的是多媒体存储(MM,MultiMedia);
SD强调的是安全和数据保护(S,Secure);
SDIO是从SD演化出来的,强调的是接口(IO,Input/Output),不再关注另一端的具体形态(可以是WIFI设备、Bluetooth设备、GPS等等)。

1.1 MMC卡

MMC(Multimedia Card)卡是一种较早的记忆卡标准,目前已经被SD标准所取代,目前基本上仅存eMMC。卡的管脚有VDD、GND、RST、CLK、CMD和DATA等,VDD和GND提供power,RST用于复位,CLK、CMD和DATA为MMC总线协议的物理通道
在这里插入图片描述

CLK有一条,提供同步时钟,可以在CLK的上升沿(或者下降沿,或者上升沿和下降沿)采集数据;
CMD有一条,用于传输双向的命令。
DATA用于传输双向的数据,根据MMC的类型,可以有一条(1-bit)、四条(4-bit)或者八条(8-bit)。

电压范围为1.65V和3.6V,根据工作电压的不同,MMC卡可以分为两类:
High Voltage MultiMediaCard,工作电压为2.7V~3.6V。
Dual Voltage MultiMediaCard,工作电压有两种,1.70V1.95V和2.7V3.6V,CPU可以根据需要切换。

CLK的频率范围,包括0-20MHz、0-26MHz、0-52MHz等几种,结合数据线宽度,基本决定了MMC的访问速度
在这里插入图片描述
在这里插入图片描述

1.2 SD卡

SD(Secure Digital)是一种flash memory card的标准,是一般常见的SD记忆卡。SD协议支持三种模式:4-wire mode, 1-wire mode, SPI mode。三种模式的信号定义如下:
在这里插入图片描述
在这里插入图片描述
SD卡按供电范围划分,分两种:
High Voltage SD Memory Card: 操作的电压范围在2.7-3.6V
UHS-II SD Memory Card: 操作的电压范围VDD1: 2.7-3.6V, VDD2: 1.70-1.95V

SD卡按总线速度模式来分,有下面几种:
Default Speed mode: 3.3V供电模式,频率上限25MHz,速度上限 12.5MB/sec
High Speed mode: 3.3V供电模式,频率上限50MHz,速度上限 25MB/sec
SDR12: UHS-I卡, 1.8V供电模式,频率上限25MHz,速度上限 12.5MB/sec
SDR25: UHS-I卡, 1.8V供电模式,频率上限50MHz,速度上限 25MB/sec
SDR50: UHS-I卡, 1.8V供电模式,频率上限100MHz,速度上限 50MB/sec
SDR104: UHS-I卡, 1.8V供电模式,频率上限208MHz,速度上限 104MB/sec
DDR50: UHS-I卡, 1.8V供电模式,频率上限50MHz,性能上限 50MB/sec
UHS156: UHS-II RCLK Frequency Range 26MHz - 52MHz, up to 1.56Gbps per lane.

注:UHS(Ultra High Speed)

1.3 SDIO

SDIO(Secure Digital I/O):就是SD的I/O接口(interface)的意思,更具体的说明,SD本来是记忆卡的标准,但是现在也可以把SD拿来插上一些外围接口使用,这样的技术便是SDIO

SDIO总线和USB总线类似,SDIO总线也有两端,其中一端是主机(HOST)端,另一端是设备端(DEVICE),采用HOST- DEVICE这样的设计是为了简化DEVICE的设计,所有的通信都是由HOST端发出命令开始的。在DEVICE端只要能解析HOST的命令,就可以同HOST进行通信了,SDIO的HOST可以连接多个DEVICE

2. 总线协议

2.1 协议

SDIO(EMMC通用,只不过数据线不一样)协议,其中包括“无数据传输的一般命令”,“有数据传输的写命令”,“有数据传输的读命令”。协议包含三个要素:命令Command,应答Response和数据Data。

Command:由HOST发送,DEVICE接收,在CMD信号线上传输。每一个命令Token都由一个起始位(’0’)前导,以一个停止位(’1’)终止。总长度是48比特。每一个Token都用CRC保护,因此可以检测到传输错误,可重复操作。
在这里插入图片描述
Response:由DEVICE发送,HOST接收,在CMD信号线上传输。应答根据不同命令分为4种(R1R3,R6)/EMMC有5种(R1R5),长度有48位或136位。
在这里插入图片描述
Data:数据是双向的传送的。可以设置为1线/4线模式,eMMC可以8线。数据是通过DAT0-DAT3/ DAT7信号线传输的(注:下图是SDR[区别DDR是时钟上下沿都进行通信]通信模式)。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.2 一般协议

一般协议传输无应答(no response)命令和无数据(no data)命令。无应答命令只需要传输CMD,不需要应答,命令即携带了所有信息。无数据命令需要在CMD传输之后,返回相应的应答,但无数据传输。应答格式有多种
在这里插入图片描述

2.3 写数据

写数据的传输是分块进行的。数据块后面总是跟着CRC位。定义了单块和多块操作。多块操作模式更适合更快的写入操作。当CMD线路上出现停止命令时,多块传输终止。块写操作期间通过 Data0 信号线指示Busy 状态。
在这里插入图片描述

2.4 读数据

当无数据传输时,DAT0-DAT7总线上为高电平。传输数据块由各个DAT线上的起始位(低),以及随后连续的数据流所组成。数据流以各条线上的停止位(高)终结。数据传输是以时钟信号同步的
在这里插入图片描述

2.5 卡模式

除通用的协议之外,eMMC和SDIO协议已有较大不同,因此需要分别说明,比如卡模式,SD卡有3种eMMC有5种(3种和SD卡模式相同,另外多出2种),并且有各自不同的卡状态。

2.5.1 SD卡模式

非活动模式:设备工作电压范围或访问模式无效,则设备进入非活动模式。设备也可以通过使用GO_INACTIVE_STATE命令(CMD15)进入非活动模式

设备识别模式:复位后,Host 处于卡识别模式,寻找总线上的新卡。卡将处于这个模式,直到接收到Send_RCA命令(CMD3)

数据传输模式:卡的 RCA 首次发布后,卡进入数据传输模式。Host 识别完毕总线上的所有卡后,进入数据传输模式

在这里插入图片描述

2.5.2 eMMC模式

引导模式:上电周期后,接受参数为0xF0F0F0F0的CMD0或硬件复位信号有效,设备处于引导模式。

设备识别模式:在引导模式结束或主机、设备不支持引导操作模式时,设备处于设备识别模式。设备将在此模式下,直至接收到SET_RCA命令(CMD3)。在设备识别模式下,主机复位设备,验证工作电压范围和访问模式,识别设备并为总线上的设备分配相对设备地址(RCA)在设备识别模式下的所有数据通讯都仅采用命令线CMD

中断模式:主机与设备同时进入中断模式。在中断模式下没有数据传输。唯一允许的消息是来自主机或设备的中断服务请求。e•MMC系统的中断模式使主机能够向从机(设备)授予同时传输的许可。这种模式减少了主机轮询的负担,因而降低了系统功耗,同时保持了主机对设备服务请求的足够的责任。支持e•MMC中断模式是可选的,对主机和设备都是如此

数据传输模式:一旦分配了RCA,设备就进入数据传输模式。主机在识别总线上的设备后即进入数据传输模式。当设备处于stand-by状态,在CMD和DAT线上的通讯都将以推拉模式执行。直到主机知道CSD寄存器内容之前,fPP时钟速率都必须保持在fOD。主机发送SEND_CSD(CMD9)来获取设备专用数据(CSD寄存器),如块长度、设备存储容量、最大时钟速率等等。
当设备处于Stand-by状态时,CMD7被用于通过参数中包含设备的相对地址来选定设备并将其置于Transfer状态。如果设备此前已经被选定并处于Transfer状态,则当CMD7通过参数中不等于该设备自己相对地址的任意地址来取消选定时,它与主机的连接被释放,并返回Stand-by状态。当CMD7以保留的相对设备地址0x0000发送时,该设备返回Stand-by状态。处于Transfer状态的设备接收到有设备自己的相对地址的CMD7时,将忽略该命令,也可能当作非法命令来处理。在设备被分配了一个RCA之后,就不再应答识别命令——CMD1、CMD2和CMD3

非活动模式:如果设备工作电压范围或访问模式无效,则设备进入非活动模式。设备也可以通过使用GO_INACTIVE_STATE命令(CMD15)进入非活动模式。上电周期后,设备将复位到Pre- idle模式。
在这里插入图片描述

2.6 命令

协议定义了4种命令:

  • 无应答广播命令(bc)
  • 有应答广播命令(bcr)
  • 寻址(点对点)命令(ac),无DAT线数据传输
  • 寻址数据传输(点对点)命令(adtc),数据在DAT线传输

所有的命令有固定 48Bit 编码长度,需要传输时间1.92us@25MHz 和0.96us@50MHz
在这里插入图片描述

2.6.1 命令类

在SD协议中Class 0,2,4,5 和8 是强制的,应该被所有的卡支持,在emmc协议中Class 0是必需的,所有的设备均应支持。其他类对特定类型设备可能是必需的,也可能是可选的
在这里插入图片描述

2.6.2 详细命令

下面皆以eMMC为例,CMD0~15为基本命令
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
CMD16~18,CMD21为块读命令
在这里插入图片描述
CMD23~27,块写
在这里插入图片描述
CMD35,CMD36,CMD38块擦除
在这里插入图片描述
在这里插入图片描述

2.7 应答

所有的应答均通过命令线CMD发送。编码长度取决于应答类型。应答总是以起始位开始(总是‘0’),紧接表示传输方向的比特(设备= ‘0’)。下面表中标记为 ‘x’ 的值表示一个变量。除R3类型之外,所有应答将被CRC保护。每一个应答编码都以停止位结束(总是‘1’)

R1(正常应答类型):编码长度48 bit。bits 45:40表示应答相对的命令索引数字(0到63)。设备的状态编码用32 bit表示。(R1b额外在数据线 DAT0上发送可选的忙信号,其余与R1相同)
在这里插入图片描述
R2(CID、CSD寄存器):编码长度136 bit。CID寄存器的内容作为对CMD2和CMD10的应答发送。CSD寄存器的内容作为CMD9的应答发送。CID和CSD只有bit [127:1]被发送,保留的bit 0被应答的停止位替代
在这里插入图片描述
R3(OCR寄存器):编码长度48 bit。OCR寄存器的内容作为CMD1的应答发送
在这里插入图片描述
R4(快速I/O):编码长度48 bit。参数域包含被寻址设备的RCA、要读写的寄存器地址及其内容。如果操作成功参数中的结果位被置位。
在这里插入图片描述
R5(中断请求):编码长度48 bit。如果应答是主机生成的,参数中的RCA应为0。
在这里插入图片描述

2.8 寄存器

协议中规定的几个寄存器分别为:OCR、CID、CSD(扩展CSD)、RCA、DSR(可选),和SDIO协议中的SCR。下面皆以eMMC寄存器为例
在这里插入图片描述

2.8.1 OCR

32比特的工作条件寄存器(OCR)寄存着设备的VDD电压概况和访问模式指示。另外,此寄存器包括一个状态信息位。此状态位当设备上电例程结束时置位。所有设备均应实现OCR寄存器。
该寄存器的作用:

  • 存储Vdd电压曲线
  • 存储器件访问模式,从而可以知道器件是否为大容量设备(即设备容量大于2G,只有大容量设备才支持扇区访问模式,小容量设备只支持字节访问模式)
  • 指示设备上电过程(即bit31:如果设备没有完成上电例程,此位设置为低)
    在这里插入图片描述

2.8.2 CID

卡的识别寄存器(CID)是一个128Bit 宽度。其包括了卡的鉴别信息,其用于在卡的鉴别相中。每一个读/写(RW)卡应该有一个唯一的鉴别号。其中MID号由JEDEC管理,分配给eMMC制造商,每个制造商的MID都是独一无二的(同理SD卡的MID由SD-3C控制并分配)。
在这里插入图片描述

2.8.3 CSD

设备专用数据寄存器(CSD)提供设备内容访问方式的信息。CSD定义了数据格式、纠错类型、最长数据访问时间、数据传输速度、DSR寄存器是否可用等等。寄存器可编程的部分(标有W或E的项目,见下)可以用CMD27命令更改。

R: 只读
W: 可一次编程且不可读
R/W: 可一次编程且可读
W/E: 可多次写,其值在掉电、硬件复位和任何CMD0复位后保持,不可读
R/W/E: 可多次写,其值在掉电、硬件复位和任何CMD0复位后保持,可读
R/W/C_P: 在掉电和硬件复位清除值后(值不被CMD0复位清除)可写,可读
R/W/E_P: 可多次写,其值在掉电、硬件复位和任何CMD0复位后复位,可读
W/E_P: 可多次写,其值在掉电、硬件复位和任何CMD0复位后复位,不可读
在这里插入图片描述
在这里插入图片描述

2.8.4 RCA

可写的16-bit 设备相对地址(RCA)寄存器,载有在设备识别期间主机分配的设备地址。此地址用于设备识别例程之后寻址的主机-设备通讯。RCA寄存器缺省值是0x0001。值0x0000是为将所有设备以CMD7置于Stand-by状态而保留的。

2.8.5 扩展CSD

扩展CSD寄存器定义了设备属性和选定的模式。它长512字节。高320字节是属性段,定义了设备能力,不能被主机更改。低192字节是模式段,定义了设备的工作配置。这些模式可以被主机通过SWITCH命令改变。具体寄存器略

3. 关键结构

在这里插入图片描述

3.1 struct sdhci_host

struct sdhci_host {
    /* Data set by hardware interface driver */
    const char *hw_name;    /* Hardware bus name */

	// 癖好,可以理解为硬件sdhci controller和标准sdhci规范不符合的地方
    unsigned int quirks;    /* Deviations from spec. */
    unsigned int quirks2;   /* More deviations from spec. */

	// sdhci的中断
	int irq;        /* Device IRQ */
	// sdhci寄存器的基地址
    void __iomem *ioaddr;   /* Mapped address */
    phys_addr_t mapbase;    /* physical address base */
    char *bounce_buffer;    /* For packing SDMA reads/writes */
    dma_addr_t bounce_addr;
    unsigned int bounce_buffer_size;

	// 底层硬件的操作接口
    const struct sdhci_ops *ops;    /* Low level hw interface */

	// struct mmc_host,用于注册到mmc subsystem中
    /* Internal data */
    struct mmc_host *mmc;   /* MMC structure */
    struct mmc_host_ops mmc_host_ops;   /* MMC host ops */
    u64 dma_mask;       /* custom DMA mask */

    spinlock_t lock;    /* Mutex */

    int flags;      /* Host attributes */
    unsigned int version;   /* SDHCI spec. version */

	// 该sdhci支持的最大时钟频率
	unsigned int max_clk;   /* Max possible freq (MHz) */
	// 超时频率
	unsigned int timeout_clk;   /* Timeout freq (KHz) */
	// 当前倍频值
    unsigned int clk_mul;   /* Clock Muliplier value */
	// 当前工作频率
	unsigned int clock; /* Current clock (MHz) */
	// 当前工作电压
    u8 pwr;         /* Current voltage */

	// 是否支持某些状态
    bool runtime_suspended; /* Host is runtime suspended */
    bool bus_on;        /* Bus power prevents runtime suspend */
    bool preset_enabled;    /* Preset is enabled */
    bool pending_reset; /* Cmd/data reset is pending */
    bool irq_wake_enabled;  /* IRQ wakeup is enabled */
    bool v4_mode;       /* Host Version 4 Enable */
    bool use_external_dma;  /* Host selects to use external DMA */
    bool always_defer_done; /* Always defer to complete requests */

	// 正在处理的请求,允许同一时间存在一个命令请求和数据命令请求
	struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];  /* Requests done */
	// 当前的命令
	struct mmc_command *cmd;    /* Current command */
	struct mmc_command *data_cmd;   /* Current data command */
	// 推迟的命令请求
	struct mmc_command *deferred_cmd;   /* Deferred command */
	// 当前的数据请求
	struct mmc_data *data;  /* Current data request */
	// 表示在CMD处理完成前,data已经处理完成
    unsigned int data_early:1;  /* Data finished before cmd */

    /* 删除部分 */

	// 工作队列,基本上所有事情都在工作队列上实现
    struct workqueue_struct *complete_wq;   /* Request completion wq */
    struct work_struct  complete_work;  /* Request completion work */

	// 两个用于超时的定时器
    struct timer_list timer;    /* Timer for timeouts */
    struct timer_list data_timer;   /* Timer for data timeouts */

	// 表示该sdhci controller的属性
    u32 caps;       /* CAPABILITY_0 */
    u32 caps1;      /* CAPABILITY_1 */
    bool read_caps;     /* Capability flags have been read */
	bool sdhci_core_to_disable_vqmmc;  /* sdhci core can disable vqmmc */
	// 在该sdhci controller上可用的ocr值(代表了其可用电压)
    unsigned int            ocr_avail_sdio; /* OCR bit masks */
    unsigned int            ocr_avail_sd;
    unsigned int            ocr_avail_mmc;
    u32 ocr_mask;       /* available voltages */

    unsigned        timing;     /* Current timing */

    u32         thread_isr;

    /* cached registers */
    u32         ier;
    bool        cqe_on;     /* CQE is operating */
    u32         cqe_ier;    /* CQE interrupt mask */
    u32         cqe_err_ier;    /* CQE error interrupt mask */

    wait_queue_head_t   buf_ready_int;  /* Waitqueue for Buffer Read Ready interrupt */
    unsigned int        tuning_done;    /* Condition flag set when CMD19 succeeds */
    unsigned int        tuning_count;   /* Timer count for re-tuning */
    unsigned int        tuning_mode;    /* Re-tuning mode supported by host */
    unsigned int        tuning_err; /* Error code for re-tuning */
    /* Delay (ms) between tuning commands */
    int         tuning_delay;
    int         tuning_loop_count;

    /* Host SDMA buffer boundary. */
    u32         sdma_boundary;
    /* Host ADMA table count */
    u32         adma_table_cnt;

    u64         data_timeout;

    unsigned long private[] ____cacheline_aligned;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113

3.2 struct sdhci_ops

sdhci core只是提供了一些接口和符合mmc core的操作集方法给对应的host driver使用。由于各个host的硬件有所差异,所以实际和硬件交互的驱动部分还是在host driver中实现。

所以sdhci core要求host提供标准的访问硬件的一些方法。而这些方法就被定义在了struct sdhci_ops结构体内部。

struct sdhci_ops {
#ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
	// 表示host另外提供了一套访问寄存器的方法,
	// 没有定义的话,则说明使用通用的读写寄存器的方法
    u32     (*read_l)(struct sdhci_host *host, int reg);
    u16     (*read_w)(struct sdhci_host *host, int reg);
    u8      (*read_b)(struct sdhci_host *host, int reg);
    void    (*write_l)(struct sdhci_host *host, u32 val, int reg);
    void    (*write_w)(struct sdhci_host *host, u16 val, int reg);
    void    (*write_b)(struct sdhci_host *host, u8 val, int reg);
#endif

	// 设置时钟频率,电源
    void    (*set_clock)(struct sdhci_host *host, unsigned int clock);
    void    (*set_power)(struct sdhci_host *host, unsigned char mode,
                 unsigned short vdd);
	// 平台host的中断回调
    u32     (*irq)(struct sdhci_host *host, u32 intmask);
	// 设置,使能dma
    int     (*set_dma_mask)(struct sdhci_host *host);
	int     (*enable_dma)(struct sdhci_host *host);
	// 获取支持的最大/最小时钟频率
    unsigned int    (*get_max_clock)(struct sdhci_host *host);
    unsigned int    (*get_min_clock)(struct sdhci_host *host);
    /* get_timeout_clock should return clk rate in unit of Hz */
    unsigned int    (*get_timeout_clock)(struct sdhci_host *host);
    unsigned int    (*get_max_timeout_count)(struct sdhci_host *host);
    void        (*set_timeout)(struct sdhci_host *host,
                       struct mmc_command *cmd);
    void        (*set_bus_width)(struct sdhci_host *host, int width);
    void (*platform_send_init_74_clocks)(struct sdhci_host *host,
                         u8 power_mode);
	unsigned int    (*get_ro)(struct sdhci_host *host);
	// 软复位
    void        (*reset)(struct sdhci_host *host, u8 mask);
    int (*platform_execute_tuning)(struct sdhci_host *host, u32 opcode);
	void    (*set_uhs_signaling)(struct sdhci_host *host, unsigned int uhs);
	// 硬复位
    void    (*hw_reset)(struct sdhci_host *host);
    void    (*adma_workaround)(struct sdhci_host *host, u32 intmask);
	void    (*card_event)(struct sdhci_host *host);
	// 电压切换
    void    (*voltage_switch)(struct sdhci_host *host);
    void    (*adma_write_desc)(struct sdhci_host *host, void **desc,
                   dma_addr_t addr, int len, unsigned int cmd);
    void    (*copy_to_bounce_buffer)(struct sdhci_host *host,
                     struct mmc_data *data,
                     unsigned int length);
    void    (*request_done)(struct sdhci_host *host,
                struct mmc_request *mrq);
    void    (*dump_vendor_regs)(struct sdhci_host *host);
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

3.3 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设置
    struct mmc_pwrseq   *pwrseq;
    unsigned int        f_min;  // 该host支持的最低频率
    unsigned int        f_max;  // 该host支持的最大频率
	unsigned int        f_init; // 该host初始化时使用的频率
	/*
	 * OCR(Operating Conditions Register)
	 * 是MMC/SD/SDIO卡的一个32-bit的寄存器,
	 * 其中有些bit指明了该卡的操作电压。
	 * MMC host在驱动这些卡的时候,
	 * 需要和Host自身所支持的电压范围匹配之后,
	 * 才能正常操作,这就是ocr_avail的存在意义
	 */
    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 wakeup_source    *ws;        /* Enable consume of uevents */
    u32         max_current_330;  // 3.3V时的最大电流
    u32         max_current_300;  // 3.0V时的最大电流
    u32         max_current_180;  // 1.8V时的最大电流

	// host属性
    u32         caps;       /* Host capabilities */
    u32         caps2;      /* More host capabilities */

    int         fixed_drv_type; /* fixed driver type for non-removable media */
	// 电源管理属性
    mmc_pm_flag_t       pm_caps;    /* supported pm features */

    /* 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_busy_timeout; /* max busy timeout in ms */

    /* private data */
    spinlock_t      lock;       /* lock for claim and bus ops */
	// 用于保存MMC bus的当前配置
    struct mmc_ios      ios;        /* current io bus settings */

    /* group bitfields together to minimize padding */
	unsigned int        use_spi_crc:1;
	// host是否已经被占用
	unsigned int        claimed:1;  /* host exclusively claimed */
	// host的bus是否处于激活状态
    unsigned int        bus_dead:1; /* bus has been released */
    unsigned int        doing_init_tune:1; /* initial tuning in progress */
    unsigned int        can_retune:1;   /* re-tuning can be used */
    unsigned int        doing_retune:1; /* re-tuning in progress */
    unsigned int        retune_now:1;   /* do re-tuning at next req */
    unsigned int        retune_paused:1; /* re-tuning is temporarily disabled */
    unsigned int        use_blk_mq:1;   /* use blk-mq */
    unsigned int        retune_crc_disable:1; /* don't trigger retune upon crc */
    unsigned int        can_dma_map_merge:1; /* merging can be used */

	// 禁止rescan的标识,禁止搜索card
	int         rescan_disable; /* disable card detection */
	// 是否已经rescan过的标识,对应不可移除的设备只能rescan一次
    int         rescan_entered; /* used with nonremovable devices */

    int         need_retune;    /* re-tuning is needed */
    int         hold_retune;    /* hold off re-tuning */
    unsigned int        retune_period;  /* re-tuning period in secs */
    struct timer_list   retune_timer;   /* for periodic re-tuning */

    bool            trigger_card_event; /* card_event necessary */

	// 和该host绑定在一起的card
    struct mmc_card     *card;      /* device attached to this host */

	wait_queue_head_t   wq;
	// 该host的占有者进程
	struct mmc_ctx      *claimer;   /* context that has host claimed */
	// 占有者进程对该host的占用计数
    int         claim_cnt;  /* "claim" nesting count */
    struct mmc_ctx      default_ctx;    /* default context */

	// 检测卡槽变化的工作
	struct delayed_work detect;
	// 需要检测卡槽变化的标识
	int         detect_change;  /* card detect flag */
	// 卡槽的结构体
    struct mmc_slot     slot;
	// host的mmc总线的操作集
    const struct mmc_bus_ops *bus_ops;  /* current bus driver */
    unsigned int        bus_refs;   /* reference counter */

    unsigned int        sdio_irqs;
    struct task_struct  *sdio_irq_thread;
    struct delayed_work sdio_irq_work;
    bool            sdio_irq_pending;
    atomic_t        sdio_irq_thread_abort;

    mmc_pm_flag_t       pm_flags;   /* requested pm features */

    struct led_trigger  *led;       /* activity led */

#ifdef CONFIG_REGULATOR
    bool            regulator_enabled; /* regulator state */
#endif
    struct mmc_supply   supply;

    struct dentry       *debugfs_root;

    /* Ongoing data transfer that allows commands during transfer */
    struct mmc_request  *ongoing_mrq;

    unsigned int        actual_clock;   /* Actual HC clock rate */

    unsigned int        slotno; /* used for sdio acpi binding */

    int         dsr_req;    /* DSR value is valid */
    u32         dsr;    /* optional driver stage (DSR) value */

    /* Command Queue Engine (CQE) support */
    const struct mmc_cqe_ops *cqe_ops;
    void            *cqe_private;
    int         cqe_qdepth;
    bool            cqe_enabled;
    bool            cqe_on;

    /* Host Software Queue support */
    bool            hsq_enabled;

    unsigned long       private[] ____cacheline_aligned;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134

3.4 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 {
    /*
     * 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是为了实现异步请求处理而设置的
	// 异步请求处理就是指,当另外一个异步请求还没有处理完成的时候,
	// 可以先准备另外一个异步请求而不必等待
    void    (*post_req)(struct mmc_host *host, struct mmc_request *req,
                int err);
	void    (*pre_req)(struct mmc_host *host, struct mmc_request *req);
	// host处理mmc请求的方法,在mmc_start_request中会调用
    void    (*request)(struct mmc_host *host, struct mmc_request *req);
    /* Submit one request to host in atomic context. */
    int (*request_atomic)(struct mmc_host *host,
                  struct mmc_request *req);

    /*
     * 避免过于频繁或在“快速路径”中调用接下来的三个函数,因为底层控制器可能以昂贵
     * 和/或缓慢的方式实现它们。还需要注意的是,这些函数可能会进入睡眠状态,
     * 所以不要在原子上下文中调用它们!
	 */
    // 设置host的总线的io setting
    void    (*set_ios)(struct mmc_host *host, struct mmc_ios *ios);
    // 获取host上的card的读写属性
    int (*get_ro)(struct mmc_host *host);
    // 检测host的卡槽中card的插入状态
    int (*get_cd)(struct mmc_host *host);

    void    (*enable_sdio_irq)(struct mmc_host *host, int enable);
    /* Mandatory callback when using MMC_CAP2_SDIO_IRQ_NOTHREAD. */
    void    (*ack_sdio_irq)(struct mmc_host *host);

    // 初始化card的方法
    void    (*init_card)(struct mmc_host *host, struct mmc_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 */
	// 用于检测card是否处于busy状态
    int (*card_busy)(struct mmc_host *host);

    /* The tuning command opcode value is different for SD and eMMC cards */
    int (*execute_tuning)(struct mmc_host *host, u32 opcode);

    /* Prepare HS400 target operating frequency depending host driver */
    int (*prepare_hs400_tuning)(struct mmc_host *host, struct mmc_ios *ios);

    /* Prepare switch to DDR during the HS400 init sequence */
    int (*hs400_prepare_ddr)(struct mmc_host *host);

    /* Prepare for switching from HS400 to HS200 */
    void    (*hs400_downgrade)(struct mmc_host *host);

    /* Complete selection of HS400 */
    void    (*hs400_complete)(struct mmc_host *host);

    /* Prepare enhanced strobe depending host driver */
    void    (*hs400_enhanced_strobe)(struct mmc_host *host,
                     struct mmc_ios *ios);
    int (*select_drive_strength)(struct mmc_card *card,
                     unsigned int max_dtr, int host_drv,
                     int card_drv, int *drv_type);
    /* Reset the eMMC card via RST_n */
    void    (*hw_reset)(struct mmc_host *host);
    void    (*card_event)(struct mmc_host *host);

    /*
     * Optional callback to support controllers with HW issues for multiple
     * I/O. Returns the number of supported blocks for the request.
     */
    int (*multi_io_quirk)(struct mmc_card *card,
                  unsigned int direction, int blk_size);
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79

3.5 struct mmc_card

struct mmc_card是mmc core由mmc设备抽象出来的card设备的结构体,用于代表一个mmc设备。

struct mmc_card {
	// 该mmc_card所属host
    struct mmc_host     *host;      /* the host this device belongs to */
    struct device       dev;        /* the device */
	u32         ocr;        /* the current OCR setting */
	// 该card的RCA地址
    unsigned int        rca;        /* relative card address of device */
    unsigned int        type;       /* 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 */
    unsigned int        state;      /* (our) card state */
    unsigned int        quirks;     /* card quirks */
    unsigned int        quirk_max_rate; /* max rate set by quirks */

    bool            reenable_cmdq;  /* Re-enable Command Queue */

    unsigned int        erase_size; /* erase size in sectors */
    unsigned int        erase_shift;    /* if erase unit is power 2 */
    unsigned int        pref_erase; /* in sectors */
    unsigned int        eg_boundary;    /* don't cross erase-group boundaries */
    unsigned int        erase_arg;  /* erase / trim / discard */
    u8          erased_byte;    /* value of erased bytes */

	// 原始的各寄存器的值
    u32         raw_cid[4]; /* raw card CID */
    u32         raw_csd[4]; /* raw card CSD */
    u32         raw_scr[2]; /* raw card SCR */
	u32         raw_ssr[16];    /* raw card SSR */
	// 从cid寄存器的值解析出来的信息
	struct mmc_cid      cid;        /* card identification */
	// 从csd寄存器的值解析出来的信息
	struct mmc_csd      csd;        /* card specific */
	// 从ext_csd寄存器的值解析出来的信息
	struct mmc_ext_csd  ext_csd;    /* mmc v4 extended card specific */
	// 外部sdcard的信息
	struct sd_scr       scr;        /* extra SD information */
	// 更多关于sd card的信息
	struct sd_ssr       ssr;        /* yet more SD information */
	// sd的切换属性
    struct sd_switch_caps   sw_caps;    /* switch (CMD6) caps */

    unsigned int        sdio_funcs; /* number of SDIO functions */
    atomic_t        sdio_funcs_probed; /* number of probed SDIO funcs */
    struct sdio_cccr    cccr;       /* common card info */
    struct sdio_cis     cis;        /* common tuple info */
    struct sdio_func    *sdio_func[SDIO_MAX_FUNCS]; /* SDIO functions (devices) */
    struct sdio_func    *sdio_single_irq; /* SDIO function when only one IRQ active */
    u8          major_rev;  /* major revision number */
    u8          minor_rev;  /* minor revision number */
    unsigned        num_info;   /* number of info strings */
    const char      **info;     /* info strings */
    struct sdio_func_tuple  *tuples;    /* unknown common tuples */

    unsigned int        sd_bus_speed;   /* Bus Speed Mode set for the card */
    unsigned int        mmc_avail_type; /* supported device type by both host and card */
    unsigned int        drive_strength; /* for UHS-I, HS200 or HS400 */

	struct dentry       *debugfs_root;
	// 物理分区
	struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
	// 分区数量
    unsigned int    nr_parts;

    unsigned int        bouncesz;   /* Bounce buffer size */
    struct workqueue_struct *complete_wq;   /* Private workqueue */
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68

3.6 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;
	struct completion   cmd_completion;
	// 传输结束后的回调函数
    void            (*done)(struct mmc_request *);/* completion function */
    /*
 * 通知上层(例如mmc块驱动程序)由于与mmc_request相关的错误需要恢复。目前仅由CQE使用。
 */
    void            (*recovery_notifier)(struct mmc_request *);
    struct mmc_host     *host;

    /* Allow other commands during this ongoing data transfer or busy wait */
    bool            cap_cmd_during_tfr;

    int         tag;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

3.7 struct mmc_command

struct mmc_command {
	// 命令的操作码,如MMC_GO_IDLE_STATE、MMC_SEND_OP_COND等等
	u32         opcode;
	// 命令的参数
	u32         arg;  
	// response值
	u32         resp[4];
	// 期待的response的类型
    unsigned int        flags;      /* expected response type */
	// 失败时的重复尝试次数
    unsigned int        retries;    /* max number of retries */
    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        busy_timeout;   /* busy detect timeout in ms */
    struct mmc_data     *data;      /* data segment associated with cmd */
    struct mmc_request  *mrq;       /* associated request */
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

3.8 struct mmc_data

mmc core用struct mmc_data来表示一个命令包

struct mmc_data {
	// 超时时间,以ns为单位
	unsigned int        timeout_ns; /* data timeout (in ns, max 80ms) */
	// 超时时间,以clock为单位
	unsigned int        timeout_clks;   /* data timeout (in clocks) */
	// 块大小
	unsigned int        blksz;      /* data block size */
	// 块数量
    unsigned int        blocks;     /* number of blocks */
    unsigned int        blk_addr;   /* block address */
	int         error;      /* data error */
	// 传输标识
    unsigned int        flags;

    unsigned int        bytes_xfered;

	struct mmc_command  *stop;      /* stop command */
	// 该命令关联到哪个request
    struct mmc_request  *mrq;       /* associated request */

    unsigned int        sg_len;     /* size of scatter list */
    int         sg_count;   /* mapped sg entries */
    struct scatterlist  *sg;        /* I/O scatter list */
    s32         host_cookie;    /* host private data */
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

4. 注册

注册流程按照mmc_host和mmc_core两层分别分析,从mmc_host层的主机控制器的probe开始进行分析。mmc控制器的注册流程如下图所示:
在这里插入图片描述

4.1 mmc_host层

host controller,是指mmc总线上的主机端,mmc总线的控制器,每个host controller对应一条mmc总线。

host controller会控制命令线、数据线和时钟线,从而实现mmc总线上的通讯。 上层发送mmc请求时,就是通过host controller产生对应的mmc通讯时序,下发至mmc设备,与mmc设备通讯。注意,host的部分主要是实现card的通讯和检测,不去负责card的具体功能。

平台实现mmc驱动,核心内容就是要实现host controller的驱动。在mmc subsystem中,把host controller的驱动都放在了/drivers/mmc/host目录下。

一个host driver要做的事情如下:

  • 申请mmc_host
  • 设置mmc_host的成员,包括操作集等等
  • 完成host controller的初始化(哪些方面的初始化)
  • 注册mmc_host,注册之后会去搜索card

再次说明:应实际的card设备(emmc card、sd card),mmc core部分已经实现了其协议中初始化的部分,而其card设备具体功能的实现则是在card模块中进行实现。host驱动只负责card的通讯和检测等等,并不会去实现card的具体功能。

这里我们主要以sdhci类host进行源码分析(SDHC:Secure Digital(SD) Host Controller,是指一套sd host控制器的设计标准,其寄存器偏移以及意义都有一定的规范,并且提供了对应的驱动程序,方便vendor进行host controller的开发)

I. sdhci-xxxx

sdhci-XXXX.c:我们将符合sdhci标准的host称之为sdhci类host。像/drivers/mmc/host目录一些命名为“sdhci-XXXX.c”(sdhci-pltfm除外)的驱动都表示对应的host是sdhci类host。例如我目前使用的平台mmc host设计就使用了sdhci的标准,因此符合的就属于sdhci类host,具体代码对应sdhci-cadence.c。该部分代码通过识别并解析设备树进行probe然后执行sdhci中相关接口(主要是寄存器读写等,填充struct sdhci_ops)进行注册,如下为probe函数分析

static int sdhci_cdns_probe(struct platform_device *pdev)
{
    struct sdhci_host *host;
    const struct sdhci_pltfm_data *data;
    struct sdhci_pltfm_host *pltfm_host;
    struct sdhci_cdns_priv *priv;
    struct clk *clk;
    unsigned int nr_phy_params;
    int ret;
    struct device *dev = &pdev->dev;
    static const u16 version = SDHCI_SPEC_400 << SDHCI_SPEC_VER_SHIFT;

	// 该结构体指向一个 const struct sdhci_ops *ops;
	// 定义了实际上平台操作控制器的实际寄存器读写方法
	data = &sdhci_cdns_pltfm_data;
	// 从设备树中获取对应phy的可能的参数数量,见下图
	nr_phy_params = sdhci_cdns_phy_param_count(dev->of_node);

	// 该函数在pltfm层重点分析
    host = sdhci_pltfm_init(pdev, data,
                struct_size(priv, phy_params, nr_phy_params));
    if (IS_ERR(host)) {
        ret = PTR_ERR(host);
        goto disable_clk;
    }
    // 控制器硬件层面的复位和初始化
    sdhci_mmc_host_reset_init(host);

	// 获取host的私有数据
    pltfm_host = sdhci_priv(host);
    pltfm_host->clk = clk;
	// pltfm的私有数据
    priv = sdhci_pltfm_priv(pltfm_host);
	priv->nr_phy_params = nr_phy_params;
	// sdhci寄存器基址赋值,该ioaddr在sdhci_pltfm_init中获取的
	priv->hrs_addr = host->ioaddr; 
	// 这里实际上说明不支持HS400ES模式
    priv->enhanced_strobe = false;
	host->ioaddr += SDHCI_CDNS_SRS_BASE;
	// HS400和HS400ES模式的切换函数接口
    host->mmc_host_ops.hs400_enhanced_strobe =
                sdhci_cdns_hs400_enhanced_strobe;
	// 使能V4模式
	sdhci_enable_v4_mode(host);
	// 获取控制器版本和特性
    __sdhci_read_caps(host, &version, NULL, NULL);
	// 从设备树中获取部分属性,比如总线宽度,是否需要cd(non-removable),
	// 以及其他的一些标明该路控制器的属性比如no-mmc/no-sdio/no-sd
	// 如果设备树中标明了cd脚,还会申请cd gpio
    ret = mmc_of_parse(host->mmc);
    if (ret)
        goto free;
	// 上面获取数量,这里进行解析,如果没有就拉倒
    sdhci_cdns_phy_param_parse(dev->of_node, priv);
	// 对phy进行相关初始化,如果上面有参数配置的话
    ret = sdhci_cdns_phy_init(priv);
    if (ret)
        goto free;
	// 下面详细分析
    ret = sdhci_add_host(host);
    if (ret)
        goto free;

    return 0;
free:
    sdhci_pltfm_free(pdev);
disable_clk:
    clk_disable_unprepare(clk);
    return ret;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70

在这里插入图片描述

II. sdhci_pltfm

sdhci_pltfm_host:虽然平台host符合sdhci标准,但是有些内容是由平台决定,但是又是sdhci core需要的,这部分内容被封装到sdhci_pltfm_data中。相应的,平台设备的host可以通过sdhci_pltfm_host来实现和sdhci_host的关联,也就是一个中间层。对应代码:drivers/mmc/host/sdhci-pltfm.c

struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev,
                    const struct sdhci_pltfm_data *pdata,
                    size_t priv_size)
{
    struct sdhci_host *host;
    void __iomem *ioaddr;
    int irq, ret;

	// 解析设备树中寄存器基址并直接ioremap
    ioaddr = devm_platform_ioremap_resource(pdev, 0);
    if (IS_ERR(ioaddr)) {
        ret = PTR_ERR(ioaddr);
        goto err;
    }

	// 获取中断号
    irq = platform_get_irq(pdev, 0);
    if (irq < 0) {
        ret = irq;
        goto err;
    }

	// 下面详细分析
    host = sdhci_alloc_host(&pdev->dev,
        sizeof(struct sdhci_pltfm_host) + priv_size);

    if (IS_ERR(host)) {
        ret = PTR_ERR(host);
        goto err;
    }

	// 给申请到的host赋值
    host->ioaddr = ioaddr;
    host->irq = irq;
    host->hw_name = dev_name(&pdev->dev);
    if (pdata && pdata->ops)
        host->ops = pdata->ops;
    else
        host->ops = &sdhci_pltfm_ops;
    if (pdata) {
        host->quirks = pdata->quirks;
        host->quirks2 = pdata->quirks2;
    }

    platform_set_drvdata(pdev, host);

    return host;
err:
    dev_err(&pdev->dev, "%s failed %d\n", __func__, ret);
    return ERR_PTR(ret);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

III. sdhci

sdhci_host:对于sdhci类host(也就是符合sdhci标准)的host来说,直接通过sdhci core来实现host controller的使用。而sdhci core会为对应的host抽象出对应的struct sdhci_host结构体进行管理。对应代码:drivers/mmc/host/sdhci.c

a. sdhci_alloc_host

sdhci_alloc_host为host driver分配一个sdhci_host和mmc_host,并实现其初始化,以及sdhci_host和mmc_host的关联

struct sdhci_host *sdhci_alloc_host(struct device *dev,
    size_t priv_size)
{
	// 以下变量要注意区分
	// host是指要注册的sdhci host
	// mmc是指要注册到mmc subsystem的host,封装在sdhci host中
    struct mmc_host *mmc;
    struct sdhci_host *host;

    WARN_ON(dev == NULL);
	// 分配mmc_host的同时也分配了sizeof(struct sdhci_host) + 
	// priv_size的私有数据空间,这部分就是作为sdhci_host及其私有数据使用的
	// 该函数在mmc_core host中在详细分析
    mmc = mmc_alloc_host(sizeof(struct sdhci_host) + priv_size, dev);
    if (!mmc)
        return ERR_PTR(-ENOMEM);

	// 将sdhci_host作为mmc_host的私有数据,
	// sdhci_host = mmc_host->private
    host = mmc_priv(mmc);
	host->mmc = mmc;
	// sdhci_ops见下图
    host->mmc_host_ops = sdhci_ops;
    mmc->ops = &host->mmc_host_ops;
	// 默认先使用3.3V电压
    host->flags = SDHCI_SIGNALING_330;
	// CQE: Command Queueing Engine,关于CQE的一些配置
    host->cqe_ier     = SDHCI_CQE_INT_MASK;
    host->cqe_err_ier = SDHCI_CQE_INT_ERR_MASK;
	// tuning相关配置,最大tuning次数:40次
    host->tuning_delay = -1;
    host->tuning_loop_count = MAX_TUNING_LOOP;

    host->sdma_boundary = SDHCI_DEFAULT_BOUNDARY_ARG;

    /*
     * The DMA table descriptor count is calculated as the maximum
     * number of segments times 2, to allow for an alignment
     * descriptor for each segment, plus 1 for a nop end descriptor.
     */
    host->adma_table_cnt = SDHCI_MAX_SEGS * 2 + 1;

    return host;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

在这里插入图片描述

b. sdhci_add_host

在add_host之前,已经完成的底层解析,并传上来的sdhci_host中包含以下信息:

  • sdhci的寄存器的映射过后的基地址(sdhci_host->ioaddr)
  • sdhci的癖好quirks、quirks2(sdhci_host->quirks,sdhci_host->quirks2)
  • sdhci的中断号(sdhci_host->irq)
  • host提供给sdhci core用来操作硬件的操作集(sdhci_host->ops)
    自此,可以正式完成host的注册,完成以下过程:
  • sdhci host复位:读取该host的sdhci的信息(从sdhci相关寄存器中读取)并设置sdhci_host相关成员
  • 中断的注册
  • sdhci host初始化:调用sdhci_init
  • 注册mmc_host到mmc core中:调用mmc_add_host
  • 使能card插入状态的检测
int sdhci_add_host(struct sdhci_host *host)
{
    int ret;
	// 该函数源码巨长,因此不贴源码,只列出该函数实现的部分功能:
	// 1. 获取sdhci controller支持的属性- sdhci_read_caps
	// |--1.1 执行sdhci_do_reset,如果host不需要复位则直接判断cd
	// |--1.2 设置v4模式,读取host版本,读取caps
	// 2. 设置sdhci_host->flags中和DMA相关的flag和部分DMA配置
	// 3. 获取sdhci controller支持的最大频率以及倍频
	// 4. 根据quirks或caps做的一堆标志处理(不详细分析了)
	// 5. 设置各个电压下的最大电流值(max_current_330/300/180)
	// 6. 设置可用的ocr(ocr_avail* [mmc][sd][sdio])
	// 7. 设置max_segs/seg_size/blk_size/blk_count
    ret = sdhci_setup_host(host);
    if (ret)
        return ret;
	// 源码见下
    ret = __sdhci_add_host(host);
    if (ret)
        goto cleanup;

    return 0;

cleanup:
    sdhci_cleanup_host(host);
    return ret;
}

int __sdhci_add_host(struct sdhci_host *host)
{
    unsigned int flags = WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_HIGHPRI;
    struct mmc_host *mmc = host->mmc;
    int ret;

	// 看控制器支不支持CQE,我手里的平台是不支持的,就不详细分析了
    if ((mmc->caps2 & MMC_CAP2_CQE) &&
        (host->quirks & SDHCI_QUIRK_BROKEN_CQE)) {
        mmc->caps2 &= ~MMC_CAP2_CQE;
        mmc->cqe_ops = NULL;
    }
	// 完成request的工作队列创建
    host->complete_wq = alloc_workqueue("sdhci", flags, 0);
    if (!host->complete_wq)
        return -ENOMEM;
	// 初始化工作线程,sdhci_request_done
    INIT_WORK(&host->complete_work, sdhci_complete_work);
	// 创建两个定时器
    timer_setup(&host->timer, sdhci_timeout_timer, 0);
    timer_setup(&host->data_timer, sdhci_timeout_data_timer, 0);
	// Buffer Read Ready interrupt 等待队列创建
    init_waitqueue_head(&host->buf_ready_int);

	// 做了一次复位,在使能v4模式,然后使能host的硬件中断
    sdhci_init(host, 0);

	// 中断处理与中断线程和中断号绑定,其中sdhci_irq返回IRQ_WAKE_THREAD
	// 时唤醒sdhci_thread_irq,类似于中断上半部和底半部
    ret = request_threaded_irq(host->irq, sdhci_irq, sdhci_thread_irq,
                   IRQF_SHARED, mmc_hostname(mmc), host);
    if (ret) {
        pr_err("%s: Failed to request IRQ %d: %d\n",
               mmc_hostname(mmc), host->irq, ret);
        goto unwq;
    }
	/* 删除sdhci_led部分 */

	// 在mmc_core host中在详细分析
    ret = mmc_add_host(mmc);
    if (ret)
        goto unled;
	// 走到这里基本上已经彻底完成控制器的初始化了,见下图
    pr_info("%s: SDHCI controller on %s [%s] using %s\n",
        mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
        host->use_external_dma ? "External DMA" :
        (host->flags & SDHCI_USE_ADMA) ?
        (host->flags & SDHCI_USE_64_BIT_DMA) ? "ADMA 64-bit" : "ADMA" :
        (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
	// 使能控制器卡插拔中断(如果不支持gpio cd的话)
    sdhci_enable_card_detection(host);

    return 0;
	/* 删除失败处理:unled,unirq,unwq */
    return ret;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84

完成控制器注册和初始化
在这里插入图片描述

4.2 mmc_core层

I. host

mmc core通过struct mmc_host来管理host。不管是什么类型的host,最终都是要实现出对应的mmc_host并注册到mmc core中交由mmc子系统进行管理。对应代码drivers/mmc/core/host.c。为底层host controller driver实现mmc host的申请以及注册的API等等,以及host相关属性的实现。其中和注册相关的两个接口如下:

a. mmc_alloc_host

底层host controller驱动调用,用来分配一个struct mmc_host结构体,将其于mmc_host_class关联,并且做部分初始化操作
主要工作:

  • 分配内存空间初始化其class device(对应/sys/class/mmc*节点)
  • 初始化detect工作队列(也就是检测工作)为mmc_rescan
  • 初始化 max_segs、max_req_size等
/**
 *  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)
{
    int index;
    struct mmc_host *host;
    int alias_id, min_idx, max_idx;
	// 申请mmc_host的空间,连带上主机控制器层中要用的私有数据大小
    host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
    if (!host)
        return NULL;

	/* scanning will be enabled when we're ready */
	// 这里禁用rescan,先不允许扫卡
    host->rescan_disable = 1;

	// 从设备树中解析mmc* 以获取索引(这个索引是按照设备树中mmc的顺序来的)
    alias_id = of_alias_get_id(dev->of_node, "mmc");
    if (alias_id >= 0) {
        index = alias_id;
    } else {
        min_idx = mmc_first_nonreserved_index();
        max_idx = 0;

        index = ida_simple_get(&mmc_host_ida, min_idx, max_idx, GFP_KERNEL);
        if (index < 0) {
            kfree(host);
            return NULL;
        }
    }

    host->index = index;
	// 根据获取的索引设置mmc名
    dev_set_name(&host->class_dev, "mmc%d", host->index);
    host->ws = wakeup_source_register(NULL, dev_name(&host->class_dev));
	// 这个dev实际上是platform传下来的&pdev->dev
    host->parent = dev;
    host->class_dev.parent = dev;
    host->class_dev.class = &mmc_host_class;
    device_initialize(&host->class_dev);
    device_enable_async_suspend(&host->class_dev);
	// 如果设备树中有cd或者ro引脚,这里会将对应信息填充到ctx中
	// 实际我手里的平台未使用该方案,不详细分析
    if (mmc_gpio_alloc(host)) {
        put_device(&host->class_dev);
        return NULL;
    }

    spin_lock_init(&host->lock);
	init_waitqueue_head(&host->wq);
	// 扫卡用工作队列,后续调度host->detect来检测是否有card插入
    INIT_DELAYED_WORK(&host->detect, mmc_rescan);
    INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
    timer_setup(&host->retune_timer, mmc_retune_timer, 0);

    /*
     * By default, hosts do not support SGIO or large requests.
     * They have to set these according to their abilities.
     */
    host->max_segs = 1;
    host->max_seg_size = PAGE_SIZE;

    host->max_req_size = PAGE_SIZE;
    host->max_blk_size = 512;
    host->max_blk_count = PAGE_SIZE / 512;

    host->fixed_drv_type = -EINVAL;
    host->ios.power_delay_ms = 10;
    host->ios.power_mode = MMC_POWER_UNDEFINED;

    return host;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
b. mmc_add_host

底层host controller驱动调用,注册mmc_host到设备驱动中,添加到sys类下面,并设置相应的debug目录。然后启动mmc_host。

主要工作:

  • 将mmc_host的class_dev添加到设备驱动模型中,在sysfs中生成相应的节点
  • 初始化mmc_host相关的debug目录
  • 调用mmc_start_host启动host
int mmc_add_host(struct mmc_host *host)
{
    int err;

    WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
        !host->ops->enable_sdio_irq);
	// 通过device_add将mmc_host->class_dev添加到设备驱动模型中,
	// 在sys下生成相应节点
    err = device_add(&host->class_dev);
    if (err)
        return err;

    led_trigger_register_simple(dev_name(&host->class_dev), &host->led);

#ifdef CONFIG_DEBUG_FS
    mmc_add_host_debugfs(host);
#endif
	// 启动host,卡识别 
    mmc_start_host(host);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

II. core

mmc core主模块是mmc core的实现核心,对应代码位置drivers/mmc/core/core.c。其中mmc core初始化包括注册mmc bus、mm host class等等

a. mmc_init

负责初始化整个mmc core。主要工作:1.注册mmc bus;2.注册mmc host class;3.注册sdio bus

static int __init mmc_init(void)
{
    int ret;
	// 注册mmc bus 见下图,这条bus称之为mmc_bus,节点:/sys/bus/mmc
    ret = mmc_register_bus();
    if (ret)
        return ret;
	// 注册mmc_host class
    ret = mmc_register_host_class();
    if (ret)
        goto unregister_bus;
	// 注册sdio bus,这条bus称之为sdio_bus,节点:/sys/bus/sdio
    ret = sdio_register_bus();
    if (ret)
        goto unregister_host_class;

    return 0;

unregister_host_class:
    mmc_unregister_host_class();
unregister_bus:
    mmc_unregister_bus();
    return ret;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

mmc_bus这部分代码在drivers/mmc/core/bus.c中,初始化这里不详细分析
在这里插入图片描述

b. mmc_start_host

当底层host controller调用mmc_add_host来注册host时,在mmc_add_host中就会调用mmc_start_host来启动一个host了。

void mmc_start_host(struct mmc_host *host)
{
	host->f_init = max(min(freqs[0], host->f_max), host->f_min);
	// 设置rescan_disable标志为0,说明已经可以进行card检测了
    host->rescan_disable = 0;
	// 如果mmc属性设置了MMC_CAP2_NO_PRESCAN_POWERUP,
	// 也就是在rescan前不需要进行power up,否则就需要
	if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) {
		// 因为上电操作涉及到对host的使用和设置,需要先占用host
		// 关于host_claim下面详细解析一下
        mmc_claim_host(host);
		// 为MMC设备供电。这是一个两阶段的过程。
        // 首先,我们在不运行时钟的情况下为卡启用电源
		// 然后稍等片刻,让电源稳定。最后启用总线驱动程序和给时钟到卡
		// 在电源稳定之前,我们必须不启用时钟
        mmc_power_up(host, host->ocr_avail);
		// 解除占用
        mmc_release_host(host);
    }
	// 如果是设备树标明的gpio cd则去申请该gpio中断
	mmc_gpiod_request_cd_irq(host);
	// 调用mmc_detect_change检测card变化
    _mmc_detect_change(host, 0, false);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
c. mmc_claim/release_host

这2个接口的配对使用,目的是为了独占式的使用host,凡是需要独占使用host的场景都可以调用这两个接口,比如扫卡/识别卡阶段,host上下电阶段,卡的suspend/ resume

int __mmc_claim_host(struct mmc_host *host, struct mmc_ctx *ctx,
             atomic_t *abort)
{
	struct task_struct *task = ctx ? NULL : current;
	// 创建等待队列成员
    DECLARE_WAITQUEUE(wait, current);
    unsigned long flags;
    int stop;
    bool pm = false;

    might_sleep();
	// 加入到等待队列中
	add_wait_queue(&host->wq, &wait);
	// 加锁保护
    spin_lock_irqsave(&host->lock, flags);
	while (1) {
		// 该进程不可中断唤醒
        set_current_state(TASK_UNINTERRUPTIBLE);
		// 传入的abort非空?
        stop = abort ? atomic_read(abort) : 0;
		// 如果abort的锁读出来是0,则可以申请该host
		// !host->claimed表示已经该host还没被占用,可以申请该host
		// 如果上下文相同,或者没有上下文但任务相同,可以申请该host
        if (stop || !host->claimed || mmc_ctx_matches(host, ctx, task))
            break;
        spin_unlock_irqrestore(&host->lock, flags);
		// 如果能进这里,说明之前已经有申请过的了,需要等待释放wait
		// 才会在调度回来,然后在进行上面的判断
        schedule();
        spin_lock_irqsave(&host->lock, flags);
    }
    set_current_state(TASK_RUNNING);
	if (!stop) {
		// 可以申请host的情况,该host需要被占用
	        host->claimed = 1;
			// host-> claimer进行上下文绑定
	        mmc_ctx_set_claimer(host, ctx, task);
			// 计数++
	        host->claim_cnt += 1;
			// 如果是第一次占用,则执行pm相关的电源管理,这里不详细分析
	        if (host->claim_cnt == 1)
	            pm = true;
	} else
		// 否则则去唤醒上一次的占用
        wake_up(&host->wq);
	spin_unlock_irqrestore(&host->lock, flags);
	// 然后将本次的等待队列中的成员删掉,完成一次循环
    remove_wait_queue(&host->wq, &wait);

    if (pm)
        pm_runtime_get_sync(mmc_dev(host));
	// 返回申请情况,返回非0说明之前想要占用该host失败了
    return stop;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

释放函数如下:

void mmc_release_host(struct mmc_host *host)
{
    unsigned long flags;
	// 如果没占用就释放(调用了该函数)就报警告,肯定有点问题
    WARN_ON(!host->claimed);

	spin_lock_irqsave(&host->lock, flags);
	// 计数自减如果不是0,说明可能同一个task或者相同上下文多次占用中
    if (--host->claim_cnt) {
        /* Release for nested claim */
        spin_unlock_irqrestore(&host->lock, flags);
	} else {
		// 这里说明能真的释放了
        host->claimed = 0;
        host->claimer->task = NULL;
        host->claimer = NULL;
        spin_unlock_irqrestore(&host->lock, flags);
		// 唤醒等待队列,本次唤醒后,其他在等待该host的task就可以去占用了
        wake_up(&host->wq);
		// 电源管理相关,不分析
        pm_runtime_mark_last_busy(mmc_dev(host));
        if (host->caps & MMC_CAP_SYNC_RUNTIME_PM)
            pm_runtime_put_sync_suspend(mmc_dev(host));
        else
            pm_runtime_put_autosuspend(mmc_dev(host));
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
d. _mmc_detect_change

到这里触发扫卡工作流程

void _mmc_detect_change(struct mmc_host *host, unsigned long delay, bool cd_irq)
{
    /*
     * Prevent system sleep for 5s to allow user space to consume the
     * corresponding uevent. This is especially useful, when CD irq is used
     * as a system wakeup, but doesn't hurt in other cases.
     */
    if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL))
        __pm_wakeup_event(host->ws, 5000);

	host->detect_change = 1;
	// 触发INIT_DELAYED_WORK(&host->detect, mmc_rescan);
	// 开始扫卡流程
    mmc_schedule_delayed_work(&host->detect, delay);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

5. 扫卡(识别)

当_mmc_detect_change执行后,触发了扫卡的工作队列,并且使能了卡检测,则正式进入扫卡识别阶段,通过唤醒工作队列,执行mmc_rescan,如下图为实际设备识别emmc的流程(注:dump_stack加到mmc_add_card函数的最后)
在这里插入图片描述
在这里插入图片描述

5.1 mmc_rescan

用于检测host的卡槽状态,并对状态变化做相应的操作。有card插入时,重新扫描mmc card,mmc card rescan的方式有如下几种:

  1. mmc card是不可移除的(如emmc),则在mmc host初始化时设置mmc host为nonremovable(仅在mmc_add_host时,调用mmc_detect_change完成一次mmc rescan,此后不再执行mmc rescan操作);
  2. mmc host支持mmc card detect功能(通过提供mmc detect中断,进行mmc card detect),此种情况在mmc card detect中断对应的中断处理接口中,调用mmc_detect_change接口,对延迟工作队列进行调度,从而调用接口mmc_rescan,完成一次mmc card的rescan;
  3. mmc host不支持mmc card detect功能,针对此情形,可以设置mmc host为poll模式。针对此种模式,在mmc_add_host执行一次mmc rescan时,在mmc rescan的最后会执行延迟1s调度该延迟工作队列,从而完成每秒执行一次mmc rescan操作。
void mmc_rescan(struct work_struct *work)
{
	// 通过work获取mmc_host结构体指针
    struct mmc_host *host =
        container_of(work, struct mmc_host, detect.work);
    int i;
	// 是否禁用扫卡?如果禁用则不执行
    if (host->rescan_disable)
        return;

	/* If there is a non-removable card registered, only scan once */
	// 对于不可移除(non-removable)的卡(emmc就是不可移除,
	// 因此设备树中会标注有non-removable属性),scan只做一次
    if (!mmc_card_is_removable(host) && host->rescan_entered)
        return;
    host->rescan_entered = 1;

    /* 删除部分 */
	// 执行mmc_host->bus_refs++,说明执行到这里该总线已经算被使用了
	// 引用计数+1
    mmc_bus_get(host);

	/* Verify a registered card to be functional, else remove it. */
	// 在首次扫卡执行时(还未执行mmc_attach_bus)时,mmc_host->bus_ops = NULL
	// 再次执行时,host->bus_ops存在的话说明之前是有card插入的状态
	// 即执行mmc_host->bus_ops->detect判断之前的卡还在不在
	// 不在则执行对应卡(mmc/sd/sdio)的移除操作
	// 后面进行详细分析
    if (host->bus_ops && !host->bus_dead)
        host->bus_ops->detect(host);

    host->detect_change = 0;

    /*
     * Let mmc_bus_put() free the bus/bus_ops if we've found that
     * the card is no longer present.
     */
	// 释放总线,执行mmc_host->bus_refs--,
	// 如果mmc_host->bus_ops不为NULL,并且引用计数为0,
	// 则还会执行mmc_host->bus_ops = NULL;的操作
    mmc_bus_put(host);
    mmc_bus_get(host);

	/* if there still is a card present, stop here */
	// 如果bus_ops还非空,说明该总线还有被占用 
	if (host->bus_ops != NULL) {
	// 引用计数减1,然后退出扫描流程
        mmc_bus_put(host);
        goto out;
    }

    /*
     * Only we can add a new handler, so it's safe to
     * release the lock here.
     */
    mmc_bus_put(host);

	// 占用该mmc host
	mmc_claim_host(host);
	// 卡是可移除的,并且host支持get_cd功能,
	// 由控制器执行对应功能函数,判断cd引脚返回
	// 如果返回0,说明卡拔出去的状态,否则卡是插入状态
    if (mmc_card_is_removable(host) && host->ops->get_cd &&
            host->ops->get_cd(host) == 0) {
        mmc_power_off(host);
        mmc_release_host(host);
        goto out;
    }

    for (i = 0; i < ARRAY_SIZE(freqs); i++) {
        unsigned int freq = freqs[i];
        if (freq > host->f_max) {
            if (i + 1 < ARRAY_SIZE(freqs))
                continue;
            freq = host->f_max;
        }
		// 尝试用最高的频率去识别卡,其中freqs可能的值为:
		// 400K,300K,200K,100K
        if (!mmc_rescan_try_freq(host, max(freq, host->f_min)))
            break;
        if (freqs[i] <= host->f_min)
            break;
	}
	// 释放该host
    mmc_release_host(host);

 out:
	// 如果设置了是轮询扫卡的话,这里就相当于poll的一个过程
	// 按照HZ的频率持续性的执行该工作队列,轮询扫卡
    if (host->caps & MMC_CAP_NEEDS_POLL)
        mmc_schedule_delayed_work(&host->detect, HZ);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92

5.2 mmc_rescan_try_freq

以一定频率搜索host bus上的card。

static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
{
    host->f_init = freq;

    pr_debug("%s: %s: trying to init card at %u Hz\n",
        mmc_hostname(host), __func__, host->f_init);
	// 用可用电压选择一个最基础的模式上电
    mmc_power_up(host, host->ocr_avail);

	// 一些eMMC(VCCQ始终开启)在上电后可能不会重置,
	// 因此如果可能的话,进行硬件重置。     
    mmc_hw_reset_for_init(host);

	// sdio_reset通过发送CMD52来重置卡。
	// 由于我们不知道卡是否正在重新初始化,只需发送它即可。
	// CMD52应该被SD/eMMC卡忽略。
	// 如果我们已经知道不支持SDIO命令,就跳过它。
    if (!(host->caps2 & MMC_CAP2_NO_SDIO))
        sdio_reset(host);

	// 给设备发cmd0,设备进入idle状态(协议) 
    mmc_go_idle(host);

	// sd卡需发送cmd8,获取card的可用电压,存储到host->ocr_avail中
    // 协议见下
    if (!(host->caps2 & MMC_CAP2_NO_SD))
        mmc_send_if_cond(host, host->ocr_avail);

	/* Order's important: probe SDIO, then SD, then MMC */
	// 识别是不是一个sdio设备
    if (!(host->caps2 & MMC_CAP2_NO_SDIO))
        if (!mmc_attach_sdio(host))
            return 0;
	// 识别是不是一个sd卡
    if (!(host->caps2 & MMC_CAP2_NO_SD))
        if (!mmc_attach_sd(host))
            return 0;
	// 识别是不是一个(e)mmc
    if (!(host->caps2 & MMC_CAP2_NO_MMC))
        if (!mmc_attach_mmc(host))
            return 0;
	// 如果都识别不到,就下电
    mmc_power_off(host);
    return -EIO;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

在这里插入图片描述

5.3 mmc_attach_xx(主要以emmc进行分析)

这里以mmc_attach_mmc为例进行分析

int mmc_attach_mmc(struct mmc_host *host)
{
    int err;
    u32 ocr, rocr;

    WARN_ON(!host->claimed);

	/* Set correct bus mode for MMC before attempting attach */
	// bus_mode,两种信号模式,open-drain(MMC_BUSMODE_OPENDRAIN)
	// 和push-pull(MMC_BUSMODE_PUSHPULL),对应不同的高低电平
    if (!mmc_host_is_spi(host)) // 不是spi通信方式
        mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
	// 协议,发送cmd1(协议),获取mmc ocr
    err = mmc_send_op_cond(host, 0, &ocr);
    if (err)
        return err;
	// 总线ops匹配到mmc_ops,见下图
	// host->bus_ops = ops; host->bus_refs = 1; host->bus_dead = 0;
	mmc_attach_bus(host, &mmc_ops);
	// 控制器的供电能力赋值
    if (host->ocr_avail_mmc)
        host->ocr_avail = host->ocr_avail_mmc;

    /*
     * We need to get OCR a different way for SPI.
     */
    if (mmc_host_is_spi(host)) {
        err = mmc_spi_read_ocr(host, 1, &ocr);
        if (err)
            goto err;
    }
	// 控制器和mmc的ocr电压匹配,选择一个合适的电压,重新供电
    rocr = mmc_select_voltage(host, ocr);

    /*
     * Can we support the voltage of the card?
     */
    if (!rocr) {
        err = -EINVAL;
        goto err;
    }

    /*
     * Detect and init the card.
     */
	// 下面详细分析
    err = mmc_init_card(host, rocr, NULL);
    if (err)
        goto err;
	
	mmc_release_host(host);
	// 下面具体分析
    err = mmc_add_card(host->card);
    if (err)
        goto remove_card;
	// 最后占用住该host
    mmc_claim_host(host);
    return 0;

remove_card:
    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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71

在这里插入图片描述

5.4 mmc_init_card

该函数巨长,因此源码部分删减,该函数主要是协议的收发并配置卡,主要操作如下:

  1. mmc_go_idle,发送cmd0,置emmc进idle状态
  2. mmc_send_op_cond,发送cmd1,获取ocr寄存器值(包括bit30,访问模式)
  3. mmc_send_cid,发送cmd2,获取cid寄存器值
  4. 申请mmc_card结构空间,并部分初始化
  5. 发送cmd3,将rca赋值给emmc,此时emmc进入standby状态,并将信号从开漏转为上推拉模式
  6. 发送cmd9,获取csd寄存器,并解码cid和csd
  7. 如果卡支持DSR寄存器,host需要发送cmd4对dsr进行配置,
  8. 发送cmd7,card由stand-by切换到transfer-mode
  9. 发送cmd8 读取扩展CSD,并解析。注:此时设备已经处于发送模式
  10. 发送cmd6设置扩展csd的175寄存器,设置值为0,设置擦除组定义大小,这里使用默认大小
  11. 发送cmd6设置扩展csd的179寄存器,访问权限设置,设置成默认(只访问用户分区)
  12. 发送cmd6设置扩展csd的34寄存器,设置值为1,设置主机下电通知设备
  13. 开始调速HS400ES/HS200/HS,以及位宽选择(这个过程不详细分析了,也是各种发命令进行设置)
  14. 发送cmd6设置扩展csd的187寄存器,根据位宽选择一个合适的功耗等级
  15. 发送cmd6配置扩展csd的161寄存器,使能HPI (High Priority Interrupt高优先级中断,该机制可以中断一些还没有完成的优先级比较低的操作,来满足对高优先级操作的需求)
  16. 发送cmd6配置扩展csd的15寄存器,使能CQE
  17. mmc_host->card 赋值,识别卡到这里基本就成功一半了
static int mmc_init_card(struct mmc_host *host, u32 ocr,
    struct mmc_card *oldcard)
{
    struct mmc_card *card;
    int err;
    u32 cid[4];
    u32 rocr;

    /* 删减 */
	// 1. mmc_go_idle,发送cmd0,置emmc进idle状态
    mmc_go_idle(host);

    // 2. mmc_send_op_cond,发送cmd1,获取ocr寄存器值(包括bit30,访问模式)
    err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
    if (err)
        goto err;

    /* 删减 */
	// 3. mmc_send_cid,发送cmd2,获取cid寄存器值
    err = mmc_send_cid(host, cid);
    if (err)
        goto err;

    if (oldcard) {
        /* 删减,就是cid对比,如果不一样就go err,否则card=oldcard */
    } else {
        // 4. 申请mmc_card结构空间,并执行以下操作:
		// card->host = mmc_host,初始化card->dev,
		// card->dev.bus = &mmc_bus_type(见下图)
		// card->dev.type = mmc_type
        card = mmc_alloc_card(host, &mmc_type);
        if (IS_ERR(card)) {
            err = PTR_ERR(card);
            goto err;
        }

        card->ocr = ocr;
        card->type = MMC_TYPE_MMC;
        card->rca = 1; //rca地址先写死成1了
		// 把cid赋值给card_raw_cid
        memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
    }

    /* 删减 */

    /*
     * For native busses:  set card RCA and quit open drain mode.
     */
	if (!mmc_host_is_spi(host)) {
		// 5. 发送cmd3,将rca赋值给emmc
		// 一旦接收到RCA,设备就变为Stand-by状态,
		// 设备将其输出驱动器从开漏切换到推拉,到这里已经完成了设备识别
		// 具体见下图emmc状态图(设备识别模式)
        err = mmc_set_relative_addr(card);
        if (err)
            goto free_card;
		// 信号模式改为push-pull,第一章MMC卡接口含义图有说明
        mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
    }

    if (!oldcard) {
        // 6. 发送cmd9,获取csd寄存器
        err = mmc_send_csd(card, card->raw_csd);
        if (err)
            goto free_card;
		// 7. 对返回的csd寄存器的值进行解码(主要看寄存器手册了)
        err = mmc_decode_csd(card);
        if (err)
            goto free_card;
		// 8. 对返回的cid寄存器的值进行解码(主要看寄存器手册了)
        err = mmc_decode_cid(card);
        if (err)
            goto free_card;
    }

    /*
     * handling only for cards supporting DSR and hosts requesting
     * DSR configuration
     */
	// 9. 如果卡支持DSR寄存器,host需要对dsr进行配置,发送cmd4
    if (card->csd.dsr_imp && host->dsr_req)
        mmc_set_dsr(host);

    /*
     * Select card, as all following commands rely on that.
     */
	if (!mmc_host_is_spi(host)) {
		// 10. 发送cmd7,card由stand-by切换到transfer-mode
        err = mmc_select_card(card);
        if (err)
            goto free_card;
    }

    if (!oldcard) {
        /* Read extended CSD. */
		// 11. 发送cmd8 读取扩展CSD,并解析。此时设备已经处于发送模式
        err = mmc_read_ext_csd(card);
        if (err)
            goto free_card;

        // 如果ocr的bit30被置位,就是扇区寻址方式
		// emmc容量大于2G的话,最小单位是扇区,小于2G可以字节寻址
        if (rocr & BIT(30))
            mmc_card_set_blockaddr(card);

        /* Erase size depends on CSD and Extended CSD */
		// 根据寄存器值设置擦除大小
        mmc_set_erase_size(card);
    }

    /* Enable ERASE_GRP_DEF. This bit is lost after a reset or power off. */
	if (card->ext_csd.rev >= 3) {
		// 12. 擦除组定义大小用默认大小,发送cmd6,
		// 设置扩展csd的175寄存器,设置值为0,寄存器描述见下图
        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                 EXT_CSD_ERASE_GROUP_DEF, 1,
                 card->ext_csd.generic_cmd6_time);

        if (err && err != -EBADMSG)
            goto free_card;

        if (err) {
            err = 0;
            /*
             * Just disable enhanced area off & sz
             * will try to enable ERASE_GROUP_DEF
             * during next time reinit
             */
            card->ext_csd.enhanced_area_offset = -EINVAL;
            card->ext_csd.enhanced_area_size = -EINVAL;
        } else {
            card->ext_csd.erase_group_def = 1;
            /*
             * enable ERASE_GRP_DEF successfully.
             * This will affect the erase size, so
             * here need to reset erase size
             */
            mmc_set_erase_size(card);
        }
    }

    /*
     * Ensure eMMC user default partition is enabled
     */
    if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
        card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
		// 13. 访问权限设置,设置成默认(只访问用户分区),发送cmd6
		// 设置扩展csd的179寄存器,设置值为0,寄存器描述见下图
        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
                 card->ext_csd.part_config,
                 card->ext_csd.part_time);
        if (err && err != -EBADMSG)
            goto free_card;
    }

    /*
     * Enable power_off_notification byte in the ext_csd register
     */
	if (card->ext_csd.rev >= 6) {
	// 14. 设置主机下电通知设备,发送cmd6
    // 设置扩展csd的34寄存器,设置值为1,寄存器描述见下图
        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                 EXT_CSD_POWER_OFF_NOTIFICATION,
                 EXT_CSD_POWER_ON,
                 card->ext_csd.generic_cmd6_time);
        if (err && err != -EBADMSG)
            goto free_card;

        /*
         * The err can be -EBADMSG or 0,
         * so check for success and update the flag
         */
        if (!err)
            card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
    }

    /* 删除部分 */

    /*
     * Select timing interface
     */
	// 15. 调速:HS400ES/HS200/HS,以及位宽选择,这个过程略,不详细分析
    err = mmc_select_timing(card);
    if (err)
        goto free_card;

    /* 删除部分调速和位宽选择代码 */

    /*
     * Choose the power class with selected bus interface
     */
	// 16. 根据位宽选择一个合适的功耗等级,不详细分析,
	// 主要是设置扩展csd的187寄存器
    mmc_select_powerclass(card);

    /*
     * Enable HPI feature (if supported)
     */
	/* 删除部分使能HPI的代码,主要是配置扩展csd的161寄存器 */
	
	/*  删除部分设置cache代码,保留注释,主要是配置扩展csd的33寄存器
	如果缓存大小大于0,这表示存在缓存,并且可以打开。请注意,
	来自Micron的一些eMMC已经被报告需要在突然断电测试后
	启用缓存时需要约800毫秒的超时时间。
	让我们将超时时间扩展到至少DEFAULT_CACHE_EN_TIMEOUT_MS,
	并为所有卡片执行此操作。
	*/
	
	/* 删除CQE相关配置(命令队列使能) 主要是配置扩展csd的15寄存器 */
	
	// mmc_host->card 赋值
    if (!oldcard)
        host->card = card;

    return 0;

free_card:
    if (!oldcard)
        mmc_remove_card(card);
err:
    return err;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222

I. mmc_bus_type描述:

在这里插入图片描述

II. 扩展CSD寄存器175寄存器描述:

在这里插入图片描述

III. 扩展CSD寄存器179寄存器描述:

在这里插入图片描述
在这里插入图片描述

IV. 扩展CSD寄存器34寄存器描述:

在这里插入图片描述

V. 扩展CSD寄存器187寄存器描述:

在这里插入图片描述

VI. 扩展CSD寄存器161寄存器描述:

在这里插入图片描述

VII. 扩展CSD寄存器15寄存器描述:

在这里插入图片描述

5.5 mmc_add_card

将卡正式进行注册,打印一些卡信息,并注册到debugfs中,至此识卡完成

int mmc_add_card(struct mmc_card *card)
{
    int ret;
    const char *type;
    const char *uhs_bus_speed_mode = "";
    static const char *const uhs_speeds[] = {
        [UHS_SDR12_BUS_SPEED] = "SDR12 ",
        [UHS_SDR25_BUS_SPEED] = "SDR25 ",
        [UHS_SDR50_BUS_SPEED] = "SDR50 ",
        [UHS_SDR104_BUS_SPEED] = "SDR104 ",
        [UHS_DDR50_BUS_SPEED] = "DDR50 ",
    };
	// 设置卡名:host+4位rca
    dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);

    switch (card->type) {
    case MMC_TYPE_MMC:
        type = "MMC";
        break;
    case MMC_TYPE_SD:
        type = "SD";
        if (mmc_card_blockaddr(card)) {
            if (mmc_card_ext_capacity(card))
                type = "SDXC";
            else
                type = "SDHC";
        }
        break;
    case MMC_TYPE_SDIO:
        type = "SDIO";
        break;
    case MMC_TYPE_SD_COMBO:
        type = "SD-combo";
        if (mmc_card_blockaddr(card))
            type = "SDHC-combo";
        break;
    default:
        type = "?";
        break;
    }
	// 识别是否是uhs卡和卡速度
    if (mmc_card_uhs(card) &&
        (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
        uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];

	// 打印卡的一些信息,如本设备的打印如下:
	// mmc2: new ultra high speed SDR12 MMC card at address 0001
    if (mmc_host_is_spi(card->host)) {
        pr_info("%s: new %s%s%s card on SPI\n",
            mmc_hostname(card->host),
            mmc_card_hs(card) ? "high speed " : "",
            mmc_card_ddr52(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_hs(card) ? "high speed " : ""),
            mmc_card_hs400(card) ? "HS400 " :
            (mmc_card_hs200(card) ? "HS200 " : ""),
            mmc_card_hs400es(card) ? "Enhanced strobe " : "",
            mmc_card_ddr52(card) ? "DDR " : "",
            uhs_bus_speed_mode, type, card->rca);
    }

#ifdef CONFIG_DEBUG_FS
	// 加入到debugfs,见下图,可以查看一些卡属性
    mmc_add_card_debugfs(card);
#endif
    card->dev.of_node = mmc_of_find_child_device(card->host, 0);

    device_enable_async_suspend(&card->dev);
	// 将该卡注册,添加到dev中
    ret = device_add(&card->dev);
    if (ret)
        return ret;
	// 置卡在线标志
    mmc_card_set_present(card);

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81

I. Debugfs下可以查看的一些属性

可以查看对应host的caps、卡的ext_csd(emmc)、卡的status(通过cmd13获取,详情见协议手册中6.13 设备状态)和卡的state(见下图)
在这里插入图片描述
在这里插入图片描述

5.6 e•MMC状态图(设备识别模式)

在这里插入图片描述

5.7 e•MMC状态图(数据传输模式)

在这里插入图片描述

6. 通信(命令)

本章节分析mmc子系统的通信流程,以上面emmc扫卡识别中,使用的mmc_go_idle(命令发送)为例进行分析。
在这里插入图片描述

6.1 mmc_go_idle

源码如下,有部分删减,可以看出实际就是填充cmd结构,然后调用mmc_wait_for_cmd

int mmc_go_idle(struct mmc_host *host)
{
    int err;
    struct mmc_command cmd = {};

    /* 删 */

    cmd.opcode = MMC_GO_IDLE_STATE; // cmd0
	cmd.arg = 0;
	// 这里置标志,在后面详细说明
    cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;

    err = mmc_wait_for_cmd(host, &cmd, 0);

    /* 删 */

    return err;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

6.2 mmc_wait_for_cmd

该函数是命令发送的核心

/**
 *  mmc_wait_for_cmd - start a command and wait for completion
 *  @host: MMC host to start command
 *  @cmd: MMC command to start
 *  @retries: maximum number of retries
 *
 *  Start a new MMC command for a host, and wait for the command
 *  to complete.  Return any error that occurred while the command
 *  was executing.  Do not attempt to parse the response.
 */
int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
{
    struct mmc_request mrq = {};

    WARN_ON(!host->claimed);
	// 命令回复清空
	memset(cmd->resp, 0, sizeof(cmd->resp));
	// 赋值最大重试次数
    cmd->retries = retries;

    mrq.cmd = cmd;
    cmd->data = NULL;

    mmc_wait_for_req(host, &mrq);

    return cmd->error;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

6.3 mmc_wait_for_req

实际上该函数主要执行两步:1.开启命令请求;2.等待请求完成,其中cap_cmd_during_tfr标志的作用为:在此进行数据传输或忙碌等待期间允许其他命令(在代码中没发现哪里会置ture,因此后续先不管这个变量了)

void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
{
    __mmc_start_req(host, mrq);

    if (!mrq->cap_cmd_during_tfr)
        mmc_wait_for_req_done(host, mrq);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

6.4 __mmc_start_req

在这里插入图片描述

static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
{
    int err;
	// 这个只有cap_cmd_during_tfr生效时才起作用,不分析
    mmc_wait_ongoing_tfr_cmd(host);
	// 初始化完成量
	init_completion(&mrq->completion);
	// 实际上就是complete(&mrq->completion);
    mrq->done = mmc_wait_done;
	// 开始请求,下面详细分析
    err = mmc_start_request(host, mrq);
	if (err) {
		// 出错处理
        mrq->cmd->error = err;
		// 这个函数也是只有cap_cmd_during_tfr生效时才起作用,不分析
        mmc_complete_cmd(mrq);
        complete(&mrq->completion);
    }

    return err;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

6.5 mmc_start_request

在这里插入图片描述

int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{
    int err;
	// 初始化cmd_xxx完成量,cap_cmd_during_tfr置位时生效,不细究
    init_completion(&mrq->cmd_completion);
	// 执行后,未释放时是不允许mmc进行调速操作的
    mmc_retune_hold(host);
	// 卡state处于移除状态,则直接放回错误
    if (mmc_card_removed(host->card))
        return -ENOMEDIUM;
	// debug打印
    mmc_mrq_pr_debug(host, mrq, false);
	// 如果host没被占有,则警告
    WARN_ON(!host->claimed);
	// 对mrq数据结构进行部分初始化和部分数据校验,
	// 主要是判断数据大小不能超过host一次写入的大小
    err = mmc_mrq_prep(host, mrq);
    if (err)
        return err;
	// 灯,不管
	led_trigger_event(host->led, LED_FULL);
	// 正式开启数据请求,实际上就是执行mmc_host->ops->request(host, mrq);
	// 也就是执行 sdhci_request
    __mmc_start_request(host, mrq);

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

6.6 sdhci_request

这里涉及到控制器层面操作了,主要是通过配置host寄存器实现数据收发
在这里插入图片描述

void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
    struct sdhci_host *host = mmc_priv(mmc);
    struct mmc_command *cmd;
    unsigned long flags;
    bool present;

	/* Firstly check card presence */
	// 获取卡的在线状态
    present = mmc->ops->get_cd(mmc);
	// 加锁,禁中断
    spin_lock_irqsave(&host->lock, flags);
	// 灯不管
    sdhci_led_activate(host);
	// 如果卡不在了,直接退出就完事了,并赋值错误状态
    if (sdhci_present_error(host, mrq->cmd, present))
        goto out_finish;

    cmd = sdhci_manual_cmd23(host, mrq) ? mrq->sbc : mrq->cmd;
	// 这里主要涉及控制器层面的一些操作了
	// 这里面涉及非常复杂的操作,各种定时器,工作队列和控制器中断等等
	// 实际上主要执行sdhci_send_command,中间包含部分休眠等待多次重试的操作
    if (!sdhci_send_command_retry(host, cmd, flags))
        goto out_finish;

    spin_unlock_irqrestore(&host->lock, flags);

    return;

out_finish:
	// 成功发送数据,完成请求,后面详细分析
    sdhci_finish_mrq(host, mrq);
    spin_unlock_irqrestore(&host->lock, flags);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

I. sdhci_send_command

执行cmd发送,主要是对控制器的一些操作,配置各个寄存器
在这里插入图片描述

static bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
{
    int flags;
    u32 mask;
    unsigned long timeout;
    u16 mode = 0;

    WARN_ON(host->cmd);

    /* Initially, a command has no error */
    cmd->error = 0;

    if ((host->quirks2 & SDHCI_QUIRK2_STOP_WITH_TC) &&
        cmd->opcode == MMC_STOP_TRANSMISSION)
        cmd->flags |= MMC_RSP_BUSY;
	// 掩码置位,命令发送一定要检测,见主机控制器24H寄存器描述
	mask = SDHCI_CMD_INHIBIT;
	// 判断是否要发送数据,或者cmd->flags & MMC_RSP_BUSY
    if (sdhci_data_line_cmd(cmd))
        mask |= SDHCI_DATA_INHIBIT; //如果发送数据,掩码置位数据bit

    /* We shouldn't wait for data inihibit for stop commands, even
       though they might use busy signaling */
	// 意思是如果需要发停止,就不用等数据线ok了
    if (cmd->mrq->data && (cmd == cmd->mrq->data->stop))
        mask &= ~SDHCI_DATA_INHIBIT;
	// 读24H寄存器,如果与掩码与上之后有某个bit是1,说明cmd或者data
	// 有一个还在忙,不能发送命令或数据
    if (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask)
        return false;
	// 命令给到主机控制器
    host->cmd = cmd;
    host->data_timeout = 0;
    if (sdhci_data_line_cmd(cmd)) {
        WARN_ON(host->data_cmd);
        host->data_cmd = cmd;
		// 计算一个合适的超时时间(设置2EH寄存器)
		// 并使能数据超时中断
        sdhci_set_timeout(host, cmd);
    }

    if (cmd->data) {
        /* 删除dma相关 */
		// 如果存在数据,则进行一些校验,初始化等操作,这里不详细分析
        sdhci_prepare_data(host, cmd);
    }
	// 写命令参数,到主机控制器08H
    sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
	// 设置发送模式,写0CH寄存器
    mode = sdhci_set_transfer_mode(host, cmd);

    if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
        WARN_ONCE(1, "Unsupported response type!\n");
        /*
         * This does not happen in practice because 136-bit response
         * commands never have busy waiting, so rather than complicate
         * the error path, just remove busy waiting and continue.
         */
        cmd->flags &= ~MMC_RSP_BUSY;
    }
	// 一些标志位设置
    if (!(cmd->flags & MMC_RSP_PRESENT))
        flags = SDHCI_CMD_RESP_NONE;
    else if (cmd->flags & MMC_RSP_136)
        flags = SDHCI_CMD_RESP_LONG;
    else if (cmd->flags & MMC_RSP_BUSY)
        flags = SDHCI_CMD_RESP_SHORT_BUSY;
    else
        flags = SDHCI_CMD_RESP_SHORT;

    if (cmd->flags & MMC_RSP_CRC)
        flags |= SDHCI_CMD_CRC;
    if (cmd->flags & MMC_RSP_OPCODE)
        flags |= SDHCI_CMD_INDEX;

    /* CMD19 is special in that the Data Present Select should be set */
    if (cmd->data || cmd->opcode == MMC_SEND_TUNING_BLOCK ||
        cmd->opcode == MMC_SEND_TUNING_BLOCK_HS200)
        flags |= SDHCI_CMD_DATA;

    timeout = jiffies;
    if (host->data_timeout)
        timeout += nsecs_to_jiffies(host->data_timeout);
    else if (!cmd->data && cmd->busy_timeout > 9000)
        timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
    else
        timeout += 10 * HZ;
	// 如果涉及数据发送,则mod_timer(&host->data_timer, timeout);
	// 如果只是cmd,则mod_timer(&host->timer, timeout);
    sdhci_mod_timer(host, cmd->mrq, timeout);

	/* dma删除 */
	// 发送命令,写0E寄存器
    sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);

    return true;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
a. sdhci主机控制器24H寄存器

在这里插入图片描述
其中D00的含义如下,即当该bit为1时不能发送命令
在这里插入图片描述
D01的含义如下,同D00,该bit为1时不能发送数据
在这里插入图片描述

b. sdhci主机控制器08H寄存器

在这里插入图片描述

c. sdhci主机控制器0CH寄存器

在这里插入图片描述
其中D03-D02的含义如下
在这里插入图片描述
其中D04的含义如下
在这里插入图片描述

d. sdhci主机控制器0EH寄存器

在这里插入图片描述
其中D013-D08的含义如下
在这里插入图片描述
其中D07-D06的含义如下
在这里插入图片描述
其中D05的含义如下
在这里插入图片描述
其中D01-D00的含义如下
在这里插入图片描述

II. sdhci_cmd_irq

控制器在初始化阶段已经配置了默认的中断,中断配置如下,当cmd发送完成后,如果正常将触发host中断,并进入sdhci_irq然后通过掩码判断进入sdhci_cmd_irq
在这里插入图片描述

static void sdhci_set_default_irqs(struct sdhci_host *host)
{
    host->ier = SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT |
            SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT |
            SDHCI_INT_INDEX | SDHCI_INT_END_BIT | SDHCI_INT_CRC |
            SDHCI_INT_TIMEOUT | SDHCI_INT_DATA_END |
            SDHCI_INT_RESPONSE;

    if (host->tuning_mode == SDHCI_TUNING_MODE_2 ||
        host->tuning_mode == SDHCI_TUNING_MODE_3)
        host->ier |= SDHCI_INT_RETUNE;

    sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); //34H寄存器
    sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); //38H寄存器
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

sdhci_cmd_irq源码如下,其中initmask通过读取30H寄存器(读取的32位,因此连带中断错误状态[32H]一起都读了)

static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask, u32 *intmask_p)
{
	/* Handle auto-CMD12 error */
	// 判断一下自动命令是否有报错,报的什么错
    if (intmask & SDHCI_INT_AUTO_CMD_ERR && host->data_cmd) {
        struct mmc_request *mrq = host->data_cmd->mrq;
        u16 auto_cmd_status = sdhci_readw(host, SDHCI_AUTO_CMD_STATUS);
        int data_err_bit = (auto_cmd_status & SDHCI_AUTO_CMD_TIMEOUT) ?
                   SDHCI_INT_DATA_TIMEOUT :
                   SDHCI_INT_DATA_CRC;

        /* Treat auto-CMD12 error the same as data error */
        if (!mrq->sbc && (host->flags & SDHCI_AUTO_CMD12)) {
            *intmask_p |= data_err_bit;
            return;
        }
    }
	// 本身是命令的中断回调,结果命令还是空的,肯定有问题
    if (!host->cmd) {
        /*
         * SDHCI recovers from errors by resetting the cmd and data
         * circuits.  Until that is done, there very well might be more
         * interrupts, so ignore them in that case.
         */
        if (host->pending_reset)
            return;
        pr_err("%s: Got command interrupt 0x%08x even though no command operation was in progress.\n",
               mmc_hostname(host->mmc), (unsigned)intmask);
        sdhci_dumpregs(host);
        return;
    }

	// 存在下述4种错误,对应32H的D3-D0,做一些处理
    if (intmask & (SDHCI_INT_TIMEOUT | SDHCI_INT_CRC |
               SDHCI_INT_END_BIT | SDHCI_INT_INDEX)) {
        if (intmask & SDHCI_INT_TIMEOUT)
            host->cmd->error = -ETIMEDOUT;
        else
            host->cmd->error = -EILSEQ;

        /* Treat data command CRC error the same as data CRC error */
        if (host->cmd->data &&
            (intmask & (SDHCI_INT_CRC | SDHCI_INT_TIMEOUT)) ==
             SDHCI_INT_CRC) {
            host->cmd = NULL;
            *intmask_p |= SDHCI_INT_DATA_CRC;
            return;
        }

        __sdhci_finish_mrq(host, host->cmd->mrq);
        return;
    }

    /* Handle auto-CMD23 error */
    if (intmask & SDHCI_INT_AUTO_CMD_ERR) {
        struct mmc_request *mrq = host->cmd->mrq;
        u16 auto_cmd_status = sdhci_readw(host, SDHCI_AUTO_CMD_STATUS);
        int err = (auto_cmd_status & SDHCI_AUTO_CMD_TIMEOUT) ?
              -ETIMEDOUT :
              -EILSEQ;

        if (mrq->sbc && (host->flags & SDHCI_AUTO_CMD23)) {
            mrq->sbc->error = err;
            __sdhci_finish_mrq(host, mrq);
            return;
        }
    }
	// 上面都是错误处理,到这里才是真的的命令发送完成中断
	// 对应30H的D0
    if (intmask & SDHCI_INT_RESPONSE)
        sdhci_finish_command(host);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
a. sdhci主机控制器34H寄存器

在这里插入图片描述

b. sdhci主机控制器38H寄存器

在这里插入图片描述

c. sdhci主机控制器30H寄存器(中断状态)

根据描述可知,sdhci主机控制器的中断状态想要获取到的话,34H和38H都要使能才行
在这里插入图片描述

d. sdhci主机控制器32H寄存器(中断错误状态)

在这里插入图片描述

III. sdhci_finish_command

到这里,命令发送完成,执行相关处理,在此之前,我们来看下cmd->flags,这个flags的标记都在执行命令时候进行设置,如mmc_go_idle中就对cmd->flags置了MMC_RSP_NONE,相当于不需要任何回复。

/*
 * These are the native response types, and correspond to valid bit
 * patterns of the above flags.  One additional valid pattern
 * is all zeros, which means we don't expect a response.
 */
#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)

static void sdhci_finish_command(struct sdhci_host *host)
{
    struct mmc_command *cmd = host->cmd;

    host->cmd = NULL;
	// 如果对于需要回复的
	if (cmd->flags & MMC_RSP_PRESENT) {
		// RSP_136实际对应R2这种长数据应答,读10H寄存器
        if (cmd->flags & MMC_RSP_136) {
            sdhci_read_rsp_136(host, cmd);
        } else {
			// 正常应答,也是读10H寄存器,具体见下图
            cmd->resp[0] = sdhci_readl(host, SDHCI_RESPONSE);
        }
    }
	/* 删除部分 */

	/* Processed actual command. */
	// 正常只有置位MMC_RSP_BUSY了的情况,会触发这个条件
    if (host->data && host->data_early)
        sdhci_finish_data(host); //后面再分析
	// 确定不是一个数据命令
	if (!cmd->data)
		// 调用完成
        __sdhci_finish_mrq(host, cmd->mrq);
   
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
a. sdhci主机控制器10H寄存器

其中Response Field对应协议中应答的具体字段,Response Register是对应寄存器的那些值来进行表示。
在这里插入图片描述

IV. sdhci_timeout_timer

如果数据传输出现超时,在sdhci_send_command中经sdhci_mod_timer,到时后唤起对应定时器
在这里插入图片描述

static void sdhci_timeout_timer(struct timer_list *t)
{
    struct sdhci_host *host;
    unsigned long flags;

    host = from_timer(host, t, timer);

    spin_lock_irqsave(&host->lock, flags);
	// cmd非空,并且没有数据要发送
	if (host->cmd && !sdhci_data_line_cmd(host->cmd)) {
		// 报错,超时了
        pr_err("%s: Timeout waiting for hardware cmd interrupt.\n",
               mmc_hostname(host->mmc));
        sdhci_dumpregs(host);

        host->cmd->error = -ETIMEDOUT;	
		// 后面分析
        sdhci_finish_mrq(host, host->cmd->mrq);
    }

    spin_unlock_irqrestore(&host->lock, flags);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

6.7 sdhci_finish_mrq

实际上主体还是唤醒工作队列执行sdhci_request_done
在这里插入图片描述

static void sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
{
    __sdhci_finish_mrq(host, mrq);
	// 唤醒工作队列,执行sdhci_complete_work,即执行sdhci_request_done
    queue_work(host->complete_wq, &host->complete_work);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

I. __sdhci_finish_mrq

只做了3件事:置空,host->mrqs_done = mrq(request_done用),删除超时定时器

static void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
{
	// 各种置空,该发的到这里都发完了
    if (host->cmd && host->cmd->mrq == mrq)
        host->cmd = NULL;

    if (host->data_cmd && host->data_cmd->mrq == mrq)
        host->data_cmd = NULL;

    if (host->deferred_cmd && host->deferred_cmd->mrq == mrq)
        host->deferred_cmd = NULL;

    if (host->data && host->data->mrq == mrq)
        host->data = NULL;

    if (sdhci_needs_reset(host, mrq))
        host->pending_reset = true;
	// 设置要完成的请求是哪一个,实际上就是host->mrqs_done = mrq
    sdhci_set_mrq_done(host, mrq);
	// 超时用的定时器删掉
    sdhci_del_timer(host, mrq);
	// 灯,不管
    if (!sdhci_has_requests(host))
        sdhci_led_deactivate(host);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

II. sdhci_request_done

执行完该函数,才意味着完成了一次通信

static bool sdhci_request_done(struct sdhci_host *host)
{
    unsigned long flags;
    struct mmc_request *mrq;
    int i;

    spin_lock_irqsave(&host->lock, flags);
	// 获取要完成的请求
    for (i = 0; i < SDHCI_MAX_MRQS; i++) {
        mrq = host->mrqs_done[i];
        if (mrq)
            break;
    }
	// 如果要完成的请求是空的,直接返回就行了
    if (!mrq) {
        spin_unlock_irqrestore(&host->lock, flags);
        return true;
    }

    /* 删除如果出错或因为其他原因重启host的代码 */

    /*
     * Always unmap the data buffers if they were mapped by
     * sdhci_prepare_data() whenever we finish with a request.
     * This avoids leaking DMA mappings on error.
     */
    /* 删除了一些dma相关的操作 */
	// mrqs_done一共有两个,循环利用,这里这个到这里可以置空了
    host->mrqs_done[i] = NULL;

    spin_unlock_irqrestore(&host->lock, flags);

    if (host->ops->request_done)
        host->ops->request_done(host, mrq);
	else
		// 调用mmc层的函数,实际上就是执行mrq->done = mmc_wait_done;
		// 该函数中间有一些调试打印,无关紧要
		// 而done执行:complete(&mrq->completion);
		// 而该完成量在mmc_wait_for_req_done进行等待
        mmc_request_done(host->mmc, mrq);

    return false;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

6.8 mmc_wait_for_req_done

在这里插入图片描述

void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq)
{
    struct mmc_command *cmd;

	while (1) {
		// 等待完成量
        wait_for_completion(&mrq->completion);

        cmd = mrq->cmd;
		// 没有报错,说明这次通信成功了,没有重试次数了
		// 卡拔出了,都退出
        if (!cmd->error || !cmd->retries ||
            mmc_card_removed(host->card))
            break;

        mmc_retune_recheck(host);

        pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
             mmc_hostname(host), cmd->opcode, cmd->error);
		// 非上述3种情况,重试次数自减,错误清0,然后继续执行通信
        cmd->retries--;
        cmd->error = 0;
        __mmc_start_request(host, mrq);
    }

    mmc_retune_release(host);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

7. 通信(数据)

本章节分析mmc子系统的通信流程,以上面emmc扫卡识别中,使用的mmc_read_ext_csd ->mmc_get_ext_csd ->mmc_send_cxd_data (扩展寄存器读)为例进行分析。实际上对比命令通信,数据通信多了设置数据通信量(写04H/06H)并执行数据通信操作,中断和超时处理略有差异
在这里插入图片描述

7.1 mmc_send_cxd_data

在上一层级,调用参数为:mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, ext_csd, 512);其中MMC_SEND_EXT_CSD的值为8,即使用cmd8进行通信

static int
mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
        u32 opcode, void *buf, unsigned len)
{
    struct mmc_request mrq = {};
    struct mmc_command cmd = {};
    struct mmc_data data = {};
    struct scatterlist sg;

    mrq.cmd = &cmd;
    mrq.data = &data;

    cmd.opcode = opcode;
    cmd.arg = 0;

    /* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
     * rely on callers to never use this with "native" calls for reading
     * CSD or CID.  Native versions of those commands use the R2 type,
     * not R1 plus a data block.
     */
    cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
	// 这里填充数据,块大小512,块个数1个,进行块读
    data.blksz = len;
    data.blocks = 1;
    data.flags = MMC_DATA_READ;
    data.sg = &sg;
    data.sg_len = 1;

    sg_init_one(&sg, buf, len);

    if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
        /*
         * The spec states that CSR and CID accesses have a timeout
         * of 64 clock cycles.
         */
        data.timeout_ns = 0;
        data.timeout_clks = 64;
	} else
		// 计算确定data->timeout_ns和data.timeout_clks
        mmc_set_data_timeout(&data, card);
	// 回到了熟悉的环节,这里我们来分析一下和data通信相关,
	// 在之前未分析的函数
    mmc_wait_for_req(host, &mrq);

    if (cmd.error)
        return cmd.error;
    if (data.error)
        return data.error;

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

7.2 sdhci_prepare_data

在执行sdhci_send_command时,如果cmd->data不空,则需要对data进行“前期准备”的操作

static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
{
    struct mmc_data *data = cmd->data;
	// 执行 host->data = data; 并对块大小校验
	// BUG_ON(data->blksz * data->blocks > 524288); // 512K
	// BUG_ON(data->blksz > host->mmc->max_blk_size);
	// BUG_ON(data->blocks > 65535);
    sdhci_initialize_data(host, data);

    /* 删除大段dma相关设置,DMA相关的不分析 */
    sdhci_config_dma(host);
    /* 删除大段dma相关设置,DMA相关的不分析 */
	// 使能数据中断
    sdhci_set_transfer_irqs(host);
	// 见下
    sdhci_set_block_info(host, data);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

7.3 sdhci_set_block_info

static inline void sdhci_set_block_info(struct sdhci_host *host,
                    struct mmc_data *data)
{
	/* Set the DMA boundary value and block size */
	// 配置04H寄存器,设置读写的块大小
    sdhci_writew(host,
             SDHCI_MAKE_BLKSZ(host->sdma_boundary, data->blksz),
             SDHCI_BLOCK_SIZE);
	/* 删除一种(SDHCI_QUIRK2_USE_32BIT_BLK_CNT)的特殊情况 */
	// 配置06H寄存器,设置写入的块数量
    sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
    // 一次读写入的块大小*读写入的块数量 = 总计读写的数据量
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

I. sdhci主机控制器04H寄存器

在这里插入图片描述
在这里插入图片描述

II. sdhci主机控制器06H寄存器

在这里插入图片描述
在这里插入图片描述

7.4 sdhci_data_irq

在这里插入图片描述

static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
{
    u32 command;

	/* CMD19 generates _only_ Buffer Read Ready interrupt */
	// 命令19和命令21都是用来调速的测试命令,到这里就算tuning完成
    if (intmask & SDHCI_INT_DATA_AVAIL) {
        command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
        if (command == MMC_SEND_TUNING_BLOCK ||
            command == MMC_SEND_TUNING_BLOCK_HS200) {
            host->tuning_done = 1;
            wake_up(&host->buf_ready_int);
            return;
        }
    }
	// 没有数据的数据中断,即在发送命令时,是MMC_RSP_BUSY的状态
    if (!host->data) {
        struct mmc_command *data_cmd = host->data_cmd;

        /*
         * The "data complete" interrupt is also used to
         * indicate that a busy state has ended. See comment
         * above in sdhci_cmd_irq().
         */

        if (data_cmd && (data_cmd->flags & MMC_RSP_BUSY)) {
            if (intmask & SDHCI_INT_DATA_TIMEOUT) {
                host->data_cmd = NULL;
                data_cmd->error = -ETIMEDOUT;
				// 这个cmd也发送超时了
                __sdhci_finish_mrq(host, data_cmd->mrq);
                return;
            }
            if (intmask & SDHCI_INT_DATA_END) {
                host->data_cmd = NULL;
                /*
                  * 有些卡在命令完成之前就处理了忙碌结束中断,
				  * 因此请确保我们按照正确的顺序进行操作。
                  */
                if (host->cmd == data_cmd)
                    return;

                __sdhci_finish_mrq(host, data_cmd->mrq);
                return;
            }
        }

        /*
         * SDHCI通过重置命令和数据电路从错误中恢复。
         * 在那之前,很可能还会有更多的中断,所以在这种情况下忽略它们。
         */
        if (host->pending_reset)
            return;

        pr_err("%s: Got data interrupt 0x%08x even though no data operation was in progress.\n",
               mmc_hostname(host->mmc), (unsigned)intmask);
        sdhci_dumpregs(host);
        return;
    }
	// 根据中断状态标记错误
    if (intmask & SDHCI_INT_DATA_TIMEOUT)
        host->data->error = -ETIMEDOUT;
    else if (intmask & SDHCI_INT_DATA_END_BIT)
        host->data->error = -EILSEQ;
    else if ((intmask & SDHCI_INT_DATA_CRC) &&
        SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND))
            != MMC_BUS_TEST_R)
        host->data->error = -EILSEQ;
    else if (intmask & SDHCI_INT_ADMA_ERROR) {
        pr_err("%s: ADMA error: 0x%08x\n", mmc_hostname(host->mmc),
               intmask);
        sdhci_adma_show_error(host);
        host->data->error = -EIO;
        if (host->ops->adma_workaround)
            host->ops->adma_workaround(host, intmask);
    }
	// 如果发生了错误,执行finish
    if (host->data->error)
        sdhci_finish_data(host);
	else {
		// 中断状态为:buffer可读可写
        if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
			// 下面详细分析
            sdhci_transfer_pio(host);

        /* DMA相关删除 */

        if (intmask & SDHCI_INT_DATA_END) {
            if (host->cmd == host->data_cmd) {
                /*
                 * Data managed to finish before the
                 * command completed. Make sure we do
                 * things in the proper order.
                 */
				// 数据比命令完成的还快,需要做特殊处理
				// 在sdhci_cmd_irq->sdhci_finish_command,
				// 会判断该标志,最后执行sdhci_finish_data
                host->data_early = 1;
            } else {
				// 下面详细分析
                sdhci_finish_data(host);
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105

7.5 sdhci_transfer_pio

在这里完成真正的数据读写

static void sdhci_transfer_pio(struct sdhci_host *host)
{
    u32 mask;

    if (host->blocks == 0)
        return;
	// 判断是要读还是要写,置位掩码
    if (host->data->flags & MMC_DATA_READ)
        mask = SDHCI_DATA_AVAILABLE;
    else
        mask = SDHCI_SPACE_AVAILABLE;

    /* 删除部分特性的特殊处理 */

	// 读状态寄存器24H,判断D10/D9
    while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
        if (host->quirks & SDHCI_QUIRK_PIO_NEEDS_DELAY)
            udelay(100);
		// 实际就是将数据读/写入20H寄存器
        if (host->data->flags & MMC_DATA_READ)
            sdhci_read_block_pio(host);
        else
            sdhci_write_block_pio(host);
		// 直到读写完全部块
        host->blocks--;
        if (host->blocks == 0)
            break;
    }

    DBG("PIO transfer complete.\n");
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

I. sdhci主机控制器20H寄存器

在这里插入图片描述

7.6 sdhci_finish_data

在这里插入图片描述

static void sdhci_finish_data(struct sdhci_host *host)
{
    __sdhci_finish_data(host, false);
}

static void __sdhci_finish_data(struct sdhci_host *host, bool sw_data_timeout)
{
    struct mmc_command *data_cmd = host->data_cmd;
    struct mmc_data *data = host->data;
	// 数据都清掉
    host->data = NULL;
    host->data_cmd = NULL;

    /*
     * The controller needs a reset of internal state machines upon error
     * conditions.
     */
	if (data->error) {
		// 如果有报错,尝试复位
        if (!host->cmd || host->cmd == data_cmd)
            sdhci_do_reset(host, SDHCI_RESET_CMD);
        sdhci_do_reset(host, SDHCI_RESET_DATA);
    }

    /* DMA删 */

    /*
     * 规范指出必须更新块计数寄存器,
     * 但并未具体说明在数据流的哪个点进行更新。
     * 这使得寄存器读取回来完全没有用处,
     * 因此我们必须假设在发生错误时没有任何数据被传送到卡中。
     */
    if (data->error)
        data->bytes_xfered = 0;
    else
        data->bytes_xfered = data->blksz * data->blocks;

    /*
     * Need to send CMD12 if -
     * a) open-ended multiblock transfer not using auto CMD12 (no CMD23)
     * b) error in multiblock transfer
     */
	// 如果不支持自动cmd12,并且还需要发stop,或者数据通信有报错
	// 通过sdhci_send_command发stop
    if (data->stop &&
        ((!data->mrq->sbc && !sdhci_auto_cmd12(host, data->mrq)) ||
         data->error)) {
        /*
         * 'cap_cmd_during_tfr' request must not use the command line
         * after mmc_command_done() has been called. It is upper layer's
         * responsibility to send the stop command if required.
         */
        if (data->mrq->cap_cmd_during_tfr) {
            __sdhci_finish_mrq(host, data->mrq);
        } else {
            /* Avoid triggering warning in sdhci_send_command() */
            host->cmd = NULL;
            if (!sdhci_send_command(host, data->stop)) {
                if (sw_data_timeout) {
                    /*
                     * This is anyway a sw data timeout, so
                     * give up now.
                     */
					// 如果是因为超时进来的,然后发stop的cmd也失败了
					// 说明硬件可能有问题,置io错误
                    data->stop->error = -EIO;
                    __sdhci_finish_mrq(host, data->mrq);
                } else {
                    WARN_ON(host->deferred_cmd);
					// 如果不是因为超时进来,但是命令还发送失败了
					// 将命令推迟执行,在下次中断执行时候,会执行
					// sdhci_thread_irq,这个后面分析
                    host->deferred_cmd = data->stop;
                }
            }
        }
	} else {
		// 执行完成
        __sdhci_finish_mrq(host, data->mrq);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81

7.7 sdhci_timeout_data_timer

在这里插入图片描述

static void sdhci_timeout_data_timer(struct timer_list *t)
{
    struct sdhci_host *host;
    unsigned long flags;

    host = from_timer(host, t, data_timer);

    spin_lock_irqsave(&host->lock, flags);
	// 有数据,或者需要使用数据线发送
    if (host->data || host->data_cmd ||
        (host->cmd && sdhci_data_line_cmd(host->cmd))) {
        pr_err("%s: Timeout waiting for hardware interrupt.\n",
               mmc_hostname(host->mmc));
        sdhci_dumpregs(host);
		// 置超时错误
        if (host->data) {
            host->data->error = -ETIMEDOUT;
            __sdhci_finish_data(host, true);
			// 唤醒sdhci_complete_work,执行sdhci_request_done
            queue_work(host->complete_wq, &host->complete_work);
        } else if (host->data_cmd) {
            host->data_cmd->error = -ETIMEDOUT;
            sdhci_finish_mrq(host, host->data_cmd->mrq);
        } else {
            host->cmd->error = -ETIMEDOUT;
            sdhci_finish_mrq(host, host->cmd->mrq);
        }
    }

    spin_unlock_irqrestore(&host->lock, flags);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

8. 中断

在前文已经初步分析过了中断,数据通信过程中的sdhci_data_irq和sdhci_cmd_irq,实际上中断还要处理其他事件,比如sd卡的热插拔等,直接分析源码。

8.1 sdhci_irq

主机控制器的中断在注册阶段通过request_threaded_irq(host->irq, sdhci_irq, sdhci_thread_irq, IRQF_SHARED , mmc_hostname ( host->mmc ), host); 进行绑定。主机控制器中断中处理包括:数据,命令,热插拔等事件,最终确保非空的mrq_done一定能够唤醒request_done

static irqreturn_t sdhci_irq(int irq, void *dev_id)
{
    struct mmc_request *mrqs_done[SDHCI_MAX_MRQS] = {0};
    irqreturn_t result = IRQ_NONE;
    struct sdhci_host *host = dev_id;
    u32 intmask, mask, unexpected = 0;
    int max_loops = 16;
    int i;

    spin_lock(&host->lock);
	// 运行过程中被挂起,中断不处理了
    if (host->runtime_suspended) {
        spin_unlock(&host->lock);
        return IRQ_NONE;
    }
	// 读取30H+32H中断状态和中断错误状态寄存器
    intmask = sdhci_readl(host, SDHCI_INT_STATUS);
    if (!intmask || intmask == 0xffffffff) {
        result = IRQ_NONE;
        goto out;
    }

	do {
		// 根据中断状态循环进行处理
        DBG("IRQ status 0x%08x\n", intmask);
		// 如果控制器底层还有额外的处理流程,就执行
        if (host->ops->irq) {
            intmask = host->ops->irq(host, intmask);
            if (!intmask)
                goto cont;
        }

        /* Clear selected interrupts. */
        mask = intmask & (SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK |
                  SDHCI_INT_BUS_POWER);
		// 清除cmd,data和SD BUS POWER错误
        sdhci_writel(host, mask, SDHCI_INT_STATUS);

        if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
			// 卡插入或拔出,获取卡状态
            u32 present = (sdhci_readl(host, SDHCI_PRESENT_STATE) &
                      SDHCI_CARD_PRESENT);

            /*
             * There is a observation on i.mx esdhc.  INSERT
             * bit will be immediately set again when it gets
             * cleared, if a card is inserted.  We have to mask
             * the irq to prevent interrupt storm which will
             * freeze the system.  And the REMOVE gets the
             * same situation.
             *
             * More testing are needed here to ensure it works
             * for other platforms though.
             */
			// 重新使能卡插入或拔出中断
            host->ier &= ~(SDHCI_INT_CARD_INSERT |
                       SDHCI_INT_CARD_REMOVE);
            host->ier |= present ? SDHCI_INT_CARD_REMOVE :
                           SDHCI_INT_CARD_INSERT;
            sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
            sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
			// 清除中断标志
            sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT |
                     SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);
			// 中断线程中标记是卡插拔
            host->thread_isr |= intmask & (SDHCI_INT_CARD_INSERT |
                               SDHCI_INT_CARD_REMOVE);
			// 只有返回IRQ_WAKE_THREAD,后续才会调用中断线程
            result = IRQ_WAKE_THREAD;
        }
		// 命令处理
        if (intmask & SDHCI_INT_CMD_MASK)
            sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK, &intmask);
		// 数据处理
        if (intmask & SDHCI_INT_DATA_MASK)
            sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK);
		
        /* 删部分 */

		// 将已经处理的中断都清掉
        intmask &= ~(SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE |
                 SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK |
                 SDHCI_INT_ERROR | SDHCI_INT_BUS_POWER |
                 SDHCI_INT_RETUNE | SDHCI_INT_CARD_INT);
		// 如果还是非0,说明有中断处理不了,是异常的
        if (intmask) {
            unexpected |= intmask;
			// 吧能处理的中断清掉
            sdhci_writel(host, intmask, SDHCI_INT_STATUS);
        }
cont:
        if (result == IRQ_NONE)
            result = IRQ_HANDLED;
		// 在读中断状态
        intmask = sdhci_readl(host, SDHCI_INT_STATUS);
    } while (intmask && --max_loops);

    /* Determine if mrqs can be completed immediately */
    for (i = 0; i < SDHCI_MAX_MRQS; i++) {
        struct mmc_request *mrq = host->mrqs_done[i];

        if (!mrq)
            continue;
		// 由于各种原因请求完成需要被推迟
        if (sdhci_defer_done(host, mrq)) {
            result = IRQ_WAKE_THREAD;
        } else {
			// 到这里,只要非空的请求,要确保最后一定能完成
            mrqs_done[i] = mrq;
            host->mrqs_done[i] = NULL;
        }
    }
out:
	// 如果有被推迟的命令,唤醒中断线程
    if (host->deferred_cmd)
        result = IRQ_WAKE_THREAD;

    spin_unlock(&host->lock);

    /* Process mrqs ready for immediate completion */
    for (i = 0; i < SDHCI_MAX_MRQS; i++) {
        if (!mrqs_done[i])
            continue;
		// 上面获取到的需要完成的mrq,这里唤醒完成请求
        if (host->ops->request_done)
            host->ops->request_done(host, mrqs_done[i]);
        else
            mmc_request_done(host->mmc, mrqs_done[i]);
    }
	// 有异常,抛出相关打印
    if (unexpected) {
        pr_err("%s: Unexpected interrupt 0x%08x.\n",
               mmc_hostname(host->mmc), unexpected);
        sdhci_dumpregs(host);
    }

    return result;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138

8.2 sdhci_thread_irq

中断线程(下半部),处理被推迟的命令或可以被完成的请求,处理卡插拔,并重新触发扫卡逻辑

static irqreturn_t sdhci_thread_irq(int irq, void *dev_id)
{
    struct sdhci_host *host = dev_id;
    struct mmc_command *cmd;
    unsigned long flags;
    u32 isr;
	// 被推迟的mrq_done在这里进行处理
    while (!sdhci_request_done(host))
        ;

    spin_lock_irqsave(&host->lock, flags);
	// 插拔卡的标记获取
    isr = host->thread_isr;
    host->thread_isr = 0;
	// 被推迟的命令获取
	cmd = host->deferred_cmd;
	// 如果命令非空,并且重试了还执行不成功
	if (cmd && !sdhci_send_command_retry(host, cmd, flags))
	// 强制完成拉倒
        sdhci_finish_mrq(host, cmd->mrq);

    spin_unlock_irqrestore(&host->lock, flags);

    if (isr & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
        struct mmc_host *mmc = host->mmc;
		// 处理卡插拔,然后重新执行扫卡
        mmc->ops->card_event(mmc);
        mmc_detect_change(mmc, msecs_to_jiffies(200));
    }

    return IRQ_HANDLED;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

9. 块设备

emmc或sd最终要注册成一个块设备供上层使用的。其实在注册章节,我们有一步是没有分析的,就是如何注册成一个块设备。以及作为一个块设备,是怎样被上层调用并进行数据通信的。

9.1 作为块设备的注册

如下图为实际作为块设备的注册流程,在mmc/core/block.c中会先进行mmc_blk_init,并进行驱动注册(注册mmc_driver,见下图),随后mmc_add_card执行时,经由device_add与实际驱动进行匹配,最终注册成一个mmcblk设备
在这里插入图片描述
在这里插入图片描述

I. mmc_blk_probe

static int mmc_blk_probe(struct mmc_card *card)
{
    struct mmc_blk_data *md, *part_md;
    char cap_str[10];

    /*
     * Check that the card supports the command class(es) we need.
     */
	// 需要保证这个块设备可以读取
    if (!(card->csd.cmdclass & CCC_BLOCK_READ))
        return -ENODEV;
	// 申请一个工作队列
    card->complete_wq = alloc_workqueue("mmc_complete",
                    WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
    if (unlikely(!card->complete_wq)) {
        pr_err("Failed to create mmc completion workqueue");
        return -ENOMEM;
    }
	// 获取扇区大小后执行mmc_blk_alloc_req
	// 对于emmc设备来说,其容量是从ext_csd寄存器的sectors域获取
	// 对于sd card来说,其容量是从csd的capacity域获取的
	// 计算方法memory capacity = (C_SIZE+1) * 512K byte
    md = mmc_blk_alloc(card);
    if (IS_ERR(md))
        return PTR_ERR(md);
	// 获取卡容量
    string_get_size((u64)get_capacity(md->disk), 512, STRING_UNITS_2,
            cap_str, sizeof(cap_str));
	// 打印关键信息,块设备号,mmc号+RCA地址,卡名,和容量
    pr_info("%s: %s %s %s %s\n",
        md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
        cap_str, md->read_only ? "(ro)" : "");
	// 为物理分区(例如rpmb分区)分配和设置mmc_blk_data下面分析
    if (mmc_blk_alloc_parts(card, md))
        goto out;
	// dev->driver_data = md;
    dev_set_drvdata(&card->dev, md);
	// 将mmc_blk构造的gendisk注册到系统中,识别分区,生成对应的块设备
	// 然后在将其加入到sysfs中,具体就不解析了
    if (mmc_add_disk(md))
        goto out;

	list_for_each_entry(part_md, &md->part, part) {
		// 列出这个设备的所有分区,并add_disk
        if (mmc_add_disk(part_md))
            goto out;
    }

	/* Add two debugfs entries */
	// debug_fs
    mmc_blk_add_debugfs(card, md);

    /* 电源管理删 */
    return 0;

 out:
    mmc_blk_remove_parts(card, md);
    mmc_blk_remove_req(md);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60

II. mmc_blk_alloc_req

static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
                          struct device *parent,
                          sector_t size,
                          bool default_ro,
                          const char *subname,
                          int area_type)
{
    struct mmc_blk_data *md;
    int devidx, ret;
	// 分配一个mmcblk的从设备号
    devidx = ida_simple_get(&mmc_blk_ida, 0, max_devices, GFP_KERNEL);
    if (devidx < 0) {
        if (devidx == -ENOSPC)
            dev_err(mmc_dev(card->host),
                "no more device IDs available\n");

        return ERR_PTR(devidx);
    }
	// 分配struct mmc_blk_data的空间
    md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
    if (!md) {
        ret = -ENOMEM;
        goto out;
    }

    md->area_type = area_type;

    /*
     * Set the read-only status based on the supported commands
     * and the write protect switch.
     */
	// 是否只读?
    md->read_only = mmc_blk_readonly(card);
	// 调用alloc_disk分配一个gendisk结构体
    md->disk = alloc_disk(perdev_minors);
    if (md->disk == NULL) {
        ret = -ENOMEM;
        goto err_kfree;
    }
	// 初始化挂载其他物理分区的链表和挂载rpmbs物理分区的链表
    INIT_LIST_HEAD(&md->part);
	INIT_LIST_HEAD(&md->rpmbs);
	// 使用计数设置为1
    md->usage = 1;
	// 初始化队列,该函数也及其复杂,涉及块设备和队列,以后分析块设备层在分析
	// 主要是设置mmc_mq_ops,见下图
	// 通过blk_mq_init_queue申请md->queue
	// blk_queue_rq_timeout(mq->queue, 60 * HZ);超时时间60HZ
	// 执行mmc_setup_queue,初始化一些锁和工作队列,具体不分析
    ret = mmc_init_queue(&md->queue, card);
    if (ret)
        goto err_putdisk;

    md->queue.blkdata = md;

    /*
     * Keep an extra reference to the queue so that we can shutdown the
     * queue (i.e. call blk_cleanup_queue()) while there are still
     * references to the 'md'. The corresponding blk_put_queue() is in
     * mmc_blk_put().
     */
    if (!blk_get_queue(md->queue.queue)) {
        mmc_cleanup_queue(&md->queue);
        ret = -ENODEV;
        goto err_putdisk;
    }

	md->disk->major = MMC_BLOCK_MAJOR;
	// 每个设备的子设备号,其中
	// perdev_minors = CONFIG_MMC_BLOCK_MINORS(32)
	// 可以见我手里的设备,分区和子设备号,是符合的
    md->disk->first_minor = devidx * perdev_minors;
    md->disk->fops = &mmc_bdops;
	md->disk->private_data = md;
	// 关联gendisk和request_queue
    md->disk->queue = md->queue.queue;
	md->parent = parent;
	// 设置gendisk的只读属性
    set_disk_ro(md->disk, md->read_only || default_ro);
    md->disk->flags = GENHD_FL_EXT_DEVT;
    if (area_type & (MMC_BLK_DATA_AREA_RPMB | MMC_BLK_DATA_AREA_BOOT))
        md->disk->flags |= GENHD_FL_NO_PART_SCAN
                   | GENHD_FL_SUPPRESS_PARTITION_INFO;
    
	// 设置gendisk的容量,size是以扇区为单位
    set_capacity(md->disk, size);

    /* 删除部分 */

    return md;

 err_putdisk:
    put_disk(md->disk);
 err_kfree:
    kfree(md);
 out:
    ida_simple_remove(&mmc_blk_ida, devidx);
    return ERR_PTR(ret);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99

在这里插入图片描述
在这里插入图片描述

III. mmc_blk_alloc_parts

对于emmc设备在执行mmc_decode_ext_csd过程中,会根据扩展csd寄存器判断boot0/1,rpmb的大小是否能够正常访问,以及是否存在gp分区(可配的)。一个emmc的标准分区如下。在解码扩展csd时并通过mmc_part_add将识别到的分区进行添加(顺带添加了分区标识)
在这里插入图片描述

static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
{
    int idx, ret;

    if (!mmc_card_mmc(card))
        return 0;

    for (idx = 0; idx < card->nr_parts; idx++) {
        if (card->part[idx].area_type & MMC_BLK_DATA_AREA_RPMB) {
            /*
             * RPMB partitions does not provide block access, they
             * are only accessed using ioctl():s. Thus create
             * special RPMB block devices that do not have a
             * backing block queue for these.
             */
            ret = mmc_blk_alloc_rpmb_part(card, md,
                card->part[idx].part_cfg,
                card->part[idx].size >> 9,
                card->part[idx].name);
            if (ret)
                return ret;
        } else if (card->part[idx].size) {
            ret = mmc_blk_alloc_part(card, md,
                card->part[idx].part_cfg,
                card->part[idx].size >> 9,
                card->part[idx].force_ro,
                card->part[idx].name,
                card->part[idx].area_type);
            if (ret)
                return ret;
        }
    }

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

以普通分区添加为例:

static int mmc_blk_alloc_part(struct mmc_card *card,
                  struct mmc_blk_data *md,
                  unsigned int part_type,
                  sector_t size,
                  bool default_ro,
                  const char *subname,
                  int area_type)
{
    char cap_str[10];
    struct mmc_blk_data *part_md;
	// 依旧是调用mmc_blk_alloc_req,申请子分区的结构
    part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro, subname, area_type);
    if (IS_ERR(part_md))
        return PTR_ERR(part_md);
	part_md->part_type = part_type;
	// 加入到链表中
    list_add(&part_md->part, &md->part);
	// 设置容量
	string_get_size((u64)get_capacity(part_md->disk), 512, STRING_UNITS_2, cap_str, sizeof(cap_str));
	// 打印见下图
    pr_info("%s: %s %s partition %u %s\n",
           part_md->disk->disk_name, mmc_card_id(card),
           mmc_card_name(card), part_md->part_type, cap_str);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

实际设备识别后的分区,当然这里没包括用户分区
在这里插入图片描述

IV. 用户分区识别

执行mmc_add_disk时会进行disk注册,这期间会执行块设备的分区扫描,具体执行函数路径为如下图所示
在这里插入图片描述
然后check_partition根据check_part支持的分区划分进行匹配,比如我手里的设备,emmc使用的cmdline分区
在这里插入图片描述
在具体的这里就不在分析了,后续有空分析一下block层在具体分析。

9.2 block层的调用

如下图,使用ftrace跟踪的一次sync后,数据写入emmc的函数调用情况
在这里插入图片描述
执行一次数据写入,跟踪如下
在这里插入图片描述
具体的这里就不在详细分析了,我们只来简单看一下mmc_blk_mq_issue_rq函数

I. mmc_blk_mq_issue_rq

emmc作为块设备,经过一系列块层调用(工作队列),最后一定会执行到该函数,进行读写或者刷cache的请求,比如sync,最终调用到mmc_blk_issue_flush;数据写入,最终调用到mmc_blk_mq_issue_rw_rq。然后在执行部分数据处理,最终又调用到了mmc_start_request,完成数据读写。至此,mmc子系统和block层也就彻底连起来了

enum mmc_issued mmc_blk_mq_issue_rq(struct mmc_queue *mq, struct request *req)
{
    struct mmc_blk_data *md = mq->blkdata;
    struct mmc_card *card = md->queue.card;
    struct mmc_host *host = card->host;
    int ret;

    ret = mmc_blk_part_switch(card, md->part_type);
    if (ret)
        return MMC_REQ_FAILED_TO_START;

    switch (mmc_issue_type(mq, req)) {
    case MMC_ISSUE_SYNC:
        ret = mmc_blk_wait_for_idle(mq, host);
        if (ret)
            return MMC_REQ_BUSY;
        switch (req_op(req)) {
        case REQ_OP_DRV_IN:
        case REQ_OP_DRV_OUT:
            mmc_blk_issue_drv_op(mq, req);
            break;
        case REQ_OP_DISCARD:
            mmc_blk_issue_discard_rq(mq, req);
            break;
        case REQ_OP_SECURE_ERASE:
            mmc_blk_issue_secdiscard_rq(mq, req);
            break;
        case REQ_OP_FLUSH:
            mmc_blk_issue_flush(mq, req);
            break;
        default:
            WARN_ON_ONCE(1);
            return MMC_REQ_FAILED_TO_START;
        }
        return MMC_REQ_FINISHED;
    case MMC_ISSUE_DCMD:
    case MMC_ISSUE_ASYNC:
        switch (req_op(req)) {
        case REQ_OP_FLUSH:
            if (!mmc_cache_enabled(host)) {
                blk_mq_end_request(req, BLK_STS_OK);
                return MMC_REQ_FINISHED;
            }
            ret = mmc_blk_cqe_issue_flush(mq, req);
            break;
        case REQ_OP_READ:
        case REQ_OP_WRITE:
            if (mq->use_cqe)
                ret = mmc_blk_cqe_issue_rw_rq(mq, req);
            else
                ret = mmc_blk_mq_issue_rw_rq(mq, req);
            break;
        default:
            WARN_ON_ONCE(1);
            ret = -EINVAL;
        }
        if (!ret)
            return MMC_REQ_STARTED;
        return ret == -EBUSY ? MMC_REQ_BUSY : MMC_REQ_FAILED_TO_START;
    default:
        WARN_ON_ONCE(1);
        return MMC_REQ_FAILED_TO_START;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

10. 参考文档

  1. emmc5.1协议+4.51中文版
  2. SD3.0协议
  3. PartA2_SD Host_Controller_Simplified_Specification_Ver4.20
  4. https://blog.csdn.net/lickylin/article/details/104717742
  5. http://www.wowotech.net/basic_tech/mmc_sd_sdio_intro.html
  6. SD 卡 和 microSD 卡速度等级指南- 金士顿科技 (kingston.com.cn)
  7. https://blog.csdn.net/u013606261/article/details/112567922
  8. https://blog.csdn.net/swanghn/article/details/112643632
  9. https://www.cnblogs.com/cslunatic/p/3678045.html
  10. https://www.cnblogs.com/linhaostudy/p/10790115.html
  11. https://www.cnblogs.com/linhaostudy/p/10813200.html#_label1_0
  12. https://blog.csdn.net/wzm_c1386666/article/details/120618363 (对__mmc_claim_host讲解)
声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号