详解sd协议以及裸机和u-boot中的sd卡驱动(2)

最新推荐文章于 2023-09-15 15:14:39 发布
最新推荐文章于 2023-09-15 15:14:39 发布
阅读量1.5k 收藏 10
点赞数
分类专栏： u-boot 文章标签： microsd u-boot 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CallMe_Xu/article/details/107420453
版权

3. sd卡驱动

3.1 引入

经过第2章我们知道，要想实现读写sd卡，需要按照sd协议规定的基本传输单位（命令、响应、数据）以及流程（初始化、读、写），向sd卡发送信号或者从sd卡接收信号。

为了简化cpu的操作，人们在soc内部设计了一个sd控制器，这个sd控制器专门按照sd规定的协议进行收发信号，并把我们上述提到的基本传输单位命令、响应以及数据的内容简化到一个个寄存器，比如s3c2440内部的sd控制器中包含有：

  • SDICmdArg寄存器：用来保存命令的参数，当我们需要发送命令到sd卡时，对于命令的参数，只需要写入该寄存器即可；
  • SDICmdCon寄存器：低八位用来保存命令的编号，当我们需要发送命令到sd卡时，对于命令的编号，只需要写入该寄存器即可；
  • SDIRSP0——SDIRSP3寄存器：用来保存响应的内容，当我们需要读取sd卡发来的响应值时，便可以读取该寄存器；
  • SDIDAT寄存器：用来保存数据的内容，当我们需要读取从sd卡发来的数据或者向sd卡写入数据时，便可以操作该寄存器；

等等还有很多寄存器，上面只是简单举例说明。

现在我们来回答问题2：cpu如何控制sd控制器来发出各种信号？

答案便是：通过读写其内部的寄存器，这也是sd驱动的主要内容。

现在，我想大家应该明白了，所谓sd卡驱动即是：

​ 通过sd控制器提供的简化功能，按照sd协议的规定通过cpu读写其相应的寄存器，以此来达到向sd卡发出或者从sd卡接收一系列信号的目的，最终完成读写sd卡的功能。

下面从裸机、u-boot层面对sd卡驱动进行分析，并着重比较其实现的异同。

3.2 裸机中的sd卡驱动

注：本裸机驱动来自我之前写的移植u-boot 2020文章中的spl工程。

现在我们已经知道，sd卡驱动的内容主要便是按照sd协议的规定读写sd控制器中的寄存器，这在裸机驱动中表现得最为明显。

对于裸机中的sd卡驱动，主要围绕如下三个功能的实现而展开：

  • 初始化sd卡
  • 读sd卡
  • 写sd卡
3.2.1 初始化sd卡

初始化的过程就是按照sd协议中规定的流程进行的。

过程如下：

  1. 初始化连接sd卡的gpio引脚以及sd控制器；
  2. 等待74个CLK
  3. 发送CMD0复位卡
  4. 发送CMD1检测是否为sd卡或者mmc卡
  5. 发送CMD2获取sd卡的CID
  6. 发送CMD3设置sd卡或者mmc卡的RCA
  7. 发送CMD9获取sd卡的CSD
  8. 发送CMD7选中sd卡
  9. 发送CMD13查询是否为传输状态
  10. 发送ACMD6设置总线带宽

代码如下：

u8 sd_init()
{
	int i;
	
	debug("\r\nSDI初始化开始！");
	
	GPEUP  = 0xf83f;   			// The pull up  1111 1000 0011 1111  必须上拉
    GPECON = 0xaaaaaaaa;  		// 1010 1010 1010 1010 1010 1010 1010 1010
    SDICSTA = 0xffff;   		//SDI指令状态
    SDIDSTA = 0xffff;			//SDI数据状态
 
	SDIPRE = 124; 				// 400KHz  波特率设置 频率 PCLK/400K -1
    SDICON = 1; 				// Type A,  clk enable SDI控制
    SDIFSTA |= 1 << 16; 		//FIFO reset
	SDIBSIZE = 0x200; 			// 512byte(128word)  SDI块大小
	SDIDTIMER = 0x7fffff; 		// Set timeout count 数据传输超时时间
	
	//等待74个CLK
    for(i=0;i<0x1000;i++);
	
	//先执行CMD0,复位
	CMD0(); 
	
	//判断卡的类型
	if(SDI_MMC_OCR()) 
		SDCard.sdiType = 1;  //卡为MMC
	else
		SDCard.sdiType = 0;  //卡为SD
		
	//检测SD卡
	if (SDI_SD_OCR()) {
		debug("SD is ready\r\n");
	} else{
		debug("Initialize fail\r\nNo Card assertion\r\n");
        return 0;
    }  
	
	//读CID
	if (CMD2(SDCard.cCardCID)) {
		debug("CID\r\n");
		debug("MID = %d\r\n",SDCard.cCardCID[0]);
		debug("OLD = %d\r\n",(SDCard.cCardCID[1]*0X100)+SDCard.cCardCID[2]);
		debug("生产厂家:%s\r\n",(SDCard.cCardCID+3));
		debug("生产日期:20%d,%d\r\n",((SDCard.cCardCID[13]&0x0f)<<4)+((SDCard.cCardCID[14]&0xf0)>>4),										(SDCard.cCardCID[14]&0x0f));
	} else {
		debug("Read Card CID is fail!\r\n");
		return 0;
	}
	
	//设置RCA       MMC的RCA=1   SD的RCA=0
	//MMC
	if (SDCard.sdiType==1) {
		if (CMD3(1,&SDCard.sdiRCA)) {
			SDCard.sdiRCA = 1;
			SDIPRE = 2;  //16MHZ
			debug("MMC Card RCA = 0x%x\r\n",SDCard.sdiRCA);
			debug("MMC Frequency is %dHz\r\n",(PCLK/(SDIPRE+1)));
		} else {
			debug("Read MMC RCA is fail!\r\n");
			return 0;
		}
	//SD
	} else {
		if (CMD3(0,&SDCard.sdiRCA)) {
			SDIPRE = 1; // Normal clock=25MHz
			debug("SD Card RCA = 0x%x\r\n",SDCard.sdiRCA);
			debug("SD Frequency is %dHz\r\n",(PCLK/(SDIPRE+1)));
		} else {
			debug("Read SD RCA is fail!\r\n");
			return 0;
		}
	}
	
	//读CSD
	if (CMD9(SDCard.sdiRCA,SDCard.lCardCSD)) {
		SDCard.lCardSize = (((SDCard.lCardCSD[1]&0x0000003f)<<16)+((SDCard.lCardCSD[2]&0xffff0000)>>16)+1)*512;
		SDCard.lSectorSize = ((SDCard.lCardCSD[2]>>6)&0x0000007f)+1;
		debug("Read Card CSD OK!\r\n");
		debug("0x%08x\r\n",SDCard.lCardCSD[0]);
		debug("0x%08x\r\n",SDCard.lCardCSD[1]);
		debug("0x%08x\r\n",SDCard.lCardCSD[2]);
		debug("0x%08x\r\n",SDCard.lCardCSD[3]);
		debug("卡容量为:%dKB,%dMB\r\n",SDCard.lCardSize,SDCard.lCardSize/1024);
	} else {
		debug("Read Card CSD Fail!\r\n");
		return 0;
	}
	
	//选中卡  CMD7  进入传输状态
	//1表示选中卡 
	if (select_card(1,SDCard.sdiRCA)) {
		debug("Card sel desel OK!\r\n");
	} else {
		debug("Card sel desel fail!\r\n");
		return 0;
	}
	
	//CMD13 查询是否为传输状态
	while ((CMD13(SDCard.sdiRCA) & 0x1e00) != 0x800);

	//设置总线带宽 ACMD6
	if (Set_bus_Width(SDCard.sdiType,1,SDCard.sdiRCA)) {
		SDCard.sdiWide = 1;
		debug("Bus Width is 4bit\r\n");
	} else {
		SDCard.sdiWide = 0;
		debug("Bus Width is 1bit\r\n");
	}
	
	return 1;
}
3.2.2 读sd卡

