Linux驱动——sdio type card（八）

朴灿烈づ我的快乐病毒、 2022-09-16 15:29 737阅读 0赞

# Linux驱动——sdio type card（八） #

备注：  
  1. Kernel版本：5.4  
  2. 使用工具：Source Insight 4.0

### 文章目录 ###

*  Linux驱动——sdio type card（八）
 *   *  概述
     *  数据结构
     *   *  mmc\_sdio\_ops
     *  核心接口说明
     *   *  sdio type card匹配相关
         *   *  mmc\_attach\_sdio
             *  mmc\_sdio\_init\_card
         *  sdio ops相关函数
         *   *  mmc\_send\_io\_op\_cond
             *  mmc\_io\_rw\_direct
             *  mmc\_io\_rw\_extended
             *  sdio\_reset
         *  sdio irq相关函数
         *   *  注册sdio\_irq——sdio\_claim\_irq
             *  释放sdio\_irq——sdio\_release\_irq
             *  创建sdio\_irq\_thread——sdio\_card\_irq\_get
             *  实现sdio\_irq\_thread——sdio\_irq\_thread
         *  sdio io相关函数
         *   *  host相关
             *  sdio func相关
             *  块配置相关
             *  IO读写相关

## 概述 ##

card相关模块为对应card实现相应的操作，包括初始化操作、以及对应的总线操作集合。负责和对应card协议层相关的东西。  
sdio type card相关代码：

drivers/mmc/core/sdio.c（提供接口）
    drivers/mmc/core/sdio_ops.c（提供和sdio type card协议相关的操作）
    drivers/mmc/core/sdio_irq.c（提供sdio irq相关功能的操作）
    drivers/mmc/core/sdio_cis.c（提供sdio cis相关功能的操作）
    drivers/mmc/core/sdio_ops.h

## 数据结构 ##

### mmc\_sdio\_ops ###

static const struct mmc_bus_ops mmc_sdio_ops = {
    	.remove = mmc_sdio_remove,
    	.detect = mmc_sdio_detect,
    	.pre_suspend = mmc_sdio_pre_suspend,
    	.suspend = mmc_sdio_suspend,
    	.resume = mmc_sdio_resume,
    	.runtime_suspend = mmc_sdio_runtime_suspend,
    	.runtime_resume = mmc_sdio_runtime_resume,
    	.alive = mmc_sdio_alive,
    	.hw_reset = mmc_sdio_hw_reset,
    	.sw_reset = mmc_sdio_sw_reset,
    };

## 核心接口说明 ##

### sdio type card匹配相关 ###

#### mmc\_attach\_sdio ####

