Linux驱动——mmc core浅析（三）

小灰灰 2022-09-16 15:29 1002阅读 0赞

# Linux驱动——mmc core浅析（三） #

备注：  
  1. Kernel版本：5.4  
  2. 使用工具：Source Insight 4.0  
  3. 参考博客：  
[6. \[mmc subsystem\] mmc core（第六章）——mmc core主模块][6. _mmc subsystem_ mmc core_mmc core]

### 文章目录 ###

*  Linux驱动——mmc core浅析（三）
 *   *  mmc core概述
     *  API总览
     *   *  mmc core初始化相关
         *  mmc host的管理和维护相关
         *  mmc card的操作相关（包括card状态的获取）
         *  总线io setting相关
         *  host的mmc总线相关
         *  mmc请求相关
         *  card检测相关
     *  mmc core初始化相关
     *   *  mmc\_init的实现
     *  mmc host的管理和维护相关
     *   *  mmc\_claim\_host & mmc\_release\_host
         *  mmc\_power\_up & mmc\_power\_off
         *  mmc\_start\_host & mmc\_stop\_host
     *  card检测相关
     *   *  mmc\_detect\_change
         *  mmc\_rescan
         *  mmc\_rescan\_try\_freq
     *  总线io setting相关
     *   *  mmc\_set\_ios
         *  mmc\_set\_bus\_mode & mmc\_set\_bus\_width
         *  mmc\_set\_clock
     *  host的mmc总线相关
     *   *  mmc\_attach\_bus & mmc\_detach\_bus
         *  mmc\_bus\_get & mmc\_bus\_put
     *  mmc请求相关
     *   *  同步的mmc请求
         *  异步的mmc请求
         *  mmc\_wait\_for\_req
         *  \_\_mmc\_start\_req
         *  mmc\_start\_request
         *  \_\_mmc\_start\_request
         *  mmc\_wait\_for\_req\_done
         *  mmc\_request\_done
         *  mmc\_wait\_for\_cmd

## mmc core概述 ##

本章主要介绍mmc core主模块，是mmc的实现核心，其对应的代码位置为：**drivers/mmc/core/core.c**。  
  本模块的主要功能有以下几个：

*  mmc core初始化，如：mmc bus、sdio bus、mmc host class等等。
 *  mmc host的管理和维护，及为其他模块提供mmc\_host的操作接口，如下：  
      host的启动与停止  
      host的占用与释放  
      host的电源状态的控制  
      host总线的的配置，如：bus\_width、clock等  
      host的卡状态检测
 *  为其他模块提供的mmc\_card的操作接口，如下：  
      card的休眠与唤醒  
      card擦除  
      card的属性获取
 *  为其他模块提供总线io setting的接口
 *  为其他模块提供mmc请求接口
 *  card检测接口

## API总览 ##

### mmc core初始化相关 ###

static int __init mmc_init(void);  // 注册bus、host class
    static void __exit mmc_exit(void);

### mmc host的管理和维护相关 ###

static inline void mmc_claim_host(struct mmc_host *host); // 申请占用host
    void mmc_release_host(struct mmc_host *host);  // 释放占用的host
    
    void mmc_power_up(struct mmc_host *host, u32 ocr); // host上电
    void mmc_power_off(struct mmc_host *host);            // host掉电
    
    void mmc_start_host(struct mmc_host *host); // 启动host
    void mmc_stop_host(struct mmc_host *host); // 关闭host

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

int mmc_hw_reset(struct mmc_host *host); // host硬件reset
    int mmc_sw_reset(struct mmc_host *host); // host软件reset
    
    int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, unsigned int arg)；
    int mmc_can_erase(struct mmc_card *card)；
    int mmc_can_trim(struct mmc_card *card)；
    int mmc_can_discard(struct mmc_card *card)；
    int mmc_can_sanitize(struct mmc_card *card)；
    int mmc_can_secure_erase_trim(struct mmc_card *card)；
    int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, unsigned int nr)；

### 总线io setting相关 ###

