插曲：
因为使用的平台是telechips的tcc803x，其芯片用户手册描述寄存器都是四字节寻址的，但是在代码驱动中用的很可能是单字节寻址，咋一看，有可能有的地址在芯片手册上没有或者感觉写错了，其实不是，这个需要注意一下。
简单流程：
mmc host主控器注册完成之后，会分别生成一个底层硬件相关的主控制设备（struct）sdhci_host和通用抽象的主控制器设备（struct）mmc_host，当检测到有sd卡等mmc从设备插入时，mmc host主控制器会向sd卡等mmc从设备发起会话，sd卡等从设备作出相应的应答。mmc host主控制建立会话的机制是先通过通用抽象的（struct）mmc_host主设备的通用操作集（struct）mmc_host_ops，再由通用操作集（struct）mmc_host_ops进一步调用底层硬件相关的操作集（struct）sdhci_ops实现主从设备的通信的。
转载：linux MMC framework(2) - sdhci host driver_Hacker_Albert的博客-优快云博客
注册mmc主控制器：
static int sdhci_tcc_probe(struct platform_device *pdev)
{
const struct of_device_id *match;
const struct sdhci_tcc_soc_data *soc_data;
struct sdhci_host *host;
struct sdhci_pltfm_host *pltfm_host;
struct sdhci_tcc *tcc = NULL;
match = of_match_device(sdhci_tcc_of_match_table, &pdev->dev);
soc_data = match->data;
host = sdhci_pltfm_init(pdev, soc_data->pdata, sizeof(*tcc));
pltfm_host = sdhci_priv(host);
tcc = sdhci_pltfm_priv(pltfm_host);
sdhci_get_of_property(pdev);
mmc_of_parse(host->mmc);
sdhci_tcc_parse_configs(pdev, host);
//设置SDMMC1的基础时钟，即PCLKCTL_IO2,输出到外设SDMMC1的时钟
tcc->soc_data->set_core_clock(host);
sdhci_add_host(host);
}sdhci_tcc_of_match_table表：
static const struct of_device_id sdhci_tcc_of_match_table[] = {
{ .compatible = "telechips,tcc803x-sdhci,module-only", .data = &soc_data_tcc803x},
{}
};表里的soc_data_tcc803x结构：
static const struct sdhci_tcc_soc_data soc_data_tcc803x = {
.pdata = &sdhci_tcc803x_pdata,
.parse_channel_configs = sdhci_tcc803x_parse_channel_configs,
.set_channel_configs = sdhci_tcc803x_set_channel_configs,
.set_core_clock = sdhci_tcc803x_set_core_clock,
.sdhci_tcc_quirks = 0,
};sdhci_tcc803x_pdata平台数据结构：
static const struct sdhci_pltfm_data sdhci_tcc803x_pdata = {
.ops = &sdhci_tcc803x_ops,
//重点关注quirks，表示异于通常特性
.quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN,
.quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN |
SDHCI_QUIRK2_STOP_WITH_TC,
};sdhci_tcc803x_ops操作集：
static const struct sdhci_ops sdhci_tcc803x_ops = {
.get_max_clock = sdhci_tcc803x_clk_get_max_clock,
.set_clock = sdhci_tcc_set_clock,
.set_bus_width = sdhci_set_bus_width,
.reset = sdhci_tcc_reset,
.hw_reset = sdhci_tcc_hw_reset,
.set_uhs_signaling = sdhci_set_uhs_signaling,
.get_ro = sdhci_tcc_get_ro,
};sdhci_ops与主控制硬件打交道，所以是再host主控制器驱动中实现的。
重新回到probe函数，看sdhci_pltfm_init函数：
struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev,
const struct sdhci_pltfm_data *pdata,
size_t priv_size)
{
struct sdhci_host *host;
//分配一个struct sdhci_host结构空间，附带分配一个struct sdhci_pltfm_host结构空间
//和一个priv_size大小的空间
host = sdhci_alloc_host(&pdev->dev,sizeof(struct sdhci_pltfm_host) + priv_size);
if (pdata && pdata->ops)
host->ops = pdata->ops; //对应上面定义的struct sdhci_ops sdhci_tcc803x_ops变量
return host;
}sdhci_alloc_host函数：
struct sdhci_host *sdhci_alloc_host(struct device *dev,
size_t priv_size)
{
struct mmc_host *mmc;
struct sdhci_host *host;
//在分配一个mmc_host内存空间的同时也分配了一个sdhci_host内存空间以及sdhci_host附属空间
mmc = mmc_alloc_host(sizeof(struct sdhci_host) + priv_size, dev);
host = mmc_priv(mmc);
host->mmc = mmc;
host->mmc_host_ops = sdhci_ops;
mmc->ops = &host->mmc_host_ops;
return host;
}mmc_alloc_host函数：分配一个mmc_host结构体内存空间，也分配了其它以外的内存空间。
struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
{
int err;
struct mmc_host *host;
//除了分配mmc_host内存空间，也分配了其它以外的内存空间
host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
/* scanning will be enabled when we're ready */
host->rescan_disable = 1;
dev_set_name(&host->class_dev, "mmc%d", host->index);
//mmc_host的父设备是probe函数层层传下来的pdev，就是sdhc主控制器设备，即对应sdhc设备节点
host->parent = dev;
host->class_dev.parent = dev;
host->class_dev.class = &mmc_host_class;
device_initialize(&host->class_dev);
init_waitqueue_head(&host->wq);
INIT_DELAYED_WORK(&host->detect, mmc_rescan);
INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host);
return host;
}mmc_priv函数：
static inline void *mmc_priv(struct mmc_host *host)
{
return (void *)host->private;
}mmc_host结构体：
struct mmc_host {
struct device *parent;
struct device class_dev;
const struct mmc_host_ops *ops;
unsigned int f_min;
unsigned int f_max;
unsigned int f_init;
......
unsigned long private[0] ____cacheline_aligned;
}回到probe函数，看sdhci_priv函数：
static inline void *sdhci_priv(struct sdhci_host *host)
{
return host->private;
}sdhci_host结构：
struct sdhci_host {
/* Data set by hardware interface driver */
const char *hw_name; /* Hardware bus name */
const struct sdhci_ops *ops; /* Low level hw interface */
/* Internal data */
struct mmc_host *mmc; /* MMC structure */
struct mmc_host_ops mmc_host_ops; /* MMC host ops */
......
unsigned long private[0] ____cacheline_aligned;
}回到probe函数，继续往下看：
sdhci_get_of_property函数：
void sdhci_get_of_property(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct sdhci_host *host = platform_get_drvdata(pdev);
struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
u32 bus_width;
if (of_get_property(np, "sdhci,auto-cmd12", NULL))
host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
if (of_get_property(np, "sdhci,1-bit-only", NULL) ||
(of_property_read_u32(np, "bus-width", &bus_width) == 0 &&
bus_width == 1))
host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA;
if (sdhci_of_wp_inverted(np))
host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
if (of_get_property(np, "broken-cd", NULL))
host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
if (of_get_property(np, "no-1-8-v", NULL))
host->quirks2 |= SDHCI_QUIRK2_NO_1_8_V;
......
}mmc_of_parse函数：
mmc_of_parse
device_property_read_u32(dev, "bus-width", &bus_width);
......
device_property_read_u32(dev, "max-frequency", &host->f_max);
if (device_property_read_bool(dev, "cap-sd-highspeed"))
host->caps |= MMC_CAP_SD_HIGHSPEED;
......sdhci_tcc803x_set_core_clock函数：
sdhci_tcc803x_set_core_clock
//成员变量mmc的数据类型是struct mmc_host*
clk_set_rate(pltfm_host->clk, host->mmc->f_max);
clk_core_set_rate_nolock
clk_change_rate
core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);static struct clk_ops tcc_peri_ops = {
.set_rate = tcc_peri_set_rate,
......
};tcc_peri_set_rate
//rate传到安全核设置
arm_smccc_smc(SIP_CLK_SET_PCLKCTRL, tcc->id, 1, rate, vflags, 0, 0, 0, &res);sdhci_add_host函数：
int sdhci_add_host(struct sdhci_host *host)
{
sdhci_setup_host(host);
__sdhci_add_host(host);
return 0;
}sdhci_setup_host函数：
sdhci_setup_host
sdhci_read_caps(host);
......
if (host->caps & SDHCI_CAN_DO_HISPD)
mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
......
//host->quirks2见上面pdata有定义
if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
host->caps1 &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 | SDHCI_SUPPORT_DDR50);
}
if (host->caps1 & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 | SDHCI_SUPPORT_DDR50))
mmc->caps |= MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25;
if (host->caps1 & SDHCI_SUPPORT_SDR104) {
mmc->caps |= MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_SDR50;
} else if (host->caps1 & SDHCI_SUPPORT_SDR50) {
mmc->caps |= MMC_CAP_UHS_SDR50;
}
if ((host->caps1 & SDHCI_SUPPORT_DDR50) &&!(host->quirks2 &
SDHCI_QUIRK2_BROKEN_DDR50))
mmc->caps |= MMC_CAP_UHS_DDR50;
sdhci_read_caps函数：
sdhci_read_caps
__sdhci_read_caps(host, NULL, NULL, NULL);
of_property_read_u64(mmc_dev(host->mmc)->of_node,"sdhci-caps-mask",
&dt_caps_mask);
of_property_read_u64(mmc_dev(host->mmc)->of_node,"sdhci-caps", &dt_caps);
......
host->caps = sdhci_readl(host, SDHCI_CAPABILITIES);
host->caps &= ~lower_32_bits(dt_caps_mask);
host->caps |= lower_32_bits(dt_caps);
host->caps1 = sdhci_readl(host, SDHCI_CAPABILITIES_1);
host->caps1 &= ~upper_32_bits(dt_caps_mask);
host->caps1 |= upper_32_bits(dt_caps);__sdhci_add_host函数：
int __sdhci_add_host(struct sdhci_host *host)
{
struct mmc_host *mmc = host->mmc;
.....
sdhci_init(host, 0);
request_threaded_irq(host->irq, sdhci_irq, sdhci_thread_irq,
IRQF_SHARED, mmc_hostname(mmc), host);
.....
mmc_add_host(mmc);
......
return 0;
}sdhc主控制器的中断处理函数分为上半部分sdhci_irq和下半部分sdhci_thread_irq。
sdhci_irq：
static irqreturn_t sdhci_irq(int irq, void *dev_id)
{
irqreturn_t result = IRQ_NONE;
struct sdhci_host *host = dev_id;
u32 intmask, mask, unexpected = 0;
int max_loops = 16;
intmask = sdhci_readl(host, SDHCI_INT_STATUS);
if (!intmask || intmask == 0xffffffff) {
result = IRQ_NONE;
goto out;
}
do {
if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT;
......
result = IRQ_WAKE_THREAD;
}
if (intmask & SDHCI_INT_CMD_MASK){
sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK, &intmask);
}
......
cont:
if (result == IRQ_NONE)
result = IRQ_HANDLED;
intmask = sdhci_readl(host, SDHCI_INT_STATUS);
} while (intmask && --max_loops);
out:
return result;
}
sdhci_cmd_irq函数：
static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask, u32 *intmask_p)
{
......
//#define SDHCI_INT_RESPONSE 0x00000001
if (intmask & SDHCI_INT_RESPONSE){
sdhci_finish_command(host);
}
}中断状态寄存器：
auto-cmd12、auto-cmd23补充：
软件设置控制器相关寄存器，让控制器自行发 stop transfer的命令，即 Auto CMD23或 Auto CMD12。
sdhci_set_transfer_mode函数解析 - xxxdk's blog
struct mmc_request的变量 sbc，即SET_BLOCK_COUNT。
mmc_add_host函数：
mmc_add_host
mmc_start_host
mmc_gpiod_request_cd_irq
_mmc_detect_change
//对应上面的INIT_DELAYED_WORK(&host->detect, mmc_rescan);
mmc_schedule_delayed_work(&host->detect, delay);mmc_rescan函数：该函数是detect工作队列的处理函数，该工作队列只在两个地方被调用，一个是在函数_mmc_detect_change里被调用（该函数虽然可能会被多个地方调用，但是正常时候只在初始化的时候被mmc_sart_host函数调用一次），一个是在函数mmc_rescan里递归调用。
void mmc_rescan(struct work_struct *work)
{
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 */
if (!mmc_card_is_removable(host) && host->rescan_entered)
return;
host->rescan_entered = 1;
.....
/* if there is a _removable_ card registered, check whether it is still present*/
if (host->bus_ops && !host->bus_dead && mmc_card_is_removable(host))
host->bus_ops->detect(host);
......
for (i = 0; i < ARRAY_SIZE(freqs); i++) {
if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
break;
if (freqs[i] <= host->f_min)
break;
}
.....
out:
if (host->caps & MMC_CAP_NEEDS_POLL) //只有SD卡主控制器会递归调用轮询扫描
mmc_schedule_delayed_work(&host->detect, HZ);
}mmc_rescan_try_freq函数：
mmc_rescan_try_freq
mmc_attach_sdio
mmc_sdio_init_card
mmc_set_clock(host, mmc_sdio_get_max_clock(card));mmc_set_clock函数：设置实际频率,除了sdio设备，emmc也是调用该函数设置时钟频率。
void mmc_set_clock(struct mmc_host *host, unsigned int hz)
{
//hz：最高频率，host->f_max:实际设置的频率，在设备树中定义，
//对应max-frequency属性，上面有对该属性值获取
if (hz > host->f_max)
hz = host->f_max;
host->ios.clock = hz; //注意：是ios.clock
mmc_set_ios(host);
}mmc_set_ios函数：该函数除了被mmc_set_clock函数调用，还在mmc_rescan扫描设备的时候和更前面mmc_start_host->mmc_power_up的时候被调用设置时钟，这时的频率：host->f_init = freq;
mmc_set_ios
host->ops->set_ios(host, ios);
static const struct mmc_host_ops sdhci_ops = {
.set_ios = sdhci_set_ios,
......
};
sdhci_set_ios
//注意：第一次设置的是ios->clock，第二次设置的是host->clock
// host->version == SDHCI_SPEC_300
// host->preset_enabled == 0
if (!ios->clock || ios->clock != host->clock) {
host->ops->set_clock(host, ios->clock);
host->clock = ios->clock;
}
host->ops->set_uhs_signaling(host, ios->timing);
host->timing = ios->timing;
if (host->version >= SDHCI_SPEC_300) {
//set_clock对应sdhci_tcc_set_clock函数
host->ops->set_clock(host, host->clock);
}
sdhci_tcc_set_clock
sdhci_set_clock(host, clock);
host->mmc->actual_clock = 0;
sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
//如果传入的clock等于0，返回
if (clock == 0){
return;
}
clk = sdhci_calc_clk(host, clock, &host->mmc->actual_clock);
sdhci_enable_clk(host, clk);
sdhci_calc_clk
int div = 0;
int real_div = div, clk_mul = 1; //注意：clk_mul和host->clk_mul不一样
u16 clk = 0;
bool switch_base_clk = false;
// host->version == SDHCI_SPEC_300
//host->preset_enabled == 0
//host->clk_mul == 0
if (host->version >= SDHCI_SPEC_300) {
if (!host->clk_mul || switch_base_clk) {
//1、如果max_clk小于等于clock，设置div等参数，使能该频率；
//2、否则对max_clk分频，分频后的频率小于clock，设置div等参数，使能该频率；
if (host->max_clk <= clock){
div = 1;
}
else {
for (div = 2; div < SDHCI_MAX_DIV_SPEC_300;div += 2) {
if ((host->max_clk / div) <= clock)
break;
}
}
real_div = div;
div >>= 1;
}
if (real_div){
*actual_clock = (host->max_clk * clk_mul) / real_div;
}
clk |= (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
<< SDHCI_DIVIDER_HI_SHIFT;注：
quirks: 怪癖的意思,也就是说它某种特性与通常的某种设备不相同。
如果设置3.3V、高速，只要在sdhc主控制器节点上添加“no-1-8-v;”和“cap-sd-highspeed;”
SDR模式下：一个时钟采样一次，一次4bit，即0.5Byte，50MHZ，传输速度25MB/s。
卡容量：
1） 标准容量卡（SDSC）:不超于2GB
2) 高容量卡 （SDHC）:大于2GB又不超过32GB
3） 扩展容量卡（SDXC）:大于32GB又不超过2TB的卡
工作电压范围：2.7V~3.6V
总线速率：（SDR-single Data Rate） DDR（Double Data Rate）
1) 默认速率模式：3.3V 信号，高达 25MHz，数据速率 12.5MB/S
2) 高速率模式：3.3V 信号，高达 50MHz，数据速率 25MB/S
3) SDR12：1.8V 信号，高达 25MHz，数据速率 12.5MB/S
4) SDR25：1.8V 信号，高达 50MHz，数据速率 25MB/S
5) SDR50：1.8V 信号，高达 100MHz，数据速率 50MB/S
6) SDR104：1.8V 信号，高达 208MHz，数据速率 104MB/S
7) DDR50：1.8V 信号，高达 50MHz，双时钟沿采样数据，数据速率 50MB/S
ocr：
u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
{
int bit;
//低7位是reserve位，清零
if (ocr & 0x7F) {
dev_warn(mmc_dev(host),
"card claims to support voltages below defined range\n");
ocr &= ~0x7F;
}
......
}参考：
第12章 SD卡和SDIO接口（一）
[mmc]Linux下MMC/SD/SDIO的识别与操作_anxuan3201的博客-优快云博客
UHS：Ultra High-Speed
超高速和超高清接口是下一代实现 SDHC 和 SDXC 卡高速数据传输的的总线接口。
UHS 总线接口现在共有三个版本：UHS-I 、UHS-II、UHS-III。
CCCR全称是Card Common Control Registers。
CIS：card infomation structure，在CCCR寄存器中。
参考：二，sdio总线简介之Commond_sdio cmd_初雨细无声的博客-优快云博客
其它：
扫一扫
531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