/*
     * Starting point for SDIO card init.
     */
    int mmc_attach_sdio(struct mmc_host *host)
    {
    	int err, i, funcs;
    	u32 ocr, rocr;
    	struct mmc_card *card;
    
    	WARN_ON(!host->claimed);
    	
    	/*
    	 * 
    	 * 以下部分，连同mmc_rescan_try_freq中的
    	 * mmc_go_idle和mmc_send_if_cond一起构成了
    	 * “尝试获取一个合适的工作电压” 的任务 
    	 */
    
    	// host发送参数为0的ACMD41命令，提取response中的VHS，
    	// 得到card支持的工作电压范围
    
    	err = mmc_send_io_op_cond(host, 0, &ocr);
    	if (err)
    		return err;
    
    	//创建sd_ops，host->bus_ops指向mmc_sdio_ops
    	mmc_attach_bus(host, &mmc_sdio_ops);
    	if (host->ocr_avail_sdio)
    		host->ocr_avail = host->ocr_avail_sdio;
    
    	// host选择一个card和host都支持的最低的工作电压，
    	// 并将host提供给card的工作电压设置为这个值。
    	// 后续就以host->ocr作为工作电压对sd card进行初始化
    	rocr = mmc_select_voltage(host, ocr);
    
    	/*
    	 * Can we support the voltage(s) of the card(s)?
    	 */
    	if (!rocr) {
    		err = -EINVAL;
    		goto err;
    	}
    
    	/*
    	 * Detect and init the card.
    	 */
    	/** 上述已经完成了card的识别操作，并且为card选择了一个合适的工作电压 **/
    	/** 后续调用mmc_sdio_init_card对sdio card进行初始化，也就是代码核心 **/
    	err = mmc_sdio_init_card(host, rocr, NULL);
    	if (err)
    		goto err;
    
    	card = host->card;
    
    	/*
    	 * Enable runtime PM only if supported by host+card+board
    	 */
    	if (host->caps & MMC_CAP_POWER_OFF_CARD) {
    		/*
    		 * Do not allow runtime suspend until after SDIO function
    		 * devices are added.
    		 */
    		pm_runtime_get_noresume(&card->dev);
    
    		/*
    		 * Let runtime PM core know our card is active
    		 */
    		err = pm_runtime_set_active(&card->dev);
    		if (err)
    			goto remove;
    
    		/*
    		 * Enable runtime PM for this card
    		 */
    		pm_runtime_enable(&card->dev);
    	}
    
    	/*
    	 * The number of functions on the card is encoded inside
    	 * the ocr.
    	 */
    	// 根据ocr寄存器获取func数目
    	funcs = (ocr & 0x70000000) >> 28;
    	card->sdio_funcs = 0;
    
    	/*
    	 * Initialize (but don't add) all present functions.
    	 */
    	// 初始化sdio_func
    	for (i = 0; i < funcs; i++, card->sdio_funcs++) {
    		err = sdio_init_func(host->card, i + 1);
    		if (err)
    			goto remove;
    
    		/*
    		 * Enable Runtime PM for this func (if supported)
    		 */
    		if (host->caps & MMC_CAP_POWER_OFF_CARD)
    			pm_runtime_enable(&card->sdio_func[i]->dev);
    	}
    
    	/*
    	 * First add the card to the driver model...
    	 */
    	mmc_release_host(host);
    
    	// 将sd card添加到device中
    	err = mmc_add_card(host->card);
    	if (err)
    		goto remove_added;
    
    	/*
    	 * ...then the SDIO functions.
    	 */
    	//注册 sdio_func 到driver中
    	for (i = 0;i < funcs;i++) {
    		err = sdio_add_func(host->card->sdio_func[i]);
    		if (err)
    			goto remove_added;
    	}
    
    	if (host->caps & MMC_CAP_POWER_OFF_CARD)
    		pm_runtime_put(&card->dev);
    
    	mmc_claim_host(host);
    	return 0;
    
    
    remove:
    	mmc_release_host(host);
    remove_added:
    	/*
    	 * The devices are being deleted so it is not necessary to disable
    	 * runtime PM. Similarly we also don't pm_runtime_put() the SDIO card
    	 * because it needs to be active to remove any function devices that
    	 * were probed, and after that it gets deleted.
    	 */
    	mmc_sdio_remove(host);
    	mmc_claim_host(host);
    err:
    	mmc_detach_bus(host);
    
    	pr_err("%s: error %d whilst initialising SDIO card\n",
    		mmc_hostname(host), err);
    
    	return err;
    }

#### mmc\_sdio\_init\_card ####

