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

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

uCOS

开发平台：

C/C++

sddriver.c：源码内容
  1. /****************************************Copyright (c)**************************************************
  2. **                               Hangzhou yh software  Co.,LTD.
  3. **                                     
  4. **                                 http://www.armgcc.com
  5. **
  6. **--------------File Info-------------------------------------------------------------------------------
  7. ** File name: sddriver.c
  8. ** Last modified Date: 2007-10-15
  9. ** Last Version: V1.0
  10. ** Descriptions: SD/MMC卡读写模块: 物理层 用户API函数
  11. **
  12. **------------------------------------------------------------------------------------------------------
  13. ** Created by: lhlzjut@hotmail.com
  14. ** Created date: 2007-10-15
  15. ** Version: V1.0
  16. ** Descriptions: The original version
  17. **
  18. **------------------------------------------------------------------------------------------------------
  19. ********************************************************************************************************/
  20. #include <stdio.h>
  22. #include "sdhal.h"
  23. #include "sdcmd.h"
  24. #include "sddriver.h"
  26. #if SD_UCOSII_EN    
  27. #include  "ucos_ii.h"
  28. #endif
  30. #if SD_UCOSII_EN
  31. OS_EVENT *pSemSD = NULL; /* 卡访问权限信号量 semaphore that access card */
  32. #endif 
  34. /* SD卡信息结构体变量 the information structure variable of SD Card */
  35. sd_struct sds;
  37. /* 超时时间单位表(单位:0.000000001ns) timeout unit table */
  38. const INT32U time_unit[8] = {1000000000,100000000,10000000,
  39.  1000000,100000,10000,1000,100};
  41. /* 超时时间表 timeout value table */  
  42. const INT8U time_value[16] = {0,10,12,13,15,20,25,30,
  43.                               35,40,45,50,55,60,70,80};
  44.  
  45. /* 超时时间因数表 timeout factor table */                              
  46. const INT8U r2w_fator[8] = {1,2,4,8,16,32,64,128};                           
  47.  
  49. void SD_Sleep(INT32U cpt_loop)
  50. {
  51.   while (cpt_loop -- != 0);
  52. }   
  53. /*       
  54. ***************************************************************************************************
  56.      用户API函数:  初始化,读,写,擦 SD卡  User API Function: Initialize,read,write,erase SD Card 
  58. ***************************************************************************************************
  59. */
  61. /*******************************************************************************************************************
  62. ** 函数名称: INT8U SD_Initialize() Name:   INT8U SD_Initialize()
  63. ** 功能描述: 初始化SD/MMC卡 Function: initialize SD/MMC card
  64. ** 输　  入: 无 Input:   NULL
  65. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  66. ********************************************************************************************************************/
  67. INT8U SD_Initialize(void)
  68. {
  69. INT8U recbuf[4],ret;
  71. #if SD_UCOSII_EN
  72. if (pSemSD == NULL)
  73. {
  74.      pSemSD = OSSemCreate(1); /* 创建访问SD/MMC卡信号量 create SD/MMC semaphore */ 
  75. if (pSemSD == NULL)
  76.   return SD_ERR_CREATE_SEMSD;
  77. }     
  78. #endif
  79.    
  80.     SD_StartSD();
  81.     SD_HardWareInit();      /* 初始化读写SD卡的硬件条件 Initialize the hardware that access SD Card */
  82.     
  83.     if (SD_ChkCard() != 1) /* 检查卡是否插入 check weather card is inserted */
  84.     {
  85.      ret = SD_ERR_NO_CARD;   
  86.      goto SD_ERR;
  87.     }
  88.         
  89.     SPI_CS_Assert(); /* 1. 置CS为低 assert CS */  
  91. SD_SPIDelay(200); /* 2. 至少延时 74 clock delay more than 74 clock */
  92.     
  93. SPI_CS_Deassert(); /* 3. 置CS为高 dessert CS */
  94.     SD_SPIDelay(4); /* 4. 延时2(8 clock) delay 2(8 clock) */
  95.      
  96.     SD_Sleep(1000000);
  97.     
  98.     ret = SD_ResetSD(); /* 5. 发出CMDO命令复位SD卡 send CMD0 command to reset sd card */
  99.    
  100.     if (ret != SD_NO_ERR)
  101.         goto SD_ERR;
  102.  
  103.   ret = SD_ActiveInit(); /* 6. 激活卡进入初始化过程. active card initialize process */
  104.   if (ret != SD_NO_ERR)
  105.   goto SD_ERR;
  106.     
  107.     ret = SD_ReadOCR(4, recbuf);   /* 7. 读OCR寄存器,查询卡支持的电压值 read OCR register,get the supported voltage */
  108.     if (ret != SD_NO_ERR)
  109.         goto SD_ERR;
  110.     
  111.     if ((recbuf[1] & MSK_OCR_33) != MSK_OCR_33)
  112.     {   
  113.         ret = SD_ERR_VOL_NOTSUSP; /* 不支持3.3V,返回错误码  not support 3.3V,return error code */
  114.      goto SD_ERR;
  115.     }
  116.           
  117. #if SD_CRC_EN        
  118.     ret = SD_EnableCRC(1); /* 使能CRC校验 enable CRC check */
  119. if (ret != SD_NO_ERR)  
  120.    goto SD_ERR;
  121. #endif
  123.     ret = SD_SetBlockLen(SD_BLOCKSIZE); /* 8. 设置块的长度: 512Bytes Set the block length: 512Bytes */
  124.     if (ret != SD_NO_ERR)  
  125.         goto SD_ERR;
  126.         
  127.     ret = SD_GetCardInfo(); /* 9. 读CSD寄存器,获取SD卡信息 read CSD register, get the information of SD card */    
  128. if (ret != SD_NO_ERR)
  129. goto SD_ERR;
  131. SD_EndSD();
  133. SPI_ClkToMax(); /* 10. 设置SPI时钟到最大值 set SPI clock to maximum */
  135. return SD_NO_ERR; /* 初始化成功 initialize sucessfully */
  137. SD_ERR:
  138. SD_EndSD();
  139. return ret;
  140. }
  142. /********************************************************************************************************************
  143. ** 函数名称: INT8U SD_ReadBlock() Name:   INT8U SD_ReadBlock()
  144. ** 功能描述: 从SD/MMC卡中读一个块 Function: read a single block from SD/MMC card
  145. ** 输　  入: INT32U blockaddr: 块地址 Input:    INT32U blockaddr: address of block
  146.  INT8U *recbuf   : 接收缓冲区,长度512Bytes     INT8U *recbuf   : the buffer of receive,length is 512Bytes
  147. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  148. *********************************************************************************************************************/
  149. INT8U SD_ReadBlock(INT32U blockaddr,INT32U len, INT8U *recbuf)
  150. {
  151. INT8U ret; 
  153. SD_StartSD(); /* 向OS申请访问卡信号量 request semaphore acessed SD/MMC to OS */
  154.     if (SD_ChkCard() != 1)
  155.     {
  156.      SD_EndSD();
  157.      return SD_ERR_NO_CARD;    /* 卡没完全插入卡中 card is not inserted entirely */
  158. }
  160. if (blockaddr > sds.block_num)
  161. {
  162. SD_EndSD();
  163. return SD_ERR_OVER_CARDRANGE; /* 操作超出卡容量范围 operate over the card range */
  164. }
  166.   ret = SD_ReadSingleBlock(blockaddr); /* 读单块命令 read single blocks command */
  167.   if (ret != SD_NO_ERR)
  168.   {
  169.   SD_EndSD();
  170.   return ret;
  171.   }
  172.  
  173.    ret = SD_ReadBlockData(len, recbuf); /* 读出数据 read data from sd card */
  174. SD_EndSD(); /* 归还访问卡信号量 return semaphore acessed SD/MMC to OS */
  176. return ret;
  177. }
  179. /********************************************************************************************************************
  180. ** 函数名称: INT8U SD_ReadMultiBlock() Name:   INT8U SD_ReadMultiBlock()
  181. ** 功能描述: 从SD/MMC卡中读多个块 Function: read multi blocks from SD/MMC card
  182. ** 输　  入: INT32U blockaddr: 块地址 Input:   INT32U blockaddr: address of block
  183.  INT32U blocknum : 块数量   INT32U blocknum : the numbers of block
  184.  INT8U *recbuf   : 接收缓冲区,每块512字节   INT8U *recbuf   : the buffer of receive,each block length is 512Bytes
  185. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  186. *********************************************************************************************************************/
  187. #if SD_ReadMultiBlock_EN
  188. INT8U SD_ReadMultiBlock(INT32U blockaddr, INT32U blocknum, INT8U *recbuf)
  189. {
  190.     INT32U i;
  191.     INT8U ret;
  192.        
  193. SD_StartSD(); /* 向OS申请访问卡信号量 request semaphore acessed SD/MMC to OS */
  194.     if (SD_ChkCard() != 1)
  195.     {
  196.      SD_EndSD();
  197.      return SD_ERR_NO_CARD;    /* 卡没完全插入卡中 card is not inserted entirely */
  198. }
  200. if ((blockaddr + blocknum) > sds.block_num)
  201. {
  202. SD_EndSD();
  203. return SD_ERR_OVER_CARDRANGE; /* 操作超出卡容量范围 operate over the card range */
  204. }       
  205.     
  206. ret = SD_ReadMultipleBlock(blockaddr); /* 读多块命令 read multiple blocks command */
  207. if (ret != SD_NO_ERR)
  208. {
  209. SD_EndSD(); /* 归还访问卡信号量 return semaphore acessed SD/MMC to OS */
  210. return ret;
  211.     }
  212.     
  213.     for (i = 0; i < blocknum; i++)
  214.     { /* 读出数据 read data from SD/MMC card */
  215.      ret = SD_ReadBlockData(SD_BLOCKSIZE, recbuf);
  216.      if (ret == SD_NO_ERR)
  217.         recbuf = recbuf + SD_BLOCKSIZE;
  218.      else
  219.      {
  220.      SD_EndSD();
  221.      return ret;
  222.      }
  223.     }
  224.    
  225.   ret = SD_StopTransmission();     /* 结束数据传输 stop transmission operation */ 
  226.  
  227.   SD_EndSD();
  228. return ret; 
  229. }
  231. #endif
  233. /********************************************************************************************************************
  234. ** 函数名称: INT8U SD_WriteBlock() Name:   INT8U SD_WriteBlock()
  235. ** 功能描述: 向SD/MMC卡中写入一个块 Function: write a block to SD/MMC card
  236. ** 输　  入: INT32U blockaddr: 块地址 Input:    INT32U blockaddr: address of block
  237.  INT8U *sendbuf  : 发送缓冲区,长度512Bytes      INT8U *sendbuf  : the buffer of send,length is 512Bytes
  238. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  239. *********************************************************************************************************************/
  240. INT8U SD_WriteBlock(INT32U blockaddr, INT32U len, INT8U *sendbuf)
  241. {
  242. INT8U ret,tmp[2];
  244. SD_StartSD(); /* 向OS申请访问卡信号量 request semaphore acessed SD/MMC to OS */
  245.     if (SD_ChkCard() != 1)
  246.     {
  247.      SD_EndSD();
  248.      return SD_ERR_NO_CARD;    /* 卡没完全插入卡中 card is not inserted entirely */
  249. }
  251. if (blockaddr > sds.block_num)
  252. {
  253. SD_EndSD();
  254. return SD_ERR_OVER_CARDRANGE; /* 操作超出卡容量范围 operate over the card range */
  255. }
  257. if (SD_ChkCardWP() == 1)
  258. {
  259. SD_EndSD();
  260. return SD_ERR_WRITE_PROTECT; /* 卡有写保护 */
  261. }
  263. ret = SD_WriteSingleBlock(blockaddr); /* 写单块命令 write single block */
  264. if (ret != SD_NO_ERR)
  265. {
  266. SD_EndSD();
  267. return ret;
  268. }
  270. ret = SD_WriteBlockData(0, len, sendbuf); /* 写入数据 write data */
  271.  
  272. if (ret == SD_NO_ERR) /* 读Card Status寄存器, 检查写入是否成功 */
  273.   { /* read Card Status register to check write wheather sucessfully */
  274.   ret = SD_ReadCard_Status(2, tmp);
  275.   if (ret != SD_NO_ERR)
  276.   {
  277.   SD_EndSD();
  278.   return ret; /* 读寄存器失败 read register fail */
  279. }
  281.   if((tmp[0] != 0) || (tmp[1] != 0))
  282.   {
  283.   SD_EndSD();
  284. ret = SD_ERR_WRITE_BLK;        /* 响应指示写失败 response indicate write fail */
  285.   }
  286.   }
  287.   
  288.     SD_EndSD();
  289.   return ret; /* 返回写入结果 return the result of writing */
  290. }
  292. /**********************************************************************************************************************
  293. ** 函数名称: INT8U SD_WriteMultiBlock() Name:   INT8U SD_WriteMultiBlock()
  294. ** 功能描述: 向SD/MMC卡中写入多个块 Function: write multi blocks to SD/MMC card
  295. ** 输　  入: INT32U blockaddr: 块地址 Input:   INT32U blockaddr: address of block
  296.  INT32U blocknum : 块数量   INT32U blocknum : the numbers of block
  297.  INT8U *sendbuf  : 发送缓冲区每块512字节       INT8U *sendbuf  : the send buffer,each block length is 512Bytes
  298. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  299. ***********************************************************************************************************************/
  300. #if SD_WriteMultiBlock_EN
  301. INT8U SD_WriteMultiBlock(INT32U blockaddr, INT32U blocknum, INT8U *sendbuf)
  302. {
  303. INT32U i;
  304. INT8U ret,tmp[2];
  306. SD_StartSD(); /* 向OS申请访问卡信号量 request semaphore acessed SD/MMC to OS */
  307.     if (SD_ChkCard() != 1)
  308.     {
  309.      SD_EndSD();
  310.      return SD_ERR_NO_CARD;    /* 卡没完全插入卡中 card is not inserted entirely */
  311. }
  313. if ((blockaddr + blocknum) > sds.block_num)
  314. {
  315. SD_EndSD();
  316. return SD_ERR_OVER_CARDRANGE; /* 操作超出卡容量范围 operate over the card range */
  317. }
  319. if (SD_ChkCardWP() == 1)
  320. {
  321. SD_EndSD();
  322. return SD_ERR_WRITE_PROTECT; /* 卡有写保护 */
  323. }
  325. ret = SD_WriteMultipleBlock(blockaddr); /* 写多块命令 write multiple blocks command */
  326. if (ret != SD_NO_ERR)
  327. {
  328. SD_EndSD();
  329. return ret;
  330. }
  332.     for (i = 0; i < blocknum; i++)
  333.     {
  334.   ret = SD_WriteBlockData(1, SD_BLOCKSIZE, sendbuf); /* 写入数据 write data */
  335.   if (ret == SD_NO_ERR)
  336.   sendbuf = sendbuf + SD_BLOCKSIZE;
  337.   else
  338.   { /* 写失败 write fail */
  339. SD_StopTransmission(); /* 停止数据传输 stop data transmission */
  340. SD_WaitBusy(SD_WAIT_WRITE); /* 等待 waiting */
  341. SD_EndSD();
  342. return ret;
  343. }
  344. }
  345.    
  346.     SD_StopMultiToken(); /* 发送数据停止令牌 send data stop token */
  347.       
  348.     ret = SD_WaitBusy(SD_WAIT_WRITE); /* 等待写入的完成 wait for finishing writing */
  349.     if (ret != SD_NO_ERR)
  350.     {
  351.      SD_EndSD();
  352.      return SD_ERR_TIMEOUT_WRITE;
  353.     }
  354.     
  355.     if (sds.card_type == CARDTYPE_SD)
  356.     {
  357.     ret = SD_GetNumWRBlcoks(&i); /* 读正确写入的块数 read the blocks that be written correctly */
  358.     if (ret != SD_NO_ERR)
  359.     {
  360.     SD_EndSD();
  361.        return ret;
  362.     }
  363.     if(i != blocknum)
  364. ret =  SD_ERR_WRITE_BLKNUMS; /* 正确写入块数错误 the blocks that be written correctly is error */
  365.     }
  366.     else
  367.     {
  368.       ret = SD_ReadCard_Status(2, tmp);
  369.   if (ret != SD_NO_ERR)
  370.   {
  371.   SD_EndSD();
  372.   return ret; /* 读寄存器失败 read register fail */
  373. }
  374.   if((tmp[0] != 0) || (tmp[1] != 0))
  375. ret = SD_ERR_WRITE_BLK;        /* 响应指示写失败 response indicate write fail */
  376.     }
  377.      
  378.     SD_EndSD();         
  379. return ret; /* 返回写入成功 return write sucessfully */
  380. }
  381. #endif
  383. /*********************************************************************************************************************
  384. ** 函数名称: INT8U SD_EraseBlock() Name:   INT8U SD_EraseBlock()
  385. ** 功能描述: 擦除SD/MMC卡中的块 Function: Erase the block of SD/MMC card
  386. ** 输　  入: INT32U startaddr: 起始地址 Input:    INT32U startaddr: start address
  387.  INT32U endaddr  : 终止地址   INT32U endaddr  : end address
  388. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  389. ** 注    意: startaddr 和 blocknum 建议为 sds.erase_unit 的整数倍, 因为有的卡只能以 sds.erase_unit 为单位进行擦除
  390. *********************************************************************************************************************/
  391. #if SD_EraseBlock_EN
  392. INT8U SD_EraseBlock(INT32U startaddr, INT32U blocknum)
  393. {
  394. INT32 tmp;
  395. INT8U ret;
  397. SD_StartSD(); /* 向OS申请访问卡信号量 request semaphore acessed SD/MMC to OS */
  398.     if (SD_ChkCard() != 1)
  399.     {
  400.      SD_EndSD();
  401.      return SD_ERR_NO_CARD;    /* 卡没完全插入卡中 card is not inserted entirely */
  402. }
  404. if ((startaddr + blocknum) > sds.block_num)
  405. {
  406. SD_EndSD();
  407. return SD_ERR_OVER_CARDRANGE; /* 操作超出卡容量范围 operate over the card range */
  408. }
  410. if (SD_ChkCardWP() == 1)
  411. {
  412. SD_EndSD();
  413. return SD_ERR_WRITE_PROTECT; /* 卡有写保护 */
  414. }
  416. tmp = blocknum - sds.erase_unit;
  417. while(tmp >= 0)  /* 每次擦除扇区 once erase is sector size */
  418. {
  419. ret = SD_EraseStartBlock(startaddr); /* 选择起始块地址 select start address */
  420. if (ret != SD_NO_ERR)
  421. {
  422. SD_EndSD();
  423. return ret;
  424. }
  426. ret = SD_EraseEndBlock(startaddr + sds.erase_unit - 1); /* 选择终止块地址 select end address */
  427. if (ret != SD_NO_ERR)
  428. {
  429. SD_EndSD();
  430. return ret;
  431. }
  433. ret = SD_EraseSelectedBlock(); /* 擦除所选的块 erase blocks selected */
  434. if (ret != SD_NO_ERR)
  435. {
  436. SD_EndSD();
  437. return ret;
  438. }
  440. startaddr += sds.erase_unit; /* 起始地址递增 */
  441. blocknum  -= sds.erase_unit;
  442. tmp = blocknum - sds.erase_unit;
  443. };
  445. if (blocknum > 0) /* 擦除不够once_erase块 */
  446. { /* erase blocks that numbers is not enough once_erase */
  447. ret = SD_EraseStartBlock(startaddr);
  448. if (ret != SD_NO_ERR)
  449. {
  450. SD_EndSD();
  451. return ret;
  452. }
  454. ret = SD_EraseEndBlock(startaddr + blocknum - 1);
  455. if (ret != SD_NO_ERR)
  456. {
  457. SD_EndSD();
  458. return ret;
  459. }
  461. ret = SD_EraseSelectedBlock();
  462. if (ret != SD_NO_ERR)
  463. {
  464. SD_EndSD();
  465. return ret;
  466. }
  467. }
  469. SD_EndSD();
  470. return SD_NO_ERR; /* 返回擦除成功 return erase sucessfully */
  471. }
  472. #endif
  475. /*****************************************************************
  477.      下面为子程序
  478.  
  479. *****************************************************************/
  480. /*******************************************************************************************************************
  481. ** 函数名称: INT8U SD_GetCardInfo() Name:   INT8U SD_GetCardInfo()
  482. ** 功能描述: 获得SD/MMC卡的信息 Function: get the information of SD/MMC card
  483. ** 输　  入: INT8U cardtype: 卡类型 Input:    INT8U cardtype: card type
  484. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  485. *******************************************************************************************************************/
  486. INT8U SD_GetCardInfo()
  487. {
  488. INT32U tmp;
  489. INT8U csdbuf[16],ret;
  491. ret = SD_ReadCSD(16, csdbuf);        /* 读CSD寄存器    read CSD register */
  492. if (ret != SD_NO_ERR)
  493. return ret;
  495. SD_CalTimeout(csdbuf); /* 计算超时时间值 calculate timeout value */
  497. /* 计算块的最大长度  */ /* calculate the size of a sector */
  498. sds.block_len = 1 << (csdbuf[READ_BL_LEN_POS] & READ_BL_LEN_MSK);   /* (2 ^ READ_BL_LEN) */
  500. /* 计算卡中块的个数 */ /* calculate the sector numbers of the SD Card */
  501. sds.block_num = ((csdbuf[C_SIZE_POS1] & C_SIZE_MSK1) << 10) +
  502.         (csdbuf[C_SIZE_POS2] << 2) +
  503.     ((csdbuf[C_SIZE_POS3] & C_SIZE_MSK3) >> 6) + 1; /* (C_SIZE + 1)*/
  504.     
  505. tmp = ((csdbuf[C_SIZE_MULT_POS1] & C_SIZE_MULT_MSK1) << 1) +   
  506.       ((csdbuf[C_SIZE_MULT_POS2] & C_SIZE_MULT_MSK2) >> 7) + 2; /* (C_SIZE_MULT + 2) */
  507.     
  508.     /* 获得卡中块的数量 */ /* get the block numbers in card */
  509. sds.block_num = sds.block_num * (1 << tmp); /* (C_SIZE + 1) * 2 ^ (C_SIZE_MULT + 2) */
  511. /* 计算擦除的单位(单位: 块) */
  512. if (sds.card_type == CARDTYPE_MMC)
  513. {     
  514. tmp  = ((csdbuf[ERASE_GRP_SIZE_POS] & ERASE_GRP_SIZE_MSK) >> 2) + 1;   /* (ERASE_GRP_SIZE + 1)  */ 
  516. /* (ERASE_GRP_SIZE + 1) * (ERASE_GRP_MULTI + 1) */
  517. tmp *= ((csdbuf[ERASE_GRP_MULTI_POS1] & ERASE_GRP_MULTI_MSK1) << 3) +
  518.        ((csdbuf[ERASE_GRP_MULTI_POS2] & ERASE_GRP_MULTI_MSK2) >> 5) + 1;
  519. }
  520. else /*calculate the size of sector */
  521. tmp = ((csdbuf[SECTOR_SIZE_POS1] & SECTOR_SIZE_MSK1) << 1) +  
  522.           ((csdbuf[SECTOR_SIZE_POS2] & SECTOR_SIZE_MSK2) >> 7) + 1; /* SD: SECTOR_SIZE */
  524. sds.erase_unit = tmp;      /* 擦除单位(块) */ 
  526. return SD_NO_ERR; /* 返回执行成功 return perform sucessfully */
  527. }
  530. /*******************************************************************************************************************
  531. ** 函数名称: INT8U SD_CalTimeout() Name:   INT8U SD_CalTimeout()
  532. ** 功能描述: 计算读/写/擦超时时间 Function: calculate timeout of reading,writing,erasing
  533. ** 输　  入: INT8U *csdbuf : CSD寄存器内容 Input:    INT8U *csdbuf : CSD register content
  534. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  535. *******************************************************************************************************************/
  536. INT8U SD_CalTimeout(INT8U *csdbuf)
  537. {
  538. INT32U tmp;
  539. INT8U time_u,time_v,fator;
  541. sds.timeout_read = READ_TIMEOUT_100MS; /* 默认读超时为100ms */
  542. sds.timeout_write = WRITE_TIMEOUT_250MS; /* 默认写超时为250ms */
  543. sds.timeout_erase = WRITE_TIMEOUT_250MS;
  545. time_u = (csdbuf[TAAC_POS] & TAAC_MSK); /* 读超时时间单位 read timeout unit */
  546. time_v = (csdbuf[TAAC_POS] & NSAC_MSK) >> 3; /* 读超时时间值   read timeout value */
  547. fator = (csdbuf[R2WFACTOR_POS] & R2WFACTOR_MSK) >> 2; /* 读超时时间因数 read timeout factor */
  549. if(time_v == 0) return SD_ERR_CARD_PARAM; /* 卡参数有错误 card parameter is error */
  551. tmp = SPI_CLOCK * time_value[time_v] / 10 / time_unit[time_u]; /* TACC * f (单位 unit: clock) */
  552. tmp = tmp + csdbuf[NSAC_POS] * 100; /* TACC * f + NSAC * 100 (单位 unit: clock) */
  554. /* 计算得到的超时值 the timeout value of being calculated */
  555. sds.timeout_read = tmp;
  556. sds.timeout_write = tmp * r2w_fator[fator]; /* (TACC * f + NSAC * 100) * R2WFACTOR (单位 unit:clock)*/
  558. if (sds.card_type == CARDTYPE_SD)
  559. {
  560. sds.timeout_read  = sds.timeout_read * 100 / 8; /* 实际值为计算值的100倍 */
  561. sds.timeout_write = sds.timeout_write * 100 / 8;
  562. if (sds.timeout_read > READ_TIMEOUT_100MS) /* 取计算值与默认值中的最小值 */
  563. sds.timeout_read = READ_TIMEOUT_100MS;
  565. if (sds.timeout_write > WRITE_TIMEOUT_250MS)
  566. sds.timeout_write = WRITE_TIMEOUT_250MS;
  567. }
  568. else
  569. {
  570. sds.timeout_read  = sds.timeout_read * 10 / 8; /* 实际值为计算值的10倍 */
  571. sds.timeout_write = sds.timeout_write * 10 / 8;
  572. }
  574. sds.timeout_erase = sds.timeout_write;
  576. #if SD_UCOSII_EN
  577. sds.timeout_read = (sds.timeout_read << 3) * OS_TICKS_PER_SEC / SPI_CLOCK; 
  578. sds.timeout_write =(sds.timeout_write << 3) * OS_TICKS_PER_SEC / SPI_CLOCK;
  579. sds.timeout_erase = sds.timeout_write; /* (单位 unit: os tick) */
  580. #endif
  582. return SD_NO_ERR;
  583. }
  585. /*******************************************************************************************************************
  586. ** 函数名称: INT8U SD_ActiveInit() Name:   INT8U SD_ActiveInit()
  587. ** 功能描述: 激活卡,并获得卡型 Function: active card, and get the card type 
  588. ** 输　  入: 无   Input:    NULL
  589. ** 输    出: 0:   成功    >0:  错误码 Output:   0:  right >0:  error code
  590. ** 函数说明: 该命令不断重复发送到SD卡，直到响应R1的Bit0(Idle)位为0，表示SD卡内部初始化处理完成。
  591.      当响应的Idle位为0时，SD卡就完全进入SPI模式了。当然重复发送命令CMD1是有次数限制的，
  592.      最大次数为宏定义SD_IDLE_WAIT_MAX.
  593. *******************************************************************************************************************/
  594. INT8U SD_ActiveInit(void)
  595. {
  596. INT8U param[4] = {0,0,0,0},resp[5],ret;
  597. INT32U i = 0;
  599.   do 
  600.     { /* 发出CMD1, 查询卡的状态, send CMD1 to poll card status */
  601.         ret = SD_SendCmd(CMD1, param, CMD1_R, resp);
  602.         if (ret != SD_NO_ERR)
  603.         return ret;
  604.         i ++;
  605.     }while (((resp[0] & MSK_IDLE) == MSK_IDLE) && (i <= SD_IDLE_WAIT_MAX));
  606.      /* 如果响应R1的最低位Idle位为1,则继续循环 */
  607.      /* if response R1 Idle bit is 1,continue recycle */    
  608.     if (i >= SD_IDLE_WAIT_MAX)
  609.         return SD_ERR_TIMEOUT_WAITIDLE; /* 超时,返回错误 time out,return error */
  611.     ret = SD_SendCmd(CMD55, param, CMD55_R, resp);
  612.     if (ret != SD_NO_ERR)
  613.         return ret;
  614.        
  615.     ret = SD_SendCmd(ACMD41, param, ACMD41_R, resp); /* 激活内部初始化命令 active card to initialize process internal */
  616.     if (ret != SD_NO_ERR)
  617.      return SD_ERR_UNKNOWN_CARD;
  618.     
  619.     if ((resp[0] & 0xFE) == 0)
  620.        sds.card_type = CARDTYPE_SD; /* 是SD卡 the card is SD card */
  621.     else
  622.      sds.card_type = CARDTYPE_MMC; /* 是MMC卡 the card is MMC card */
  624. return SD_NO_ERR;
  625. }
  627. /*******************************************************************************************************************
  628. ** 函数名称: void SD_StartSD() Name:   INT8U SD_StartSD()
  629. ** 功能描述: 向操作系统申请访问SD卡的权限 Function: request the right of operating sd to OS
  630. ** 输　  入: 无 Input:   NULL
  631. ** 返  回: 无 return:   NULL
  632. ********************************************************************************************************************/
  633. void SD_StartSD(void)
  634. {
  635. #if SD_UCOSII_EN
  636. INT8U ret;
  638. OSSemPend(pSemSD, 0, &ret); /* 等待访问卡信号量可用 wait for semaphore that accessed Card */
  639. #endif
  640. }
  642. /*******************************************************************************************************************
  643. ** 函数名称: void SD_EndSD() Name:   INT8U SD_EndSD()
  644. ** 功能描述: 访问SD卡的权限归还操作系统 Function: return the right of operating sd to OS
  645. ** 输　  入: 无 Input:   NULL
  646. ** 返  回: 无 return:   NULL
  647. ********************************************************************************************************************/
  648. void SD_EndSD(void)
  649. {
  650. #if SD_UCOSII_EN
  651. OSSemPost(pSemSD); /* 将访问卡信号量还给操作系统 return the semaphore accessing Card to OS */
  652. #endif
  653. }
  656. /*******************************************************************************************************************
  657. ** 函数名称: INT16U SD_GetZLGSDVer() Name:   INT16U SD_GetZLGSDVer()
  658. ** 功能描述: 得到ZLG/SD的版本号 Function: get the version of ZLG/SD
  659. ** 输　  入: 无 Input:    NULL
  660. ** 输 　 出: 版本号 Output:   Version
  661. ** 版本记录:
  662.  V1.0   支持访问SD 卡,只能在前后台系统运行
  663.  
  664.  V2.0   支持访问SD和MMC卡,可运行于前后系统或UCOS-II
  665. *******************************************************************************************************************/
  666. INT16U SD_GetZLGSDVer(void)
  667. {
  668. return 0x0200; /* 版本号为 2.00 */
  669. }