读sd卡的过程也是按照sd协议中规定的流程进行的。

过程如下：

  1. 设置sd控制器；
  2. 发送CMD18多块读sd卡
  3. 通过sd控制器中的SDIDAT寄存器获取读到的数据到指定内存地址
  4. 清除sd控制器中的状态寄存器
  5. 发送CMD12停止多块读传输

代码如下：

/*
 * sd_read_sector - 从SD卡中读出指定块起始地址的单个或多个数据块
 *
 * @addr  被读块的起始地址
 * @buffer 用于接收读出数据的缓冲区
 * @block_num 读的块数
 *
 * @return 
 *		0 读块操作不成功
 *		1 读块操作成功
 *
 */
u8 sd_read_sector(u32 *buf, u32 addr, u32 block_num)
{
	u32 i=0;
	u32 status=0;
	 
	SDIDTIMER = 0x7fffff; 				// Set timeout count
	SDIBSIZE = 0x200; 					// 512byte(128word)
	SDIFSTA = SDIFSTA | (1 << 16); 		// FIFO reset
	SDIDCON = (block_num << 0) | (2 << 12) | (1 << 14) | (SDCard.sdiWide << 16) | (1 << 17) | (1 << 19) | (2 << 22);

//	debug("enter sd_read_sector(): src_block = %d, block_num = %d\r\n", addr, block_num);
	
	//发送读多个块指令
	while (CMD18(addr) != 1)		
		SDICSTA = 0xF << 9;

	//开始接收数据到缓冲区
	while (i < block_num * 128) { 
		//检查是否超时和CRC校验是否出错
		if (SDIDSTA & 0x60) { 
			//清除超时标志和CRC错误标志
			SDIDSTA = (0x3 << 0x5); 
			return -1;
		}
		
		status = SDIFSTA;
		//如果接收FIFO中有数据
		if ((status & 0x1000) == 0x1000) { 
			*buf = SDIDAT;
			buf++;
			i++;
		}
	}
	 
	SDIDCON = SDIDCON & ~(7 << 12);
	SDIFSTA = SDIFSTA & 0x200;			//Clear Rx FIFO Last data Ready 
	SDIDSTA = 0x10;						//Clear data Tx/Rx end detect 

	//发送结束指令 
	while (CMD12() != 1)				
		SDICSTA = 0xF << 9;
	debug("leave sd_read_sector(): src_block = %d, block_num = %d\r\n", addr, block_num);
	 
	return 0;
}
3.2.3 写sd卡

与读sd卡过程相似，写sd卡的过程也是按照sd协议中规定的流程进行的。

过程如下：

  1. 设置sd控制器；
  2. 发送CMD25多块写sd卡
  3. 将指定内存地址处的要写入sd卡的数据写到sd控制器中的SDIDAT寄存器
  4. 设置sd控制器；
  5. 发送CMD12停止多块写传输

代码如下：

/*
 * sd_write_sector - 向SD卡的一个或多个数据块写入数据
 *
 * @addr  被写块的起始地址
 * @buffer 用于发送数据的缓冲区
 * @block_num 块数
 *
 * @return 
 *		0 数据写入操作失败
 *		1 数据写入操作成功
 *
 */
u8 sd_write_sector(u32 *buf, u32 addr, u32 block_num)
{
	u16 i = 0;
	u32 status = 0;
	 
	SDIDTIMER = 0x7fffff; 				// Set timeout count
	SDIBSIZE = 0x200; 					// 512byte(128word)
	SDIFSTA = SDIFSTA | (1 << 16); 		// FIFO reset
	SDIDCON = (block_num << 0) | (3 << 12) | (1 << 14) | (1 << 16) | (1 << 17) | (1 << 20) | (2 << 22);

	//发送写多个块指令
	while (CMD25(addr) != 1)
		SDICSTA = 0xF << 9;

	//开始传递数据到缓冲区
	while (i < block_num * 128) { 
		status = SDIFSTA;
		
		//如果发送FIFO可用，即FIFO未满
		if ((status & 0x2000) == 0x2000) {
			SDIDAT = *buf;
			buf++;
			i++;
		}
	}
	
	SDIDCON = SDIDCON & ~(7 << 12);

	//发送结束指令 
	while (CMD12() != 1)
		SDICSTA=0xF<<9;

	//等待数据发送结束
	do { 
		status = SDIDSTA;
	} while ((status & 0x2) == 0x2);

	SDIDSTA = status; 
	SDIDSTA = 0xf4;

	return 0;
}
3.2.4 具体命令实现举例

在前面的sd卡初始化、读、写函数中，主要的内容均是按照sd协议的规定发送一系列的命令，那具体每个命令是怎么实现的呢？下面举例说明：

  • CMD9：获取卡的CSD寄存器的值

    过程如下：

    1. 指定使用哪个sd卡，将卡的RCA作为命令的参数写入SDICARG寄存器
    2. 将命令的编号写入SDICCON寄存器，同时指定响应类型为长响应，并启动向sd卡发送该命令
    3. 读取sd控制器中的状态寄存器，检查命令是否发送完成
    4. 待命令发送完成后，读取SDIRSP0—SDIRSP3寄存器获取响应值，也即sd卡的CSD寄存器的值

    代码如下：

    //获取卡的CSD寄存器的值
u8 CMD9(u16 iRCA,u32 *lCSD) 
{
	SDICARG = iRCA<<16; // (RCA,stuff bit)
	SDICCON = (0x1<<10)|(0x1<<9)|(0x1<<8)|0x49; // long_resp, wait_resp, start
	 
	if(!SDI_Check_CMD_End(9, 1)) 
		return 0;
	 
	*(lCSD+0) = SDIRSP0;
	*(lCSD+1) = SDIRSP1;
	*(lCSD+2) = SDIRSP2;
	*(lCSD+3) = SDIRSP3;

    return 1;
}

  • CMD18：读取多个数据块

    过程如下：

    1. 指定读取sd卡的地址，将地址命令的参数写入SDICARG寄存器
    2. 将命令的编号写入SDICCON寄存器，并启动向sd卡发送该命令
    3. 读取sd控制器中的状态寄存器，检查命令是否发送完成

    代码如下：

    //读取多个数据块
u8 CMD18(u32 addr) 
{
    //STEP1:发送指令 
    SDICARG = addr; //设定指令参数 
    SDICCON = (1<<9)|(1<<8)|0x52; //发送CMD18指令
    
    if(SDI_Check_CMD_End(18,1))
     	return 1;
    else
     	return 0;
}

  • CMD25：写入多个数据块

    过程如下：

    1. 指定写入sd卡的地址，将地址命令的参数写入SDICARG寄存器
    2. 将命令的编号写入SDICCON寄存器，并启动向sd卡发送该命令
    3. 读取sd控制器中的状态寄存器，检查命令是否发送完成

    代码如下：

    //写入多个数据块
