开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 微处理器开发 > 查看源码
sdcmd.c
资源名称：SD卡读写模块.rar　[点击查看]
上传用户：pudewen666
上传日期：2007-06-08
资源大小：75k
文件大小：34k
源码类别：

微处理器开发

开发平台：

Windows_Unix

sdcmd.c：源码内容
  1. /****************************************Copyright (c)**************************************************
  2. **                               Guangzhou ZLG-MCU Development Co.,LTD.
  3. **                                      graduate school
  4. **                                 http://www.zlgmcu.com
  5. **
  6. **--------------File Info-------------------------------------------------------------------------------
  7. ** File name: sddriver.c
  8. ** Last modified Date: 2005-1-6
  9. ** Last Version: V1.0
  10. ** Descriptions: sd 卡驱动软件包: SD卡物理层 ---- SD卡SPI模式支持的命令 
  11. ** Soft Packet of SD Card Driver: commands that sd card supported in spi mode
  12. **
  13. **------------------------------------------------------------------------------------------------------
  14. ** Created by: Ming Yuan Zheng
  15. ** Created date: 2005-1-6
  16. ** Version: V1.0
  17. ** Descriptions: The original version
  18. **
  19. **------------------------------------------------------------------------------------------------------
  20. ** Modified by:
  21. ** Modified date:
  22. ** Version:
  23. ** Descriptions:
  24. **
  25. **------------------------------------------------------------------------------------------------------
  26. ** Modified by: 
  27. ** Modified date:
  28. ** Version:
  29. ** Descriptions: 
  30. **
  31. ********************************************************************************************************/
  33. #include "config.h"
  34. #include "sdconfig.h"
  35. #include "sdhal.h"
  36. #include "sdcrc.h"
  37. #include "sdcmd.h"
  38. #include "sddriver.h"
  40. /********************************************************************************************************************
  41. ** 函数名称: INT8U SD_SendCmd() Name:   INT8U SD_SendCmd()
  42. ** 功能描述: 向卡发送命令,并取得响应 Function: send command to the card,and get a response
  43. ** 输　  入: INT8U cmd     : 命令字 Input:   INT8U cmd     : command byte
  44.  INT8U *param : 命令参数,长度为4字节   INT8U *param : command parameter,length is 4 bytes  
  45.  INT8U resptype : 响应类型   INT8U resptype: response type
  46.  INT8U *resp : 响应,长度为1-5字节   INT8U *resp : response,length is 1-5 bytes
  47. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  48. ********************************************************************************************************************/
  49. INT8U SD_SendCmd(INT8U cmd, INT8U *param, INT8U resptype, INT8U *resp)
  50. {
  51. INT32 i,rlen;
  52. INT8U tmp;
  53.     
  54. SPI_CS_Assert();
  55.    
  56.     SPI_SendByte((cmd & 0x3F) | 0x40);  /* 发送命令头和命令字 send command header and word */
  57.     
  58.     for (i = 3; i >= 0; i--)
  59.         SPI_SendByte(param[i]);  /* 发送参数 send parameters */
  61. #if SD_CRC_EN
  62. tmp = SD_GetCmdByte6((cmd & 0x3F) | 0x40, param);
  63. SPI_SendByte(tmp);
  64. #else
  65.     SPI_SendByte(0x95);    /* CRC校验码,只用于第1个命令 CRC,only used for the first command */
  66. #endif 
  67.     
  68.     rlen = 0;
  69.     switch (resptype)  /* 根据不同的命令,得到不同的响应长度 */
  70.     {  /* according various command,get the various response length */
  71.    case R1:
  72.       case R1B: rlen = 1;  break;
  73.          
  74.      case R2:  rlen = 2;  break;
  75.          
  76.     case R3:  rlen = 5;  break;
  77.          
  78.      default:  SPI_SendByte(0xFF);
  79.              SPI_CS_Deassert();  
  80.                return SD_ERR_CMD_RESPTYPE;  /* 返回命令响应类型错误 return error of command response type */
  81.            break;
  82.     }
  83.     
  84.     i = 0;
  85.     do   /* 等待响应,响应的开始位为0 */
  86.     {  /* Wait for a response,a response is a start bit(zero) */ 
  87.         tmp = SPI_RecByte();
  88.         i++;
  89.     }while (((tmp & 0x80) != 0) && (i < SD_CMD_TIMEOUT));
  90.     
  91.     if (i >= SD_CMD_TIMEOUT)
  92.     {  
  93.         SPI_CS_Deassert();
  94.         return SD_ERR_CMD_TIMEOUT;  /* 返回命令超时 return response timeout of command */
  95.     }
  96.     
  97.     for (i = rlen - 1; i >= 0; i--)
  98.     {
  99.         resp[i] = tmp;
  100.         tmp = SPI_RecByte();    /* 循环的最后发送8clock  at the last recycle,clock out 8 clock */
  101.     }
  102.       
  103.     SPI_CS_Deassert();
  104.     return SD_NO_ERR;  /* 返回执行成功 return perform sucessfully */
  105. }
  107. /********************************************************************************************************************
  108. ** 函数名称: void SD_PackParam() Name:   void SD_PackParam()
  109. ** 功能描述: 将32位的参数转为字节形式 Function: change 32bit parameter to bytes form 
  110. ** 输　  入: INT8U *parameter: 字节参数缓冲区 Input:   INT8U *parameter: the buffer of bytes parameter
  111.  INT32U value    : 32位参数   INT32U value    : 32bit parameter
  112. ** 输 　 出: 无 Output:   NULL
  113. *********************************************************************************************************************/
  114. void SD_PackParam(INT8U *parameter, INT32U value)
  115. {
  116.     parameter[3] = (INT8U)(value >> 24);
  117.     parameter[2] = (INT8U)(value >> 16);
  118.     parameter[1] = (INT8U)(value >> 8);
  119.     parameter[0] = (INT8U)(value);
  120. }
  122. /********************************************************************************************************************
  123. ** 函数名称: INT8U SD_BlockCommand() Name:   INT8U SD_BlockCommand()
  124. ** 功能描述: 块命令 Function: command about block operation
  125. ** 输　  入: INT8U cmd      : 命令字 Input:   INT8U cmd       : command byte 
  126.  INT8U resptype  : 响应类型   INT8U resptype  : response type
  127.  INT32U parameter: 块操作参数     INT32U parameter: parameter of block operation
  128. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  129. *********************************************************************************************************************/
  130. INT8U SD_BlockCommand(INT8U cmd, INT8U resptype, INT32U parameter)
  131. {
  132. INT8U param[4],resp,ret;
  134. parameter <<= SD_BLOCKSIZE_NBITS;  /* 调整地址:左移9位 adjust address: move 9 bits left */
  136. SD_PackParam(param, parameter);  /* 将参数转化为字节形式 change the parameter to bytes form */
  138. ret = SD_SendCmd(cmd, param, resptype, &resp);
  139. if (ret != SD_NO_ERR)
  140.      return ret;    /* 结束数据传输失败 stop transmission operation fail */
  142. if (resp != 0)
  143.  return SD_ERR_CMD_RESP;    /* 响应错误 response is error */
  144.  
  145. return SD_NO_ERR;
  146. }
  148. /*
  149. ************************************************
  151.   下面为SD卡SPI命令
  153. ************************************************
  154. */
  156. /********************************************************************************************************************
  157. ** 函数名称: INT8U SD_ResetSD() Name:   INT8U SD_ResetSD()
  158. ** 功能描述: 复位SD卡 Function: reset sd card
  159. ** 输　  入: 无 Input:   NULL
  160. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  161. *********************************************************************************************************************/
  162. INT8U SD_ResetSD(void)
  163. {
  164. INT8U param[4] = {0,0,0,0},resp;
  166.     return (SD_SendCmd(CMD0, param, CMD0_R, &resp)); /* 复位命令 command that reset sd card */
  167. }
  169. /********************************************************************************************************************
  170. ** 函数名称: INT8U SD_ReadCSD() Name:   INT8U SD_ReadCSD()
  171. ** 功能描述: 读SD卡的CSD寄存器 Function: read CSD register of sd card 
  172. ** 输　  入: INT8U csdlen  : 寄存器长度(固定为16)   INT8U csdlen  : len of register (fixed,is 16)
  173.  INT8U *recbuf : 接收缓冲区       INT8U *recbuf : recbuffer
  174. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  175. *********************************************************************************************************************/
  176. INT8U SD_ReadCSD(INT8U csdlen, INT8U *recbuf)
  177. {
  178.     INT8U param[4] = {0,0,0,0},resp,ret;
  179.   
  180.     ret = SD_SendCmd(CMD9, param, CMD9_R, &resp); /* 读CSD寄存器命令 command that read CSD register */
  181.     if (ret != SD_NO_ERR) 
  182.         return ret;
  183.   
  184.     if (resp != 0)
  185.         return SD_ERR_CMD_RESP; /* 响应错误 response is error */
  186.     
  187. return (SD_ReadRegister(csdlen, recbuf));
  188. }
  190. /*******************************************************************************************************************
  191. ** 函数名称: INT8U SD_ReadCID() Name:   INT8U SD_ReadCID()
  192. ** 功能描述: 读SD卡的CID寄存器 Function: read CID register of sd card
  193. ** 输　  入: INT8U cidlen  : 寄存器长度(固定为16)   INT8U cidlen  : len of register (fixed,is 16)
  194.  INT8U *recbuf : 接收缓冲区       INT8U *recbuf : recbuffer
  195. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  196. ********************************************************************************************************************/
  197. #if SD_ReadCID_EN
  198. INT8U SD_ReadCID(INT8U cidlen, INT8U *recbuf)
  199. {
  200.     INT8U param[4] = {0,0,0,0},resp,ret;
  201.  
  202.     ret = SD_SendCmd(CMD10, param, CMD10_R, &resp); /* 读CID寄存器命令 command that read CID register */
  203.     if ( ret != SD_NO_ERR)
  204.     return ret;   
  205.    
  206.     if (resp != 0)
  207.         return SD_ERR_CMD_RESP; /* 响应错误 response is error */
  208.       
  209.    return (SD_ReadRegister(cidlen, recbuf));
  210. }
  211. #endif
  213. /********************************************************************************************************************
  214. ** 函数名称: INT8U SD_StopTransmission() Name:   INT8U SD_StopTransmission()
  215. ** 功能描述: 停止数据传输 Function: stop data transmission 
  216. ** 输　  入: 无   Input:    NULL
  217. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  218. *********************************************************************************************************************/
  219. INT8U SD_StopTransmission(void)
  220. {
  221. INT8U param[4] = {0,0,0,0},resp;
  223.   return (SD_SendCmd(CMD12, param, CMD12_R, &resp)); /* 结束数据传输命令失败 stop transmission command fail */
  224. }
  226. /*********************************************************************************************************************
  227. ** 函数名称: INT8U SD_ReadCard_Status() Name:   INT8U SD_ReadCard_Status()
  228. ** 功能描述: 读SD卡的 Card Status 寄存器 Function: read Card Status register of sd card 
  229. ** 输　  入: INT8U len:   寄存器长度(固定为2)   INT8U len:      len of register (fixed,is 2)
  230.  INT8U *recbuf : 接收缓冲区       INT8U *recbuf : recbuffer
  231. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  232. **********************************************************************************************************************/
  233. INT8U SD_ReadCard_Status(INT8U len, INT8U *buffer)
  234. {
  235.     INT8U param[4] = {0,0,0,0};
  237.     return (SD_SendCmd(CMD13, param, CMD13_R, buffer)); /* 读 Card Status 寄存器 */
  238.          /* read register of Card Status */
  239. }
  242. /********************************************************************************************************************
  243. ** 函数名称: INT8U Sd_SetBlockLen() Name:   INT8U Sd_SetBlockLen()
  244. ** 功能描述: 设置一个块的长度 Function: set a block len of sd card 
  245. ** 输　  入: INT32U length : 块的长度值 Input:   INT32U length : the length of a block
  246. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  247. *********************************************************************************************************************/
  248. INT8U SD_SetBlockLen(INT32U length)
  249. {
  250. INT8U param[4],resp,ret;
  251.   
  252.     SD_PackParam(param, length); /* 将参数转化为字节形式 change the parameter to bytes form */
  253.           
  254.     ret = SD_SendCmd(CMD16, param, CMD16_R, &resp);
  255.     if (ret != SD_NO_ERR)
  256.   return ret; /* 设置块的长度为length失败 set the length of block to length fail */
  258. if (resp != 0)
  259.      return SD_ERR_CMD_RESP;     /* 响应错误 response is error */
  260.     
  261.     return SD_NO_ERR;  /* 返回执行成功 return perform sucessfully */
  262. }
  264. /********************************************************************************************************************
  265. ** 函数名称: INT8U SD_ReadSingleBlock() Name:   INT8U SD_ReadSingleBlock()
  266. ** 功能描述: 读单块命令 Function: read single block command
  267. ** 输　  入: INT32U blockaddr: 块地址 Input:   INT32U blockaddr: block address
  268. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  269. *********************************************************************************************************************/
  270. INT8U SD_ReadSingleBlock(INT32U blockaddr)
  271. {
  272. return (SD_BlockCommand(CMD17, CMD17_R, blockaddr)); /* 读单块命令 command that read single block */
  273. }
  275. /********************************************************************************************************************
  276. ** 函数名称: INT8U SD_ReadMultipleBlock() Name:   INT8U SD_ReadMultipleBlock()
  277. ** 功能描述: 读多块命令 Function: read multiple block command 
  278. ** 输　  入: INT32U blockaddr: 块地址 Input:   INT32U blockaddr: block address
  279. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  280. *********************************************************************************************************************/
  281. INT8U SD_ReadMultipleBlock(INT32U blockaddr)
  282. {
  283. return (SD_BlockCommand(CMD18, CMD18_R, blockaddr)); /* 读多块命令 command that read multiple block */
  284. }
  286. /********************************************************************************************************************
  287. ** 函数名称: INT8U SD_WriteSingleBlock() Name:   INT8U SD_WriteSingleBlock()
  288. ** 功能描述: 写单块命令 Function: write single block command
  289. ** 输　  入: INT32U blockaddr: block address Input:   INT32U blockaddr: block address
  290. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  291. *********************************************************************************************************************/
  292. INT8U SD_WriteSingleBlock(INT32U blockaddr)
  293. {
  294. return (SD_BlockCommand(CMD24, CMD24_R, blockaddr)); /* 写单块命令 command that write single block */
  295. }
  297. /********************************************************************************************************************
  298. ** 函数名称: INT8U SD_WriteMultipleBlock() Name:   INT8U SD_WriteMultipleBlock()
  299. ** 功能描述: 写多块命令 Function: write multiple block command
  300. ** 输　  入: INT32U blockaddr: 块地址 Input:   INT32U blockaddr: block address
  301. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  302. *********************************************************************************************************************/
  303. INT8U SD_WriteMultipleBlock(INT32U blockaddr)
  304. {
  305. return (SD_BlockCommand(CMD25, CMD25_R, blockaddr)); /* 写多块命令 command that write multiple block */
  306. }
  308. /********************************************************************************************************************
  309. ** 函数名称: INT8U SD_ProgramCSD() Name:   INT8U SD_ProgramCSD()
  310. ** 功能描述: 写CSD寄存器 Function: write CSD register
  311. ** 输　  入: INT8U *buff     : CSD寄存器内容 Input:   INT8U *buff      : the content of CSD register
  312.  INT8U len     : CSD寄存器长度      INT8U len   : the length of CSD register
  313. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  314. ********************************************************************************************************************/
  315. #if SD_ProgramCSD_EN
  316. INT8U SD_ProgramCSD(INT8U len, INT8U *buff)
  317. {
  318. INT8U param[4] = {0,0,0,0},resp,ret;
  320. if (len != 16) return SD_ERR_USER_PARAM;
  322. ret = SD_SendCmd(CMD27, param, CMD27_R, &resp);  /* 发送写CSD寄存器命令 send command that write CSD */
  323. if (ret != SD_NO_ERR)
  324. return ret;
  325.         
  326.     if (resp != 0)    
  327.         return SD_ERR_CMD_RESP;
  329. buff[15] = (SD_GetCRC7(buff, 15) << 1) + 0x01;   /* 计算CSD中的crc 位域 calculate crc field in CSD */
  331. return(SD_WriteBlockData(0, 16, buff));
  332. }
  334. /********************************************************************************************************************
  335. ** 函数名称: INT8U SD_GetCRC7() Name:   INT8U SD_GetCRC7()
  336. ** 功能描述: 计算CRC7 Function: calculate crc7
  337. ** 输　  入: INT8U *pSource: 数据 Input:    INT8U *pSource: data
  338.  INT16U len    : 数据长度   INT16U len   : data length
  339. ** 输 　 出: CRC7码 Output:   CRC7 code
  340. *********************************************************************************************************************/
  341. INT8U SD_GetCRC7(INT8U *pSource, INT16U len)
  342. {
  343. INT8U i = 0, j;
  344. INT8U reg = 0;
  346. do
  347. {
  348.     for (j = 0; j < 8; j++)
  349.     {
  350. reg <<= 1;
  351. reg ^= ((((pSource[i] << j) ^ reg) & 0x80) ? 0x9 : 0);
  352.     }
  353.     
  354.     i++;
  355.     
  356. }while(i < len);
  358. return reg;
  359. }
  360. #endif
  362. #if SD_EraseBlock_EN
  363. /********************************************************************************************************************
  364. ** 函数名称: INT8U SD_EraseStartBlock() Name:   INT8U SD_EraseStartBlock()
  365. ** 功能描述: 设置块擦除起始地址 Function: select the start block address of erasing operation 
  366. ** 输　  入: INT32U startblock: 块地址 Input:    INT32U startblock : block address
  367. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right    >0:  error code
  368. *********************************************************************************************************************/
  369. INT8U SD_EraseStartBlock(INT32U startblock)
  370. {
  371. return (SD_BlockCommand(CMD32, CMD32_R, startblock)); /* 发送擦除起始块地址 send the start block address of erasing operation */
  372. }
  374. /********************************************************************************************************************
  375. ** 函数名称: INT8U SD_EraseEndBlock() Name:   INT8U SD_EraseEndBlock()
  376. ** 功能描述: 设置块擦除终止地址 Function: select the end block address of erasing operation  
  377. ** 输　  入: INT32U endblock: 块地址 Input:   INT32U Length : block address
  378. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right    >0:  error code
  379. *********************************************************************************************************************/
  380. INT8U SD_EraseEndBlock(INT32U endblock)
  381. {
  382. return (SD_BlockCommand(CMD33, CMD33_R, endblock));     /* 发送擦除终止块地址 send the end block address of erasing operation */
  383. }
  385. /********************************************************************************************************************
  386. ** 函数名称: INT8U SD_EraseSelectedBlock() Name:   INT8U SD_EraseSelectedBlock()
  387. ** 功能描述: 擦除已选中的块 Function: erase block selected
  388. ** 输　  入: 无 Input:   NULL
  389. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  390. *********************************************************************************************************************/
  391. INT8U SD_EraseSelectedBlock(void)
  392. {
  393. INT8U param[4],resp,tmp;
  395. SD_PackParam(param, 0);
  397. tmp = SD_SendCmd(CMD38, param, CMD38_R, &resp);       /* 擦除所选择的块  erase blocks selected */
  398. if (tmp != SD_NO_ERR)
  399. return tmp;  
  401. if (SD_WaitBusy(SD_WAIT_ERASE) != SD_NO_ERR) /* 等待擦除完成 wait for finishing erasing */
  402. return SD_ERR_TIMEOUT_ERASE;
  403. else
  404. return SD_NO_ERR;
  405. }
  406. #endif
  408. /*********************************************************************************************************************
  409. ** 函数名称: INT8U SD_ReadOCR() Name:   INT8U SD_ReadOCR()
  410. ** 功能描述: 读操作条件寄存器OCR Function: read OCR register of sd card
  411. ** 输　  入: INT8U ocrlen  : 寄存器长度(固定为4) Input:   INT8U ocrlen  : len of register (fixed,is 4)
  412.  INT8U *recbuf : 接收缓冲区       INT8U *recbuf : recbuffer
  413. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  414. **********************************************************************************************************************/
  415. INT8U SD_ReadOCR(INT8U ocrlen, INT8U *recbuf)
  416. {
  417.     INT8U param[4] = {0,0,0,0},resp[5],tmp;
  419.     tmp = SD_SendCmd(CMD58, param, CMD58_R, resp); /* 读 OCR 寄存器命令 */
  420.     if (tmp != SD_NO_ERR) /* read OCR register command */
  421.      return tmp;  
  422.     
  423.     if (resp[0] != 0)
  424.         return SD_ERR_CMD_RESP;   /* 响应错误 response is error */
  425.     
  426.     for (tmp = 0; tmp < 4; tmp++)
  427.      recbuf[tmp] = resp[tmp + 1]; /* 复制OCR寄存器内容到接收缓冲区 */
  428.     
  429.     return SD_NO_ERR;
  430. }
  432. /********************************************************************************************************************
  433. ** 函数名称: INT8U SD_EnableCRC() Name:   INT8U SD_EnableCRC()
  434. ** 功能描述: 使能SD卡的CRC校验功能 Function: enable crc check of SD Card 
  435. ** 输　  入: INT8U bEnable : 1:使能 0:禁止 Input:   INT8U bEnable : 1:enable  0: disable
  436. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  437. *********************************************************************************************************************/
  438. #if SD_CRC_EN
  439. INT8U SD_EnableCRC(INT8U bEnable)
  440. {
  441. INT8U param[4],resp,ret;
  443. if (bEnable == 1)
  444. param[0] = 1; /* 使能crc enable crc */
  445. else
  446. param[1] = 0;  /* 禁止crc disalbe crc */
  448. ret = SD_SendCmd(CMD59, param, CMD59_R, &resp); /* "使能/禁止CRC"命令 enable/disable crc command */
  449. if (ret != SD_NO_ERR)
  450.         return ret;  
  451.     
  452.     if (resp != 0)    
  453.         return SD_ERR_CMD_RESP; /* 响应错误 response is error */
  454.  
  455. return SD_NO_ERR;
  457. }
  458. #endif
  460. /*********************************************************************************************************************
  461. ** 函数名称: INT8U SD_Read_SD_Status()      Name:    INT8U SD_Read_SD_Status()
  462. ** 功能描述: 读SD卡的 SD_Status 寄存器      Function: read SD_Status register of sd card 
  463. ** 输　  入: INT8U sdslen   : 寄存器长度(固定为64)  Input:    INT8U sdslen: len of register (fixed,is 64)
  464.  INT8U *recbuf  : 接收缓冲区        INT8U *recbuf: recbuffer
  465. ** 输 　 出: 0:   正确    >0:   错误码     Output:   0:  right >0:  error code
  466. **********************************************************************************************************************/
  467. #if SD_ReadSD_Status_EN
  468. INT8U SD_ReadSD_Status(INT8U sdslen, INT8U *recbuf)
  469. {
  470.     INT8U param[4] = {0,0,0,0},resp[2],ret;
  471.     
  472.     ret = SD_SendCmd(CMD55, param, CMD55_R, resp); /* 后续命令为一个应用命令 */
  473.     if (ret != SD_NO_ERR)
  474.      return ret; /* command that the followed commnad is a specific application */
  475.       
  476.     if (resp[0] != 0)
  477.         return SD_ERR_CMD_RESP; /* 响应错误 response is error */
  478.     
  479.     ret = SD_SendCmd(ACMD13, param, ACMD13_R, resp); /* 读 SD_Status 命令 */
  480.     if (ret != SD_NO_ERR)
  481.      return ret; /* command that read SD_Status register */
  482.    
  483.     if ((resp[0] != 0) || (resp[1] != 0))
  484.         return SD_ERR_CMD_RESP; /* 响应错误 response is error */
  485.         
  486. return (SD_ReadBlockData(sdslen, recbuf)); /* 读出寄存器内容 read the content of the register */
  487. }
  488. #endif
  490. /*******************************************************************************************************************
  491. ** 函数名称: INT8U SD_ReadSCR() Name:   INT8U SD_ReadSCR()
  492. ** 功能描述: 读SD卡的 SCR 寄存器 Function: read SCR register of sd card 
  493. ** 输　  入: INT8U scrlen   : 寄存器长度(固定为8)  Input:    INT8U scrlen  : len of register (fixed,is 8)
  494.  INT8U *recbuf  : 接收缓冲区   INT8U *recbuf  : recbuffer
  495. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  496. ********************************************************************************************************************/
  497. #if SD_ReadSCR_EN
  498. INT8U SD_ReadSCR(INT8U scrlen, INT8U *recbuf)
  499. {
  500.     INT8U param[4] = {0,0,0,0},resp,ret;
  501.     
  502.     ret = SD_SendCmd(CMD55, param, CMD55_R, &resp); /* 后续命令为一个应用命令 */
  503.     if (ret != SD_NO_ERR) /* command that the followed commnad is a specific application */
  504.      return ret;
  505.       
  506.     if (resp != 0)
  507.         return SD_ERR_CMD_RESP; /* 响应错误 response is error */
  508.     
  509.     ret = SD_SendCmd(ACMD51, param, ACMD51_R, &resp);    /* 发送读 SD_Status 命令*/
  510.     if (ret != SD_NO_ERR) /* command that read SD_Status register */
  511.     return ret;
  512.     
  513.     if (resp != 0)
  514.         return SD_ERR_CMD_RESP;   /* 响应错误 response is error */
  515.         
  516. return (SD_ReadBlockData(scrlen, recbuf));   /* 读出寄存器内容 read the content of the register */
  517. }
  518. #endif
  520. /********************************************************************************************************************
  521. ** 函数名称: INT8U SD_GetNumWRBlcoks() Name:   INT8U SD_GetNumWRBlcoks()
  522. ** 功能描述: 得到正确写入的块数 Function: get the block numbers that written correctly
  523. ** 输　  入: INT32U *blocknum: 返回的块数 Input:   INT32U blocknum : the block numbers returned
  524. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  525. *********************************************************************************************************************/
  526. #if SD_WriteMultiBlock_EN
  527. INT8U SD_GetNumWRBlcoks(INT32U *blocknum)
  528. {
  529.     INT8U tmp[4] = {0,0,0,0},resp,ret;
  530.   
  531.     ret = SD_SendCmd(CMD55, tmp, CMD55_R, &resp);    /* 后续命令为一个应用命令 */
  532.     if (ret != SD_NO_ERR)  /* command that the followed commnad is a specific application */
  533.      return ret;
  534.       
  535.     if (resp != 0)
  536.      return SD_ERR_CMD_RESP;    
  537.  
  538.     ret = SD_SendCmd(ACMD22, tmp, ACMD22_R, &resp);   /* 读取正确写入的块数命令 */
  539.     if (ret != SD_NO_ERR) /* command that read the numbers of block written correctly */
  540.     return ret;     
  541.      
  542. if (resp != 0)
  543.      return SD_ERR_CMD_RESP; /* 响应错误 response is error */
  544.     
  545.     ret = SD_ReadBlockData(4, tmp); /* 读块数 read the numbvers of block */
  546.     if (ret != SD_NO_ERR)
  547.      return ret;
  548.     
  549.     *blocknum = (tmp[0] << 24) + (tmp[1] << 16) + (tmp[2] << 8) + tmp[3];
  550.      /* 转换为32位 change to 32 bits */
  552. return SD_NO_ERR;     /* 返回执行成功 return perform sucessfully */
  553. }
  554. #endif
  556. /*********************************************************
  558.      下面为一些数据传输函数
  560. **********************************************************/
  562. /********************************************************************************************************************
  563. ** 函数名称: INT8U SD_ReadRegister() Name:   INT8U SD_ReadRegister()
  564. ** 功能描述: 从SD卡读取数据 Function: read data from SD card
  565. ** 输　  入: INT32U len   : 长度 Input:   INT32U len   : length
  566.  INT8U *recbuf: 接收缓冲区     INT8U *recbuf: receive buffer
  567. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  568. *********************************************************************************************************************/
  569. INT8U SD_ReadRegister(INT32U len, INT8U *recbuf)
  570. {
  571. INT32U i = 0;
  572. INT8U resp;
  574.     SPI_CS_Assert();
  575.     do{     /* 等待数据起始令牌 wait for data start token */
  576.         resp = SPI_RecByte();
  577.      i++;
  578.     }while((resp == 0xFF) && (i < SD_READREG_TIMEOUT));    
  579.     
  580.     if (i >= SD_READREG_TIMEOUT)
  581.     {
  582.      SPI_CS_Deassert();
  583.      return SD_ERR_TIMEOUT_READ; /* 超时, 返回错误 timeout, return error */
  584.    }
  585.   
  586.     if (resp != SD_TOK_READ_STARTBLOCK)
  587.     { /* 不是收到数据起始令牌 not receive data start token */
  588. recbuf[0] = resp;
  589. i = 1; /* 还有len - 1个字节要接收 still len - 1 bytes will be received */
  590.     }
  591.     else
  592.     i = 0; /* 收到数据起始令牌,还有len个字节要接收 received data start token,still len bytes will be received */
  593.       
  594.     for (; i < len; i++)
  595.     recbuf[i] = SPI_RecByte(); /* 接收数据 receive data */
  596.    
  597.     i = SPI_RecByte();
  598.     i = (i << 8) + SPI_RecByte();     /* 读取16位CRC get 16-bit CRC */
  600. #if SD_CRC_EN 
  601.     if (i != SD_GetCRC16(recbuf, len))
  602.     { /* CRC校验错误 CRC check is error */
  603.     SPI_CS_Deassert();
  604.     SPI_SendByte(0xFF);    
  605.    return SD_ERR_DATA_CRC16; /* 返回RCR16错误  return error of CRC16 */
  606.    }    
  607. #endif   
  608.   
  609.     SPI_SendByte(0xFF); /* 返回之前发送8个clock  clock out 8 clk before return */
  610.     SPI_CS_Deassert();
  611.     
  612. return SD_NO_ERR;
  613. }
  615. /*******************************************************************************************************************
  616. ** 函数名称: INT8U SD_ReadBlockData() Name:   INT8U SD_ReadBlockData()
  617. ** 功能描述: 从SD卡中读取数据块 Function: read block data from sd card
  618. ** 输　  入: INT32U len    : 长度 Input:   INT32U len    : length
  619.  INT8U *recbuf : 接收缓冲区   INT8U *recbuf : the buffer of receive
  620. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  621. *******************************************************************************************************************/
  622. INT8U SD_ReadBlockData(INT32U len, INT8U *recbuf)
  623. {
  624.     INT8U tmp;
  625.     INT32U i = 0;
  626.     
  627.     SPI_CS_Assert();    
  628.     do
  629.     {      /* 等待接收数据开始令牌0xFE  wait for receiving data start token 0xFE */
  630.         tmp = SPI_RecByte();
  631.         i++;
  632.      }while((tmp == 0xFF) && (i < sds.timeout_read));
  634. if (i >= sds.timeout_read)
  635. {
  636. SPI_CS_Deassert();
  637.         return SD_ERR_TIMEOUT_READ; /* 返回读超时错误码  return error timeout error code of reading */
  638. }
  640. if (tmp != SD_TOK_READ_STARTBLOCK) /* 块读开始令牌错误 read start block token is error */
  641. {
  642. SPI_SendByte(0xFF);
  643. SPI_CS_Deassert();
  644. return SD_ERR_DATA_START_TOK;
  645. }
  647. for (i = 0; i < len; i++)
  648.     recbuf[i] = SPI_RecByte(); /* 接收数据 receive data */
  649.    
  650.     i = SPI_RecByte();
  651.     i = (i << 8) + SPI_RecByte();     /* 读取16位CRC get 16-bit CRC */
  653. #if SD_CRC_EN 
  654.     if (i != SD_GetCRC16(recbuf, len))
  655.     { /* CRC校验错误 CRC check is error */
  656.     SPI_SendByte(0xFF); 
  657.     SPI_CS_Deassert();  
  658.    return SD_ERR_DATA_CRC16; /* 返回CRC16错误  return error of CRC16 */
  659.    }    
  660. #endif   
  662. SPI_SendByte(0xFF); 
  663. SPI_CS_Deassert();
  665.    return SD_NO_ERR; /* 返回函数执行成功 return function perform sucessfully */
  666. }
  668. /*******************************************************************************************************************
  669. ** 函数名称: INT8U SD_WriteBlockData() Name:   INT8U SD_WriteBlockData()
  670. ** 功能描述: 向sd卡写数据块 Function: write block data to sd card
  671. ** 输　  入: INT8U bmulti  : 是否为多块操作1:是0:否 Input:   INT8U bmulti   : multi blocks operate 1:Y 0:N 
  672.  INT32U len    : 长度      INT32U len     : length
  673.  INT8U *sendbuf: 发送缓冲区     INT8U *sendbuf : the buffer of send
  674. ** 输 　 出: 0:   正确    >0:   错误码    Output:   0:  right >0:  error code
  675. ********************************************************************************************************************/
  676. INT8U SD_WriteBlockData(INT8U bmulti, INT32U len, INT8U *sendbuf)
  677. {
  678. INT16U i;
  679. INT8U tmp;
  681. SPI_CS_Assert();
  683.     SPI_SendByte(0xFF); /* 开始发送数据之前发送8个clock clock out 8 clk before start */
  684.     
  685.     if (bmulti == 1)
  686.         SPI_SendByte(SD_TOK_WRITE_STARTBLOCK_M); /* 写多块开始令牌 start token of write multi blocks */
  687. else
  688. SPI_SendByte(SD_TOK_WRITE_STARTBLOCK); /* 写单块开始令牌 start token of write single block */
  690. for (i = 0; i < len; i++)
  691.         SPI_SendByte(sendbuf[i]); /* 发送数据 send data */
  693. #if SD_CRC_EN
  694. i = SD_GetCRC16(sendbuf,len); /* 计算CRC16 calculate CRC16 */
  695. #endif
  697. SPI_SendByte((i >> 8) & 0xFF);
  698. SPI_SendByte(i & 0xFF);  /* 发送CRC16校验码 send CRC16 check code */
  699.     
  700. tmp = SPI_RecByte();
  701.    if ((tmp & SD_RESP_DATA_MSK) != SD_RESP_DATA_ACCETPTED)
  702.    {
  703.     SPI_SendByte(0xFF); /* 返回之前发送8个clock  clock out 8 clk before return */
  704.     SPI_CS_Deassert();
  705.     return SD_ERR_DATA_RESP; /* 数据响应错误 data response error */
  706.     }
  707.         
  708.     SPI_CS_Deassert();
  709.      
  710.     if (SD_WaitBusy(SD_WAIT_WRITE) != SD_NO_ERR)
  711.      return SD_ERR_TIMEOUT_WRITE; /* 写入超时 write time out */
  712.     else
  713.      return SD_NO_ERR;  /* 写入正确 write right */
  714.  }
  716. /*******************************************************************************************************************
  717. ** 函数名称: void SD_StopMultiToken() Name:   void SD_StopMultiToken(void)
  718. ** 功能描述: 发送多块写停止令牌 Function: send the token that stop multiple block write
  719. ** 输　  入: 无     Input:   NULL
  720. ** 输 　 出: 无 Output:   NULL
  721. ********************************************************************************************************************/
  722. void SD_StopMultiToken(void)
  723. {
  724. SPI_CS_Assert();
  726. SPI_SendByte(0xFF); /* 先发送8个clock send 8 clock first */
  727. SPI_SendByte(SD_TOK_STOP_MULTI); /* 发送停止数据传输令牌 send stop transmission token */
  728. SPI_RecByte();
  730.     SPI_CS_Deassert();
  731. }
  734. /********************************************************************************************************************
  735. ** 函数名称: void SD_WaitBusy() Name:   void SD_WaitBusy()
  736. ** 功能描述: 查询SD卡是否处于忙状态 Function: poll SD Card wheather it is busy
  737. ** 输　  入: INT32U waittype: 超时类型 Input:   INT32U timeout: time out type
  738. ** 输 　 出: 0: 未超时  >0: 错误码 Output:   0: not time out   > 0: error code
  739. *********************************************************************************************************************/
  740. INT8U SD_WaitBusy(INT8U waittype)
  741. {
  742.     INT32U timeout, i = 0;
  743.     INT8U tmp;
  744.     
  745.     if (waittype == SD_WAIT_WRITE)
  746.      timeout = sds.timeout_write;
  747.     else
  748.      timeout = sds.timeout_erase;
  750. SPI_CS_Assert();
  751.     do
  752.     {  /* 等待忙结束 wait for being busy end */
  753.         tmp = SPI_RecByte();
  754.         i++;
  755.     }while ((tmp != 0xFF) && (i < timeout)); /* 忙时收到的值为0xFF always receive 0xFF when card is busy */    
  756. SPI_CS_Deassert(); /* 有错 */
  758. if(i < timeout) 
  759. return SD_NO_ERR; /* 返回0,表示没超时 return 0 indicate that operation is not time out */
  760. else 
  761. return SD_ERR_TIMEOUT_WAIT; /* 返回错误码,表示超时 return error code indicate that operation is time out */
  762. }
  764. /********************************************************************************************************************
  765. ** 函数名称: void SD_SPIDelay() Name:   void SD_SPIDelay()
  766. ** 功能描述: SPI总线延时 Function: SPI Bus delay 
  767. ** 输　  入: INT8U value: 延时值,不超过255     Input:   INT8U value : delay value,do not beyond 255
  768. ** 输 　 出: 无 Output:   NULL
  769. *********************************************************************************************************************/
  770. void SD_SPIDelay(INT8U value)
  771. {
  772.     INT8U i;
  774.     for (i = 0; i < value; i++)
  775.         SPI_SendByte(0xFF);   /* 发送0xFF clock out 0xFF */
  776. }