6. [mmc subsystem] mmc core（第六章）——mmc core主模块

一、说明

1、mmc core概述

mmc core主模块是mmc core的实现核心。也是本章的重点内容。

对应代码位置drivers/mmc/core/core.c。

其主要负责如下功能：

• mmc core初始化，包括注册mmc bus、mm host class等等
• mmc host的管理和维护，包括为其他模块提供mmc_host的操作接口，如下
  • host的启动和停止
  • host的占用和释放
  • host电源状态的保存和恢复
  • host总线操作集的绑定和解绑
  • host上卡状态检测
• 为其他模块提供mmc_card的操作接口，如下
  • card的唤醒和休眠
  • card擦除
  • card属性的获取
• 为其他模块提供总线io setting的接口
• 为其他模块提供mmc请求接口
• card检测接口
• bkops操作接口
• regulator操作接口
• clock操作接口
• mmc core电源管理操作接口

2、操作集说明

在mmc_host中有两个操作集成员，需要理解一下，以免在代码中产生误会：

• mmc_host->struct mmc_host_ops *ops，这个是host的操作集，由host controller驱动决定。对于sdhci类host来说，就是sdhci_ops（sdhci.c中设置）。
• mmc_host->struct mmc_bus_ops *bus_ops，这个是mmc总线的操作集（也可以理解为host的mmc bus handler，host的总线处理方法），由总线上的card type决定。对于mmc card type来说，就是mmc_ops_unsafe或者mmc_ops（mmc_attach_bus_ops中设置）。

二、API总览

1、mmc core初始化相关

• mmc_init & mmc_exit (模块内使用)

2、mmc host的管理和维护相关

• mmc_claim_host & mmc_try_claim_host & mmc_release_host （模块内使用）
• mmc_power_up & mmc_power_off
• mmc_start_host & mmc_stop_host
• mmc_power_save_host & mmc_power_restore_host
• mmc_resume_host & mmc_suspend_host
• mmc_pm_notify

3、mmc card的操作相关（包括card状态的获取）

• mmc_hw_reset & mmc_hw_reset_check &
• mmc_card_awake & mmc_card_sleep
• mmc_card_is_prog_state
• mmc_can_erase
• mmc_can_trim
• mmc_can_discard
• mmc_can_sanitize
• mmc_can_secure_erase_trim
• mmc_erase_group_aligned

4、总线io setting相关

• mmc_set_ios
• mmc_set_chip_select
• mmc_set_clock
• mmc_set_bus_mode
• mmc_set_bus_width
• mmc_select_voltage
• mmc_set_signal_voltage（特殊）
• mmc_set_timing
• mmc_set_driver_type
• mmc_get_max_frequency & mmc_get_min_frequency

5、host的mmc总线相关

• mmc_resume_bus
• mmc_attach_bus & mmc_detach_bus

6、mmc请求相关

• mmc_request_done
• mmc_wait_for_req
• mmc_wait_for_cmd
• mmc_set_data_timeout
• mmc_align_data_size

7、card检测相关

mmc_detect_change
mmc_rescan
mmc_detect_card_removed

8、bkops操作相关

• mmc_blk_init_bkops_statistics
• mmc_start_delayed_bkops
• mmc_start_bkops & mmc_stop_bkops
• mmc_start_idle_time_bkops
• mmc_read_bkops_status

9、regulator操作相关

• mmc_regulator_get_ocrmask
• mmc_regulator_set_ocr
• mmc_regulator_get_supply

10、card擦除操作相关

• mmc_init_erase
• mmc_erase

11、clock操作接口

• mmc_init_clk_scaling & mmc_exit_clk_scaling
• mmc_can_scale_clk
• mmc_disable_clk_scaling

12、mmc core电源管理操作

• mmc_rpm_hold & mmc_rpm_release

二、接口代码说明——mmc core初始化相关

1、mmc_init实现

负责初始化整个mmc core。

• 主要工作：

  • 分配一个workqueue，用于专门处理mmc core的执行的工作
  • 注册mmc bus
  • 注册mmc host class

代码如下：

static int __init mmc_init(void)
{
    int ret;

/* 分配一个workqueue，用于专门处理mmc core的执行的工作 */
    workqueue = alloc_ordered_workqueue("kmmcd", 0);

/* 注册mmc bus */
    ret = mmc_register_bus();    // 调用mmc_register_bus注册mmc bus，具体参考《mmc core——bus模块说明》
        // 会生成/sys/bus/mmc目录

/* 注册mmc host class */
    ret = mmc_register_host_class();    // 调用mmc_register_host_class注册mmc host class，具体参考《mmc core——host模块说明》
        // 会生成/sys/class/mmc_host目录

/* 注册sdio bus */
    ret = sdio_register_bus();

    return 0;

}

subsys_initcall(mmc_init);

三、接口代码说明——mmc host的管理和维护相关

1、mmc_claim_host & mmc_try_claim_host & mmc_release_host

host被使能之后就不能再次被使能，并且只能被某个进程独自占用。

可以简单地将host理解为一种资源，同时只能被一个进程获取，但是在占用进程里面可以重复占用。

在对host进行操作之前（包括发起mmc请求），必须使用mmc_claim_host和mmc_release_host来进行获取和释放。

• 变量说明

  • mmc_host->claimed用来表示host是否被占用
  • mmc_host->claimer用来表示host的占用者（进程）
  • mmc_host->claim_cnt用来表示host的占用者的占用计数，为0时则会释放这个host

