SD卡(Secure Digital Memory Card)具有体积小、容量大、数据传输快、可插拔、安全性好等优点，被广泛应用于便携式设备上。例如作为数码相机的存储卡，作为手机、平板多媒体扩展卡用的TF卡(micro sd)。 笔者此处就s3c2416 sd卡驱动的实现作一个简单的介绍。

1、sd卡概述

sd卡技术是在MMC卡的基础上发展起来的，其尺寸与MMC卡一样，只是比MMC卡厚了0.7mm，因此sd设备可以识别并存取MMC卡。sd卡接口除了保留MMC卡的7针外，还在两边加了2针，作为数据线，目的是通过把传输方式由串行变成并行，以提高传输速率。 此时的规范为sd1.0版本，最高容量只能到4GB。为了跟进产品的更新换代，sd联合协会在06年发布了容量更大、存储更快的下一代sd卡规范sd2.0。该规范重新定义了sd卡的速度等级，分为三档：Class 2、4、6，分别对应写入速度2MB/s、4MB/s、6MB/s。根据卡容量又分为标准卡(小于2GB)和高容量卡(2GB ~ 32GB)，目前市面上应用的sd卡绝大部分都是sd2.0版本的卡。为了让储存卡更加迷你，通过sd卡规范标准，又衍生了MiniSD卡和Micro SD卡，这些卡均比标准sd卡尺寸小，通过sd转接卡可以当作一般的sd卡使用。尤其是Micro SD卡，可以算是最小的存储卡了，超小的体积可以极大的节省消费电子产品内部设计的空间，基本目前的android手机均是选用Micro SD卡作为多媒体扩展储存卡。随着科技的进步，sd2.0规范sd卡也渐渐无法满足应用的需求，在10年sd联合协会又发布了新的sd3.0规范，该规范定义了sdxc和uhs，并增加了Class10，容量范围为32GB ~ 2TB。在sdxc卡仍需进一步坐等其价格下降的情况下，sd4.0规范已经开始在紧张的制订中，这已超出本文的讨论范围内了。

2、sd卡驱动编写

sd卡共支持三种传输模式：spi模式、1位sd模式、4位sd模式。所有的sd卡都必须支持较老的spi/mmc模式，这个模式支持慢速的四线spi接口，使很多微控制器都可以通过spi或模拟spi接口来读写sd卡。由于s3c2416具有sd总线控制器，并且兼容sd2.0的sd卡，因此此处只分析4位sd模式、sd2.0及sd1.0版本的sd卡驱动实现，sd2.0以上版本sd卡、MMC卡、spi方式读写sd卡在本文不适用。 sd卡驱动的编写必须参考sd2.0规范，此处只根据sd2.0规范讲解几个重要的过程或概念，这些过程具体的实现请参考sd驱动模块中相应的函数实现。

2.1、sd卡初始化及识别过程

sd卡上电后，将进入idle状态，此时的sd卡为1位sd模式。通过拉低CS线将可使sd进入spi模式(不再讨论范围内)，在sd模式下卡的初始化及识别过程见图2.1.1，其步骤如下： 1) 发送CMD0软件复位所有的卡到idle状态。 2) 发送CMD8来检查卡是否支持主机电压(2.7v ~ 3.3v)，这个命令在sd2.0以上才被定义，若没有收到回复信号，则可能为sd1.0或MMC卡，若接收到卡回复信号，说明为sd2.0版本卡，跳转到步骤5 3) CMD8没有收到回复信号，可进一步发送ACMD41(CMD55+CMD41)，参数HCS位为0(非高容量卡)，如果没有回复信号，说明是MMC卡或其它不能识别的卡，可进一步发送CMD1确定是否MMC卡(此处不再分析) 4) ACMD41能收到回复，并且从回复中确定sd卡己准备好，即可确定这是sd1.x版本的卡，若回复中表明sd卡未准备好，则需重复发送ACMD41等待卡准备好，可通过超时(卡一直busy)判断卡不支持主机电压，此时表明卡不可用。判断出sd1.x的卡后，跳转到步骤9 5) CMD8有回复说明为sd2.0以上的卡，从回复中确定卡是否能在该电压下工作，不能则认为卡不可用。 6) 回复中确定卡能在2.7v~3.3v电压工作后，进一步发送ACMD41(CMD55+CMD41)，参数HCS位为1表明主机支持高容量的卡 7) 检查ACMD41卡回复中忙标志，若卡处于忙状态，则重复发送ACDM41，直到卡准备好，可通过超时(卡一直忙状态)可认为该卡不可用。 8) ACMD41回复准备好后，再检查回复中的CCS位，该位为1说明是sd2.0高容量sdhc卡，若为0，则说明为sd2.0标准容量卡。 9) 在识别出sd1.x、sd2.0标准卡或sd2.0高容量卡后，此时卡进入ready态。进一步通过CMD2请求卡发送其CID(Card Identification)，此时卡进入Identification态。 10) 卡在Identification态后，发送CMD3请求卡发布一个16位新的相对地址(RCA)，以后主机与卡之间的点对点通信均会以这个RCA地址来进行，此时卡进入Stand-by态。 11) 至此，卡的初始化及识别过程结束，此时卡进入数据传输模式(data transfer mode)

16_SD卡驱动实现 - 图1

图2.1.1. sd卡初始化及识别流程

2.2、 数据传输模式