/*
     * Handle the detection and initialisation of a card.
     *
     * In the case of a resume, "oldcard" will contain the card
     * we're trying to reinitialise.
     */
    static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
    			      struct mmc_card *oldcard)
    {
    	struct mmc_card *card;
    	int err;
    	int retries = 10;
    	u32 rocr = 0;
    	u32 ocr_card = ocr;
    
    	WARN_ON(!host->claimed);
    
    	/* to query card if 1.8V signalling is supported */
    	if (mmc_host_uhs(host))
    		ocr |= R4_18V_PRESENT;
    
    try_again:
    	/** 在mmc_sd_get_cid中完成如下工作：：： **/
    	/** 重新复位，完成card的内部初始化 **/
    	/** 设置信号电压，包括card和host的设置 **/
    	/** 获取card的CID值 **/
    	// 调用mmc_sd_get_cid进行复位、内部初始化，
    	// 设置信号电压，然后获取CID值，
    	// 最终card进入了identification state。
    
    	if (!retries) {
    		pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
    		ocr &= ~R4_18V_PRESENT;
    	}
    
    	/*
    	 * Inform the card of the voltage
    	 */
    	err = mmc_send_io_op_cond(host, ocr, &rocr);
    	if (err)
    		return err;
    
    	/*
    	 * For SPI, enable CRC as appropriate.
    	 */
    	if (mmc_host_is_spi(host)) {
    		err = mmc_spi_set_crc(host, use_spi_crc);
    		if (err)
    			return err;
    	}
    
    	/*
    	 * Allocate card structure.
    	 */
    	card = mmc_alloc_card(host, NULL);
    	if (IS_ERR(card))
    		return PTR_ERR(card);
    
    	if ((rocr & R4_MEMORY_PRESENT) &&
    	    mmc_sd_get_cid(host, ocr & rocr, card->raw_cid, NULL) == 0) {
    		card->type = MMC_TYPE_SD_COMBO;
    
    		if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO ||
    		    memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) {
    			err = -ENOENT;
    			goto mismatch;
    		}
    	} else {
    		card->type = MMC_TYPE_SDIO;
    
    		if (oldcard && oldcard->type != MMC_TYPE_SDIO) {
    			err = -ENOENT;
    			goto mismatch;
    		}
    	}
    
    	/*
    	 * Call the optional HC's init_card function to handle quirks.
    	 */
    	if (host->ops->init_card)
    		host->ops->init_card(host, card);
    
    	/*
    	 * If the host and card support UHS-I mode request the card
    	 * to switch to 1.8V signaling level.  No 1.8v signalling if
    	 * UHS mode is not enabled to maintain compatibility and some
    	 * systems that claim 1.8v signalling in fact do not support
    	 * it. Per SDIO spec v3, section 3.1.2, if the voltage is already
    	 * 1.8v, the card sets S18A to 0 in the R4 response. So it will
    	 * fails to check rocr & R4_18V_PRESENT,  but we still need to
    	 * try to init uhs card. sdio_read_cccr will take over this task
    	 * to make sure which speed mode should work.
    	 */
    	if (rocr & ocr & R4_18V_PRESENT) {
    		err = mmc_set_uhs_voltage(host, ocr_card);
    		if (err == -EAGAIN) {
    			mmc_sdio_resend_if_cond(host, card);
    			retries--;
    			goto try_again;
    		} else if (err) {
    			ocr &= ~R4_18V_PRESENT;
    		}
    	}
    
    	/*
    	 * For native busses:  set card RCA and quit open drain mode.
    	 */
    	if (!mmc_host_is_spi(host)) {
    		err = mmc_send_relative_addr(host, &card->rca);
    		if (err)
    			goto remove;
    
    		/*
    		 * Update oldcard with the new RCA received from the SDIO
    		 * device -- we're doing this so that it's updated in the
    		 * "card" struct when oldcard overwrites that later.
    		 */
    		if (oldcard)
    			oldcard->rca = card->rca;
    	}
    
    	/*
    	 * Read CSD, before selecting the card
    	 */
    	if (!oldcard && card->type == MMC_TYPE_SD_COMBO) {
    		err = mmc_sd_get_csd(host, card);
    		if (err)
    			goto remove;
    
    		mmc_decode_cid(card);
    	}
    
    	/*
    	 * Select card, as all following commands rely on that.
    	 */
    	if (!mmc_host_is_spi(host)) {
    		err = mmc_select_card(card);
    		if (err)
    			goto remove;
    	}
    
    	if (card->quirks & MMC_QUIRK_NONSTD_SDIO) {
    		/*
    		 * This is non-standard SDIO device, meaning it doesn't
    		 * have any CIA (Common I/O area) registers present.
    		 * It's host's responsibility to fill cccr and cis
    		 * structures in init_card().
    		 */
    		mmc_set_clock(host, card->cis.max_dtr);
    
    		if (card->cccr.high_speed) {
    			mmc_set_timing(card->host, MMC_TIMING_SD_HS);
    		}
    
    		if (oldcard)
    			mmc_remove_card(card);
    		else
    			host->card = card;
    
    		return 0;
    	}
    
    	/*
    	 * Read the common registers. Note that we should try to
    	 * validate whether UHS would work or not.
    	 */
    	err = sdio_read_cccr(card, ocr);
    	if (err) {
    		mmc_sdio_resend_if_cond(host, card);
    		if (ocr & R4_18V_PRESENT) {
    			/* Retry init sequence, but without R4_18V_PRESENT. */
    			retries = 0;
    			goto try_again;
    		}
    		return err;
    	}
    
    	/*
    	 * Read the common CIS tuples.
    	 */
    	// 获取card CIS 值
    	err = sdio_read_common_cis(card);
    	if (err)
    		goto remove;
    
    	if (oldcard) {
    		if (card->cis.vendor == oldcard->cis.vendor &&
    		    card->cis.device == oldcard->cis.device) {
    			mmc_remove_card(card);
    			card = oldcard;
    		} else {
    			err = -ENOENT;
    			goto mismatch;
    		}
    	}
    	card->ocr = ocr_card;
    	mmc_fixup_device(card, sdio_fixup_methods);
    
    
    	/** 获取sd card的配置寄存器和状态寄存器 **/
    	/** 读取card 的switch状态，也就是其支持的function **/
    	// host发送ACMD51命令，要求card回复其SCR寄存器（SD configuration register）的值
    	// host发送ACMD13命令，要求card回复其SSR寄存器（SD status regiter）的值
    	// host发送CMD6命令来读取card switch status。
    	// 通过card switch status可以得到card支持的总线速度模式以及驱动强度类型。
    	if (card->type == MMC_TYPE_SD_COMBO) {
    		err = mmc_sd_setup_card(host, card, oldcard != NULL);
    		/* handle as SDIO-only card if memory init failed */
    		if (err) {
    			mmc_go_idle(host);
    			if (mmc_host_is_spi(host))
    				/* should not fail, as it worked previously */
    				mmc_spi_set_crc(host, use_spi_crc);
    			card->type = MMC_TYPE_SDIO;
    		} else
    			card->dev.type = &sd_type;
    	}
    
    	/*
    	 * If needed, disconnect card detection pull-up resistor.
    	 */
    	// 关闭 card detection 功能
    	err = sdio_disable_cd(card);
    	if (err)
    		goto remove;
    
    	/* Initialization sequence for UHS-I cards */
    	/* Only if card supports 1.8v and UHS signaling */
    	// 切换到sdio highspeed 模式、配置时钟速率、配置数据总线宽度
    	if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
    		err = mmc_sdio_init_uhs_card(card);
    		if (err)
    			goto remove;
    	} else {
    		/*
    		 * Switch to high-speed (if supported).
    		 */
    		err = sdio_enable_hs(card);
    		if (err > 0)
    			mmc_set_timing(card->host, MMC_TIMING_SD_HS);
    		else if (err)
    			goto remove;
    
    		/*
    		 * Change to the card's maximum speed.
    		 */
    		mmc_set_clock(host, mmc_sdio_get_max_clock(card));
    
    		/*
    		 * Switch to wider bus (if supported).
    		 */
    		err = sdio_enable_4bit_bus(card);
    		if (err)
    			goto remove;
    	}
    
    	if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
    	    host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
    		pr_err("%s: Host failed to negotiate down from 3.3V\n",
    			mmc_hostname(host));
    		err = -EINVAL;
    		goto remove;
    	}
    
    	host->card = card;
    	return 0;
    
    mismatch:
    	pr_debug("%s: Perhaps the card was replaced\n", mmc_hostname(host));
    remove:
    	if (oldcard != card)
    		mmc_remove_card(card);
    	return err;
    }