• 代码如下

static inline void mmc_claim_host(struct mmc_host *host)
{
    __mmc_claim_host(host, NULL);·// 调用__mmc_claim_host来获取host
}

int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
{
/////只考虑abort为NULL的情况，在mmc core中的mmc_claim_host也是将其设置为NULL
    DECLARE_WAITQUEUE(wait, current);    
    unsigned long flags;
    int stop;

    might_sleep();        // 说明这个函数可能导致进程休眠

    add_wait_queue(&host->wq, &wait);    // 把当前进程加入到等待队列中

    spin_lock_irqsave(&host->lock, flags);
    while (1) {    // 以下尝试获取host，如果host正在被占用，会进入休眠
        set_current_state(TASK_UNINTERRUPTIBLE);    // 设置进程状态为TASK_UNINTERRUPTIBLE状态
        stop = abort ? atomic_read(abort) : 0;
        if (stop || !host->claimed || host->claimer == current)    // 当host的占用标志claimed为0，或者占用者是当前进程的时候，说明可以占用了，退出
            break;
        spin_unlock_irqrestore(&host->lock, flags);
        schedule();    // 否则，进行调度进入休眠
        spin_lock_irqsave(&host->lock, flags);
    }
    set_current_state(TASK_RUNNING);    // 设置进程为运行状态
    if (!stop) {
        host->claimed = 1;    // 设置占用标志claimed 
        host->claimer = current;    // 设置占用者为当前进程
        host->claim_cnt += 1;    // 占用计数加1
    } else
        wake_up(&host->wq);
    spin_unlock_irqrestore(&host->lock, flags);
    remove_wait_queue(&host->wq, &wait);    // 将当前进程从等待队列中退出
    if (host->ops->enable && !stop && host->claim_cnt == 1)
        host->ops->enable(host);  // 调用host操作集中的enable方法来占用该host，对应sdhci类host即为sdhci_enable
    return stop;
}

void mmc_release_host(struct mmc_host *host)
{
    unsigned long flags;

    WARN_ON(!host->claimed);

    if (host->ops->disable && host->claim_cnt == 1)    // 当前claim_cnt为1（马上要变为0），调用释放host了
        host->ops->disable(host);    // 调用host操作集中的disable方法来释放该host，对应sdhci类host即为sdhci_disable

    spin_lock_irqsave(&host->lock, flags);
    if (--host->claim_cnt) {
        /* Release for nested claim */
        spin_unlock_irqrestore(&host->lock, flags);    // 如果减一之后计数还不为0，说明当前进程需要继续占用该host，不做其他操作
    } else {    // 以下需要释放该host
        host->claimed = 0;    // 设置占用标志claimed为0
        host->claimer = NULL;    // 清空占用者（进程）
        spin_unlock_irqrestore(&host->lock, flags);
        wake_up(&host->wq);    // 唤醒host的等待队列，让那些调用mmc_claim_host睡眠等待host资源的进程被唤醒
    }
}

int mmc_try_claim_host(struct mmc_host *host) 
{
// 和mmc_claim_host的主要区别在于进程不会休眠，获取失败直接返回
    int claimed_host = 0;
    unsigned long flags;

    spin_lock_irqsave(&host->lock, flags);
    if (!host->claimed || host->claimer == current) {
        host->claimed = 1;
        host->claimer = current;
        host->claim_cnt += 1;
        claimed_host = 1;
    }
    spin_unlock_irqrestore(&host->lock, flags);
    if (host->ops->enable && claimed_host && host->claim_cnt == 1)
        host->ops->enable(host);
    return claimed_host;
}

会调用mmc_host->struct mmc_host_ops->enable和mmc_host->struct mmc_host_ops->disable来使能和禁用host。

对于sdhci类的host，相应就是sdhci_enable和sdhci_disable。

2、mmc_power_up & mmc_power_off

mmc host的上电操作和关电操作。

• mmc的power状态

  • MMC_POWER_OFF：掉电状态
  • MMC_POWER_UP：正在上电的状态
  • MMC_POWER_ON：供电正常的状态

• 主要工作
  主要工作就是初始化host的总线设置、总线时钟以及工作电压、信号电压。

代码如下

void mmc_power_up(struct mmc_host *host)
{
    int bit;

/* 判断是否已经处于MMC_POWER_ON，是的话不进行后续操作 */
    if (host->ios.power_mode == MMC_POWER_ON)
        return;

/* 第一阶段，先设置对应的io setting使host处于MMC_POWER_UP的状态（总线工作频率没有设置） */
    mmc_host_clk_hold(host);    // 先获取host时钟

    /* If ocr is set, we use it */
    if (host->ocr)
        bit = ffs(host->ocr) - 1;    // 选择一个ocr配置设置为host的工作电压
    else
        bit = fls(host->ocr_avail) - 1;
    host->ios.vdd = bit;
    if (mmc_host_is_spi(host))
        host->ios.chip_select = MMC_CS_HIGH;
    else {
        host->ios.chip_select = MMC_CS_DONTCARE;
        host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;    // 设置总线模式
    }
    host->ios.power_mode = MMC_POWER_UP;
    host->ios.bus_width = MMC_BUS_WIDTH_1;    // 设置总线宽度为1
    host->ios.timing = MMC_TIMING_LEGACY;    // 串口时序
    mmc_set_ios(host);    // 调用mmc_set_ios设置总线的io setting，后面会说明

    /*
     * This delay should be sufficient to allow the power supply
     * to reach the minimum voltage.
     */
    mmc_delay(10);

/* 第二阶段，以host的初始化工作频率再次设置io setting，使host处于MMC_POWER_ON状态 */
    host->ios.clock = host->f_init;    // 设置总线的时钟频率
    host->ios.power_mode = MMC_POWER_ON;
    mmc_set_ios(host);   // 调用mmc_set_ios设置总线的io setting，后面会说明

    /*
     * This delay must be at least 74 clock sizes, or 1 ms, or the
     * time required to reach a stable voltage.
     */
    mmc_delay(10);

/* 设置信号的电压 */
    /* Set signal voltage to 3.3V */
    __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);

    mmc_host_clk_release(host);    // 释放host时钟
}