static inline void mmc_set_ios(struct mmc_host *host); // 模块内部使用，配置io属性
    
    void mmc_set_chip_select(struct mmc_host *host, int mode); // spi mode配置cs
    
    void mmc_set_clock(struct mmc_host *host, unsigned int hz); // 配置时钟频率
    
    void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode); // 配置IO模式：开漏/上拉
    void mmc_set_bus_width(struct mmc_host *host, unsigned int width); // 配置IO数据宽度
    
    u32 mmc_select_voltage(struct mmc_host *host, u32 ocr); // 配置电压
    int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage);
    
    
    void mmc_set_timing(struct mmc_host *host, unsigned int timing); //配置时序模式
    void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type); // 配置驱动类型

### host的mmc总线相关 ###

void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops); // 绑定host的bus
    void mmc_detach_bus(struct mmc_host *host);

### mmc请求相关 ###

void mmc_command_done(struct mmc_host *host, struct mmc_request *mrq); // cmd done
    void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq);   // mrq done
    
    
    int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq); // 直接发送mrq
    
    void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq); //等待mrq done
    
    
    void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq); //发送mrq，并等待mrq done
    int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries); //发送cmd， 并等待cmd done
    
    
    void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card); // 配置data传输超时时间

### card检测相关 ###

void mmc_detect_change(struct mmc_host *host, unsigned long delay); //启动card状态检测
    int mmc_detect_card_removed(struct mmc_host *host); //card移除
    
    void mmc_rescan(struct work_struct *work); //card状态检测task

## mmc core初始化相关 ##

### mmc\_init的实现 ###

负责初始化整个mmc core。主要工作：

*  注册mmc bus
 *  注册mmc host class
 *  注册sdio bus

static int __init mmc_init(void)
    {
    	int ret;
    
    	/* 注册mmc bus */
    	ret = mmc_register_bus();
    	if (ret)
    		return ret;
    
    	/* 注册mmc host class */
    	ret = mmc_register_host_class();
    	if (ret)
    		goto unregister_bus;
    
    	/* 注册sdio bus */
    	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;
    }
    
    static void __exit mmc_exit(void)
    {
    	sdio_unregister_bus();
    	mmc_unregister_host_class();
    	mmc_unregister_bus();
    }
    
    subsys_initcall(mmc_init);
    module_exit(mmc_exit);
    
    MODULE_LICENSE("GPL");

## mmc host的管理和维护相关 ##

### mmc\_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, NULL);  // 调用__mmc_claim_host来获取host
    }
    
    /**
     *	__mmc_claim_host - exclusively claim a host
     *	@host: mmc host to claim
     *	@ctx: context that claims the host or NULL in which case the default
     *	context will be used
     *	@abort: whether or not the operation should be aborted
     *
     *	Claim a host for a set of operations.  If @abort is non null and
     *	dereference a non-zero value then this will return prematurely with
     *	that non-zero value without acquiring the lock.  Returns zero
     *	with the lock held otherwise.
     */
    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) { // 以下尝试获取host，如果host正在被占用，会进入休眠
    		set_current_state(TASK_UNINTERRUPTIBLE);// 设置进程状态为TASK_UNINTERRUPTIBLE状态
    		stop = abort ? atomic_read(abort) : 0;
    		if (stop || !host->claimed || mmc_ctx_matches(host, ctx, task))// 当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
    		mmc_ctx_set_claimer(host, ctx, task);// 设置占用者为当前进程
    		host->claim_cnt += 1;                // 占用计数加1
    		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));
    
    	return stop;
    }