### sdio ops相关函数 ###

#### mmc\_send\_io\_op\_cond ####

int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
    {
    	struct mmc_command cmd = {};
    	int i, err = 0;
    
    	cmd.opcode = SD_IO_SEND_OP_COND;
    	cmd.arg = ocr;
    	cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
    
    	for (i = 100; i; i--) {
    		err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
    		if (err)
    			break;
    
    		/* if we're just probing, do a single pass */
    		if (ocr == 0)
    			break;
    
    		/* otherwise wait until reset completes */
    		if (mmc_host_is_spi(host)) {
    			/*
    			 * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate
    			 * an initialized card under SPI, but some cards
    			 * (Marvell's) only behave when looking at this
    			 * one.
    			 */
    			if (cmd.resp[1] & MMC_CARD_BUSY)
    				break;
    		} else {
    			if (cmd.resp[0] & MMC_CARD_BUSY)
    				break;
    		}
    
    		err = -ETIMEDOUT;
    
    		mmc_delay(10);
    	}
    
    	if (rocr)
    		*rocr = cmd.resp[mmc_host_is_spi(host) ? 1 : 0];
    
    	return err;
    }

#### mmc\_io\_rw\_direct ####

int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
    	unsigned addr, u8 in, u8 *out)
    {
    	return mmc_io_rw_direct_host(card->host, write, fn, addr, in, out);
    }

static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
    	unsigned addr, u8 in, u8 *out)
    {
    	struct mmc_command cmd = {};
    	int err;
    
    	if (fn > 7)
    		return -EINVAL;
    
    	/* sanity check */
    	if (addr & ~0x1FFFF)
    		return -EINVAL;
    
    	cmd.opcode = SD_IO_RW_DIRECT;
    	cmd.arg = write ? 0x80000000 : 0x00000000;
    	cmd.arg |= fn << 28;
    	cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
    	cmd.arg |= addr << 9;
    	cmd.arg |= in;
    	cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
    
    	err = mmc_wait_for_cmd(host, &cmd, 0);
    	if (err)
    		return err;
    
    	if (mmc_host_is_spi(host)) {
    		/* host driver already reported errors */
    	} else {
    		if (cmd.resp[0] & R5_ERROR)
    			return -EIO;
    		if (cmd.resp[0] & R5_FUNCTION_NUMBER)
    			return -EINVAL;
    		if (cmd.resp[0] & R5_OUT_OF_RANGE)
    			return -ERANGE;
    	}
    
    	if (out) {
    		if (mmc_host_is_spi(host))
    			*out = (cmd.resp[0] >> 8) & 0xFF;
    		else
    			*out = cmd.resp[0] & 0xFF;
    	}
    
    	return 0;
    }