3、mmc_start_host & mmc_stop_host

mmc_start_host 用来启动一个host，mmc_stop_host用来停止一个host。

当底层host controller调用mmc_add_host来注册host时，在mmc_add_host中就会调用mmc_start_host来启动一个host了。具体参考《mmc core——host模块说明》。

相对应的，会在mmc_remove_host中调用mmc_stop_host停止host。

void mmc_start_host(struct mmc_host *host)
{
    mmc_claim_host(host);    // 因为上电操作涉及到对host的使用和设置，需要先占用host

    host->f_init = max(freqs[0], host->f_min);    // 通过最小频率要设置初始化频率
    host->rescan_disable = 0;    // 设置rescan_disable标志为0，说明已经可以进行card检测了
    if (host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)    // 如果mmc属性设置了MMC_CAP2_NO_PRESCAN_POWERUP，也就是在rescan前不需要进行power up操作时，则进行关电
        mmc_power_off(host);
    else
        mmc_power_up(host);    // 否则，调用mmc_power_up对host进行上电操作。这里也是mmc core中启动host的核心函数。

    mmc_release_host(host);    // 完成上电操作，释放host

/* 到这里host已经可以工作了，可以开始进行后续的card操作了 */
    mmc_detect_change(host, 0);    // 调用mmc_detect_change检测card变化，后续会继续说明
}

四、接口代码说明——card检测相关

1、mmc_detect_change

在上述中我们知道在启动host的函数mmc_start_host 中最后调用了mmc_detect_change来开始检测card（也就是检测mmc卡槽的状态变化情况）。

其实mmc_detect_change是在driver发现mmc卡槽状态发生变化时，调用mmc_detect_change来进行确认和处理。

void mmc_detect_change(struct mmc_host *host, unsigned long delay)
{
#ifdef CONFIG_MMC_DEBUG
    unsigned long flags;
    spin_lock_irqsave(&host->lock, flags);
    WARN_ON(host->removed);
    spin_unlock_irqrestore(&host->lock, flags);
#endif
    host->detect_change = 1;    // 检测到card状态发生变化的标识

    mmc_schedule_delayed_work(&host->detect, delay);    // 间隔delay jiffies之后调用host->detect的工作
}

在《host模块说明》已经知道了在mmc_alloc_host中默认将host->detect工作设置为mmc_rescan（card重新扫描）函数， INIT_DELAYED_WORK(&host->detect, mmc_rescan)。
当然，host也可以自己另外设置，但是一般都是使用mmc core提供的mmc_rescan作为detect工作来搜索card。下面说明。

2、mmc_rescan

用于检测host的卡槽状态，并对状态变化做相应的操作。

有card插入时，重新扫描mmc card。

void mmc_rescan(struct work_struct *work)
{
    struct mmc_host *host =
        container_of(work, struct mmc_host, detect.work);
    bool extend_wakelock = false;

/* 如果rescan_disable被设置，说明host此时还禁止rescan */
    if (host->rescan_disable)
        return;

/* 对于设备不可移除的host来说，只能rescan一次 */
    /* If there is a non-removable card registered, only scan once */
    if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
        return;
    host->rescan_entered = 1;

    mmc_bus_get(host);    // 获取host对应的bus
    mmc_rpm_hold(host, &host->class_dev);    // 使host处于rpm resume的状态

/* 以下判断原来的card是否已经被移除，移除了则需要做相应的操作 */
    /*
     * if there is a _removable_ card registered, check whether it is
     * still present
     */
    if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
        && !(host->caps & MMC_CAP_NONREMOVABLE))
        host->bus_ops->detect(host);    
        // host->bus_ops存在的话说明之前是有card插入的状态
        // 需要调用host->bus_ops->detect检测card是否被移除，是的话在host->bus_ops->detect中做相应的处理
        // 对于mmc type card来说，对应就是mmc_detect，具体参考《card相关模块》

    host->detect_change = 0;
    /* If the card was removed the bus will be marked
     * as dead - extend the wakelock so userspace
     * can respond */
    if (host->bus_dead)
        extend_wakelock = 1;    // 需要设置一个wakelock锁，使用户空间可以及时做出相应

    /*
     * Let mmc_bus_put() free the bus/bus_ops if we've found that
     * the card is no longer present.
     */
    mmc_bus_put(host);    
       // 因为在这个函数的前面已经获取了一次host，可能导致host->bus_ops->detect中检测到card拔出之后，没有真正释放到host的bus，所以这里先put一次
        // host bus的计数（bus_refs）为0的时候，会调用__mmc_release_bus清空host bus的信息
    mmc_bus_get(host);
        // 再获取host bus

    /* if there still is a card present, stop here */
    if (host->bus_ops != NULL) {    // 说明此时还有card插入，退出后续的操作
        mmc_rpm_release(host, &host->class_dev);
        mmc_bus_put(host);
        goto out;
    }

    mmc_rpm_release(host, &host->class_dev);    

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