u8 CMD25(u32 addr) 
{
    //STEP1:发送指令 
    SDICARG = addr; //设定指令参数 
    SDICCON = (1<<9)|(1<<8)|0x59; //发送CMD25指令
    
    if(SDI_Check_CMD_End(25,1))
    	return 1;
    else
    	return 0;
}
3.2.5 优缺点总结

  • 优点：

    代码简单，容易理解，函数功能清晰明确，代码流程基本按照sd协议的规定走下去，便于初学者学习寄存器的操作与sd协议

  • 缺点：
    在这里插入图片描述

    复用性、扩展性差，当需要同时支持多个sd控制器的时候，改动会非常大

3.3 u-boot中的sd卡驱动

相比于裸机，u-boot中的sd卡驱动在对sd控制器中的各个寄存器的操作以及对sd协议的遵循两方面基本相同，主要区别在于拥有良好的扩展性。所以，相比于寄存器与协议两方面，这里会更着重分析其组织框架，探究其支持良好扩展性的原因。

3.3.1 框架概述

下图是我总结的sd驱动的整体框架图：

其中，

  • sd协议层

    sd协议相关的内容，由于sd协议硬件无关，相比于3.2 裸机中的sd卡驱动，u-boot中将该内容单独作为一层，并且已经作为公共部分实现好，任何的sd卡驱动均可以复用该层的内容，也就是说在sd卡驱动中不必涉及协议相关的内容，只需关注于对sd控制器中的寄存器操作，这样，便实现了硬件操作与sd协议相分离

  • sd核心层

    由于不同的sd控制器针对sd协议中发送命令、接收响应等操作需要不同的硬件操作，所以sd核心层的作用在于向下屏蔽不同sd控制器所带来的不同的硬件操作，向上提供统一的接口给sd协议层

  • sd驱动层

    sd卡驱动在上述框架中的位置为sd driver，不具有通用性，需要针对具体的sd控制器进行编写，这也是移植sd卡驱动时需要做的部分

关于框架图中其他的内容，主要涉及u-boot中的驱动模型，请参考这篇博客：https://blog.csdn.net/ooonebook/article/details/53234020，讲的非常好。

3.3.2 协议层

如3.2.1所述，u-boot将sd协议单独设为一层，与sd卡驱动进行了分离，那么本节我们就开始探寻u-boot中对于sd协议是如何实现的。

3.3.2.1 初始化

初始化主要有两个函数，分别用于不同的阶段，下面进行说明：

  1. mmc_initialize函数

    该函数在u-boot的board_r阶段初始化时被调用

    #ifdef CONFIG_MMC
static int initr_mmc(void)
{
	puts("MMC:   ");
	mmc_initialize(gd->bd);
	return 0;
}
#endif

    主要完成sd卡早期的初始化工作，

    1. 调用sd卡驱动中的probe函数，进行sd控制器层面的初始化

    2. 按照sd协议发送一些命令，以探测是否有卡插入以及是sd卡还是mmc卡等

    代码如下：

    int mmc_initialize(bd_t *bis)
{
	static int initialized = 0;
	int ret;
	if (initialized)	/* Avoid initializing mmc multiple times */
		return 0;
	initialized = 1;

#if !CONFIG_IS_ENABLED(BLK)
#if !CONFIG_IS_ENABLED(MMC_TINY)
	mmc_list_init();
#endif
#endif
	ret = mmc_probe(bis);
	if (ret)
		return ret;

#ifndef CONFIG_SPL_BUILD
	print_mmc_devices(',');
#endif

	mmc_do_preinit();
	return 0;
}

  2. mmc_init函数

    该函数在u-boot启动之后的多个地方被调用，比如mmc命令、块设备驱动、dfu驱动等等，相比于mmc_initialize函数的早期初始化功能，该函数按照sd协议进行完全的初始化，具体代码如下：

    int mmc_init(struct mmc *mmc)
{
	int err = 0;
	__maybe_unused ulong start;
#if CONFIG_IS_ENABLED(DM_MMC)
	struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc->dev);

	upriv->mmc = mmc;
#endif
	if (mmc->has_init)
		return 0;

	start = get_timer(0);

	if (!mmc->init_in_progress)
		err = mmc_start_init(mmc);

	if (!err)
		err = mmc_complete_init(mmc);
	if (err)
		pr_info("%s: %d, time %lu\n", __func__, err, get_timer(start));

	return err;
}

  3. mmc_start_init函数

    这里我们选择两个初始化函数都会调用的mmc_start_init函数进行说明，一路追踪下去发现，最终会调用如下核心内容：

       ......
       
   	/* Reset the Card */
   	err = mmc_go_idle(mmc);
   
   	if (err)
   		return err;
   
   	/* The internal partition reset to user partition(0) at every CMD0*/
   	mmc_get_blk_desc(mmc)->hwpart = 0;
   
   	/* Test for SD version 2 */
   	err = mmc_send_if_cond(mmc);
   
   	/* Now try to get the SD card's operating condition */
   	err = sd_send_op_cond(mmc, uhs_en);
   	if (err && uhs_en) {
   		uhs_en = false;
   		mmc_power_cycle(mmc);
   		goto retry;
   	}
   
   	/* If the command timed out, we check for an MMC card */
   	if (err == -ETIMEDOUT) {
   		err = mmc_send_op_cond(mmc);
   
   		if (err) {
   #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
   			pr_err("Card did not respond to voltage select!\n");
   #endif
   			return -EOPNOTSUPP;
   		}
   	}
   
   ......

    这里我们重点关注如下函数：

    • mmc_go_idle
    • mmc_send_if_cond
    • sd_send_op_cond
    • mmc_send_op_cond

    至于函数的具体实现，请参考3.2.2.4

3.3.2.2 读

代码如下：

#if CONFIG_IS_ENABLED(BLK)
ulong mmc_bread(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, void *dst)
#else
ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt,
		void *dst)
#endif
{
#if CONFIG_IS_ENABLED(BLK)
	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#endif
	int dev_num = block_dev->devnum;
	int err;
	lbaint_t cur, blocks_todo = blkcnt;
	uint b_max;

	if (blkcnt == 0)
		return 0;

	struct mmc *mmc = find_mmc_device(dev_num);
	if (!mmc)
		return 0;

	if (CONFIG_IS_ENABLED(MMC_TINY))
		err = mmc_switch_part(mmc, block_dev->hwpart);
	else
		err = blk_dselect_hwpart(block_dev, block_dev->hwpart);

	if (err < 0)
		return 0;

	if ((start + blkcnt) > block_dev->lba) {
#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
		pr_err("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
		       start + blkcnt, block_dev->lba);
#endif
		return 0;
	}

	if (mmc_set_blocklen(mmc, mmc->read_bl_len)) {
		pr_debug("%s: Failed to set blocklen\n", __func__);
		return 0;
	}

	b_max = mmc_get_b_max(mmc, dst, blkcnt);

	do {
		cur = (blocks_todo > b_max) ? b_max : blocks_todo;
		if (mmc_read_blocks(mmc, dst, start, cur) != cur) {
			pr_debug("%s: Failed to read blocks\n", __func__);
			return 0;
		}
		blocks_todo -= cur;
		start += cur;
		dst += cur * mmc->read_bl_len;
	} while (blocks_todo > 0);

	return blkcnt;
}