/**
     *	mmc_release_host - release a host
     *	@host: mmc host to release
     *
     *	Release a MMC host, allowing others to claim the host
     *	for their operations.
     */
    void mmc_release_host(struct mmc_host *host)
    {
    	unsigned long flags;
    
    	WARN_ON(!host->claimed);
    
    	spin_lock_irqsave(&host->lock, flags);
    	if (--host->claim_cnt) {// 如果减一之后计数还不为0，说明当前进程需要继续占用该host，不做其他操作
    		/* Release for nested claim */
    		spin_unlock_irqrestore(&host->lock, flags);
    	} else {// 以下需要释放该host
    		host->claimed = 0;         // 设置占用标志claimed为0
    		host->claimer->task = NULL;// 清空占用者（进程）
    		host->claimer = NULL;
    		spin_unlock_irqrestore(&host->lock, flags);
    		wake_up(&host->wq);        // 唤醒host的等待队列，让那些调用mmc_claim_host睡眠等待host资源的进程被唤醒
    		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));
    	}
    }

会调用mmc\_host->struct mmc\_host\_ops->enable和mmc\_host->struct mmc\_host\_ops->disable来使能和禁用host。

### mmc\_power\_up & mmc\_power\_off ###

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

*  mmc的power状态

#define MMC_POWER_OFF		0        // 掉电状态
    #define MMC_POWER_UP		1        // 正在上电的状态
    #define MMC_POWER_ON		2       // 供电正常的状态
    #define MMC_POWER_UNDEFINED	3      // 未定义的状态

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

/*
     * Apply power to the MMC stack.  This is a two-stage process.
     * First, we enable power to the card without the clock running.
     * We then wait a bit for the power to stabilise.  Finally,
     * enable the bus drivers and clock to the card.
     *
     * We must _NOT_ enable the clock prior to power stablising.
     *
     * If a host does all the power sequencing itself, ignore the
     * initial MMC_POWER_UP stage.
     */
    void mmc_power_up(struct mmc_host *host, u32 ocr)
    {
    	if (host->ios.power_mode == MMC_POWER_ON)
    		return;
    
    	/* 第一阶段，先设置对应的io setting使host处于MMC_POWER_UP的状态（总线工作频率没有设置） */
    	mmc_pwrseq_pre_power_on(host); // 上电前的准备工作
    
    	host->ios.vdd = fls(ocr) - 1; // 选择一个ocr配置设置为host的工作电压
    	host->ios.power_mode = MMC_POWER_UP;
    	/* Set initial state and call mmc_set_ios */
    	mmc_set_initial_state(host);//初始化状态，及调用mmc_set_ios设置总线的io setting
    
    	mmc_set_initial_signal_voltage(host);
    
    	/*
    	 * This delay should be sufficient to allow the power supply
    	 * to reach the minimum voltage.
    	 */
    	mmc_delay(host->ios.power_delay_ms);
    
    	/* 第二阶段，以host的初始化工作频率再次设置io setting，使host处于MMC_POWER_ON状态 */
    	mmc_pwrseq_post_power_on(host);
    
    	host->ios.clock = host->f_init;// 设置总线的时钟频率为初始化频率
    
    	host->ios.power_mode = MMC_POWER_ON;
    	mmc_set_ios(host);
    
    	/*
    	 * This delay must be at least 74 clock sizes, or 1 ms, or the
    	 * time required to reach a stable voltage.
    	 */
    	mmc_delay(host->ios.power_delay_ms);
    }

void mmc_power_off(struct mmc_host *host)
    {
    	if (host->ios.power_mode == MMC_POWER_OFF)
    		return;
    
    	//使host处于MMC_POWER_OFF的状态
    	mmc_pwrseq_power_off(host);
    
    	host->ios.clock = 0;
    	host->ios.vdd = 0;
    
    	host->ios.power_mode = MMC_POWER_OFF;
    	/* Set initial state and call mmc_set_ios */
    	mmc_set_initial_state(host);
    
    	/*
    	 * Some configurations, such as the 802.11 SDIO card in the OLPC
    	 * XO-1.5, require a short delay after poweroff before the card
    	 * can be successfully turned on again.
    	 */
    	mmc_delay(1);
    }

### mmc\_start\_host & mmc\_stop\_host ###