/* 检测当前卡槽状态，根据卡槽状态做相应的操作 */
    if (host->ops->get_cd && host->ops->get_cd(host) == 0) {
        // 调用host->ops->get_cd来判断host的卡槽的当前card插入状态
        // 对应sdhci类型的host来说，就是sdhci_get_cd
        // 为0的时候，表示没有card插入，对应host进行power off操作之后进行退出
        // 为1的时候，表示当前有card插入，跳到后续的操作
        mmc_claim_host(host);
        mmc_power_off(host);
        mmc_release_host(host);
        goto out;
    }

    mmc_rpm_hold(host, &host->class_dev);
    mmc_claim_host(host);
    if (!mmc_rescan_try_freq(host, host->f_min))    // 调用mmc_rescan_try_freq，以支持的最低频率作为工作频率尝试搜索card，后续继续说明
        extend_wakelock = true;
    mmc_release_host(host);
    mmc_rpm_release(host, &host->class_dev);
 out:
    /* only extend the wakelock, if suspend has not started yet */
    if (extend_wakelock && !host->rescan_disable)    
        wake_lock_timeout(&host->detect_wake_lock, HZ / 2);    // 占用wakelock，使系统在HZ/2的时间内不会休眠

    if (host->caps & MMC_CAP_NEEDS_POLL)
        mmc_schedule_delayed_work(&host->detect, HZ);    
               // 当host设置了MMC_CAP_NEEDS_POLL属性时，需要每隔HZ的时间轮询检测host的卡槽状态，
                // 调度了host->detect工作，对应就是mmc_rescan
}

会调用host->ops->get_cd来判断host的卡槽的当前card插入状态，对应sdhci类型的host就是sdhci_get_cd。

会调用host->bus_ops->detect检测card是否被移除，是的话在host->bus_ops->detect中做相应的处理。对于mmc type card，就是mmc_detect。

3、mmc_rescan_try_freq

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

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

    mmc_power_up(host);    // 给host做上电操作

    mmc_hw_reset_for_init(host);    // 硬件复位和初始化
    mmc_go_idle(host);

    mmc_send_if_cond(host, host->ocr_avail);    // 获取card的可用频率，存储到host->ocr_avail中

    /* Order's important: probe SDIO, then SD, then MMC */
/* 用于绑定card到host bus上（也就是card和host的绑定）。 */
    if (!mmc_attach_sdio(host))    // 先假设card是sdio type card，尝试绑定到host bus上，失败则说明不是sdio type card，继续后面的操作，否则返回
        return 0;
    if (!mmc_attach_sd(host))  // 先假设card是sd type card，尝试绑定到host bus上，失败则说明不是sd type card，继续后面的操作，否则返回
        return 0;
    if (!mmc_attach_mmc(host))  // 先假设card是mmc type card，尝试绑定到host bus上，失败则说明不是mmc type card，继续后面的操作，否则返回
        // mmc_attach_mmc通过mmc_host获取mmc type card信息，初始化mmc_card，并进行部分驱动，最后将其注册到mmc_bus上。
        // 具体参考《card相关模块说明》
        return 0;

    mmc_power_off(host);
    return -EIO;
}

五、接口代码说明——总线io setting相关

0、mmc_ios说明

struct mmc_ios 由mmc core定义的规范的结构，用来维护mmc总线相关的一些io setting。如下：

struct mmc_ios {
    unsigned int    clock;          /* clock rate */ // 当前工作频率
    unsigned int    old_rate;       /* saved clock rate */    // 上一次的工作频率
    unsigned long   clk_ts;         /* time stamp of last updated clock */    // 上一次更新工作频率的时间戳
    unsigned short  vdd;/* vdd stores the bit number of the selected voltage range from below. */   // 支持的电压表
    unsigned char   bus_mode;       /* command output mode */    // 总线输出模式，包括开漏模式和上拉模式
    unsigned char   chip_select;        /* SPI chip select */    // spi片选
    unsigned char   power_mode;     /* power supply mode */    // 电源状态模式
    unsigned char   bus_width;      /* data bus width */    // 总线宽度
    unsigned char   timing;         /* timing specification used */    // 时序类型
    unsigned char   signal_voltage;     /* signalling voltage (1.8V or 3.3V) */    // 信号的工作电压
    unsigned char   drv_type;       /* driver type (A, B, C, D) */    // 驱动类型
};

在设置总线io setting的过程中，就是要设置mmc_host->mmc_ios中的这些成员。

然后通过调用mmc_set_ios进行统一设置。后续会继续说明。

1、mmc_set_ios

统一设置mmc总线的io设置（io setting）。

void mmc_set_ios(struct mmc_host *host)
{
    struct mmc_ios *ios = &host->ios;

    if (ios->clock > 0)
        mmc_set_ungated(host);    // 关闭clock的门控
    host->ops->set_ios(host, ios);    // 调用host->ops->set_ios来对mmc总线的io setting进行设置，核心函数
        // 对于sdhci类型的host，对应就是sdhci_set_ios
}