这里我们重点关注如下函数：

  • mmc_set_blocklen
  • mmc_read_blocks

至于函数的具体实现，请参考3.2.2.4

3.3.2.3 写

代码如下：

#if CONFIG_IS_ENABLED(BLK)
ulong mmc_bwrite(struct udevice *dev, lbaint_t start, lbaint_t blkcnt,
		 const void *src)
#else
ulong mmc_bwrite(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt,
		 const void *src)
#endif
{
#if CONFIG_IS_ENABLED(BLK)
	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#endif
	int dev_num = block_dev->devnum;
	lbaint_t cur, blocks_todo = blkcnt;
	int err;

	struct mmc *mmc = find_mmc_device(dev_num);
	if (!mmc)
		return 0;

	err = blk_select_hwpart_devnum(IF_TYPE_MMC, dev_num, block_dev->hwpart);
	if (err < 0)
		return 0;

	if (mmc_set_blocklen(mmc, mmc->write_bl_len))
		return 0;

	do {
		cur = (blocks_todo > mmc->cfg->b_max) ?
			mmc->cfg->b_max : blocks_todo;
		if (mmc_write_blocks(mmc, start, cur, src) != cur)
			return 0;
		blocks_todo -= cur;
		start += cur;
		src += cur * mmc->write_bl_len;
	} while (blocks_todo > 0);

	return blkcnt;
}

这里我们重点关注如下函数：

  • mmc_set_blocklen
  • mmc_write_blocks

至于函数的具体实现，请参考3.2.2.4

3.3.2.4 具体命令实现举例

这里用几个命令作为例子来讲解下其具体的实现，其他命令的实现原理均是类似的。

  1. mmc_go_idle函数

    static int mmc_go_idle(struct mmc *mmc)
{
	struct mmc_cmd cmd;
	int err;

	udelay(1000);

	cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
	cmd.cmdarg = 0;
	cmd.resp_type = MMC_RSP_NONE;

	err = mmc_send_cmd(mmc, &cmd, NULL);

	if (err)
		return err;

	udelay(2000);

	return 0;
}

    u-boot中将命令抽象成了一个结构体struct mmc_cmd，具体定义及变量解释如下：

    struct mmc_cmd {
	ushort cmdidx;		/* 命令编号 */
	uint resp_type;		/* 命令返回的相应类型 */
	uint cmdarg;		/* 命令参数 */
	uint response[4];	/* 命令返回的响应值 */
};

    我们看到mmc_go_idle中对应的命令编号为MMC_CMD_GO_IDLE_STATE，这个宏定义对应的值为0，然后命令参数为0，响应类型为无响应，最后调用了mmc_send_cmd函数。

    mmc_send_cmd函数的作用便是负责发送一个命令到sd卡，其具体的实现请参看后面的3.2.3一节。

  2. mmc_send_if_cond函数

    static int mmc_send_if_cond(struct mmc *mmc)
{
	struct mmc_cmd cmd;
	int err;

	cmd.cmdidx = SD_CMD_SEND_IF_COND;
	/* We set the bit if the host supports voltages between 2.7 and 3.6 V */
	cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
	cmd.resp_type = MMC_RSP_R7;

	err = mmc_send_cmd(mmc, &cmd, NULL);

	if (err)
		return err;

	if ((cmd.response[0] & 0xff) != 0xaa)
		return -EOPNOTSUPP;
	else
		mmc->version = SD_VERSION_2;

	return 0;
}

    我们看到，mmc_send_if_cond函数与mmc_go_idle函数的结构非常相似。

    通过查看宏定义SD_CMD_SEND_IF_COND可知，该函数对应的命令为CMD8，然后也是调用mmc_send_cmd函数将该命令发送出去，最后又读取了一下响应值。

  3. mmc_read_blocks函数

    static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start,
			   lbaint_t blkcnt)
{
	struct mmc_cmd cmd;
	struct mmc_data data;

	if (blkcnt > 1)
		cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
	else
		cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;

	if (mmc->high_capacity)
		cmd.cmdarg = start;
	else
		cmd.cmdarg = start * mmc->read_bl_len;

	cmd.resp_type = MMC_RSP_R1;

	data.dest = dst;
	data.blocks = blkcnt;
	data.blocksize = mmc->read_bl_len;
	data.flags = MMC_DATA_READ;

	if (mmc_send_cmd(mmc, &cmd, &data))
		return 0;

	if (blkcnt > 1) {
		cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
		cmd.cmdarg = 0;
		cmd.resp_type = MMC_RSP_R1b;
		if (mmc_send_cmd(mmc, &cmd, NULL)) {
#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
			pr_err("mmc fail to send stop cmd\n");
#endif
			return 0;
		}
	}

	return blkcnt;
}

    通过参数MMC_CMD_READ_SINGLE_BLOCK以及MMC_CMD_READ_MULTIPLE_BLOCK，可知该函数对应的命令为CMD17或者CMD18，功能为读取sd卡的一个或多个块数据，因为这两个命令是带有数据要返回的，针对sd协议中的数据，u-boot定义了结构体struct mmc_data，具体定义及变量解释如下：

    struct mmc_data {
	union {
		char *dest;			/* 针对读，数据目的地址 */
		const char *src; 	/* 针对写，数据源地址 */
	};
	uint flags;				/* 读或者写标志 */
	uint blocks;			/* 读或者写的块数量 */
	uint blocksize;			/* 读或者写的块大小 */
};

    然后对struct mmc_data结构体赋值后，连同struct mmc_cmd结构体一并作为参数调用mmc_send_cmd函数将命令发送出去。因为是读，当mmc_send_cmd函数执行完成返回后，读取到的数据便写到了struct mmc_data结构体中赋好值的目的地址上了。

    最后，如果是多块读，又调用了MMC_CMD_STOP_TRANSMISSION，也就是CMD12，功能为停止多块读或者写操作。

3.3.3 核心层

在上文的协议层中，我们发现每个命令函数最终都会调用到mmc_send_cmd函数将命令发送出去，那本节就来讲解该函数的实现以及其他一些初始化过程中会用到的函数，最后探究相比于裸机驱动为什么会多出这个核心层。

3.3.3.1 mmc_send_cmd函数

代码如下：

int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
{
	return dm_mmc_send_cmd(mmc->dev, cmd, data);
}

其中又调用了dm_mmc_send_cmd函数，代码如下：

int dm_mmc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
		    struct mmc_data *data)
{
	struct mmc *mmc = mmc_get_mmc_dev(dev);
	struct dm_mmc_ops *ops = mmc_get_ops(dev);
	int ret;

	mmmc_trace_before_send(mmc, cmd);
	if (ops->send_cmd)
		ret = ops->send_cmd(dev, cmd, data);
	else
		ret = -ENOSYS;
	mmmc_trace_after_send(mmc, cmd, ret);

	return ret;
}

我们发现，该函数最终又调用了struct dm_mmc_ops *ops的send_cmd函数指针，关于struct dm_mmc_ops定义如下：