mmc\_start\_host 用来启动一个host，mmc\_stop\_host用来停止一个host。  
  当底层host controller调用mmc\_add\_host来注册host时，在mmc\_add\_host中就会调用mmc\_start\_host来启动一个host了。  
  相对应的，会在mmc\_remove\_host中调用mmc\_stop\_host停止host。

void mmc_start_host(struct mmc_host *host)
    {
    	host->f_init = max(freqs[0], host->f_min);// 通过最小频率要设置初始化频率
    	host->rescan_disable = 0;                 // 设置rescan_disable标志为0，说明已经可以进行card检测了
    	host->ios.power_mode = MMC_POWER_UNDEFINED;
    
    	// 如果mmc属性没有设置了MMC_CAP2_NO_PRESCAN_POWERUP，也就是在rescan前需要进行power up操作时，则进行上电
    	if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) {
    		mmc_claim_host(host);               // 因为上电操作涉及到对host的使用和设置，需要先占用host
    		mmc_power_up(host, host->ocr_avail);
    		mmc_release_host(host);            // 完成上电操作，释放host
    	}
    
    	//申请 cd_gpio
    	mmc_gpiod_request_cd_irq(host);
    
    	/* 到这里host已经可以工作了，可以开始进行后续的card操作了 */
    	_mmc_detect_change(host, 0, false); // 调用mmc_detect_change检测card变化
    }

void mmc_stop_host(struct mmc_host *host)
    {
    	if (host->slot.cd_irq >= 0) { //关闭cd wakeup功能
    		mmc_gpio_set_cd_wake(host, false);
    		disable_irq(host->slot.cd_irq);
    	}
    
    	host->rescan_disable = 1;
    	cancel_delayed_work_sync(&host->detect);
    
    	/* clear pm flags now and let card drivers set them as needed */
    	host->pm_flags = 0;
    
    	mmc_bus_get(host);
    	if (host->bus_ops && !host->bus_dead) {
    		/* Calling bus_ops->remove() with a claimed host can deadlock */
    		host->bus_ops->remove(host);
    		mmc_claim_host(host);
    		mmc_detach_bus(host);
    		mmc_power_off(host);
    		mmc_release_host(host);
    		mmc_bus_put(host);
    		return;
    	}
    	mmc_bus_put(host);
    
    	mmc_claim_host(host);
    	mmc_power_off(host);   //host掉电
    	mmc_release_host(host);
    }

## card检测相关 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qWT5r2H5r2H_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

### 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, bool cd_irq)
    {
    	/*
    	 * If the device is configured as wakeup, we prevent a new sleep for
    	 * 5 s to give provision for user space to consume the event.
    	 */
    	if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL) &&
    		device_can_wakeup(mmc_dev(host)))
    		pm_wakeup_event(mmc_dev(host), 5000);
    
    	host->detect_change = 1; // 检测到card状态发生变化的标识
    	mmc_schedule_delayed_work(&host->detect, delay); // 间隔delay jiffies之后调用host->detect的工作(mmc_rescan)
    }
    
    /**
     *	mmc_detect_change - process change of state on a MMC socket
     *	@host: host which changed state.
     *	@delay: optional delay to wait before detection (jiffies)
     *
     *	MMC drivers should call this when they detect a card has been
     *	inserted or removed. The MMC layer will confirm that any
     *	present card is still functional, and initialize any newly
     *	inserted.
     */
    void mmc_detect_change(struct mmc_host *host, unsigned long delay)
    {
    	_mmc_detect_change(host, delay, true);
    }
    EXPORT_SYMBOL(mmc_detect_change);