#### mmc\_io\_rw\_extended ####

int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
    	unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
    {
    	struct mmc_request mrq = {};
    	struct mmc_command cmd = {};
    	struct mmc_data data = {};
    	struct scatterlist sg, *sg_ptr;
    	struct sg_table sgtable;
    	unsigned int nents, left_size, i;
    	unsigned int seg_size = card->host->max_seg_size;
    	int err;
    
    	WARN_ON(blksz == 0);
    
    	/* sanity check */
    	if (addr & ~0x1FFFF)
    		return -EINVAL;
    
    	mrq.cmd = &cmd;
    	mrq.data = &data;
    
    	cmd.opcode = SD_IO_RW_EXTENDED;					// cmd53
    	cmd.arg = write ? 0x80000000 : 0x00000000;		// 读写方向
    	cmd.arg |= fn << 28;							// func->num
    	cmd.arg |= incr_addr ? 0x04000000 : 0x00000000;
    	cmd.arg |= addr << 9;							// 块地址
    	if (blocks == 0)
    		cmd.arg |= (blksz == 512) ? 0 : blksz;	/* byte mode */
    	else
    		cmd.arg |= 0x08000000 | blocks;		/* block mode */
    	cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
    
    	data.blksz = blksz; // 配置块大小
    	/* Code in host drivers/fwk assumes that "blocks" always is >=1 */
    	data.blocks = blocks ? blocks : 1; // 配置块数量
    	data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
    
    	left_size = data.blksz * data.blocks;
    	nents = DIV_ROUND_UP(left_size, seg_size);
    	if (nents > 1) {
    		if (sg_alloc_table(&sgtable, nents, GFP_KERNEL))
    			return -ENOMEM;
    
    		data.sg = sgtable.sgl;
    		data.sg_len = nents;
    
    		for_each_sg(data.sg, sg_ptr, data.sg_len, i) {
    			sg_set_buf(sg_ptr, buf + i * seg_size,
    				   min(seg_size, left_size));
    			left_size -= seg_size;
    		}
    	} else {
    		data.sg = &sg;
    		data.sg_len = 1;
    
    		//初始化sg，找到buf对应的物理页地址，为DMA传输做准备
    		sg_init_one(&sg, buf, left_size);
    	}
    
    	mmc_set_data_timeout(&data, card);
    
    	mmc_pre_req(card->host, &mrq);
    
    	//发送数据，并且等待返回
    	mmc_wait_for_req(card->host, &mrq);
    
    	if (cmd.error)
    		err = cmd.error;
    	else if (data.error)
    		err = data.error;
    	else if (mmc_host_is_spi(card->host))
    		/* host driver already reported errors */
    		err = 0;
    	else if (cmd.resp[0] & R5_ERROR)//返回数据处理R5
    		err = -EIO;
    	else if (cmd.resp[0] & R5_FUNCTION_NUMBER)
    		err = -EINVAL;
    	else if (cmd.resp[0] & R5_OUT_OF_RANGE)
    		err = -ERANGE;
    	else
    		err = 0;
    
    	mmc_post_req(card->host, &mrq, err);
    
    	if (nents > 1)
    		sg_free_table(&sgtable);
    
    	return err;
    }

#### sdio\_reset ####

int sdio_reset(struct mmc_host *host)
    {
    	int ret;
    	u8 abort;
    
    	/* SDIO Simplified Specification V2.0, 4.4 Reset for SDIO */
    
    	ret = mmc_io_rw_direct_host(host, 0, 0, SDIO_CCCR_ABORT, 0, &abort);
    	if (ret)
    		abort = 0x08;
    	else
    		abort |= 0x08;
    
    	return mmc_io_rw_direct_host(host, 1, 0, SDIO_CCCR_ABORT, abort, NULL);
    }

### sdio irq相关函数 ###

#### 注册sdio\_irq——sdio\_claim\_irq ####