struct dm_mmc_ops {
	/**
	 * deferred_probe() - Some configurations that need to be deferred
	 * to just before enumerating the device
	 *
	 * @dev:	Device to init
	 * @return 0 if Ok, -ve if error
	 */
	int (*deferred_probe)(struct udevice *dev);
	/**
	 * send_cmd() - Send a command to the MMC device
	 *
	 * @dev:	Device to receive the command
	 * @cmd:	Command to send
	 * @data:	Additional data to send/receive
	 * @return 0 if OK, -ve on error
	 */
	int (*send_cmd)(struct udevice *dev, struct mmc_cmd *cmd,
			struct mmc_data *data);

	/**
	 * set_ios() - Set the I/O speed/width for an MMC device
	 *
	 * @dev:	Device to update
	 * @return 0 if OK, -ve on error
	 */
	int (*set_ios)(struct udevice *dev);

	/**
	 * get_cd() - See whether a card is present
	 *
	 * @dev:	Device to check
	 * @return 0 if not present, 1 if present, -ve on error
	 */
	int (*get_cd)(struct udevice *dev);

	/**
	 * get_wp() - See whether a card has write-protect enabled
	 *
	 * @dev:	Device to check
	 * @return 0 if write-enabled, 1 if write-protected, -ve on error
	 */
	int (*get_wp)(struct udevice *dev);

#ifdef MMC_SUPPORTS_TUNING
	/**
	 * execute_tuning() - Start the tuning process
	 *
	 * @dev:	Device to start the tuning
	 * @opcode:	Command opcode to send
	 * @return 0 if OK, -ve on error
	 */
	int (*execute_tuning)(struct udevice *dev, uint opcode);
#endif

	/**
	 * wait_dat0() - wait until dat0 is in the target state
	 *		(CLK must be running during the wait)
	 *
	 * @dev:	Device to check
	 * @state:	target state
	 * @timeout_us:	timeout in us
	 * @return 0 if dat0 is in the target state, -ve on error
	 */
	int (*wait_dat0)(struct udevice *dev, int state, int timeout_us);

#if CONFIG_IS_ENABLED(MMC_HS400_ES_SUPPORT)
	/* set_enhanced_strobe() - set HS400 enhanced strobe */
	int (*set_enhanced_strobe)(struct udevice *dev);
#endif

	/**
	 * host_power_cycle - host specific tasks in power cycle sequence
	 *		      Called between mmc_power_off() and
	 *		      mmc_power_on()
	 *
	 * @dev:	Device to check
	 * @return 0 if not present, 1 if present, -ve on error
	 */
	int (*host_power_cycle)(struct udevice *dev);

	/**
	 * get_b_max - get maximum length of single transfer
	 *	       Called before reading blocks from the card,
	 *	       useful for system which have e.g. DMA limits
	 *	       on various memory ranges.
	 *
	 * @dev:	Device to check
	 * @dst:	Destination buffer in memory
	 * @blkcnt:	Total number of blocks in this transfer
	 * @return maximum number of blocks for this transfer
	 */
	int (*get_b_max)(struct udevice *dev, void *dst, lbaint_t blkcnt);
};

其实，这种调用函数指针的方式同样用在了其他一些用于初始化时的函数，比如下列函数：

3.3.3.2 mmc_set_ios函数

该函数的功能为设置sd控制器的时钟以及数据线宽度。

int mmc_set_ios(struct mmc *mmc)
{
	return dm_mmc_set_ios(mmc->dev);
}

int dm_mmc_set_ios(struct udevice *dev)
{
	struct dm_mmc_ops *ops = mmc_get_ops(dev);

	if (!ops->set_ios)
		return -ENOSYS;
	return ops->set_ios(dev);
}
3.3.3.3 mmc_getwp函数

该函数的功能为获取sd卡的写保护功能是否使能。

int mmc_getwp(struct mmc *mmc)
{
	return dm_mmc_get_wp(mmc->dev);
}

int dm_mmc_get_wp(struct udevice *dev)
{
	struct dm_mmc_ops *ops = mmc_get_ops(dev);

	if (!ops->get_wp)
		return -ENOSYS;
	return ops->get_wp(dev);
}
3.3.3.4 mmc_getcd函数

该函数的功能为探测sd卡是否插入。

int mmc_getcd(struct mmc *mmc)
{
	return dm_mmc_get_cd(mmc->dev);
}

int dm_mmc_get_cd(struct udevice *dev)
{
	struct dm_mmc_ops *ops = mmc_get_ops(dev);

	if (!ops->get_cd)
		return -ENOSYS;
	return ops->get_cd(dev);
}
3.3.3.5 增加核心层的原因

上述一系列函数都只是调用了struct dm_mmc_ops结构体中的函数指针，我们可以想一下，为什么要这样做呢？

我们要知道，u-boot需要支持不同的sd控制器，而每种sd控制器针对上述的一系列函数的实现均不同，这样，我们就需要在上文提到的协议层与对sd控制器的控制（也就是我们后面的驱动层的内容）之间增加一层核心层，作用便是解除协议层与驱动层之间的耦合。

当需要支持不同的sd控制器时，可以针对每个sd控制器分别实现一套上述的一系列函数，然后将每一套函数均赋值到自己的struct dm_mmc_ops结构体的各个函数指针中。当需要调用时，只需找到针对每个sd控制器的struct dm_mmc_ops结构体，然后调用其中的函数指针即可。

这里我们可以猜想到，驱动层的主要工作应该就是针对每个sd控制器，去实现具体的struct dm_mmc_ops结构体中的函数指针对应的函数，事实的确如此，接下来我们便开始进入驱动层的世界。

3.3.4 驱动层

注：该驱动主要内容来自u-boot 2016版本中的sd驱动，在此基础上我做了如下工作：

  1. 由于u-boot 2016版本中的sd驱动并未支持dm驱动模型，故增加了适配dm驱动模型的代码
  2. 利用pinctrl子系统配置sd控制器接入到sd卡的引脚为sd模式
  3. 利用clock子系统使能时钟，获得时钟的频率
  4. 利用gpio子系统获得sd卡探测引脚的电平，以探测sd卡是否插入

如3.3.3.5一节中分析的那样，驱动层的工作主要便是实现struct dm_mmc_ops结构体中的需要的函数指针对应的函数，此外还需要实现一个probe函数，用于初始化sd控制器，而这一切又包含于驱动模型之中，对于驱动模型不熟悉的朋友请参考3.3.1一节。

3.3.4.1 驱动入口

下面是sd卡驱动符合驱动模型的入口：

static const struct udevice_id s3c2440_mmc_ids[] = {
	{ .compatible = "samsung,s3c2440-mmc"},
	{ /* sentinel */ }
};

U_BOOT_DRIVER(s3c2440_mmc_drv) = {
	.name		= "s3c2440_mmc",
	.id			= UCLASS_MMC,
	.of_match	= s3c2440_mmc_ids,
	.bind		= s3c2440_mmc_bind,
	.probe		= s3c2440_mmc_probe,
	.ops		= &s3c2440_mmc_ops,
	.platdata_auto_alloc_size = sizeof(struct s3c2440_mmc_plat),
	.priv_auto_alloc_size = sizeof(struct s3c2440_mmc_priv),
};
3.3.4.2 probe函数

probe函数的作用主要是初始化该驱动，下面我们分功能来了解该函数。

  1. 从设备树中获取sd控制器中寄存器的基地址、sd控制器支持的数据线宽度、sd控制器的时钟：

    代码如下：

    priv->reg = (void *)dev_read_addr(dev);