### 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);
    	int i;
    
    	/* 如果rescan_disable被设置，说明host此时还禁止rescan */
    	if (host->rescan_disable)
    		return;
    
    	/* If there is a non-removable card registered, only scan once */
    	/* 对于设备不可移除的host来说，只能rescan一次 */
    	if (!mmc_card_is_removable(host) && host->rescan_entered)
    		return;
    	host->rescan_entered = 1;
    
    	if (host->trigger_card_event && host->ops->card_event) {
    		mmc_claim_host(host);
    		host->ops->card_event(host);
    		mmc_release_host(host);
    		host->trigger_card_event = false;
    	}
    
    	mmc_bus_get(host);// 获取host对应的bus
    
    	/* Verify a registered card to be functional, else remove it. */
    	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_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);
    
    	/* if there still is a card present, stop here */
    	if (host->bus_ops != NULL) {
    		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_claim_host(host);
    	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;
    	}
    
    	// 调用mmc_rescan_try_freq，以支持的最低频率作为工作频率尝试搜索card
    	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;
    	}
    	mmc_release_host(host);
    
     out:
    	// 当host设置了MMC_CAP_NEEDS_POLL属性时，需要每隔HZ的时间轮询检测host的卡槽状态，
    	// 调度了host->detect工作，对应就是mmc_rescan
    	if (host->caps & MMC_CAP_NEEDS_POLL)
    		mmc_schedule_delayed_work(&host->detect, HZ);
    }

会调用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。

### 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); // 给host做上电操作
    
    	/*
    	 * Some eMMCs (with VCCQ always on) may not be reset after power up, so
    	 * do a hardware reset if possible.
    	 */
    	mmc_hw_reset_for_init(host); // 硬件复位和初始化
    
    	/*
    	 * sdio_reset sends CMD52 to reset card.  Since we do not know
    	 * if the card is being re-initialized, just send it.  CMD52
    	 * should be ignored by SD/eMMC cards.
    	 * Skip it if we already know that we do not support SDIO commands
    	 */
    	// sdio card需发送cmd52，使card reset
    	if (!(host->caps2 & MMC_CAP2_NO_SDIO))
    		sdio_reset(host);
    
    	mmc_go_idle(host);//发送card IDLE命令cmd0
    
    	//非sd card需发送cmd8，获取card的可用频率，存储到host->ocr_avail中
    	if (!(host->caps2 & MMC_CAP2_NO_SD))
    		mmc_send_if_cond(host, host->ocr_avail);
    
    	/* 用于绑定card到host bus上（也就是card和host的绑定）。 */
    	/* Order's important: probe SDIO, then SD, then MMC */
    	if (!(host->caps2 & MMC_CAP2_NO_SDIO)) // 未配置no-sdio，则先假设card是sdio type card，
    		if (!mmc_attach_sdio(host))        // 尝试绑定到host bus上，失败则说明不是sdio type card，
    			return 0;                      // 继续后面的操作，否则返回。已下同理
    
    	if (!(host->caps2 & MMC_CAP2_NO_SD))
    		if (!mmc_attach_sd(host))
    			return 0;
    
    	if (!(host->caps2 & MMC_CAP2_NO_MMC))
    		if (!mmc_attach_mmc(host))
    			return 0;
    
    	mmc_power_off(host);
    	return -EIO;
    }

## 总线io setting相关 ##

### mmc\_set\_ios ###

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

/*
     * Internal function that does the actual ios call to the host driver,
     * optionally printing some debug output.
     */
    static inline void mmc_set_ios(struct mmc_host *host)
    {
    	struct mmc_ios *ios = &host->ios;
    
    	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
    		"width %u timing %u\n",
    		 mmc_hostname(host), ios->clock, ios->bus_mode,
    		 ios->power_mode, ios->chip_select, ios->vdd,
    		 1 << ios->bus_width, ios->timing);
    
    	// 调用host->ops->set_ios来对mmc总线的io setting进行设置，核心函数，由host自行实现
    	host->ops->set_ios(host, ios);
    }

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

### mmc\_set\_bus\_mode & mmc\_set\_bus\_width ###

*  mmc\_set\_bus\_mode用于设置总线模式，有如下模式

#define MMC_BUSMODE_OPENDRAIN	1 //（开漏模式）
    #define MMC_BUSMODE_PUSHPULL	2 //（上拉模式）

*  mmc\_set\_bus\_width用于设置总线宽度，有如下模式

#define MMC_BUS_WIDTH_1		0
    #define MMC_BUS_WIDTH_4		2
    #define MMC_BUS_WIDTH_8		3