/**
     *	sdio_claim_irq - claim the IRQ for a SDIO function
     *	@func: SDIO function
     *	@handler: IRQ handler callback
     *
     *	Claim and activate the IRQ for the given SDIO function. The provided
     *	handler will be called when that IRQ is asserted.  The host is always
     *	claimed already when the handler is called so the handler should not
     *	call sdio_claim_host() or sdio_release_host().
     */
    int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler)
    {
    	int ret;
    	unsigned char reg;
    
    	if (!func)
    		return -EINVAL;
    
    	pr_debug("SDIO: Enabling IRQ for %s...\n", sdio_func_id(func));
    
    	// sdio_func已注册中断，则为异常
    	if (func->irq_handler) { 
    		pr_debug("SDIO: IRQ for %s already in use.\n", sdio_func_id(func));
    		return -EBUSY;
    	}
    
    	// 获取中断使能寄存器值
    	ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
    	if (ret)
    		return ret;
    
    	reg |= 1 << func->num;
    
    	reg |= 1; /* Master interrupt enable */
    	// 使能中断
    	ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
    	if (ret)
    		return ret;
    
    	func->irq_handler = handler;
    	// 创建sdio_irq_thread内核线程
    	ret = sdio_card_irq_get(func->card);
    	if (ret)
    		func->irq_handler = NULL;
    
    	// 配置sdio_single_irq
    	sdio_single_irq_set(func->card);
    
    	return ret;
    }
    EXPORT_SYMBOL_GPL(sdio_claim_irq);

#### 释放sdio\_irq——sdio\_release\_irq ####

/**
     *	sdio_release_irq - release the IRQ for a SDIO function
     *	@func: SDIO function
     *
     *	Disable and release the IRQ for the given SDIO function.
     */
    int sdio_release_irq(struct sdio_func *func)
    {
    	int ret;
    	unsigned char reg;
    
    	if (!func)
    		return -EINVAL;
    
    	pr_debug("SDIO: Disabling IRQ for %s...\n", sdio_func_id(func));
    
    	if (func->irq_handler) {
    		func->irq_handler = NULL;
    		sdio_card_irq_put(func->card);
    		sdio_single_irq_set(func->card);
    	}
    
    	ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
    	if (ret)
    		return ret;
    
    	reg &= ~(1 << func->num);
    
    	/* Disable master interrupt with the last function interrupt */
    	if (!(reg & 0xFE))
    		reg = 0;
    
    	ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
    	if (ret)
    		return ret;
    
    	return 0;
    }
    EXPORT_SYMBOL_GPL(sdio_release_irq);

#### 创建sdio\_irq\_thread——sdio\_card\_irq\_get ####

static int sdio_card_irq_get(struct mmc_card *card)
    {
    	struct mmc_host *host = card->host;
    
    	WARN_ON(!host->claimed);
    
    	if (!host->sdio_irqs++) {
    		if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD)) {
    			atomic_set(&host->sdio_irq_thread_abort, 0);
    			//创建sdio irq thread 内核线程
    			host->sdio_irq_thread =
    				kthread_run(sdio_irq_thread, host,
    					    "ksdioirqd/%s", mmc_hostname(host));
    			if (IS_ERR(host->sdio_irq_thread)) {
    				int err = PTR_ERR(host->sdio_irq_thread);
    				host->sdio_irqs--;
    				return err;
    			}
    		} else if (host->caps & MMC_CAP_SDIO_IRQ) {
    			host->ops->enable_sdio_irq(host, 1);
    		}
    	}
    
    	return 0;
    }

#### 实现sdio\_irq\_thread——sdio\_irq\_thread ####

