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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
sdcmd.c
资源名称：STM32-uCOS-II_UAV.rar　[点击查看]
上传用户：yj_qqy
上传日期：2017-01-28
资源大小：2911k
文件大小：36k
源码类别：

uCOS

开发平台：

C/C++

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