/*
     * Change the bus mode (open drain/push-pull) of a host.
     */
    /* 
     * mmc_set_bus_mode用于设置总线模式，有如下模式
     * MMC_BUSMODE_OPENDRAIN（开漏模式）
     * MMC_BUSMODE_PUSHPULL（上拉模式）
     */
    void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
    {
    	host->ios.bus_mode = mode;
    	mmc_set_ios(host);
    }

/*
     * Change data bus width of a host.
     */
    /*
     * mmc_set_bus_width用于设置总线宽度，有如下模式
     * MMC_BUS_WIDTH_1
     * MMC_BUS_WIDTH_4
     * MMC_BUS_WIDTH_8
     */
    void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
    {
    	host->ios.bus_width = width;
    	mmc_set_ios(host);
    }

### mmc\_set\_clock ###

/*
     * Sets the host clock to the highest possible frequency that
     * is below "hz".
     */
    /* 
     * mmc_set_clock用于设置总线时钟，时钟范围为：f_min <= hz <= f_max
     */
    void mmc_set_clock(struct mmc_host *host, unsigned int hz)
    {
    	WARN_ON(hz && hz < host->f_min);
    
    	if (hz > host->f_max)
    		hz = host->f_max;
    
    	host->ios.clock = hz;
    	mmc_set_ios(host);
    }

## host的mmc总线相关 ##

### 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，那么就会被激活了

/*
     * Assign a mmc bus handler to a host. Only one bus handler may control a
     * host at any given time.
     */
    void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
    {
    	unsigned long flags;
    
    	WARN_ON(!host->claimed);
    
    	spin_lock_irqsave(&host->lock, flags);
    
    	WARN_ON(host->bus_ops);  // 不允许重复设置host的mmc总线操作集
    	WARN_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);
    }

/*
     * Remove the current bus handler from a host.
     */
    void mmc_detach_bus(struct mmc_host *host)
    {
    	unsigned long flags;
    
    	WARN_ON(!host->claimed); // 不允许在占用时被释放
    	WARN_ON(!host->bus_ops);
    
    	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
    }

### mmc\_bus\_get & mmc\_bus\_put ###

/*
     * Increase reference count of bus operator
     */
    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);
    }

/*
     * Decrease reference count of bus operator and free it if
     * it is the last reference.
     */
    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)
    		__mmc_release_bus(host); // 说明host的mmc总线当前并没有使用，调用__mmc_release_bus进行实际的释放操作
    	spin_unlock_irqrestore(&host->lock, flags);
    }

## mmc请求相关 ##

### 同步的mmc请求 ###

### 异步的mmc请求 ###

并不是说调用这个接口并不会阻塞，而是不会为了等待当前请求处理完成而阻塞，但是可能会等待上一次请求处理完成而阻塞。

mmc_start_request
            |--->mmc_mrq_prep
            |--->__mmc_start_request

### mmc\_wait\_for\_req ###

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

/**
     *	mmc_wait_for_req - start a request and wait for completion
     *	@host: MMC host to start command
     *	@mrq: MMC request to start
     *
     *	Start a new MMC custom command request for a host, and wait
     *	for the command to complete. In the case of 'cap_cmd_during_tfr'
     *	requests, the transfer is ongoing and the caller can issue further
     *	commands that do not use the data lines, and then wait by calling
     *	mmc_wait_for_req_done().
     *	Does not attempt to parse the response.
     */
    void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
    {
    	__mmc_start_req(host, mrq); // 开始发起mmc_request请求
    
    	if (!mrq->cap_cmd_during_tfr)
    		mmc_wait_for_req_done(host, mrq); // 开始发起mmc_request请求
    }
    EXPORT_SYMBOL(mmc_wait_for_req);

### \_\_mmc\_start\_req ###