static int sdio_irq_thread(void *_host)
    {
    	struct mmc_host *host = _host;
    	struct sched_param param = { .sched_priority = 1 };
    	unsigned long period, idle_period;
    	int ret;
    
    	// 将sdio irq thread线程为实时线程FIFO，优先级为1
    	sched_setscheduler(current, SCHED_FIFO, &param);
    
    	/*
    	 * We want to allow for SDIO cards to work even on non SDIO
    	 * aware hosts.  One thing that non SDIO host cannot do is
    	 * asynchronous notification of pending SDIO card interrupts
    	 * hence we poll for them in that case.
    	 */
    	// 轮询运行时间为10ms
    	idle_period = msecs_to_jiffies(10);
    	// 若host支持硬件sdio_irq，则为中断模式，否则为轮询模式，10ms调度一次
    	period = (host->caps & MMC_CAP_SDIO_IRQ) ?
    		MAX_SCHEDULE_TIMEOUT : idle_period;
    
    	pr_debug("%s: IRQ thread started (poll period = %lu jiffies)\n",
    		 mmc_hostname(host), period);
    
    	do {
    		/*
    		 * We claim the host here on drivers behalf for a couple
    		 * reasons:
    		 *
    		 * 1) it is already needed to retrieve the CCCR_INTx;
    		 * 2) we want the driver(s) to clear the IRQ condition ASAP;
    		 * 3) we need to control the abort condition locally.
    		 *
    		 * Just like traditional hard IRQ handlers, we expect SDIO
    		 * IRQ handlers to be quick and to the point, so that the
    		 * holding of the host lock does not cover too much work
    		 * that doesn't require that lock to be held.
    		 */
    		// 获取host的使用权
    		ret = __mmc_claim_host(host, NULL,
    				       &host->sdio_irq_thread_abort);
    		if (ret)
    			break;
    		// 调用sdio_fun irq_handler函数或获取sdio card status再调用sdio_func
    		ret = process_sdio_pending_irqs(host);
    
    		// 释放host的使用权
    		mmc_release_host(host);
    
    		/*
    		 * Give other threads a chance to run in the presence of
    		 * errors.
    		 */
    		if (ret < 0) {
    			set_current_state(TASK_INTERRUPTIBLE);
    			if (!kthread_should_stop())
    				schedule_timeout(HZ);
    			set_current_state(TASK_RUNNING);
    		}
    
    		/*
    		 * Adaptive polling frequency based on the assumption
    		 * that an interrupt will be closely followed by more.
    		 * This has a substantial benefit for network devices.
    		 */
    		if (!(host->caps & MMC_CAP_SDIO_IRQ)) {
    			if (ret > 0)
    				period /= 2;
    			else {
    				period++;
    				if (period > idle_period)
    					period = idle_period;
    			}
    		}
    
    		set_current_state(TASK_INTERRUPTIBLE);
    
    		// 处理完sdio card中的数据，若支持sdio_irq，则使能sdio_irq
    		if (host->caps & MMC_CAP_SDIO_IRQ)
    			host->ops->enable_sdio_irq(host, 1);
    		if (!kthread_should_stop())
    			schedule_timeout(period);
    		set_current_state(TASK_RUNNING);
    	} while (!kthread_should_stop());
    
    	// 支持sdio_irq，则关闭sdio_irq
    	if (host->caps & MMC_CAP_SDIO_IRQ)
    		host->ops->enable_sdio_irq(host, 0);
    
    	pr_debug("%s: IRQ thread exiting with code %d\n",
    		 mmc_hostname(host), ret);
    
    	return ret;
    }

**process\_sdio\_pending\_irqs：**

static int process_sdio_pending_irqs(struct mmc_host *host)
    {
    	struct mmc_card *card = host->card;
    	int i, ret, count;
    	bool sdio_irq_pending = host->sdio_irq_pending;
    	unsigned char pending;
    	struct sdio_func *func;
    
    	/* Don't process SDIO IRQs if the card is suspended. */
    	if (mmc_card_suspended(card))
    		return 0;
    
    	/* Clear the flag to indicate that we have processed the IRQ. */
    	host->sdio_irq_pending = false;
    
    	/*
    	 * Optimization, if there is only 1 function interrupt registered
    	 * and we know an IRQ was signaled then call irq handler directly.
    	 * Otherwise do the full probe.
    	 */
    	// sdio_single_irq已注册，则直接调用func->irq_handler处理本次中断
    	func = card->sdio_single_irq;
    	if (func && sdio_irq_pending) {
    		func->irq_handler(func);
    		return 1;
    	}
    
    	// 发送cmd5 查询irq_pending???
    	ret = sdio_get_pending_irqs(host, &pending);
    	if (ret)
    		return ret;
    
    	// 根据pending，调用所对应的func
    	count = 0;
    	for (i = 1; i <= 7; i++) {
    		if (pending & (1 << i)) {
    			func = card->sdio_func[i - 1];
    			if (!func) {
    				pr_warn("%s: pending IRQ for non-existent function\n",
    					mmc_card_id(card));
    				ret = -EINVAL;
    			} else if (func->irq_handler) {
    				func->irq_handler(func);
    				count++;
    			} else {
    				pr_warn("%s: pending IRQ with no handler\n",
    					sdio_func_id(func));
    				ret = -EINVAL;
    			}
    		}
    	}
    
    	if (count)
    		return count;
    
    	return ret;
    }

**sdio\_get\_pending\_irqs：**

static int sdio_get_pending_irqs(struct mmc_host *host, u8 *pending)
    {
    	struct mmc_card *card = host->card;
    	int ret;
    
    	WARN_ON(!host->claimed);
    
    	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, pending);
    	if (ret) {
    		pr_debug("%s: error %d reading SDIO_CCCR_INTx\n",
    		       mmc_card_id(card), ret);
    		return ret;
    	}
    
    	if (*pending && mmc_card_broken_irq_polling(card) &&
    	    !(host->caps & MMC_CAP_SDIO_IRQ)) {
    		unsigned char dummy;
    
    		/* A fake interrupt could be created when we poll SDIO_CCCR_INTx
    		 * register with a Marvell SD8797 card. A dummy CMD52 read to
    		 * function 0 register 0xff can avoid this.
    		 */
    		mmc_io_rw_direct(card, 0, 0, 0xff, 0, &dummy);
    	}
    
    	return 0;
    }