会调用host->ops->set_ios来对mmc总线的io setting进行设置，核心函数。对于sdhci类型的host，对应就是sdhci_set_ios

2、mmc_set_bus_mode & mmc_set_bus_width

• mmc_set_bus_mode用于设置总线模式，有如下模式
  • MMC_BUSMODE_OPENDRAIN（开漏模式）
  • MMC_BUSMODE_PUSHPULL（上拉模式）
• mmc_set_bus_width用于设置总线宽度，有如下模式
  • MMC_BUS_WIDTH_1
  • MMC_BUS_WIDTH_4
  • MMC_BUS_WIDTH_8

代码如下：

void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
{
    mmc_host_clk_hold(host);
    host->ios.bus_mode = mode;
    mmc_set_ios(host);
    mmc_host_clk_release(host);
}

void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
{
    mmc_host_clk_hold(host);
    host->ios.bus_width = width;
    mmc_set_ios(host);
    mmc_host_clk_release(host);
}

其他设置io setting的函数类似，不多说明。

六、接口代码说明——host的mmc总线相关

1、mmc_attach_bus & mmc_detach_bus

• 主要功能
  • mmc_attach_bus用于将分配一个mmc总线操作集给host。
  • mmc_detach_bus用于释放和host相关联的mmc总线操作集。
• 一些变量
  • mmc_host->bus_ops，表示host的mmc总线操作集
  • mmc_host->bus_refs，表示host的mmc总线的使用者计数
  • mmc_host->bus_dead，表示host的mmc总线是否被激活，如果设置了bus_ops，那么就会被激活了
• 代码如下

void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
{
    unsigned long flags;

    spin_lock_irqsave(&host->lock, flags);

    BUG_ON(host->bus_ops);    // 不允许重复设置host的mmc总线操作集
    BUG_ON(host->bus_refs);    // 当mmc总线的使用者计数还存在时，不允许设置host的mmc总线操作集

    host->bus_ops = ops;    // 设置host的mmc总线操作集
    host->bus_refs = 1;    // host的mmc总线的使用者计数设置为1，相当于调用了mmc_bus_get
    host->bus_dead = 0;    // 总线被激活了

    spin_unlock_irqrestore(&host->lock, flags);
}

void mmc_detach_bus(struct mmc_host *host)
{
    unsigned long flags;
    spin_lock_irqsave(&host->lock, flags);
    host->bus_dead = 1;    // host的mmc总线设置为dead状态
    spin_unlock_irqrestore(&host->lock, flags);
    mmc_bus_put(host);    // 调用mmc_bus_put释放host的mmc总线，也就是对host的mmc总线的使用者计数-1
}

在《card相关模块》中可以看到mmc_attach_mmc->mmc_attach_bus_ops调用mmc_attach_bus来绑定了host的mmc总线操作集为mmc_ops_unsafe或者mmc_ops

2、mmc_bus_get & mmc_bus_put

static inline void mmc_bus_get(struct mmc_host *host)
{
    unsigned long flags;

    spin_lock_irqsave(&host->lock, flags);
    host->bus_refs++;    // 对host的mmc总线的使用者计数+1
    spin_unlock_irqrestore(&host->lock, flags);
}

static inline void mmc_bus_put(struct mmc_host *host)
{
    unsigned long flags;

    spin_lock_irqsave(&host->lock, flags);
    host->bus_refs--;    // 对host的mmc总线的使用者计数-1
    if ((host->bus_refs == 0) && host->bus_ops)    // 说明host的mmc总线当前并没有使用，调用__mmc_release_bus进行实际的释放操作
        __mmc_release_bus(host);
    spin_unlock_irqrestore(&host->lock, flags);
}

static void __mmc_release_bus(struct mmc_host *host)
{
    host->bus_ops = NULL; // 清空host的mmc总线操作集
}

七、接口代码说明——mmc请求相关

分成同步的mmc请求和异步的mmc请求。差别如下：

1、流程上的差别：
（1）会阻塞的处理流程：
mmc_wait_for_req
——》__mmc_start_req // 发起请求
————》init_completion(&mrq->completion);  
————》mrq->done = mmc_wait_done
————》mmc_start_request(host, mrq);   // 实际发起请求的操作
——》mmc_wait_for_req_done   // 阻塞等待请求处理完成
——》返回

（2）不阻塞等待该命令的处理流程：
（注意：并不是说调用这个接口并不会阻塞，而是不会为了等待当前请求处理完成而阻塞，但是可能会等待上一次请求处理完成而阻塞）
mmc_start_req
——》mmc_wait_for_data_req_done   // 阻塞等待上一次的请求处理
——》__mmc_start_data_req   // 发起异步请求
————》mrq->done = mmc_wait_data_done
————》mmc_start_request   // 实际发起请求的操作
——》返回

最后都是调用了mmc_start_request使host向MMC发起请求。

0、数据结构说明

一个mmc请求分成两部分内容，分别是命令部分和数据部分。

• mmc_command

struct mmc_command {
    u32            opcode;    // 命令的操作码，如MMC_GO_IDLE_STATE、MMC_SEND_OP_COND等等
    u32            arg;    // 命令的参数
    u32            resp[4];    // response值
    unsigned int        flags;        /* expected response type */    // 期待的response的类型
#define mmc_resp_type(cmd)    ((cmd)->flags & (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC|MMC_RSP_BUSY|MMC_RSP_OPCODE))

/*
* These are the command types.
*/
#define mmc_cmd_type(cmd)    ((cmd)->flags & MMC_CMD_MASK)