bus_width = dev_read_u32_default(dev, "bus-width", 1);

ret = clk_get_by_name(dev, "sdmmc_clk", &priv->clk);
if (ret) {
    printf("%s(): get sdmmc clk failed!\n", __func__);
    return -ENODEV;
}

    设备树节点如下：

    sdmmc: mmc@5a000000 {
    compatible = "samsung,s3c2440-mmc";
    reg = <0x5a000000 0x1000>;

    clock-names = "sdmmc_clk";
    clocks = <&clk PCLK_SDI>;

    pinctrl-names = "default";
    pinctrl-0 = <&sdmmc_pin>,<&cd_pin>;

    cd-gpio = <&gpiog 8 GPIO_ACTIVE_LOW>;
    bus-width = <4>;
};

  2. 使能sd控制器的时钟，该时钟从PCLK而来，并且获得时钟具体的频率，以供后面使用：

    ret = clk_enable(&priv->clk);
if (ret) {
    printf("%s(): enable sdmmc clk failed!\n", __func__);
    return -EAGAIN;
}

sdmmc_clk = clk_get_rate(&priv->clk);
printf("%s(): sdmmc_clk = %d\n", __func__, sdmmc_clk);

  3. 提供sd控制器的能力给核心层驱动：

    cfg->name = dev->name;
cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
cfg->host_caps = MMC_MODE_4BIT | MMC_MODE_HS;
cfg->f_min = 400000;
cfg->f_max = sdmmc_clk / 2;
cfg->b_max = 0x80;
upriv->mmc = &plat->mmc;

  4. 初始化sd控制器：

    writel(S3C2440_SDICON_SDRESET, &priv->reg->sdicon);
mdelay(10);
writel(0x7fffff, &priv->reg->sdidtimer);

writel(MMC_MAX_BLOCK_LEN, &priv->reg->sdibsize);
writel(0x0, &priv->reg->sdiimsk);

writel(S3C2410_SDICON_FIFORESET | S3C2410_SDICON_CLOCKTYPE,
       &priv->reg->sdicon);

mdelay(125);

完整代码如下：

static int s3c2440_mmc_probe(struct udevice *dev)
{
	struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
	struct s3c2440_mmc_plat *plat = dev_get_platdata(dev);
	struct s3c2440_mmc_priv *priv = dev_get_priv(dev);
	struct mmc_config *cfg = &plat->cfg;
	int bus_width, ret;
	u32 sdmmc_clk;

	priv->reg = (void *)dev_read_addr(dev);
	bus_width = dev_read_u32_default(dev, "bus-width", 1);

	ret = clk_get_by_name(dev, "sdmmc_clk", &priv->clk);
	if (ret) {
		printf("%s(): get sdmmc clk failed!\n", __func__);
		return -ENODEV;
	}

	ret = clk_enable(&priv->clk);
	if (ret) {
		printf("%s(): enable sdmmc clk failed!\n", __func__);
		return -EAGAIN;
	}

	sdmmc_clk = clk_get_rate(&priv->clk);
	printf("%s(): sdmmc_clk = %d\n", __func__, sdmmc_clk);

	cfg->name = dev->name;
	cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
	cfg->host_caps = MMC_MODE_4BIT | MMC_MODE_HS;
	cfg->f_min = 400000;
	cfg->f_max = sdmmc_clk / 2;
	cfg->b_max = 0x80;
	upriv->mmc = &plat->mmc;

	writel(S3C2440_SDICON_SDRESET, &priv->reg->sdicon);
	mdelay(10);
	writel(0x7fffff, &priv->reg->sdidtimer);

	writel(MMC_MAX_BLOCK_LEN, &priv->reg->sdibsize);
	writel(0x0, &priv->reg->sdiimsk);

	writel(S3C2410_SDICON_FIFORESET | S3C2410_SDICON_CLOCKTYPE,
	       &priv->reg->sdicon);

	mdelay(125);

	return 0;
}
3.3.4.3 ops操作函数集

ops操作函数集中的每个函数均完成一个单独的功能，由核心层进行调用，定义如下：

static const struct dm_mmc_ops s3c2440_mmc_ops = {
	.send_cmd	= s3c2440_mmc_send_cmd,
	.set_ios	= s3c2440_mmc_set_ios,
	.get_cd		= s3c2440_mmc_getcd,
	.get_wp		= s3c2440_mmc_getwp,
};

下面我们逐个分析每个函数。

  1. s3c2440_mmc_send_cmd函数

    该函数是整个sd驱动的核心，其通过读写sd控制器中的寄存器，提供发送命令到sd卡的功能，如果命令伴有响应返回则会读取响应值，如果命令伴有数据传输则会进行收发数据。

    /*
 * WARNING: We only support one SD IP block.
 * NOTE: It's not likely there will ever exist an S3C24xx with two,
 *       at least not in this universe all right.
 */
static int s3c2440_mmc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
			      struct mmc_data *data)
{
	struct s3c2440_mmc_plat *plat = dev_get_platdata(dev);
	struct s3c2440_mmc_priv *priv = dev_get_priv(dev);
	struct mmc *mmc = &plat->mmc;

	unsigned int timeout = 100000;
	int ret = 0, xfer_len, data_offset = 0;
	uint32_t sdiccon, sdicsta, sdidcon, sdidsta, sdidat, sdifsta;
	uint32_t sdicsta_wait_bit = S3C2410_SDICMDSTAT_CMDSENT;
	const uint32_t sdidsta_err_mask = S3C2410_SDIDSTA_FIFOFAIL |
		S3C2410_SDIDSTA_CRCFAIL | S3C2410_SDIDSTA_RXCRCFAIL |
		S3C2410_SDIDSTA_DATATIMEOUT;

	writel(0xffffffff, &priv->reg->sdicsta);
	writel(0xffffffff, &priv->reg->sdidsta);
	writel(0xffffffff, &priv->reg->sdifsta);

	/* Set up data transfer (if applicable). */
	if (data) {
		writel(data->blocksize, &priv->reg->sdibsize);

		sdidcon = data->blocks & S3C2410_SDIDCON_BLKNUM;
		sdidcon |= S3C2410_SDIDCON_BLOCKMODE;
		sdidcon |= S3C2440_SDIDCON_DS_WORD | S3C2440_SDIDCON_DATSTART;

		if (mmc->bus_width == 4)
			sdidcon |= S3C2410_SDIDCON_WIDEBUS;

		if (data->flags & MMC_DATA_READ) {
			sdidcon |= S3C2410_SDIDCON_RXAFTERCMD;
			sdidcon |= S3C2410_SDIDCON_XFER_RXSTART;
		} else {
			sdidcon |= S3C2410_SDIDCON_TXAFTERRESP;
			sdidcon |= S3C2410_SDIDCON_XFER_TXSTART;
		}

		writel(sdidcon, &priv->reg->sdidcon);
	}

	/* Write CMD arg. */
	writel(cmd->cmdarg, &priv->reg->sdicarg);

	/* Write CMD index. */
	sdiccon = cmd->cmdidx & S3C2410_SDICMDCON_INDEX;
	sdiccon |= S3C2410_SDICMDCON_SENDERHOST;
	sdiccon |= S3C2410_SDICMDCON_CMDSTART;