### sdio io相关函数 ###

#### host相关 ####

**sdio\_claim\_host：**

void sdio_claim_host(struct sdio_func *func)
    {
    	if (WARN_ON(!func))
    		return;
    
    	mmc_claim_host(func->card->host);
    }
    EXPORT_SYMBOL_GPL(sdio_claim_host);

**sdio\_release\_host：**

void sdio_release_host(struct sdio_func *func)
    {
    	if (WARN_ON(!func))
    		return;
    
    	mmc_release_host(func->card->host);
    }
    EXPORT_SYMBOL_GPL(sdio_release_host);

#### sdio func相关 ####

int sdio_enable_func(struct sdio_func *func);
    int sdio_disable_func(struct sdio_func *func);

#### 块配置相关 ####

int sdio_set_block_size(struct sdio_func *func, unsigned blksz);
    unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz);

#### IO读写相关 ####

// 读写1byte
    u8 sdio_readb(struct sdio_func *func, unsigned int addr, int *err_ret);
    void sdio_writeb(struct sdio_func *func, u8 b, unsigned int addr, int *err_ret);
    u8 sdio_writeb_readb(struct sdio_func *func, u8 write_byte, unsigned int addr, int *err_ret);
    
    
    // 读写块数据
    int sdio_memcpy_fromio(struct sdio_func *func, void *dst, unsigned int addr, int count);
    int sdio_memcpy_toio(struct sdio_func *func, unsigned int addr, void *src, int count);
    
    
    // 读写FIFO 1byte
    int sdio_readsb(struct sdio_func *func, void *dst, unsigned int addr, int count);
    int sdio_writesb(struct sdio_func *func, unsigned int addr, void *src, int count);
    
    // 读写16bit(2byte)
    u16 sdio_readw(struct sdio_func *func, unsigned int addr, int *err_ret);
    void sdio_writew(struct sdio_func *func, u16 b, unsigned int addr, int *err_ret);
    
    // 读写32bit(4byte)
    u32 sdio_readl(struct sdio_func *func, unsigned int addr, int *err_ret);
    void sdio_writel(struct sdio_func *func, u32 b, unsigned int addr, int *err_ret);
    
    // sdio func0 读取1byte
    unsigned char sdio_f0_readb(struct sdio_func *func, unsigned int addr, int *err_ret);
    void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr, int *err_ret);

**sdio\_io\_rw\_ext\_helper：**  
  以上IO相关的函数，最终都是调用本函数来实现相关的功能，具体实现方式如下：

/* Split an arbitrarily sized data transfer into several
     * IO_RW_EXTENDED commands. */
    static int sdio_io_rw_ext_helper(struct sdio_func *func, int write,
    	unsigned addr, int incr_addr, u8 *buf, unsigned size)
    {
    	unsigned remainder = size;
    	unsigned max_blocks;
    	int ret;
    
    	if (!func || (func->num > 7))
    		return -EINVAL;
    
    	/* Do the bulk of the transfer using block mode (if supported). */
    	// 支持多块传输，且当前传输数据大于一块大小
    	if (func->card->cccr.multi_block && (size > sdio_max_byte_size(func))) {
    		/* Blocks per command is limited by host count, host transfer
    		 * size and the maximum for IO_RW_EXTENDED of 511 blocks. */
    		max_blocks = min(func->card->host->max_blk_count, 511u);
    
    		// 快对齐收发数据
    		while (remainder >= func->cur_blksize) {
    			unsigned blocks;
    
    			blocks = remainder / func->cur_blksize;
    			if (blocks > max_blocks)
    				blocks = max_blocks;
    			size = blocks * func->cur_blksize;
    
    			ret = mmc_io_rw_extended(func->card, write,
    				func->num, addr, incr_addr, buf,
    				blocks, func->cur_blksize);
    			if (ret)
    				return ret;
    
    			remainder -= size;
    			buf += size;
    			if (incr_addr)
    				addr += size;
    		}
    	}
    
    	/* Write the remainder using byte mode. */
    	// 收发剩余数据
    	while (remainder > 0) {
    		size = min(remainder, sdio_max_byte_size(func));
    
    		/* Indicate byte mode by setting "blocks" = 0 */
    		ret = mmc_io_rw_extended(func->card, write, func->num, addr,
    			 incr_addr, buf, 0, size);
    		if (ret)
    			return ret;
    
    		remainder -= size;
    		buf += size;
    		if (incr_addr)
    			addr += size;
    	}
    	return 0;
    }