    unsigned int        retries;    /* max number of retries */    // 失败时的重复尝试次数
    unsigned int        error;        /* command error */    // 命令的错误码

/*
* Standard errno values are used for errors, but some have specific
* meaning in the MMC layer:
*
 * ETIMEDOUT    Card took too long to respond
 * EILSEQ       Basic format problem with the received or sent data
 *              (e.g. CRC check failed, incorrect opcode in response
 *              or bad end bit)
 * EINVAL       Request cannot be performed because of restrictions
 *              in hardware and/or the driver
 * ENOMEDIUM    Host can determine that the slot is empty and is
 *              actively failing requests
*/

    unsigned int        cmd_timeout_ms;    /* in milliseconds */    // 命令执行的等待超时事件

    struct mmc_data        *data;        /* data segment associated with cmd */    // 和该命令关联在一起的数据段
    struct mmc_request    *mrq;        /* associated request */    // 该命令关联到哪个request
};

• mmc_data

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

#define MMC_DATA_WRITE  (1 << 8)
#define MMC_DATA_READ   (1 << 9)
#define MMC_DATA_STREAM (1 << 10)

    unsigned int        bytes_xfered;

    struct mmc_command  *stop;      /* stop command */   // 结束传输的命令
    struct mmc_request  *mrq;       /* associated request */   // 该命令关联到哪个request

    unsigned int        sg_len;     /* size of scatter list */
    struct scatterlist  *sg;        /* I/O scatter list */
    s32         host_cookie;    /* host private data */
    bool            fault_injected; /* fault injected */
};

• mmc_request

struct mmc_request是mmc core向host controller发起命令请求的处理单位。

struct mmc_request {
    struct mmc_command    *sbc;        /* SET_BLOCK_COUNT for multiblock */    // 设置块数量的命令，怎么用的后续再补充
    struct mmc_command    *cmd;    // 要传输的命令
    struct mmc_data        *data;    // 要传输的数据
    struct mmc_command    *stop;    // 结束命令，怎么用的后续再补充

    struct completion    completion; // 完成量
    void            (*done)(struct mmc_request *);/* completion function */ // 传输结束后的回调函数
    struct mmc_host        *host;    // 所属host
};

• mmc_async_req

struct mmc_async_req {
    /* active mmc request */
    struct mmc_request  *mrq;
    unsigned int cmd_flags; /* copied from struct request */

    /*
     * Check error status of completed mmc request.
     * Returns 0 if success otherwise non zero.
     */
    int (*err_check) (struct mmc_card *, struct mmc_async_req *);
    /* Reinserts request back to the block layer */
    void (*reinsert_req) (struct mmc_async_req *);
    /* update what part of request is not done (packed_fail_idx) */
    int (*update_interrupted_req) (struct mmc_card *,
            struct mmc_async_req *);
};

1、mmc_wait_for_req

发起mmc_request请求并且等待其处理完成。由其他需要发起mmc请求的模块调用。

可以结合后面的mmc_request_done来看。

void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
{
#ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
    if (mmc_bus_needs_resume(host))
        mmc_resume_bus(host);
#endif
    __mmc_start_req(host, mrq);    // 开始发起mmc_request请求
    mmc_wait_for_req_done(host, mrq);    // 等待mmc_request处理完成
}

//-----------------------------------__mmc_start_req说明，开始发起mmc_request请求
static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
{
/* 发起mmc_request前的一些初始化工作，包括完成量和处理完成的回调函数的设置 */
    init_completion(&mrq->completion);    // 初始化完成量，在mmc_wait_for_req_done中会去等待这个完成量
    mrq->done = mmc_wait_done; 
        // 设置mmc_request处理完成的回调函数，会调用complete(&mrq->completion);来设置完成量
        // host controller会调用mmc_request_done来执行这个回调函数，具体在后面分析
    if (mmc_card_removed(host->card)) {    // 检测card是否存在
        mrq->cmd->error = -ENOMEDIUM;
        complete(&mrq->completion);
        return -ENOMEDIUM;
    }

/* 调用mmc_start_request发起mmc请求 */
    mmc_start_request(host, mrq);    // 开始处理mmc_request请求
    return 0;
}

static void
mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{

    WARN_ON(!host->claimed);

/* 以下对mmc_request的各个成员，包括cmd、data、stop做验证操作和关联操作 */
    mrq->cmd->error = 0;
    mrq->cmd->mrq = mrq;
    if (mrq->data) {
        BUG_ON(mrq->data->blksz > host->max_blk_size);
        BUG_ON(mrq->data->blocks > host->max_blk_count);
        BUG_ON(mrq->data->blocks * mrq->data->blksz >
            host->max_req_size);
        mrq->cmd->data = mrq->data;      // 也就是说mmc_request的data和其cmd中的data是一一样的
        mrq->data->error = 0;
        mrq->data->mrq = mrq;
        if (mrq->stop) {
            mrq->data->stop = mrq->stop;
            mrq->stop->error = 0;
            mrq->stop->mrq = mrq;
        }
#ifdef CONFIG_MMC_PERF_PROFILING
        if (host->perf_enable)
            host->perf.start = ktime_get();
#endif
    }

/* 获取时钟 */
    mmc_host_clk_hold(host);

/* 调用host controller的request方法来处理mmc_request请求 */
    host->ops->request(host, mrq);    
       // host->ops->request也就是host controller的request方法，对于sdhci类型的host来说，就是sdhci_request
}