sd卡主控制器是一个非常典型的状态机，每个状态只会响应该个状态下的特定命令，不要尝试在某个状态下发送这个状态不支持的命令，sd卡不会对该命令进行响应，命令只会超时。应该通过特定的触发条件转变状态或等待状态迁移完成后，再发送对应状态的命令。如图2.2.1，要想写一个块的数据到sd卡，在stand-by态的情况下，必须通过CMD7选择卡，让卡进入transfer态，然后再发送CMD24单块写命令，再发送一块的数据，此时卡进入Programming态，这时如果又紧接发送CMD24进行单块写将不会成功，必须等待sd卡编程完，从Programming态返回到transfer态才能再次接收下一个块写命令。同样，在transfer态想通过CMD9来获得Card-Specific Data(CSD)，必须通过CMD7取消选择卡，此时卡进入stand-by态后，即可通过CMD9来获得卡信息。

16_SD卡驱动实现 - 图2

图2.2.1. sd卡数据传输模式

2.3、主机控制器具体对卡的初始化

任何cpu的sd卡主机控制器都可以根据sd2.0规范给出的卡初始化及识别流程进行卡的初始化，对于具体的cpu，需要进行一些与控制器相关的设置，主要有以下几点，具体的实现可参考Hsmmc_Init()这个初始化函数。 1) 设置功能引脚，把相应引脚配置成sd接口用引脚 2) 设置sd卡时钟在100k ~ 400k，sd卡在识别阶段必须用慢速时钟进行访问 3) 按照规范给出的卡初始化流程对卡进行发送相应的命令并处理回复，成功后卡进入stand-by态 4) 通过发送CMD7选择卡，使卡进入transfer态，因为卡的大部分操作如读、写、擦除等均是在这个状态下来进行的，此时卡已完全准备好接收读写命令了。 5) 设置sd卡的时钟到一个较高值，sd卡默认支持最高25M时钟，可以设置成高速模式，最高支持50M，频率越高，数据传输速率越快 6) 通过ACMD6(CMD55+CMD6)来设置sd模式的位宽为4，sd卡初始化后默认是1线宽，更多的数据线将有更大的带宽，数据传输速率最高12.5MB/s(25M、4线)或25MB/s(50M、4线)。 7) 发送CMD16设置块长度，对于标准卡，可通过CMD16来设置块命令(如块读、块写)所操作块的长度(以字节数计)，可实现字节的读写，但对于高容量卡这个命令将被忽略，高容量卡一个块的长度均是固定512字节的。通常通过CMD16设置块长度为512字节。至此卡初始化完成。

2.4、主机命令的发送

sd规范对命令包格式、回复包、数据的传输方式等均作了详细的要求。虽然sd卡主机控制器可以帮我们对命令进行打包，对回复进行解包，产生CRC，并在sd总线上输出相应的时序。我们仍需要告诉sd卡主机控制器需发送的命令、这个命令的参数、这个命令发送后是否需要使用data线， sd卡的回复类型。具体到s3c2416的sd卡主机控制器，这些设置通过CMDREG寄存器来实现。主要有以下几点，具体的实现可参考Hsmmc_IssueCommand()这个命令发送函数。 1) 命令发送时，需检查命令线是否已被使用，若是，则等待正在发送的命令发送完才能发送这个命令 2) 如果命令回复会带忙信号(如R1b回复)，则需检查数据线是否已被使用，若是，则等待数据线空闲，带忙回复命令发送后，sd卡会拉低DAT[0]线表明sd卡正忙，数据线不可用。 3) 把命令参数写入ARGUMENT这个寄存器中 4) 在CMDREG中设置命令值[13:8] 5) 设置是否需使用data线，如块读、块写等命令发送后，会紧接着在data线上传输数据，其它不需传输数据的命令不要设置使用data线CMDREG[5] 6) 设置sd卡的回复类型，绝大部分命令在sd卡正确响应后，都会对主机进行回复(R1-R7，R1b)，每个命令对应的回复类型请参考sd卡规范。回复类型长度可能为136或48，回复中是否包含CRC或命令值的反馈，如果包含，则告诉主控制器检查回复中相应的CRC或命令值反馈是否正确，以确定传输正确。CMDREG设置好后，主控制器就会发送命令并接收设定长度的回复并根据设定检查CRC、命令值反馈是否正确(若回复中包含CRC或命令值反馈的话) 7) 等待命令完成，检查中断状态位NORINTSTS[15]以确定命令是否有错误，若没有错误并且检测到NORINTSTS[0]命令完成位为1，则说明命令发送成功。其它情况说明命令未能成功发送。

2.5、主机对sd卡的读写