static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
    {
    	int err;
    
    	mmc_wait_ongoing_tfr_cmd(host);
    
    	/* 发起mmc_request前的一些初始化工作，包括完成量和处理完成的回调函数的设置 */
    	init_completion(&mrq->completion); // 初始化完成量，在mmc_wait_for_req_done中会去等待这个完成量
    
    	// 设置mmc_request处理完成的回调函数，会调用complete(&mrq->completion);来设置完成量
    	// host controller会调用mmc_request_done来执行这个回调函数
    	mrq->done = mmc_wait_done;
    
    	/* 调用mmc_start_request发起mmc请求 */
    	err = mmc_start_request(host, mrq); // 开始处理mmc_request请求
    	if (err) { // mmc_request出错后的异常处理
    		mrq->cmd->error = err;
    		mmc_complete_cmd(mrq);
    		complete(&mrq->completion);
    	}
    
    	return err;
    }

### mmc\_start\_request ###

int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
    {
    	int err;
    
    	// 初始化cmd 完成量
    	init_completion(&mrq->cmd_completion);
    
    	mmc_retune_hold(host);
    
    	if (mmc_card_removed(host->card))
    		return -ENOMEDIUM;
    
    	mmc_mrq_pr_debug(host, mrq, false);
    
    	WARN_ON(!host->claimed);
    
    	// mmc_request发送前的初始化
    	err = mmc_mrq_prep(host, mrq);
    	if (err)
    		return err;
    
    	led_trigger_event(host->led, LED_FULL);
    	__mmc_start_request(host, mrq);
    
    	return 0;
    }

### \_\_mmc\_start\_request ###

static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
    {
    	int err;
    
    	/* Assumes host controller has been runtime resumed by mmc_claim_host */
    	err = mmc_retune(host);
    	if (err) {
    		mrq->cmd->error = err;
    		mmc_request_done(host, mrq);
    		return;
    	}
    
    	/*
    	 * For sdio rw commands we must wait for card busy otherwise some
    	 * sdio devices won't work properly.
    	 * And bypass I/O abort, reset and bus suspend operations.
    	 */
    	// sdio card需检查 I/O 是否为busy
    	if (sdio_is_io_busy(mrq->cmd->opcode, mrq->cmd->arg) &&
    	    host->ops->card_busy) {
    		int tries = 500; /* Wait aprox 500ms at maximum */
    
    		while (host->ops->card_busy(host) && --tries)
    			mmc_delay(1);
    
    		if (tries == 0) {
    			mrq->cmd->error = -EBUSY;
    			mmc_request_done(host, mrq);
    			return;
    		}
    	}
    
    	if (mrq->cap_cmd_during_tfr) {
    		host->ongoing_mrq = mrq;
    		/*
    		 * Retry path could come through here without having waiting on
    		 * cmd_completion, so ensure it is reinitialised.
    		 */
    		reinit_completion(&mrq->cmd_completion);
    	}
    
    	trace_mmc_request_start(host, mrq);
    
    	if (host->cqe_on)
    		host->cqe_ops->cqe_off(host);
    
    	/* 调用host controller的request方法来处理mmc_request请求 */
    	host->ops->request(host, mrq);
    }

### 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; // 获取对应的command
    
    		/*
    		 * If host has timed out waiting for the sanitize
    		 * to complete, card might be still in programming state
    		 * so let's try to bring the card out of programming
    		 * state.
    		 */
    		if (cmd->sanitize_busy && cmd->error == -ETIMEDOUT) {
    			if (!mmc_interrupt_hpi(host->card)) {
    				pr_warn("%s: %s: Interrupted sanitize\n",
    					mmc_hostname(host), __func__);
    				cmd->error = 0;
    				break;
    			} else {
    				pr_err("%s: %s: Failed to interrupt sanitize\n",
    				       mmc_hostname(host), __func__);
    			}
    		}
    
    		// 如果command正常处理完成，或者失败重复尝试次数为0，或者card被移除了，直接退出循环返回
    		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);
    		cmd->retries--;
    		cmd->error = 0;
    		__mmc_start_request(host, mrq);
    	}
    
    	mmc_retune_release(host);
    }