//-----------------------------------mmc_wait_for_req_done说明，等待mmc_request处理完成
static void mmc_wait_for_req_done(struct mmc_host *host,
                  struct mmc_request *mrq)
{
    struct mmc_command *cmd;

    while (1) {
        wait_for_completion_io(&mrq->completion);   // 在这里休眠，等待mrq->completion完成量，在__mmc_start_req中初始化的

        cmd = mrq->cmd;   // 获取对应的command

        /*
         * If host has timed out waiting for the commands which can be
         * HPIed then let the caller handle the timeout error as it may
         * want to send the HPI command to bring the card out of
         * programming state.
         */
        if (cmd->ignore_timeout && cmd->error == -ETIMEDOUT)
            break;

        if (!cmd->error || !cmd->retries || mmc_card_removed(host->card))
                // 如果command正常处理完成，或者失败重复尝试次数为0，或者card被移除了，直接退出循环返回
            break;

                // 以下处理失败重复尝试的情况
        pr_debug("%s: req failed (CMD%u): %d, retrying...
",
             mmc_hostname(host), cmd->opcode, cmd->error);
        cmd->retries--;
        cmd->error = 0;
        host->ops->request(host, mrq);
    }
}

会调用host->ops->request来对mmc_request进行处理，对于sdhci类型的host，对应就是sdhci_request。

这个方法就是mmc_request实际被处理的核心。

2、mmc_request_done

通知mmc core某个mmc_request已经处理完成，由host controller调用。

以sdhci类型的host为例，处理完一个mmc_request之后，会执行sdhci_tasklet_finish，而在sdhci_tasklet_finish中会调用mmc_request_done来通知host某个mmc_request已经处理完成了。

void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
{
    struct mmc_command *cmd = mrq->cmd;
    int err = cmd->error;

    if (host->card)
        mmc_update_clk_scaling(host);

    if (err && cmd->retries && !mmc_card_removed(host->card)) {
                // command执行出错，如果还需要重复尝试的话，这里不释放clock，只是通知mmc core
        if (mrq->done)
            mrq->done(mrq);   
               // 执行mmc_request的回调函数来通知mmc core，
               // 对于__mmc_start_req发起的request来说，就是mmc_wait_done，上面已经说明过了
               // 对于__mmc_start_data_req发起的request来说，就是mmc_wait_data_done，后面会说明
    } else {
        mmc_should_fail_request(host, mrq);   
                // 用于模拟data传输概率出错的情况
                // 具体参考http://blog.csdn.net/luckywang1103/article/details/52224160

        if (mrq->done)
            mrq->done(mrq);
                // 执行mmc_request的回调函数来通知mmc core，对于__mmc_start_req发起的request来说，就是mmc_wait_done，上面已经说明过了

        mmc_host_clk_release(host);
    }
}

通过上述，mrq->done被调度，mmc_wait_done被执行，mrq->completion被设置。

然后等待mrq->completion的mmc_wait_for_req_done就会继续往下执行。

3、mmc_wait_for_cmd

mmc_wait_for_cmd用于处理一个不带数据请求的命令。

会被封装到mmc_request中，通过调用mmc_wait_for_req来发起请求。

int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
{
    struct mmc_request mrq = {NULL};

    WARN_ON(!host->claimed);
    memset(cmd->resp, 0, sizeof(cmd->resp));   // 清空command的response
    cmd->retries = retries;   // 失败时的重复尝试次数
    mrq.cmd = cmd;   // 封装到mmc_request中
    cmd->data = NULL;   // 不带数据包的命令，故清空data
    mmc_wait_for_req(host, &mrq);   // 调用mmc_wait_for_req发起mmc请求并且等待其处理完成

    return cmd->error;   // 返回错误码
}

4、mmc_start_req（重要）

机制说明如下：mmc_start_req会先判断上一次的asycn_req是否处理完成，如果没有处理完成，则会等待其处理完成。

如果处理完成了，为当前要处理的asycn_req发起请求，但是并不会等待，而是直接返回。

注意：并不是说调用这个接口并不会阻塞，而是不会为了等待当前请求处理完成而阻塞，但是可能会等待上一次请求处理完成而阻塞。这样，可以利用等待的一部分时间来做其他操作。

为了方便理解这个函数，需要看一下其函数注释。

• 要注意，在函数里面有两个异步请求：
  • areq：表示新的异步请求
  • host->areq：表示上一次发起的、正在处理、等待完成的异步请求

代码如下（为了方便理解，对代码进行了简化）：

/**
 *  mmc_start_req - start a non-blocking request    // 该函数用来发起一个不阻塞的请求
 *  @host: MMC host to start command    // 要发起对应请求的host
 *  @areq: async request to start    // 要发起的异步请求
 *  @error: out parameter returns 0 for success, otherwise non zero    // 返回值，返回0表示成功，返回非零表示失败
 *
 *  Start a new MMC custom command request for a host.    // 为host发起的一个新的mmc命令请求
 *  If there is on ongoing async request wait for completion    // 如果host已经有一个正在处理、等待完成的异步请求，那么会等待这个请求完成！！！
 *  of that request and start the new one and return.    // 然后发起新的请求，然后返回！！！
 *  Does not wait for the new request to complete.    // 并不会等待这个新的请求完成！！！
 *
 *      Returns the completed request, NULL in case of none completed.    // 会返回被完成的mmc请求（而不是新的mmc请求。）空表示没有mmc请求被完成。
 *  Wait for the an ongoing request (previoulsy started) to complete and
 *  return the completed request. If there is no ongoing request, NULL
 *  is returned without waiting. NULL is not an error condition.
// 等待上一次发起的mmc请求完成，然后把这个mmc请求返回。如果没有mmc请求正在处理，那么就直接返回而不会等待。空并不是错误条件。
 */