通常对于一个sd卡驱动模块，至少实现卡初始化、块读、块写这三个接口函数。块读、块写必须在卡初始化完成后，在transfer态下才有效。通常有以下几点需要注意，具体可参考Hsmmc_ReadBlock()和Hsmmc_WriteBlock()这两个函数的实现。 1) 通过发送CMD13获得目前卡的状态，块读、块写时必须在transfer态，不然需等待状态转换的完成 2) 设置特定主机控制器的传输方式，例如s3c2416可支持DMA传输数据，通过FIFO传输数据，笔者采用DMA传输数据，则需设置DMA传输内存的首地址，传输的块数等寄存器，在开了cache的情况下，DMA传输时必须注意cache与主存数据一致性的问题。 3) 注意块写的地址，对于标准卡(小于2GB)，其块地址应为字节地址(最大寻址4GB)，但对于高容量SDHC卡，其块地址为512字节为单位。 4) 判断读写的块数，对于读写1块，则需发送命令CMD17(单块读)或CMD24(单块写)，若多块读写则应发送命令CMD18(多块读)或CMD25(多块写)。通常上层的应用不应把数据块拆分成多个单块进行读写，这样总的读写性能会很差，应该一次性进行多个数据块的读写。 5) 等待读写数据传输完成，检查中断状态位NORINTSTS[15]以确定传输是否有错误，若没有错误并且检测到NORINTSTS[1]传输完成位为1，则说明数据传输成功。其它情况说明数据传输出错。

2.6、驱动模块的其它接口