	/* Command with short response. */
	if (cmd->resp_type & MMC_RSP_PRESENT) {
		sdiccon |= S3C2410_SDICMDCON_WAITRSP;
		sdicsta_wait_bit = S3C2410_SDICMDSTAT_RSPFIN;
	}

	/* Command with long response. */
	if (cmd->resp_type & MMC_RSP_136)
		sdiccon |= S3C2410_SDICMDCON_LONGRSP;

	/* Start the command. */
	writel(sdiccon, &priv->reg->sdiccon);

	/* Wait for the command to complete or for response. */
	for (timeout = 100000; timeout; timeout--) {
		sdicsta = readl(&priv->reg->sdicsta);
		if (sdicsta & sdicsta_wait_bit)
			break;

		if (sdicsta & S3C2410_SDICMDSTAT_CMDTIMEOUT)
			timeout = 1;
	}

	/* Clean the status bits. */
	writel(readl(&priv->reg->sdicsta) | (0xf << 9), &priv->reg->sdicsta);
    // setbits_le32(&priv->reg->sdicsta, 0xf << 9);

	if (!timeout) {
		printf("S3C SDI: Command timed out!\n");
		ret = -ETIMEDOUT;
		goto error;
	}

	/* Read out the response. */
	if (cmd->resp_type & MMC_RSP_136) {
		cmd->response[0] = readl(&priv->reg->sdirsp0);
		cmd->response[1] = readl(&priv->reg->sdirsp1);
		cmd->response[2] = readl(&priv->reg->sdirsp2);
		cmd->response[3] = readl(&priv->reg->sdirsp3);
	} else {
		cmd->response[0] = readl(&priv->reg->sdirsp0);
	}

	/* If there are no data, we're done. */
	if (!data)
		return 0;

	xfer_len = data->blocksize * data->blocks;

	while (xfer_len > 0) {
		sdidsta = readl(&priv->reg->sdidsta);
		sdifsta = readl(&priv->reg->sdifsta);

		if (sdidsta & sdidsta_err_mask) {
			printf("S3C SDI: Data error (sdta=0x%08x)\n", sdidsta);
			ret = -EIO;
			goto error;
		}

		if (data->flags & MMC_DATA_READ) {
			if ((sdifsta & S3C2410_SDIFSTA_COUNTMASK) < 4)
				continue;
			sdidat = readl(&priv->reg->sdidat);
			put_unaligned_le32(sdidat, data->dest + data_offset);
		} else {	/* Write */
			/* TX FIFO half full. */
			if (!(sdifsta & S3C2410_SDIFSTA_TFHALF))
				continue;

			/* TX FIFO is below 32b full, write. */
			sdidat = get_unaligned_le32(data->src + data_offset);
			writel(sdidat, &priv->reg->sdidat);
		}
		data_offset += 4;
		xfer_len -= 4;
	}

	/* Wait for the command to complete or for response. */
	for (timeout = 100000; timeout; timeout--) {
		sdidsta = readl(&priv->reg->sdidsta);
		if (sdidsta & S3C2410_SDIDSTA_XFERFINISH)
			break;

		if (sdidsta & S3C2410_SDIDSTA_DATATIMEOUT)
			timeout = 1;
	}

	/* Clear status bits. */
	writel(0x6f8, &priv->reg->sdidsta);

	if (!timeout) {
		printf("S3C SDI: Command timed out!\n");
		ret = -ETIMEDOUT;
		goto error;
	}

	writel(0, &priv->reg->sdidcon);

	return 0;
error:
	return ret;
}

  2. s3c2440_mmc_set_ios函数

    该函数获得核心层传来的需要设置的时钟值，然后进行设置。

    static int s3c2440_mmc_set_ios(struct udevice *dev)
{
	struct s3c2440_mmc_plat *plat = dev_get_platdata(dev);
	struct s3c2440_mmc_priv *priv = dev_get_priv(dev);
	struct mmc *mmc = &plat->mmc;
    uint32_t divider = 0;
	u32 sdmmc_clk;

	printf("set ios: bus_width: %x, clock: %d\n",
	      mmc->bus_width, mmc->clock);

	if (!mmc->clock)
		return -1;

	sdmmc_clk = clk_get_rate(&priv->clk);
	printf("%s(): sdmmc_clk = %d\n", __func__, sdmmc_clk);

	divider = DIV_ROUND_UP(sdmmc_clk, mmc->clock);
	if (divider)
		divider--;

	writel(divider, &priv->reg->sdipre);
	mdelay(125);

    return 0;
}

  3. s3c2440_mmc_getcd函数

    该函数通过读取sd卡的探测引脚的电平值，进而供核心层判断sd卡是否插入。

    static int s3c2440_mmc_getcd(struct udevice *dev)
{
	struct s3c2440_mmc_priv *priv = dev_get_priv(dev);
	int value, ret;

	ret = gpio_request_by_name(dev, "cd-gpio", 0, &priv->cd_gpio, GPIOD_IS_IN);
	if (ret) {
		printf("%s(): gpio_request_by_name failed!\n", __func__);
		return ret;
	}
	
	if (!dm_gpio_is_valid(&priv->cd_gpio)) {
		printf("%s(): dm_gpio_is_valid failed!\n", __func__);
		return ret;
	}

	value = dm_gpio_get_value(&priv->cd_gpio);
	printf("%s(): value = %d\n", __func__, value);

	dm_gpio_free(dev, &priv->cd_gpio);
	
	return value;
}

  4. s3c2440_mmc_getwp函数

    该函数的作用是获取sd卡写保护引脚的电平值，由于micro sd卡没有写保护功能，故该函数设置为固定返回0，以告知核心层sd卡没有写保护，可以直接写入。

    static int s3c2440_mmc_getwp(struct udevice *dev)
{
	/* There is allways no write-protected */
	return 0;
}

4. 关于文件系统

文件系统，纯软件的概念，是一种数据在存储介质上的组织格式，目的是把对扇区的读写转换为对目录下的文件的读写。

sd卡之上的文件系统，最终也会调用sd卡的读写函数来完成对某个文件的读写。

由于这里不是本篇文章的重点，所以就不详细说明了。