struct mmc_async_req *mmc_start_req(struct mmc_host *host,
                    struct mmc_async_req *areq, int *error)
{
    int err = 0;
    int start_err = 0;
    struct mmc_async_req *data = host->areq;
    unsigned long flags;
    bool is_urgent;

    /* Prepare a new request */
/* 为新的异步请求做准备处理 */
    if (areq) {
        /*
         * start waiting here for possible interrupt
         * because mmc_pre_req() taking long time
         */
        mmc_pre_req(host, areq->mrq, !host->areq);
    }

/* 对上一次发起的、正在处理、等待完成的异步请求进行处理、等待操作 */
    if (host->areq) {
        err = mmc_wait_for_data_req_done(host, host->areq->mrq, areq);   // 在这里等待正在处理的异步请求处理完成
        //.......以下过滤了错误处理的部分
    }

/* 对新的异步请求进行发起操作 */
    if (!err && areq) {
        /* urgent notification may come again */
        spin_lock_irqsave(&host->context_info.lock, flags);
        is_urgent = host->context_info.is_urgent;
        host->context_info.is_urgent = false;
        spin_unlock_irqrestore(&host->context_info.lock, flags);
        if (!is_urgent || (areq->cmd_flags & REQ_URGENT)) {
            start_err = __mmc_start_data_req(host, areq->mrq);    // 调用__mmc_start_data_req发起新的异步请求
        } else {
            /* previous request was done */
            err = MMC_BLK_URGENT_DONE;
            if (host->areq) {
                mmc_post_req(host, host->areq->mrq, 0);
                host->areq = NULL;
            }
            areq->reinsert_req(areq);
            mmc_post_req(host, areq->mrq, 0);
            goto exit;
        }
    }

    if (host->areq)
        mmc_post_req(host, host->areq->mrq, 0);

     /* Cancel a prepared request if it was not started. */
    if ((err || start_err) && areq)
        mmc_post_req(host, areq->mrq, -EINVAL);

    if (err)
        host->areq = NULL;
    else
        host->areq = areq;

exit:
    if (error)
        *error = err;
    return data;    // 反正上一次正常处理的异步请求
}

//-----------------------------------------------------------------------------------------------------------------------------
static int __mmc_start_data_req(struct mmc_host *host, struct mmc_request *mrq)
{
    mrq->done = mmc_wait_data_done;
        // 设置mmc_request处理完成的回调函数，会唤醒正在等待请求被完成的进程，后面说明
        // host controller会调用mmc_request_done来执行这个回调函数，具体前面分析过了

    mrq->host = host;
    mmc_start_request(host, mrq);    // 开始处理mmc_request请求，前面已经说明过了

    return 0;
}

static void mmc_wait_data_done(struct mmc_request *mrq)
{
    unsigned long flags;
    struct mmc_context_info *context_info = &mrq->host->context_info;

    spin_lock_irqsave(&context_info->lock, flags);
    mrq->host->context_info.is_done_rcv = true;    // 设置is_done_rcv标识
    wake_up_interruptible(&mrq->host->context_info.wait);    // 唤醒context_info上的等待进程
    spin_unlock_irqrestore(&context_info->lock, flags);
}

//-----------------------------------------------------------------------------------------------------------------------------
static int mmc_wait_for_data_req_done(struct mmc_host *host,
                      struct mmc_request *mrq,
                      struct mmc_async_req *next_req)
{
// struct mmc_request *mrq：表示正在等待完成的请求
// struct mmc_async_req *next_req：表示下一次要执行的异步请求
    struct mmc_command *cmd;
    struct mmc_context_info *context_info = &host->context_info;
    bool pending_is_urgent = false;
    bool is_urgent = false;
    bool is_done_rcv = false;
    int err, ret;
    unsigned long flags;

    while (1) {
/* 在这里等待正在进行的请求完成，会在mmc_wait_data_done中被唤醒 */
/* 有几种情况会唤醒等待进程 */
        ret = wait_io_event_interruptible(context_info->wait,(context_info->is_done_rcv || context_info->is_new_req  || context_info->is_urgent));
        spin_lock_irqsave(&context_info->lock, flags);
        is_urgent = context_info->is_urgent;
        is_done_rcv = context_info->is_done_rcv;
        context_info->is_waiting_last_req = false;
        spin_unlock_irqrestore(&context_info->lock, flags);

/* 对请求处理完成的处理 */
        if (is_done_rcv) {
            context_info->is_done_rcv = false;
            context_info->is_new_req = false;
            cmd = mrq->cmd;


            if (!cmd->error || !cmd->retries || mmc_card_removed(host->card)) {
/* 请求正常处理完成，或者失败但是不需要重复尝试的情况的处理 */
                err = host->areq->err_check(host->card, host->areq);
                //.......
                break; /* return err */
            } else {
/* 对请求处理出错并且需要重复尝试的情况的处理 */
                //.......
            }
        }
    }
    return err;
}