### mmc\_request\_done ###

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

/**
     *	mmc_request_done - finish processing an MMC request
     *	@host: MMC host which completed request
     *	@mrq: MMC request which request
     *
     *	MMC drivers should call this function when they have completed
     *	their processing of a request.
     */
    void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
    {
    	struct mmc_command *cmd = mrq->cmd;
    	int err = cmd->error;
    
    	/* Flag re-tuning needed on CRC errors */
    	if (cmd->opcode != MMC_SEND_TUNING_BLOCK &&
    	    cmd->opcode != MMC_SEND_TUNING_BLOCK_HS200 &&
    	    !host->retune_crc_disable &&
    	    (err == -EILSEQ || (mrq->sbc && mrq->sbc->error == -EILSEQ) ||
    	    (mrq->data && mrq->data->error == -EILSEQ) ||
    	    (mrq->stop && mrq->stop->error == -EILSEQ)))
    		mmc_retune_needed(host);
    
    	// command执行出错，如果还需要重复尝试的话，只是通知mmc core
    	if (err && cmd->retries && mmc_host_is_spi(host)) {
    		if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
    			cmd->retries = 0;
    	}
    
    	if (host->ongoing_mrq == mrq)
    		host->ongoing_mrq = NULL;
    
    	mmc_complete_cmd(mrq);
    
    	trace_mmc_request_done(host, mrq);
    
    	/*
    	 * We list various conditions for the command to be considered
    	 * properly done:
    	 *
    	 * - There was no error, OK fine then
    	 * - We are not doing some kind of retry
    	 * - The card was removed (...so just complete everything no matter
    	 *   if there are errors or retries)
    	 */
    	if (!err || !cmd->retries || mmc_card_removed(host->card)) {
    		mmc_should_fail_request(host, mrq);
    
    		if (!host->ongoing_mrq)
    			led_trigger_event(host->led, LED_OFF);
    
    		if (mrq->sbc) {
    			pr_debug("%s: req done <CMD%u>: %d: %08x %08x %08x %08x\n",
    				mmc_hostname(host), mrq->sbc->opcode,
    				mrq->sbc->error,
    				mrq->sbc->resp[0], mrq->sbc->resp[1],
    				mrq->sbc->resp[2], mrq->sbc->resp[3]);
    		}
    
    		pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
    			mmc_hostname(host), cmd->opcode, err,
    			cmd->resp[0], cmd->resp[1],
    			cmd->resp[2], cmd->resp[3]);
    
    		if (mrq->data) {
    			pr_debug("%s:     %d bytes transferred: %d\n",
    				mmc_hostname(host),
    				mrq->data->bytes_xfered, mrq->data->error);
    		}
    
    		if (mrq->stop) {
    			pr_debug("%s:     (CMD%u): %d: %08x %08x %08x %08x\n",
    				mmc_hostname(host), mrq->stop->opcode,
    				mrq->stop->error,
    				mrq->stop->resp[0], mrq->stop->resp[1],
    				mrq->stop->resp[2], mrq->stop->resp[3]);
    		}
    	}
    	/*
    	 * Request starter must handle retries - see
    	 * mmc_wait_for_req_done().
    	 */
    	// 执行mmc_request的回调函数来通知mmc core，
    	// 对于__mmc_start_req发起的request来说，就是mmc_wait_done
    	// 对于__mmc_start_data_req发起的request来说，就是mmc_wait_data_done
    	if (mrq->done)
    		mrq->done(mrq);
    }

### mmc\_wait\_for\_cmd ###

mmc\_wait\_for\_cmd用于处理一个不带数据请求的命令。  
  会被封装到mmc\_request中，通过调用mmc\_wait\_for\_req来发起请求。

/**
     *	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));// 清空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; // 返回错误码
    }

[6. _mmc subsystem_ mmc core_mmc core]: https://www.cnblogs.com/linhaostudy/p/10811296.html
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qWT5r2H5r2H_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220828/589a8dc8865d4af2b92212ce43689c55.png