Asymptoteee
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
移植2022版U-Boot——SD卡驱动，解决sdhci_send_command: Timeout for status update的问题
weixin_42408707的博客
01-30 932
执行u-boot命令`fstype mmc 0:1`，显示sdhci_send_command: Timeout for status update的问题。已解决。
mini2440裸机实现简易u-boot代码.rar
03-28
3. 文件系统加载：U-Boot可以支持多种文件系统，如FAT、ext2等，通过NAND Flash或SD卡加载操作系统镜像。 4. 网络功能：U-Boot支持通过以太网启动（网络TFTP下载），方便远程更新系统映像。 5. 用户命令：U-Boot...
uboot移植之uboot中的SD卡驱动解析
weixin_33890526的博客
05-19 478
1：地址对硬件操作的影响(1)操作系统（指的是linux）下MMU肯定是开启的，也就是说linux驱动中肯定都使用的是虚拟地址。而纯裸机程序中根本不会开MMU，全部使用的是物理地址。这是裸机下和驱动中操控硬件的一个重要区别。(2)uboot早期也是纯物理地址工作的，但是现在的uboot开启了MMU做了虚拟地址映射，这个东西驱动也必须考虑。查uboot中的虚拟地...
详解sd协议以及裸机和u-boot中的sd卡驱动(1)
渐进的专栏
07-17 838
1. 引入 1.1 使用场景 对于sd卡的使用，相信大家都已经很是熟悉： 无文件系统 首先调用初始化函数，然后便可以调用读写函数进行读写扇区的操作，但是更多的使用场景是在文件系统之上。 有文件系统 pc端，以windows为例： 将sd卡（或通过usb读卡器）插在电脑的插槽里面，然后出现一个sd卡的盘符，点进去便可以访问里面的文件； 开发板： 将sd卡插在开发板的插槽里面，进入linux根文件系统的shell，执行mount命令挂载在某个目录下，然后进入该目录，便可以访问里面的文件；
uboot如何驱动SD卡
jasonwang的专栏
11-08 558
https://www.eefocus.com/marianna/blog/14-08/305552_21cba.html
uboot中SD 卡驱动移植
huhuolianmeng的博客
05-03 674
uboot中SD 卡驱动移植：2013版本的1.\u-boot-2013.10\drivers\mmc\ mmc.c和C:\u-boot-2013.10\board\samsung\goni\goni.c C:\u-boot-2013.10\arch\arm\include\asm\arch-s5pc1xx\mmc.h C:\u-boot-2013.10\drivers\mmc\s5p_sdhc
S3C6410 SD卡启动裸机代码,可以从串口下载程序
12-10
《S3C6410 SD卡启动裸机代码详解》 S3C6410是一款基于ARM11架构的高性能微处理器，常用于嵌入式系统开发。本篇文章将详细探讨S3C6410如何通过SD卡启动，并实现从串口下载程序的功能。这种启动方式在无UBOOT支持的...
210 开发板 裸机程序 启动详解
01-23
Bootloader会从指定位置（如Nor Flash、SD卡或NAND Flash）读取Linux内核映像，并将其加载到RAM中。在这个过程中，Bootloader可能还需要处理设备树（Device Tree）以配置特定的硬件资源。 4. 内核解压与初始化 ...
OK6410裸机代码
05-10
其内置了多媒体加速器、LCD控制器、USB主机和设备接口、以太网MAC、SD卡接口等丰富的外设，为开发者提供了强大的硬件基础。 编写OK6410裸机代码，首先需要熟悉S3C6410的数据手册和参考手册，了解处理器的寄存器配置...
ARM裸机知识.doc
03-08
ARM裸机知识是嵌入式开发中的重要一环，它主要涉及ARM处理器的基本概念、架构、启动流程以及相关的开发工具和技巧。以下是对ARM裸机知识的详细解析： ### 第一章 ARM预备知识 #### 1.1 ARM背景知识 **1.1.1 ARM...
Uboot中外存MMC(sd/iNand等)驱动架构代码简单分析
视野是生命的宽度，沉淀是生命的密度
07-05 970
2020-7-5 北京 屋内开空调不知道外面啥情况 一天没出屋 外面貌似闷热吧 ！ 本文仅作为技术积累，方便日后查阅！ 作家格拉德威尔在《异类》一书中指出：“人们眼中的天才之所以卓越非凡，并非天资超人一等，而是付出了持续不断的努力。1万小时的锤炼是任何人从平凡变成超凡的必要条件”。他将此称为“一万小时定律”。要成为某个领域的专家，需要10000小时，按比例计算就是：如果每天工作八个小时，一周工作五天，那么成为一个领域的专家至少需要五年。 2.10.1.uboot与linux驱动 1、uboot本.
uboot之硬件驱动部分
qq_35480173的博客
10-19 503
一、uboot和Linux驱动 1、uboot本身是裸机程序 裸机程序中是直接控制硬件的，但是操作系统中必须通过驱动来控制硬件。这2个的本质区别就是分层结构，因为在操作系统中需要按照操作系统的框架来部署驱动，也就是操作硬件的代码，按照操作系统规则来写代码。但是在裸机中没有这样的概念，分层的结构可以按照自己的思路，自己想怎么做就怎么做，所以uboot中的驱动和Linux中驱动是不同的。但是源代码...
uboot环境变量和硬件驱动
小伟的博客
10-27 1024
ENV_SIZE环境变量最大内存，10k 二、printenv命令
3. 驱动初步-------Uboot
qq_46513803的博客
10-11 968
uboot
嵌入式系统移植--uboot使用和sd卡制作
xinqi_1的博客
06-20 1896
Bootloader（引导加载程序）是计算机系统中非常重要的一个组成部分，它的主要功能是在计算机系统启动时加载操作系统内核并进行初始化，以确保操作系统能够正确运行。具体来说，Bootloader的主要功能包括：加载内核：在计算机启动时，Bootloader会从指定的位置读取操作系统内核，并将其加载到内存中。设置硬件环境：在加载内核之前，Bootloader会初始化硬件设备，例如CPU、内存、IO设备等，以确保内核能够正确运行。
Linux系统移植实验---SD卡驱动移植
sessos的博客
11-07 1127
实验七 SD卡驱动移植 【实验目的】 SD卡是嵌入式系统最常用的外部扩展存储设备，这里介绍SD驱动移植的过程。 说明：在系统移植课程实验中命令行提示符 “$”表示是在主机上执行，“#”表示在目标板执行 【实验环境】 • 主机：ubuntu 12.04发行版 • 目标机：FS4412平台 • 交叉编译工具：arm-none-linux-gnueabi-gcc 【实验步骤】 1. 修
RK3588 uboot下的emmc驱动---学习笔记
最新发布
qq_52495812的博客
09-15 2016
MMC 为 MultiMedia Card，多媒体存储卡，但后续泛指一个接口协定（一种卡式），能符合这接口的内存器都可称作 mmc 储存体。可以分为三类：1.1 mmc type card ：1.标准 mmc 卡：闪存卡的一种，使用 mmc 标准；MultiMediaCard，是 MMC 协会所制定的内嵌式存储器标准规格，带有 mmc 接口，是具备 mmc 协议的芯片。1.2 sd type card：SD 卡为 Secure Digital Memory Card, 即安全数码卡。
emmc初始化(mmc_initialize)过程
mudh118的博客
05-31 2511
4.主机发送CMD2命令，eMMC会返回CID (Card Identification)。1.电源上电后，eMMC会进入BOOT模式，此时eMMC的引脚会被配置为SDIO模式。7.主机发送ACMD6命令，eMMC会配置自身的工作模式，如时钟频率、总线宽度等。8.主机发送CMD13命令，eMMC会返回状态寄存器中的状态，如是否有错误等。3.主机发送CMD1命令，eMMC会返回自身的一些信息，如电压、容量等。2.此时，eMMC会等待主机发出CMD0命令，进入IDLE状态。
uboot 2021.10源码分析(启动流程)
anqi8955的专栏
12-06 5678
uboot版本：2021.10 平台：armv8 rk3399 eMMC 16G LPDDR4 4G 本文主要基于uboot的执行流程进行分析而忽略了相关细节，从uboot的基本框架结构着手，新的uboot框架是有三部分组成的：TPL SPL uboot，而且编译后产生的镜像也是有三部分构成，所以也可以认为是三个独立的程序，只不过合在了一个代码框架里面了。 1. 编译过程 编译过程主要是通过CONFIG_TPL_BUILDCONFIG_SPL_BUILD这两个宏来指定，三个阶段开关打开情况：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值