一个完善的sd卡驱动模块还应提供一些与文件系统相关的接口实现，如从卡CSD中获取容量等信息函数Hsmmc_Get_CSD()，块擦除函数Hsmmc_EraseBlock()等。具体的实现可以参考下面完整的驱动源码，为调试sd卡驱动，需用串口进行打印跟踪sd卡的状态及相关的寄存器值，串口打印调试的驱动在前面章节有详细的介绍。 Sd卡驱动模块实现Hsmmc.c如下：

  1. #include "s3c2416.h"
  2. #include "Hsmmc.h"
  3. #include "UART0.h"
  4. #define DEBUG_HSMMC
  5. #ifdef  DEBUG_HSMMC
  6.     #define Debug(x...) Uart0_Printf(x)
  7. #else
  8.     #define Debug(x...)
  9. #endif
  10. static unsigned char CardType; // 卡类型
  11. static unsigned int RCA; // 卡相对地址
  12. static unsigned char Hsmmc_Buffer[16*1024]
  14. __attribute__((__aligned__(4),section(".no_cache")));
  16. static void Delay_us(unsigned int nCount)
  17. {
  18.     //延时1us,共延时nCount us
  19.     __asm__ __volatile__ (
  20.         "000:\n"   
  21.         "ldr  r1, =100\n"  // Arm clock为400M     
  22.         "111:\n"
  23.         "subs r1, r1,#1\n"  // 一个Arm clock
  24.         "bne  111b\n"      // 跳转会清流水线，3个Arm clock
  25.         "subs %0, %1,#1\n" // 调用者确保nCount不为0
  26.         "bne  000b\n"
  27.        :"=r"(nCount) // nCount寄存器的值会自减改变
  28.         :"0"(nCount) // 使用与输出对象相同的寄存器
  29.         : "r1"// 临时使用了r1寄存器
  30.     );
  31. }
  33. static void Hsmmc_ClockOn(unsigned char On)
  34. {
  35.     if (On) {
  36.         rHM1_CLKCON |=(1<<2); // sd时钟使能
  37.         while(!(rHM1_CLKCON & (1<<3))) {
  38.             // 等待SD输出时钟稳定
  39.         }
  40.     } 
  41.     else {
  42.         rHM1_CLKCON &=~(1<<2); // sd时钟禁止
  43.     }
  44. }
  46. static void Hsmmc_SetClock(unsigned int Div)
  47. {
  48.     Hsmmc_ClockOn(0); // 关闭时钟  
  49.     // 选择SCLK_HSMMC:EPLLout
  50.     rCLKSRC &=~(1<<17); // HSMMC1 EPLL(96M)
  51.     rHM1_CONTROL2 =0xc0000120; // SCLK_HSMMC
  52.     rHM1_CONTROL3 =(0<<31) | (0<<23) | (0<<15) | (0<<7);
  54.     // SDCLK频率值并使能内部时钟
  55.     rHM1_CLKCON &=~(0xff<<8);
  56.     rHM1_CLKCON |=(Div<<8) | (1<<0);
  57.     while (!(rHM1_CLKCON& (1<<1))) {
  58.         // 等待内部时钟振荡稳定
  59.     }
  60.     Hsmmc_ClockOn(1); // 全能时钟
  61. }
  63. static int Hsmmc_WaitForCommandDone()
  64. {
  65.     unsigned int i;
  66.     int ErrorState;
  67.     // 等待命令发送完成
  68.     for (i=0;i<20000000; i++) {
  69.         if (rHM1_NORINTSTS& (1<<15)) { // 出现错误
  70.             break;
  71.         }
  72.         if (rHM1_NORINTSTS& (1<<0)) {
  73.             do {
  74.                 rHM1_NORINTSTS= (1<<0); // 清除命令完成位
  75.             } while(rHM1_NORINTSTS & (1<<0));         
  76.             return 0; // 命令发送成功
  77.         }
  78.     }
  79.     ErrorState =rHM1_ERRINTSTS & 0x1ff; // 可能通信错误,CRC检验错误,超时等
  80.     rHM1_NORINTSTS =rHM1_NORINTSTS; // 清除中断标志
  81.     rHM1_ERRINTSTS =rHM1_ERRINTSTS; // 清除错误中断标志   
  82.     do {
  83.         rHM1_NORINTSTS =(1<<0); // 清除命令完成位
  84.     } while(rHM1_NORINTSTS & (1<<0));
  85.     Debug("Commanderror, rHM1_ERRINTSTS = 0x%x ", ErrorState);
  86.     return ErrorState; // 命令发送出错 
  87. }
  89. static int Hsmmc_WaitForTransferDone()
  90. {
  91.     int ErrorState;
  92.     unsigned int i;
  93.     // 等待数据传输完成
  94.     for (i=0;i<20000000; i++) {
  95.         if (rHM1_NORINTSTS& (1<<15)) { // 出现错误
  96.                 break;
  97.         }
  98.         if (rHM1_NORINTSTS& (1<<1)) { // 数据传输完
  99.             do {
  100.                 rHM1_NORINTSTS|= (1<<1); // 清除传输完成位
  101.             } while(rHM1_NORINTSTS & (1<<1)); 
  102.             rHM1_NORINTSTS= (1<<3); // 清除DMA中断标志
  103.             return 0;
  104.         }
  105.         Delay_us(1);
  106.     }
  107.     ErrorState =rHM1_ERRINTSTS & 0x1ff; // 可能通信错误,CRC检验错误,超时等
  108.     rHM1_NORINTSTS =rHM1_NORINTSTS; // 清除中断标志
  109.     rHM1_ERRINTSTS =rHM1_ERRINTSTS; // 清除错误中断标志
  110.     Debug("Transfererror, rHM1_ERRINTSTS = 0x%04x\n\r", ErrorState);  
  111.     do {
  112.         rHM1_NORINTSTS =(1<<1); // 出错后清除数据完成位
  113.     } while(rHM1_NORINTSTS & (1<<1));
  114.     return ErrorState; // 数据传输出错     
  115. }
  117. static int Hsmmc_IssueCommand(unsigned char Cmd, unsigned intArg, unsigned char Data, unsigned char Response)
  118. {
  119.     unsigned int i;
  120.     unsigned int Value;
  121.     unsigned intErrorState;
  122.     // 检查CMD线是否准备好发送命令
  123.     for (i=0;i<1000000; i++) {
  124.         if (!(rHM1_PRNSTS& (1<<0))) {
  125.             break;
  126.         }
  127.     }
  128.     if (i == 1000000) {
  129.         Debug("CMDline time out, rHM1_PRNSTS: %04x\n\r", rHM1_PRNSTS);
  130.         return -1; // 命令超时
  131.     }
  133.     // 检查DAT线是否准备好
  134.     if (Response ==Response_R1b) { // R1b回复通过DAT0反馈忙信号
  135.         for (i=0;i<1000000; i++) {
  136.             if(!(rHM1_PRNSTS & (1<<1))) {
  137.                 break;
  138.             }      
  139.         }
  140.         if (i == 1000000){
  141.             Debug("Dataline time out, rHM1_PRNSTS: %04x\n\r", rHM1_PRNSTS);
  142.             return -2;
  143.         }      
  144.     }
  145.     rHM1_ARGUMENT = Arg;// 写入命令参数
  146.     Value = (Cmd <<8); // command index
  147.     // CMD12可终止传输
  148.     if (Cmd == 0x12) {
  149.         Value |= (0x3<< 6); // command type
  150.     }
  151.     if (Data) {
  152.         Value |= (1<< 5); // 需使用DAT线作为传输等
  153.     }  
  154.     switch (Response) {
  155.     case Response_NONE:
  156.         Value |=(0<<4) | (0<<3) | 0x0; // 没有回复,不检查命令及CRC
  157.         break;
  158.     case Response_R1:
  159.     case Response_R5:
  160.     case Response_R6:
  161.     case Response_R7:      
  162.         Value |=(1<<4) | (1<<3) | 0x2; // 检查回复中的命令,CRC
  163.         break;
  164.     case Response_R2:
  165.         Value |=(0<<4) | (1<<3) | 0x1; // 回复长度为136位,包含CRC
  166.         break;
  167.     case Response_R3:
  168.     case Response_R4:
  169.         Value |=(0<<4) | (0<<3) | 0x2; // 回复长度48位,不包含命令及CRC
  170.         break;
  171.     case Response_R1b:
  172.         Value |=(1<<4) | (1<<3) | 0x3; // 回复带忙信号,会占用Data[0]线
  173.         break;
  174.     default:
  175.         break; 
  176.     }
  177.     rHM1_CMDREG = Value;
  178.     ErrorState =Hsmmc_WaitForCommandDone();
  179.     if (ErrorState) {
  180.         Debug("Command= %d\r\n", Cmd);
  181.     }  
  182.     return ErrorState; // 命令发送出错
  183. }
  185. // 512位的sd卡扩展状态位
  186. int Hsmmc_GetSdState(unsigned char *pState)
  187. {
  188.     int ErrorState;
  189.     unsigned int i;
  190.     if (CardType == SD_HC|| CardType == SD_V2 || CardType == SD_V1) {
  191.         if(Hsmmc_GetCardState() != 4) { // 必需在transfer status
  192.             return -1; // 卡状态错误
  193.         }      
  194.         Hsmmc_IssueCommand(CMD55,RCA<<16, 0, Response_R1);
  195.         rHM1_SYSAD =(unsigned int)Hsmmc_Buffer; // 缓存地址   
  196.         rHM1_BLKSIZE =(7<<12) | (64<<0); // 最大DMA缓存大小,block为512位64字节
  197.         rHM1_BLKCNT = 1;// 写入这次读1block的sd状态数据
  198.         rHM1_ARGUMENT = 0;// 写入命令参数 
  199.         // DMA传输使能,读单块      
  200.         rHM1_TRNMOD =(0<<5) | (1<<4) | (0<<2) | (1<<1) | (1<<0);  
  201.         // 设置命令寄存器,读状态命令CMD13,R1回复
  202.         rHM1_CMDREG =(CMD13<<8)|(1<<5)|(1<<4)|(1<<3)|0x2;
  203.         ErrorState =Hsmmc_WaitForCommandDone();
  204.         if (ErrorState) {
  205.             Debug("CMD13error\r\n");
  206.             returnErrorState;
  207.         }
  208.         ErrorState =Hsmmc_WaitForTransferDone();
  209.         if (ErrorState) {
  210.             Debug("Getsd status error\r\n");
  211.             returnErrorState;
  212.         }
  213.         for (i=0; i<64;i++) {
  214.             *pState++ =Hsmmc_Buffer[i];
  215.         }
  216.         return 0;
  217.     }
  218.     return -1; // 非sd卡
  219. }
  220. int Hsmmc_Get_CSD(unsigned char *pCSD)
  221. {
  222.     unsigned int i;
  224.     unsigned intResponse[4];
  226.     int State = 1;
  230.     if (CardType != SD_HC&& CardType != SD_V1 && CardType != SD_V2) {
  232.         return State; // 未识别的卡
  234.     }
  236.     // 取消卡选择,任何卡均不回复,已选择的卡通过RCA=0取消选择,
  238.     // 卡回到stand-by状态
  240.     Hsmmc_IssueCommand(CMD7,0, 0, Response_NONE);
  242.     for (i=0; i<1000;i++) {
  244.         if(Hsmmc_GetCardState() == 3) { // CMD9命令需在standy-by status
  246.             Debug("GetCSD: Enter to the Stand-by State\n\r");
  248.                 break; // 状态正确
  250.         }
  252.             Delay_us(100);
  254.     }
  256.     if (i == 1000) {
  258.         return State; // 状态错误
  260.     }  
  262.     // 请求已标记卡发送卡特定数据(CSD),获得卡信息
  264.     if(!Hsmmc_IssueCommand(CMD9, RCA<<16, 0, Response_R2)) {
  266.         pCSD++; // 路过第一字节,CSD中[127:8]位对位寄存器中的[119:0]
  268.         Response[0] =rHM1_RSPREG0;
  270.         Response[1] =rHM1_RSPREG1;
  272.         Response[2] =rHM1_RSPREG2;
  274.         Response[3] =rHM1_RSPREG3;
  276.         Debug("CSD:");
  278.         for (i=0; i<15;i++) { // 拷贝回复寄存器中的[119:0]到pCSD中
  280.             *pCSD++ =((unsigned char *)Response)[i];
  282.             Debug("%02x",*(pCSD-1));
  284.         }
  286.         State = 0; // CSD获取成功
  288.     }
  292.     Hsmmc_IssueCommand(CMD7,RCA<<16, 0, Response_R1); // 选择卡,卡回到transfer状态
  294.     return State;
  296. }
  300. // R1回复中包含了32位的card state,卡识别后,可在任一状态通过CMD13获得卡状态
  302. int Hsmmc_GetCardState(void)
  304. {
  306.     if(Hsmmc_IssueCommand(CMD13, RCA<<16, 0, Response_R1)) {
  308.         return -1; // 卡出错
  310.     } else {
  312.         return((rHM1_RSPREG0>>9) & 0xf); // 返回R1回复中的[12:9]卡状态
  314.     }
  316. }
  320. static int Hsmmc_SetBusWidth(unsigned char Width)
  322. {
  324.     int State;
  326.     if ((Width != 1) ||(Width != 4)) {
  328.         return -1;
  330.     }
  332.     State = -1; // 设置初始为未成功
  334.     rHM1_NORINTSTSEN&= ~(1<<8); // 关闭卡中断
  336.     Hsmmc_IssueCommand(CMD55,RCA<<16, 0, Response_R1);
  338.     if (Width == 1) {
  340.         if(!Hsmmc_IssueCommand(CMD6, 0, 0, Response_R1)) { // 1位宽
  342.             rHM_HOSTCTL&= ~(1<<1);
  344.             State = 0; // 命令成功
  346.         }
  348.     } else {
  350.         if(!Hsmmc_IssueCommand(CMD6, 2, 0, Response_R1)) { // 4位宽
  352.             rHM_HOSTCTL |=(1<<1);
  354.             State = 0; // 命令成功
  356.         }
  358.     }
  360.     rHM1_NORINTSTSEN |=(1<<8); // 打开卡中断  
  362.     return State; // 返回0为成功
  364. }
  368. int Hsmmc_EraseBlock(unsigned int StartBlock, unsigned intEndBlock)
  370. {
  372.     unsigned int i;
  376.     if (CardType == SD_V1|| CardType == SD_V2) {
  378.         StartBlock<<= 9; // 标准卡为字节地址
  380.         EndBlock <<=9;
  382.     } else if (CardType !=SD_HC) {
  384.         return -1; // 未识别的卡
  386.     }  
  388.     Hsmmc_IssueCommand(CMD32,StartBlock, 0, Response_R1);
  390.     Hsmmc_IssueCommand(CMD33,EndBlock, 0, Response_R1);
  392.     if(!Hsmmc_IssueCommand(CMD38, 0, 0, Response_R1b)) {
  394.         for (i=0;i<10000; i++) {
  396.             if (Hsmmc_GetCardState()== 4) { // 擦除完成后返回到transfer状态
  398.                 Debug("erasingcomplete!\n\r");
  400.                 return 0;// 擦除成功              
  402.             }
  404.             Delay_us(1000);        
  406.         }      
  408.     }      
  412.     Debug("Eraseblock failed\n\r");
  414.     return 1; // 擦除失败
  416. }
  420. int Hsmmc_ReadBlock(unsigned char *pBuffer, unsigned intBlockAddr, unsigned int BlockNumber)
  422. {
  424.     unsigned int Address =0;
  426.     unsigned intReadBlock;
  428.     unsigned int i;
  430.     int ErrorState;
  434.     if (pBuffer == 0 ||BlockNumber == 0) {
  436.         return -1;
  438.     }
  442.     // 均不中断使能,产生相应的中断信号
  444.     rHM1_NORINTSIGEN&= ~0xffff; // 清除所有中断使能
  446.     rHM1_NORINTSIGEN |=(1<<1); // 命令完成中断使能
  450.     while (BlockNumber> 0) {
  452.         for (i=0;i<1000; i++) {
  454.             if(Hsmmc_GetCardState() == 4) { // 读写数据需在transfer status
  456.                 break; // 状态正确
  458.             }
  460.             Delay_us(100);
  462.         }
  464.         if (i == 1000) {
  466.             return -2; // 状态错误
  468.         }      
  472.         if (BlockNumber<= sizeof(Hsmmc_Buffer)/512) {
  474.             ReadBlock =BlockNumber; // 读取的块数小于缓存32 Block(16k)
  476.             BlockNumber =0; // 剩余读取块数为0
  478.         } else {
  480. // 读取的块数大于32 Block,分多次读
  482.             ReadBlock =sizeof(Hsmmc_Buffer)/512;
  484.             BlockNumber -=ReadBlock;
  486.         }
  488.         // 根据sd主机控制器标准,按顺序写入主机控制器相应的寄存器
  490. // 缓存地址,内存区域为关闭cache,作DMA传输
  492.         rHM1_SYSAD =(unsigned int)Hsmmc_Buffer;           
  494.         rHM1_BLKSIZE =(7<<12) | (512<<0); // 最大DMA缓存大小,block为512字节
  496.         rHM1_BLKCNT =ReadBlock; // 写入这次读block数目
  500.         if (CardType ==SD_HC) {
  502.             Address =BlockAddr; // SDHC卡写入地址为block地址
  504.         } else if(CardType == SD_V1 || CardType == SD_V2) {
  506.             Address =BlockAddr << 9; // 标准卡写入地址为字节地址
  508.         }  
  510.         BlockAddr +=ReadBlock; // 下一次读块的地址
  512.         rHM1_ARGUMENT =Address; // 写入命令参数       
  516.         if (ReadBlock ==1) {
  518.             // 设置传输模式,DMA传输使能,读单块
  520.             rHM1_TRNMOD =(0<<5) | (1<<4) | (0<<2) | (1<<1) | (1<<0);
  522.             // 设置命令寄存器,单块读CMD17,R1回复
  524.             rHM1_CMDREG =(CMD17<<8)|(1<<5)|(1<<4)|(1<<3)|0x2;
  526.         } else {
  528.             // 设置传输模式,DMA传输使能,读多块         
  530.             rHM1_TRNMOD =(1<<5) | (1<<4) | (1<<2) | (1<<1) | (1<<0);
  532.             // 设置命令寄存器,多块读CMD18,R1回复  
  534.             rHM1_CMDREG =(CMD18<<8)|(1<<5)|(1<<4)|(1<<3)|0x2;         
  536.         }  
  538.         ErrorState =Hsmmc_WaitForCommandDone();
  540.         if (ErrorState) {
  542.             Debug("ReadCommand error\r\n");
  544.             returnErrorState;
  546.         }
  548.         ErrorState =Hsmmc_WaitForTransferDone();
  550.         if (ErrorState) {
  552.             Debug("Readblock error\r\n");
  554.             returnErrorState;
  556.         }
  558.         // 数据传输成功,拷贝DMA缓存的数据到指定内存
  560.         for (i=0;i<ReadBlock*512; i++) {
  562.             *pBuffer++ =Hsmmc_Buffer[i];
  564.         }      
  566.     }
  568.     return 0; // 所有块读完
  570. }
  574. int Hsmmc_WriteBlock(unsigned char *pBuffer, unsigned intBlockAddr, unsigned int BlockNumber)
  576. {
  578.     unsigned int Address =0;
  580.     unsigned intWriteBlock;
  582.     unsigned int i;
  584.     int ErrorState;
  588.     if (pBuffer == 0 ||BlockNumber == 0) {
  590.         return -1; // 参数错误
  592.     }
  596.     rHM1_NORINTSIGEN&= ~0xffff; // 清除所有中断使能
  598.     // 数据传输完成中断使能
  600.     rHM1_NORINTSIGEN |=(1<<0);
  604.     while (BlockNumber> 0) {
  606.         for (i=0;i<1000; i++) {
  608.             if(Hsmmc_GetCardState() == 4) { // 读写数据需在transfer status
  610.                 break; // 状态正确
  612.             }
  614.             Delay_us(100);
  616.         }
  618.         if (i == 1000) {
  620.             return -2; // 状态错误或Programming超时
  622.         }
  626.         if (BlockNumber<= sizeof(Hsmmc_Buffer)/512) {
  628.             WriteBlock =BlockNumber;// 写入的块数小于缓存32 Block(16k)
  630.             BlockNumber =0; // 剩余写入块数为0
  632.         } else {
  634. // 写入的块数大于32 Block,分多次写
  636.             WriteBlock =sizeof(Hsmmc_Buffer)/512;
  638.             BlockNumber -=WriteBlock;
  640.         }
  642.         if (WriteBlock> 1) { // 多块写,发送ACMD23先设置预擦除块数
  644.             Hsmmc_IssueCommand(CMD55,RCA<<16, 0, Response_R1);
  646.             Hsmmc_IssueCommand(CMD23,WriteBlock, 0, Response_R1);
  648.         }
  652.         for (i=0;i<WriteBlock*512; i++) {
  654.             Hsmmc_Buffer[i]= *pBuffer++; // 待写数据从指定内存区拷贝到缓存区
  656.         }
  658.         // 根据sd主机控制器标准,按顺序写入主机控制器相应的寄存器
  660. // 缓存地址,内存区域为关闭cache,作DMA传输
  662.         rHM1_SYSAD =(unsigned int)Hsmmc_Buffer;
  664.         rHM1_BLKSIZE =(7<<12) | (512<<0); // 最大DMA缓存大小,block为512字节     
  666.         rHM1_BLKCNT =WriteBlock; // 写入block数目
  670.         if (CardType ==SD_HC) {
  672.             Address =BlockAddr; // SDHC卡写入地址为block地址
  674.         } else if(CardType == SD_V1 || CardType == SD_V2) {
  676.             Address =BlockAddr << 9; // 标准卡写入地址为字节地址
  678.         }
  680.         BlockAddr +=WriteBlock; // 下一次写地址
  682.         rHM1_ARGUMENT =Address; // 写入命令参数           
  686.         if (WriteBlock ==1) {
  688.             // 设置传输模式,DMA传输写单块
  690.             rHM1_TRNMOD =(0<<5) | (0<<4) | (0<<2) | (1<<1) | (1<<0);
  692.             // 设置命令寄存器,单块写CMD24,R1回复
  694.             rHM1_CMDREG =(CMD24<<8)|(1<<5)|(1<<4)|(1<<3)|0x2;         
  696.         } else {
  698.             // 设置传输模式,DMA传输写多块
  700.             rHM1_TRNMOD =(1<<5) | (0<<4) | (1<<2) | (1<<1) | (1<<0);
  702.             // 设置命令寄存器,多块写CMD25,R1回复
  704.             rHM1_CMDREG =(CMD25<<8)|(1<<5)|(1<<4)|(1<<3)|0x2;                 
  706.         }
  708.         ErrorState =Hsmmc_WaitForCommandDone();
  710.         if (ErrorState) {
  712.             Debug("WriteCommand error\r\n");
  714.             returnErrorState;
  716.         }
  718.         ErrorState =Hsmmc_WaitForTransferDone();
  720.         if (ErrorState) {
  722.             Debug("Writeblock error\r\n");
  724.             returnErrorState;
  726.         }
  728.     }
  730.     return 0; // 写完所有数据
  732. }
  736. int Hsmmc_Init()
  738. {
  740.     unsigned int i;
  742.     unsigned int OCR;
  746.     // 设置HSMMC1的接口引脚配置
  748.     rGPLCON &=~((0xffff<<0) | (0xf<<16));
  750.     rGPLCON |=(0xaaaa<<0) | (0xa<<16);
  752.     rGPLUDP &=~((0xffff<<0) | (0xf<<16)); // 上下拉禁止
  756.     rHM1_SWRST = 0x7; // 复位HSMMC
  758.     Hsmmc_SetClock(0x80);// SDCLK=96M/256=375K
  760.     rHM1_TIMEOUTCON = (0xe<< 0); // 最大超时时间
  762.     rHM1_HOSTCTL &=~(1<<2); // 正常速度模式
  764.     rHM1_NORINTSTS =rHM1_NORINTSTS; // 清除中断状态标志
  766.     rHM1_ERRINTSTS =rHM1_ERRINTSTS; // 清除错误中断状态标志
  768.     rHM1_NORINTSTSEN =0x7fff; // [14:0]中断使能
  770.     rHM1_ERRINTSTSEN =0x3ff; // [9:0]错误中断使能
  772.     Hsmmc_IssueCommand(CMD0,0, 0, Response_NONE); // 复位所有卡到空闲状态
  776.     CardType =UnusableCard; // 卡类型初始化不可用
  778.     if (Hsmmc_IssueCommand(CMD8,0x1aa, 0, Response_R7)) { // 没回复,MMC/ v1.x/
  780.             for (i=0;i<1000; i++) {
  782.                 Hsmmc_IssueCommand(CMD55,0, 0, Response_R1);
  784. // CMD41有回复说明为sd卡
  786.                 if(!Hsmmc_IssueCommand(CMD41, 0, 0, Response_R3)) {
  788.                     OCR =rHM1_RSPREG0; // 获得回复的OCR(操作条件寄存器)值
  790.                     if(OCR & 0x80000000) { // 卡上电是否完成上电流程
  792.                         CardType= SD_V1; // 正确识别出sd v1.x卡
  794.                         Debug("SDcard version 1.x is detected\n\r");
  796.                         break;
  798.                     }
  800.                 } else {
  802.                     // MMC卡识别
  804.                 }
  806.                 Delay_us(100);             
  808.             }
  810.     } else { // sd v2.0
  812. // 判断卡是否支持2.7~3.3v电压
  814.         if(((rHM1_RSPREG0&0xff) == 0xaa) &&(((rHM1_RSPREG0>>8)&0xf) == 0x1)) {
  816.             OCR = 0;
  818.             for (i=0;i<1000; i++) {
  820.                 Hsmmc_IssueCommand(CMD55,0, 0, Response_R1);
  822.                 Hsmmc_IssueCommand(CMD41,OCR, 0, Response_R3); // reday态
  824.                 OCR =rHM1_RSPREG0;
  826.                 if (OCR& 0x80000000) { // 卡上电是否完成上电流程,是否busy
  828.                     if(OCR & (1<<30)) { // 判断卡为标准卡还是高容量卡
  830.                         CardType= SD_HC; // 高容量卡
  832.                         Debug("SDHCcard is detected\n\r");
  834.                     } else{
  836.                         CardType= SD_V2; // 标准卡
  838.                 Debug("SDversion 2.0 standard card is detected\n\r");
  840.                     }
  842.                     break;
  844.                 }
  846.                 Delay_us(100);
  848.             }
  850.         }
  852.     }
  854.     if (CardType == SD_HC|| CardType == SD_V1 || CardType == SD_V2) {
  856. // 请求卡发送CID(卡ID寄存器)号,进入ident
  858.         Hsmmc_IssueCommand(CMD2,0, 0, Response_R2);
  860. // 请求卡发布新的RCA(卡相对地址),Stand-by状态
  862.         Hsmmc_IssueCommand(CMD3,0, 0, Response_R6);
  864.         RCA =(rHM1_RSPREG0 >> 16) & 0xffff; // 从卡回复中得到卡相对地址
  866. // 选择已标记的卡,transfer状态
  868.         Hsmmc_IssueCommand(CMD7,RCA<<16, 0, Response_R1);
  870.         Debug("Enterto the transfer state\n\r");      
  872.         Hsmmc_SetClock(0x2);// 设置SDCLK= 96M/4 = 24M
  876.         if(!Hsmmc_SetBusWidth(4)) {
  878.             Debug("Setbus width error\n\r");
  880.             return 1; // 位宽设置出错
  882.         }
  884.         if(Hsmmc_GetCardState() == 4) { // 此时卡应在transfer态
  886. // 设置块长度为512字节
  888.             if(!Hsmmc_IssueCommand(CMD16, 512, 0, Response_R1)) {
  890.                 rHM1_NORINTSTS= 0xffff; // 清除中断标志
  892.                 Debug("CardInitialization succeed\n\r");
  894.                 return 0;// 初始化成功
  896.             }
  898.         }
  900.     }
  902.     Debug("CardInitialization failed\n\r");
  904.     return 1; // 卡工作异常
  906. }

Sd卡驱动模块头文件Hsmmc.h如下:

  1. #ifndef __HSMMC_H__
  3. #define __HSMMC_H__
  7. #ifdef __cplusplus
  9. extern "C" {
  11. #endif
  15. #define CMD0    0
  17. #define CMD1    1
  19. #define CMD2    2  
  21. #define CMD3    3  
  23. #define CMD6    6
  25. #define CMD7    7
  27. #define CMD8    8
  29. #define CMD9    9  
  31. #define CMD13   13
  33. #define CMD16   16
  35. #define CMD17   17
  37. #define CMD18   18
  39. #define CMD23   23
  41. #define CMD24   24
  43. #define CMD25   25 
  45. #define CMD32   32 
  47. #define CMD33   33 
  49. #define CMD38   38 
  51. #define CMD41   41 
  53. #define CMD55   55 
  57. // 卡类型
  59. #define     UnusableCard    0
  61. #define     SD_V1       1
  63. #define     SD_V2       2
  65. #define     SD_HC       3
  67. #define     MMC     4
  71. #define Response_NONE       0  
  73. #define Response_R1     1
  75. #define Response_R2     2
  77. #define Response_R3     3
  79. #define Response_R4     4
  81. #define Response_R5     5
  83. #define Response_R6     6
  85. #define Response_R7     7
  87. #define Response_R1b        8
  91. int Hsmmc_Init(void);
  93. int Hsmmc_GetCardState(void);
  95. int Hsmmc_GetSdState(unsigned char *pState);
  97. int Hsmmc_Get_CSD(unsigned char *pCSD);
  99. int Hsmmc_EraseBlock(unsigned int StartBlock, unsigned int EndBlock);
  101. int Hsmmc_WriteBlock(unsigned char *pBuffer,
  103. unsigned int BlockAddr,unsigned int BlockNumber);
  105. int Hsmmc_ReadBlock(unsigned char *pBuffer,
  107. unsigned int BlockAddr, unsigned intBlockNumber);
  111. #ifdef __cplusplus
  113. }
  115. #endif
  119. #endif /*__HSMMC_H__*/

3. 附录

Hsmmc.rar，包含sd卡驱动模块实现Hsmmc.c/Hsmmc.h。

http://pan.baidu.com/s/1hqvaQgO