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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
SD.c
资源名称：SDK_M5661.rar　[点击查看]
上传用户：hjhsjcl
上传日期：2020-09-25
资源大小：11378k
文件大小：52k
源码类别：

压缩解压

开发平台：

C++ Builder

SD.c：源码内容
  1. /*==========================================================================
  2. Copyright (c) 2004 ALi Corporation. All Rights Reserved
  3. File: SD.c
  4. content: SD control/read/write functions
  5. History: Created by Vicky Hsu 2004/07/01
  6. ==========================================================================*/
  7. #define _SD_H_
  8. #include "TypeDef.h"
  9. #include "Const.h"
  10. #include "Reg5661.h"
  11. #include "Common.h"
  12. #include "SD.h"
  13. #if(ENABLE_SD_FUNCTION)
  15. //vicky050506#1
  16. #define _SD_INIT_  0
  17. #define _SD_READ_  0
  18. #define _SD_WRITE_ 0
  20. #if(_SD_API_ATAPI_)
  21. #include "Usb.h"
  22. #include "Ata.h"
  24. #undef _SD_INIT_
  25. #undef _SD_READ_
  26. #undef _SD_WRITE_
  28. #define _SD_INIT_  1
  29. #define _SD_READ_  1
  30. #define _SD_WRITE_ 1
  31. #else
  32. #if(_SD_API_INIT_)
  33. #undef _SD_INIT_
  34. #define _SD_INIT_  1
  35. #endif
  37. #if(_SD_API_READ_)
  38. #undef _SD_READ_
  39. #define _SD_READ_ 1
  40. #endif
  42. #if(_SD_API_WRITE_)
  43. #undef _SD_WRITE_
  44. #define _SD_WRITE_ 1
  45. #endif
  46. #endif
  48. #if((_PM_USB_ | _PM_MPTEST_|_PM_MTP_INIT_)) //allen050530
  49. #define _SD_CLK_USE_USB 1
  50. #else
  51. #define _SD_CLK_USE_USB 0
  52. #endif
  53. //-------------------------------------------------------------------
  54. // Global variables
  55. //-------------------------------------------------------------------
  56. XBYTE  gfSDPowerUp; //Indicate that R1 Power UP bit=TRUE (i.e CMD1/ACMD41 PASS) //Walace070102#1
  57. XBYTE  gxbSDLastCardState; //the last card state of SD/MMC card
  58. #if(_SD_INIT_) //vciky050607#4
  59. XBYTE  gxbSd_cmd; //the divisor of SD Clock (function: controll SD clock <400KHZ.)
  60. XBYTE  gxbOCR[4];
  61. XDWORD gxdwSD_Blocklen; //the size of a block (it is 512 byte in most situation.) 
  62. #endif
  65. /*SD Card Only==========================================*/
  66. //
  67. /*not used now ==========================================*/
  68. //XBYTE  gxbSDSmallerBlockAllowed;//Vicky 0812 del
  69. //XBYTE  gxbSD_TRAN_SPEED;//Vicky 0812 del
  70. //XBYTE  gbSDLastCardCMD;//Vicky 0810 del
  71. //XWORD  gxwSDMaxBlockLength;//Vicky 0810 del 
  73. #if(_SD_API_ATAPI_)
  74. XDWORD gxdwLBA_address;//the LBA acceptd from PC (in  USB read/write)
  75. #endif
  76. //-------------------------------------------------------------------
  77. // Function prototype
  78. //-------------------------------------------------------------------
  79. //Card's State Diagram+Basic Command
  80. bit CMD0(void); //go idle state
  81. bit CMD1(void); //send_OP_COND(MMC only),Response=R3 (OCR)
  82. bit CMD2(void); //all send CID,Response=R2(CID).
  83. bit CMD3(void); //Set addr(MMC:00 01),Response=R1; Send addr (SD),Response=R6.
  84. bit CMD6(BYTE bAccess, BYTE bIndex, BYTE bValue, BYTE CMDSet);//Nick061103#1 switch mode
  85. bit CMD7(void); //select/deselect card,Response=R1.
  86. bit CMD8(void); //Nick061103 send interface condition
  87. bit CMD9(void); //send CSD,Response=R2.
  88. bit CMD12(bit fpolling); //stop transmition after multiple block read,Response=R1.
  89. bit CMD13(void); //send status,Response=R1.
  90. bit CMD16(void); //set blocklen,Response=R1.
  91. bit CMD55(bit fRCA); //App cmd;fRCA=TRUE,addressed cmd for (SD only).else, for ACMD41 in SD init(SD only).Response=R1.
  92. bit ACMD41(void); //send_OP_COND(SD only),Response=R3 (OCR)
  93. bit ACMD6(void); //set bus width(SD only--> 4 bit bus),Response=R1.
  94. bit ACMD23(WORD wlen) large; //SET_WR_BLK_ERASE_COUNT,Response=R1.
  95. void CMD1_PRE(void);
  96. void ACMD41_PRE(void);
  97. void CMD18PRE(DWORD dwLBA) large; //setting of muliple block read ,dwLBA=LBA
  98. void CMD25PRE(DWORD dwLBA) large; //setting of muliple block write ,dwLBA=LBA
  99. /*SET SD Arg ========================================*/
  100. void SDArg(void); //addressd SD in argument
  101. void MMCArg(void); //addressd MMC in argument
  102. void SDStuffArg(void); //all are stuff bits in argument
  103. void SDOCRArg(void); //OCR in argument
  104. /*Check SD/MMC Response REG ==============================*/
  105. void SD_CheckR1(void); //R1 (card status, 32 error bits)
  106. void SD_CheckR6(void); //R6 (get card's Relative addr.SD only)
  107. BYTE SD_CheckR7(void); //R7 (check supplied votage accepted by SD or not) //Nick061103
  108. void SD_CheckR3(void); //R3 (OCR, Operation Condition REG)
  109. void SD_CheckR2CSD(void) large; //R2 (CSD, Card Specific REG)
  110. //SD/MMC Common Func
  112. //void SD_POWER_OFF(void);
  113. void SD_POWER_ON(void);
  114. void  DETECT_SD_WP(void);
  115. void SD_Init1(void); //SD init400k  step1 func.
  116. void SD_Init2(void)large; //SD init400k  step2 func.
  117. void SD_Delay(unsigned int DelayCnt); //Delay func
  118. bit SD_CheckStatus(void)large; //check obSDCTRL(cmd_start),obSDSTS(cmd_busy)
  119. bit SDpolling(BYTE *bCmd, BYTE bStatus,bit fTrue) large; //polling until fTRUE (max value=0xffff)
  120. bit SD_RESP_DelayCount(BYTE bResponse) large; //polling until SD State =bResponse. (max value=0x8fff)
  122. /***************************************************************************
  123. SD/MMC API function
  124. ****************************************************************************/
  125. API void SD_POWER_OFF(void) //Vicky1005 remodify
  126. {
  127. PIN_SD_PDDAT|=SD_PD; //SD power on
  128. PIN_SD_PDDIR|=SD_PD; //PDJ(Output)
  130. #if(_SD_DET_PULL) //Walace060814#1 Write Protection Output High after power down SD
  131. PIN_SD_WPDIR&=(~SD_WP);
  132. obGPIOHPUEN |=SD_WP; 
  133. obGPIOHPUHI |=SD_WP; 
  134. #else
  135. PIN_SD_WPDAT|=SD_WP;
  136. PIN_SD_WPDIR|=SD_WP;
  137. #endif
  139. obGPIOGPUEN |=0x5F; 
  140. obGPIOGPUHI &=0xA0; 
  141. obCLKSDCTRL =0x50;//Vicky041130#1 /vicky050601#1
  142. gfSDinit = FALSE;
  143. gfSDWP = FALSE;//Vicky1019
  144. gxbSDMMCState = 0;//Nick061103
  145. //gfSDStop=FALSE;
  146. gfSDPowerUp=FALSE;
  147. gfSDPowerOn =FALSE;
  148. gxbSD_Error=0;
  149. gfR1Err=FALSE;//Vicky041126#2
  150. } 
  153. #if(_SD_API_INIT_) 
  154. /******************************************************************************************
  155. //  SD INIT FUNC
  156. *******************************************************************************************/
  157. /*--------------------------------------------------------------------------
  158. Description:
  159. SD Initialization.
  161. Global arguments:
  162. gfSDinit:  indicate that SD/MMC card had been initialized.
  163. gxbSd_cmd: the divisor to controll the SD/MMC Clock (<400KHZ)
  164. gfMediumChange:  indicate that FW need to let Host know medium change. (since SD insert and init OK).
  166. Returns:
  167. TRUE: SD/MMC card was initialized successfully.
  168. FALSE: SD/MMc card  was not initialized successfully.(including SD/MMC is not inserted)
  170. 2004/08/11: Edit by Vicky
  171. --------------------------------------------------------------------------*/
  172. API bit SD_Init_400K(void) //Vicky1019  //vicky050506#1
  173. {
  174.         
  175.        #if( _SD_DET_PULL)
  176.    //Nick060808 start
  177. PIN_SD_DETDIR&=(~SD_CD);  //Nick060308#1 add it
  178. PIN_SD_DET_PULL_EN|=SD_CD;
  179. PIN_SD_DET_PULL_HIGH|=SD_CD;   
  180. //Nick060808 end
  181. #else
  182. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:21
  183. PIN_SD_DETDAT&=~SD_CD;
  184. PIN_SD_DETDIR&=~SD_CD;
  185. #else
  186. PIN_SD_DETDAT|=SD_CD;
  187. PIN_SD_DETDIR|=SD_CD;
  188. #endif
  189. #endif
  190. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:21
  191. if(PIN_SD_DETDAT&SD_CD)
  192. #else
  193. if(!(PIN_SD_DETDAT&SD_CD)) //Card IN//Vicky1005 change
  194. #endif
  195. {
  196. #if( _SD_DET_PULL)
  197. PIN_SD_DET_PULL_EN&=(~SD_CD); //Nick060808 mark it
  198. #else
  199. PIN_SD_DETDIR&=(~SD_CD);//Vicky1019
  200. #endif
  201. #if(_SD_API_ATAPI_) //allen050530
  202. if(gfSDinit && (!gfSDStop)) //Have been Initialized OK
  203. return TRUE;
  204. #else
  205. if(gfSDinit) //Have been Initialized OK
  206. return TRUE;
  207. #endif
  209. #if(_SD_API_ATAPI_) //allen050530
  210. if( (!gfSDinit) && (!gfSDStop) ) //need to Initialize
  211. #else
  212. if(!gfSDinit ) //need to Initialize
  213. #endif
  214. {
  215. for(gxbSd_cmd=90;gxbSd_cmd<100;gxbSd_cmd++)
  216. {
  217. SD_Init1();
  218. SD_Init2();
  219. if(gfSDinit==TRUE)
  220. {
  221. gfMediumChange=TRUE;//Vicky 0816 add
  222. gxbSDretry=0;
  223. return TRUE;
  224. }
  225. }
  226. }
  227. }
  228. #if( _SD_DET_PULL)
  229. PIN_SD_DET_PULL_EN&=(~SD_CD); //Nick060808
  230. #else
  231. PIN_SD_DETDIR&=(~SD_CD);
  232. #endif
  233. SD_POWER_OFF();
  234. return FALSE;
  235. }
  236. #endif // _SD_API_INIT_
  238. #if(_SD_API_READ_) //vicky050506#1
  239. /*--------------------------------------------------------------------------
  240. Description:
  241. Read data from SD. (data target: SRAM )
  243. Arguments:
  245. Global arguments:
  246. gbStorTransLen: the number of blocks to be transfered.
  247. gbStorPath:  the addr of Target  (in SRAM)
  248. gdwStorLba:  the LBA of Source  (in SD/MMC Card)
  249. gxbSD_Error:  error code(the most significant nibble:SD CMD,the least significant nibble:error condition)
  250. gxbSDCardType: SD_MODE(SD),MMC_MODE(MMC)
  251. gfR1Err: TRUE,R1 report error.
  252. Returns: 
  253. TRUE: all data are transfered to SD.
  254. FALSE: some error occured.
  256. 2004/08/11: Edit by Vicky
  257. --------------------------------------------------------------------------*/
  258. bit SD_Read(void) large
  259. {
  260. // DWORD dwStorLba; //Nick061103 mark it
  261. WORD wtransferlen=(WORD)gbStorTransLen*0x0200;
  262. gxbSD_Error=0;
  263. //Nick060808 start
  264. #if(!SD_DET_USE_INT1)
  265. if(!SD_Det(SD_DET))
  266. goto SD_DMAreset;
  267. #else
  268. if(!gfSDinit)
  269. {
  270. SD_Det(SD_FORCE_REMOVE);
  271. goto SD_DMAreset;
  272. }
  273. #endif
  274. //Nick060808 end
  275. ClkSdEn();//Vicky041126#1
  276.   //Vicky051021#1
  277.  if( (gbStorTransLen==0) || //Check Length
  278.   (gdwStorLba>gxdwSD_Blocknum) ||  //Vicky051221#3
  279.     ((gdwStorLba+gbStorTransLen) >gxdwSD_Blocknum) //Check End LBA
  280.   )   
  281. {
  282. gxbSD_Error=ERR_SD_RES2|ERR_SD_OUTOFCAPA;//Vicky1019
  283. goto SD_DMAreset;
  284. }
  287. obRACTL &= RA_DMA_DISJ;
  288. obSOURCEPATHCTRL = 0x00; //Source Dis
  289. obTARGETPATHCTRL = 0x00; //Target Dis
  290. obMODSEL3 &= NOTBYPASS_RAJ; //not bypass RA
  291. obSOURCEPATHCTRL = 0x10; //Source SD
  292. obTARGETPATHCTRL = 0x00; //Target Dis
  293. obRACTL = RA_INIT; // DMA INI
  294. obRACTL = RA_NORMAL;
  295. obRACTL = RA_COPY_MODE;
  296. obRAINIADRL = (gbStorPath*0x0200) & 0xFF;
  297. obRAINIADRH = (((gbStorPath*0x0200) >> 8) & 0x1F);
  298. obRAINIADRH |= RA_ADDR_LOAD;
  299. obRABANKSIZEH = wtransferlen>>8;
  300. obRABANKSIZEL = (BYTE)wtransferlen;
  302. obSDBLOCKLENH = 02;
  303.      obSDBLOCKLENL = 00;
  304. obSDBLOCKNUM=gbStorTransLen-1;
  305. obRACTL |= RA_DMA_EN;
  306. //Nick061103 start
  307. if(gxbSDMMCState&SD_HIGH_CAPACITY)
  308. CMD18PRE(gdwStorLba);
  309. else
  310. CMD18PRE(gdwStorLba<<9);
  311. /* dwStorLba = (gdwStorLba<<9);
  312. CMD18PRE(dwStorLba);*/
  313. //Nick061103 end
  314. if(!SDpolling(&obSDCTRL,SD_CMD_START,0)) 
  315. {
  316. gxbSD_Error=ERR_SD_CMD_START;
  317. goto SD_DMAreset;
  318. }
  319. if(!SDpolling(&obSDSTS,SD_CMD_BUSY,0)) 
  320. {
  321. gxbSD_Error=ERR_SD_CMD18|ERR_SD_CMD_BUSY;
  322. goto SD_DMAreset;
  323. }
  325. if(!SDpolling(&obSDSTS,SD_DAT_TBUSY,0))
  326. {
  327. gxbSD_Error=ERR_SD_CMD12|ERR_SD_DATLINE_BUSY;
  328. goto SD_DMAreset;
  329. }
  330. if(!CMD12(FALSE))
  331. {
  332. gxbSD_Error|=ERR_SD_CMD12;
  333. goto SD_DMAreset;
  334. }
  335. if(!SD_RESP_DelayCount(SD_STATE_TRAN))
  336. {
  337. gxbSD_Error=ERR_SD_CMD12|ERR_SD_STATE;
  338. goto SD_DMAreset;
  339. }
  341. SD_DMAreset:
  342. obRACTL &= RA_DMA_DISJ;
  343. obSOURCEPATHCTRL = 0x00; //Source Dis
  344. obTARGETPATHCTRL = 0x00; //Target Dis
  345.  
  346. if(gxbSD_Error)
  347. {
  348. if((gxbSD_Error&ERR_SD_RES2)==ERR_SD_RES2) //Vicky041126#2
  349. return FALSE; //Vicky041126#2
  351. obSYSSOFTRSTCTRL &= SD_RST_ENJ;
  352. obSYSSOFTRSTCTRL |= SD_RST_DIS;  // Disable SD reset signal
  353. //gxbSD_Error=0; //Vicky041126#2
  354. SD_Det(SD_DET); //vicky050506#1 //Nick060808 add SD_DET
  355. return FALSE;
  356. }
  358. return TRUE;
  359. }
  360. #endif
  362. #if(_SD_API_WRITE_) //Vicky050506#1
  363. /*--------------------------------------------------------------------------
  364. Description:
  365. Write data to SD. (data source: SRAM )
  367. Arguments:
  369. Global arguments:
  370. gbStorTransLen: the number of blocks to be transfered.
  371. gbStorPath:  the addr of Source (in SRAM)
  372. gdwStorLba:  the LBA of Target  (in SD/MMC Card)
  373. gxbSD_Error:  error code(the most significant nibble:SD CMD,the least significant nibble:error condition)
  374. gxbSDCardType: SD_MODE(SD),MMC_MODE(MMC)
  375. gfR1Err: TRUE, R1 report error.
  376. Returns: 
  377. TRUE: all data are transfered to SD.
  378. FALSE: some error occured.
  380. 2004/08/11: Edit by Vicky
  381. --------------------------------------------------------------------------*/
  382. bit SD_Write(void) large
  383. {
  384. // DWORD dwStorLba; //Nick061103 mark it
  385. WORD wtransferlen=(WORD)gbStorTransLen*0x0200;
  386. gxbSD_Error=0;
  388. //Nick060808 start
  389. #if(!SD_DET_USE_INT1)
  390. if(!SD_Det(SD_DET))
  391. goto SD_DMAreset;
  392. #else
  393. if(!gfSDinit)
  394. {
  395. SD_Det(SD_FORCE_REMOVE);
  396. goto SD_DMAreset;
  397. }
  398. #endif
  399. //Nick060808 end
  402. ClkSdEn();//Vicky041126#1
  403. if(gfSDWP)
  404. {
  405. gxbSD_Error=ERR_SD_RES2|ERR_SD_WP;
  406. goto SD_DMAreset;
  407. }
  408. //Vicky051021#1
  409.  if( (gbStorTransLen==0) || //Check Length
  410.    (gdwStorLba>gxdwSD_Blocknum) ||  //Vicky051221#3
  411.     ((gdwStorLba+gbStorTransLen) >gxdwSD_Blocknum) //Check End LBA
  412.   )   
  413. {
  414. gxbSD_Error=ERR_SD_RES2|ERR_SD_OUTOFCAPA;
  415. goto SD_DMAreset;
  416. }
  417.  //
  419. obRACTL &= RA_DMA_DISJ;
  420. obSOURCEPATHCTRL = 0x00; //Source Dis
  421. obTARGETPATHCTRL = 0x00; //Target Dis
  423. obTCNTLDDATAL=(BYTE)(wtransferlen/2);
  424. obTCNTLDDATAH=(wtransferlen/2)>>8;
  425. obTCNTCTRL|=TCOUNT_LOAD;
  426. obTCNTCTRL&=TCOUNT_ENJ;
  428. obMODSEL3 &= NOTBYPASS_RAJ; //not bypass RA
  429. obRACTL = RA_INIT; // DMA INI
  430. obRACTL = RA_NORMAL;
  431. obSOURCEPATHCTRL = 0x00; //Source Dis
  432. obTARGETPATHCTRL = 0x10; //Target SD
  434. obRACTL = RA_COPY_MODE;
  435. obRAINIADRL = (gbStorPath*0x0200) & 0xFF;
  436. obRAINIADRH = (((gbStorPath*0x0200) >> 8) & 0x1F);
  437. obRAINIADRH |= RA_ADDR_LOAD;
  438. obRABANKSIZEH = wtransferlen>>8;
  439. obRABANKSIZEL = (BYTE)wtransferlen;
  440. obSDBLOCKLENH = 02;
  441.      obSDBLOCKLENL = 00;
  442. obSDBLOCKNUM=gbStorTransLen-1;
  443. // dwStorLba = (gdwStorLba<<9);//LBA is byte addressed for SD/MMC. //Nick061103 mark it
  444. if(gxbSDCardType == SD_MODE)
  445.      {
  446.      if(!CMD55(TRUE))
  447. {
  448. gxbSD_Error|=ERR_SD_CMD55;
  449. goto SD_DMAreset;
  450. }
  451. if(!ACMD23(gbStorTransLen))
  452. {
  453. gxbSD_Error|=ERR_SD_ACMD23;
  454. goto SD_DMAreset;
  455. }
  456. }
  457. //Nick061103 start
  458. if(gxbSDMMCState&SD_HIGH_CAPACITY)//Nick061103
  459. CMD25PRE(gdwStorLba);
  460. else
  461. CMD25PRE(gdwStorLba<<9);
  462. //Nick061103 end
  463. if(!SDpolling(&obSDCTRL,SD_CMD_START,0)) 
  464. {
  465. gxbSD_Error=ERR_SD_CMD25|ERR_SD_CMD_START;
  466. goto SD_DMAreset;
  467. }
  468. obRACTL |= RA_DMA_EN;
  469. if(!SDpolling(&obSDSTS,SD_CMD_BUSY,0)) 
  470. {
  471. gxbSD_Error=ERR_SD_CMD25|ERR_SD_CMD_BUSY;
  472. goto SD_DMAreset;
  473. }
  474. //modify by Nick 2006/03/06 mark it. neednt add this here. it just for debug purpose originally.
  475. //And gxbSDLastCardState=(obSDRESP2>>1)&0x0F; will let SD IP lunch command randomly and unexpectly.
  476. //SD_CheckR1();
  477. if(!SDpolling(&obSDSTS,SD_DAT_TBUSY,0)) 
  478. {
  479. gxbSD_Error=ERR_SD_CMD25|ERR_SD_DAT_TBUSY;
  480. goto SD_DMAreset;
  481. }
  482. if(!SDpolling(&obSDSTS,SD_DATLINE_BUSY,1)) 
  483. {
  484. gxbSD_Error=ERR_SD_CMD25|ERR_SD_DATLINE_BUSY;
  485. goto SD_DMAreset;
  486. }
  487. if(!CMD12(TRUE))
  488. {
  489. gxbSD_Error|=ERR_SD_CMD12;
  490. goto SD_DMAreset;
  491. }
  492. obSDCLOCKWIDTH |= 0x01;
  493. if(!SDpolling(&obSDSTS,SD_DATLINE_BUSY,1))
  494. {
  495. gxbSD_Error=ERR_SD_CMD12|ERR_SD_DATLINE_BUSY;
  496. goto SD_DMAreset;
  497. }
  498. obSDCLOCKWIDTH &= 0xFE;
  499.    
  500. if(!SD_RESP_DelayCount(SD_STATE_TRAN))
  501. {
  502. gxbSD_Error=ERR_SD_CMD12|ERR_SD_STATE;
  503. goto SD_DMAreset;
  504. }   
  505. if(!SDpolling(&obTCNTCTRL,TCOUNT_FINISH,0)) 
  506. {
  507. gxbSD_Error=ERR_SD_RES1;
  508. goto SD_DMAreset;
  509. }
  510. SD_DMAreset:
  511. obRACTL &= RA_DMA_DISJ;
  512. obTCNTCTRL|=TCOUNT_DIS;
  513. obTCNTCTRL&=TCOUNT_LOAD_DIS;
  514. obSOURCEPATHCTRL = 0x00; //Source Dis
  515. obTARGETPATHCTRL = 0x00; //Target Dis
  517. if(gxbSD_Error)
  518. {
  519. if((gxbSD_Error&ERR_SD_RES2)==ERR_SD_RES2) //Vicky041126#2
  520. return FALSE; //Vicky041126#2
  522. obSYSSOFTRSTCTRL &= SD_RST_ENJ;
  523. obSYSSOFTRSTCTRL |= SD_RST_DIS; // Disable SD reset signal
  524. //gxbSD_Error=0; //Vicky041126#2
  525. SD_Det(SD_DET); //vicky050506#1 //Nick060808 add SD_DET
  526. return FALSE;
  527. }
  529. return TRUE;
  530. }
  531. #endif //_SD_API_WRITE_
  533. /***************************************************************************
  534. SD/MMC Common Func
  535. ****************************************************************************/
  536. /*--------------------------------------------------------------------------
  537. Description:
  538. Check whether SD/MMC card is inserted or not.
  540. Returns: 
  541. TRUE: SD/MMC card is inseted.
  542. FALSE: SD/MMC card is not inseted.
  543. --------------------------------------------------------------------------*/
  544. bit SD_Det(BOOL fForceSDRemove)  //vicky050506#1 //Nick060808 add BOOL fForceSDRemove
  545. {
  546.        #if( _SD_DET_PULL)
  547.    //Nick060808 start
  548.     PIN_SD_DETDIR&=SD_CDJ; //Nick060308#1 add it
  549. PIN_SD_DET_PULL_EN|=SD_CD;
  550. PIN_SD_DET_PULL_HIGH|=SD_CD;
  551.    //Nick060808 end
  552. #else
  553. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:21
  554. PIN_SD_DETDAT&=~SD_CD;
  555. PIN_SD_DETDIR&=~SD_CD;
  556. #else
  557. PIN_SD_DETDAT|=SD_CD;
  558. PIN_SD_DETDIR|=SD_CD;
  559. #endif
  560. #endif
  562. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:24
  563. if((!(PIN_SD_DETDAT&SD_CD) )|| fForceSDRemove)//Vicky1005 change //Nick060808 add || fForceSDRemove
  564. #else
  565. if((PIN_SD_DETDAT&SD_CD) || fForceSDRemove)//Vicky1005 change //Nick060808 add || fForceSDRemove
  566. #endif
  567. {
  568.  #if( _SD_DET_PULL)
  569.  //Nick060308#1 begin
  570. // obGPIOEPUEN&=(~SD_CD);
  571.   PIN_SD_DET_PULL_EN&=SD_CDJ; //Nick060808
  572.  //Nick060308#1 end
  573.  #else
  574. PIN_SD_DETDIR&=(~SD_CD);
  575. #endif
  577. if(gfSDPowerOn)
  578. SD_POWER_OFF();
  580. gxbSD_Error=ERR_SD_RES2|ERR_SD_REMOVE;//Vicky060126#1 //vicky061208#1 Move to here
  581. return FALSE;
  582. }
  583.  #if( _SD_DET_PULL)
  584.  //Nick060308#1 begin
  585. // obGPIOEPUEN&=(~SD_CD);
  586.   PIN_SD_DET_PULL_EN&=SD_CDJ; //Nick060808 
  587.  //Nick060308#1 end
  588.  #else
  589. PIN_SD_DETDIR&=(~SD_CD);
  590. #endif
  592. return TRUE;
  593. }
  594. #if(_SD_INIT_|_SD_READ_|_SD_WRITE_)
  595. /******************************************************************************************
  596. //  Check the status of the command sent  to SD/MMC Card
  597. *******************************************************************************************/
  598. bit SD_CheckStatus(void) large //vicky050506#1
  599. {
  600. DWORD times; 
  601. if(!SD_Det(SD_DET)) //Nick060808 add SD_DET
  602. return FALSE;
  603. times = 200;//Vicky0909
  604. while((obSDCTRL&SD_CMD_START)&&times) 
  605. {times--;}
  607. if(!times)
  608.        {
  609.        gfSDinit = FALSE;
  610. gxbSD_Error=ERR_SD_CMD_START; 
  611.        return FALSE;
  612.        }
  613. times =1000;//Vicky0909
  614. while((obSDSTS&SD_CMD_BUSY)&&times)
  615.        {times--;}
  617. if(!times)
  618.        {
  619.        gfSDinit = FALSE;
  620. gxbSD_Error=ERR_SD_CMD_BUSY; 
  621.          return FALSE;
  622. }
  623. return TRUE;
  624. }
  626. /*--------------------------------------------------------------------------
  627. Description:
  628. Polling until the result of "*bCmd &bStatus" is equal to fTrue. 
  629. or Sd_DelayTemp is equal to zero.
  630. Arguments:
  631. bCmd: the addr of the Reg.
  632. bStatus: the value to be compared.
  633. Return:
  634. TRUE: the result of "*bCmd &bStatus" is equal to fTrue.
  635. FALSE: Sd_DelayTemp is equal to zero.
  636. 2004/08/11: Edit by Vicky
  637. --------------------------------------------------------------------------*/
  639. bit SDpolling(BYTE *bCmd, BYTE bStatus,bit fTrue) large
  640. {
  641. //DWORD Sd_DelayTemp=0x8FFFF;//Vicky 0816 dis
  642. DWORD Sd_DelayTemp; //Vicky0908 add
  643. Sd_DelayTemp=0xFFFFF;
  645. while(Sd_DelayTemp)
  646. {
  647. if( fTrue)
  648. {
  649. if(((*bCmd) & bStatus)==bStatus) 
  650. break;
  651. }
  652. else
  653. {
  654. if(((*bCmd) & bStatus)!=bStatus) 
  655. break;
  656. }
  657. Sd_DelayTemp--; 
  658. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:24
  659. if(!(PIN_SD_DETDAT&SD_CD)) //Walace050928 bug00059
  660. #else
  661. if(PIN_SD_DETDAT&SD_CD) //Walace050928 bug00059
  662. #endif
  663.         return FALSE;
  664.    
  665. }
  666. if(!Sd_DelayTemp) 
  667. return FALSE;
  668. return TRUE;
  669. }
  670. /*--------------------------------------------------------------------------
  671. Description:
  672. Polling until 
  673. gxbSDLastCardState is the same as bResponse 
  674. or Sd_DelayTemp is equal to zero .
  675. Arguments:
  676. bResponse:card's state 
  677. 0x00:IDLE, 0x01:READY, 0x02:IDENT, 0x03:STBY
  678. 0x04:TRAN, 0x05:DATA, 0x06:RCV, 0x07:PRG, 0x08:DIS-CON   
  679. Global arguments:
  680. gxbSDLastCardState: card's state, received from the response of CMD13.(i.e. R1) 
  681. --------------------------------------------------------------------------*/
  682. bit SD_RESP_DelayCount(BYTE bResponse) large//Vicky0908 modify
  683. {
  684. DWORD Sd_DelayTemp;
  685. Sd_DelayTemp=0xFFFFF;
  687. while(Sd_DelayTemp)
  688. {
  689. CMD13();
  690. SD_CheckR1();
  691. if(gxbSDLastCardState == bResponse)
  692. break;
  693. else
  694. Sd_DelayTemp--;
  695. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:24
  696. if(!(PIN_SD_DETDAT&SD_CD)) //Walace050928 bug00059
  697. #else
  698. if(PIN_SD_DETDAT&SD_CD) //Walace050928 bug00059
  699. #endif
  700.         return FALSE;
  701. }
  702. if(!Sd_DelayTemp) 
  703. return FALSE;
  704. return TRUE;
  705. }
  707. bit CMD13(void)
  708. {
  709.     obSDCMD = 0x0D;  // CMD13: SEND_STATUS
  710.     if(gxbSDCardType == SD_MODE)
  711.     {
  712.        SDArg();
  713.        obSDCTRL = SD_R1_AC_START;
  714.     }
  715.     else if(gxbSDCardType == MMC_MODE)
  716.     {
  717.        MMCArg();
  718.        obSDCTRL = MMC_R1_AC_START;
  719.     }
  720.     if(!SD_CheckStatus())
  721. return FALSE;
  722.     if(obSDSTS&SD_CRC_ERR)
  723.     {
  724.      SD_POWER_OFF();
  725.      return FALSE;
  726.     }
  727.     return TRUE;
  728. }
  730. //Common
  731. /***************************************************************************
  732. Wreite SD Arg  
  733. ***************************************************************************/
  734. //Arg: Addressed SD Card
  735. void SDArg(void)
  736. {
  737. obSDARG0=0x00;
  738.   obSDARG1=0x00;
  739.   obSDARG2=gxbRcaL;
  740.   obSDARG3=gxbRcaH;
  741. }
  742. //Arg: Addressed MMC Card 
  743. void MMCArg(void)
  744. {
  745.    obSDARG0=0x00;
  746.    obSDARG1=0x00;
  747.    obSDARG2=0x01;
  748.    obSDARG3=0x00;
  749. }
  750. //Arg: All Stuff bits
  751. void SDStuffArg(void)
  752. {
  753.    obSDARG0 = 0x00;
  754.    obSDARG1 = 0x00;
  755.    obSDARG2 = 0x00;
  756.    obSDARG3 = 0x00;
  757. }
  758. /******************************************************************************************
  759. //  SD Responses --- R1 (card status, 32 error bits)
  760. *******************************************************************************************/
  761. void SD_CheckR1(void)
  762. {
  763. //gbSDLastCardCMD=obSDRESP5;
  764. gxbSDLastCardState=(obSDRESP2>>1)&0x0F; 
  766. //Vicky051021#1 (Skip Out of Range Flag, FW will check END LBA)
  767. if((obSDRESP4&0x40)||(obSDRESP3&0xF8)) //Vicky041126#2
  768. gfR1Err=TRUE; //Vicky041126#2
  769. }
  770. #endif
  772. #if(_SD_INIT_)
  773. /*--------------------------------------------------------------------------
  774. Description:
  775. SD Initialization. Step 1. 
  777. Global arguments:
  778. gxbSd_cmd: the divisor to controll the SD/MMC Clock (<400KHZ)
  779. gxbSD_Error:  error code(the most significant nibble:SD CMD,the least significant nibble:error condition)
  781. 2004/08/11: Edit by Vicky
  782. --------------------------------------------------------------------------*/
  783. void SD_Init1(void)
  784. {
  785. SD_POWER_OFF();
  786. SD_POWER_ON();
  787. SD_Delay(0x2FFF);//Power-up to ready need more than 50msec.
  788. obSYSSOFTRSTCTRL &= SD_RST_ENJ;
  789. obSYSSOFTRSTCTRL |= SD_RST_DIS; // Disable SD reset signal
  790. gxbSD_Error=0;
  791.   // MMC Clock = 20MHz 0x(98,02),SD Clock= 24MHz 0x(88,03)
  792. // #if((_PM_USB_ | _PM_MPTEST_)) 050528
  793. #if(_SD_CLK_USE_USB)
  794.      obCLKSDDIVF = 0x02; 
  795.  obCLKSDCTRL = 0x98;
  796. #else
  797. //Nick060327#1 mark it and add it.the same clk source with MCU. begin
  798. // obCLKSDDIVF = 0x02;
  799. //  obCLKSDCTRL = 0xb8; //73(67)/4=18.25(16.75) //David
  800. obCLKSDDIVF = 0x06;
  801. obCLKSDCTRL = 0xC8;  
  802. //Nick060327#1 mark it and add it.the same clk source with MCU. end
  803. #endif
  805.      SD_Delay(500);
  806. obSDFREQDIV = gxbSd_cmd; //<400k 
  807. obSDCLOCKWIDTH &=0xFE;//Vicky0908 add 
  808. //obSDCLOCKWIDTH = gxbSd_cmd/2;   //Vicky0908 del
  809. }
  810. /*--------------------------------------------------------------------------
  811. Description:
  812. SD Initialization. Step 2. 
  814. Global arguments:
  815. gxbSd_cmd:   the divisor to controll the SD/MMC Clock (<400KHZ)
  816. gxbSD_Error:    error code(the most significant nibble:SD CMD,the least significant nibble:error condition)
  817. gxbSDCardType:   SD_MODE(SD),MMC_MODE(MMC)
  818.   gfSDinit:   TRUE, indicate SD/MMC Card had been initialized.
  819. gfSDWP:   TRUE, indicate SD/MMC Card is write-protected.
  820. gfSDPowerUp:  TRUE, indicate R1 Power UP bit=TRUE (i.e CMD1/ACMD41 PASS)
  821. gxbSDLastCardState:card's state, received from the response of CMD13.(i.e. R1) 
  823. 2004/08/11: Edit by Vicky
  824. --------------------------------------------------------------------------*/
  825. void SD_Init2(void) large
  826. {
  827.   WORD times; //retry times
  828.   gfSDinit = FALSE;
  829. gfSDWP=FALSE;
  830. gfSDPowerUp=FALSE;
  831. gxbSDMMCState = 0;//Nick061103
  832. CMD0();
  833.    CMD1_PRE();// This step is used to distinguish SD or MMC
  834.    SD_Delay(5000);   // Wait for CMD1 finished correctly//Vicky0909 change//Vicky0908 change
  835.    if((obSDSTS&SD_CMD_BUSY) == 0x00)   //MMC
  836.    {
  837.       gxbSDCardType = MMC_MODE;
  838. CMD1_PRE();     
  839.       if(!SD_CheckStatus())
  840.       return;     
  841.    }
  842. else //SD
  843.    { 
  844.    gxbSD_Error=0;
  845.      gxbSDCardType = SD_MODE;
  846. obSYSSOFTRSTCTRL&= SD_RST_ENJ;//SD reset.
  847. obSYSSOFTRSTCTRL|= SD_RST_DIS;//Disable SD reset.
  848.     //SD Clock=24MHz 0x(88,03)(usb);  24.3/22.3 MHz (b8,01)(DCV)
  849. // #if((_PM_USB_ | _PM_MPTEST_)) 050528
  850. #if(_SD_CLK_USE_USB)
  851.      obCLKSDDIVF = 0x03; //Vicky0908 add
  852. obCLKSDCTRL = 0x88;//Vicky0908 add
  853. #else
  854. //Nick060327#1 mark it and add it.the same clk source with MCU. begin
  855. // obCLKSDDIVF = 0x01;
  856. // obCLKSDCTRL = 0xb8; //73(67)/3=24.3(22.3) //David
  857. obCLKSDDIVF = 0x04;
  858. obCLKSDCTRL = 0xC8;
  859. //Nick060327#1 mark it and add it.the same clk source with MCU. end
  860. #endif
  861.      SD_Delay(50);
  862. obSDFREQDIV = gxbSd_cmd;
  863. obSDCLOCKWIDTH &=0xFE;//Vicky0908 add 
  864. //obSDCLOCKWIDTH = gxbSd_cmd/2; //Vicky0908 del 
  866. if(!CMD0())
  867. return;
  868. //Nick061103 start
  869. if(CMD8())
  870. {
  871. if(SD_CheckR7() != SD_VOTAGE_ACCEPT)
  872. return;
  873. gxbSDMMCState |= SD_20;
  874. }
  875. else
  876. {
  877. gxbSD_Error=0;
  878. obSYSSOFTRSTCTRL&= SD_RST_ENJ;//SD reset.
  879. obSYSSOFTRSTCTRL|= SD_RST_DIS;//Disable SD reset.
  880. obSDFREQDIV = gxbSd_cmd;
  881. obSDCLOCKWIDTH &=0xFE;//Vicky0908 add 
  882. }
  883. //Nick061103 end
  884.      if(!CMD55(FALSE))
  885.     return;
  886. ACMD41_PRE();    
  887.      if(!SD_CheckStatus())
  888.      return;     
  889. }//end of  check card type
  891. for(times=0;times<1000;times++)//Vicky 0809 change
  892. {
  893. SD_CheckR3();//Vicky0908 add 
  894.    if((obSDRESP4&SD_POWER_UP) == 0x80)
  895. {
  896. gfSDPowerUp=TRUE;
  897. //Nick061103 start
  898. if((gxbSDMMCState&SD_20) && (obSDRESP4&SD_CAPACITY_STATUS))
  899. gxbSDMMCState |= SD_HIGH_CAPACITY;
  900. //Nick061103 end
  901. break;
  902.    }
  903. else
  904. {
  905. gfSDPowerUp=FALSE;
  906. if(gxbSDCardType == MMC_MODE)
  907. {
  908. if(!CMD1())
  909. return;
  910. }
  911. else if(gxbSDCardType == SD_MODE)
  912. {
  913. if(!CMD55(FALSE))
  914. return;
  915.            if(!ACMD41())
  916. return;
  917. }
  918. }
  919. }
  920.  
  921. if(gfSDPowerUp==FALSE)
  922. return;
  923. gxbSD_Error=0;
  924. CMD2();
  926. if(!CMD3())
  927. return;
  928.    SD_CheckR6();
  929.    if(gxbSDLastCardState != SD_STATE_IDENT) 
  930. return;
  931.    if(!CMD9())
  932. return;
  933.    SD_CheckR2CSD();
  934.    if(!CMD7())
  935. return;
  936.    SD_CheckR1();
  937.    if(gxbSDLastCardState != SD_STATE_STBY)
  938.        return;
  939.    if(!CMD16())
  940. return;
  941.    if(gxbSDCardType == SD_MODE)
  942.    {  
  943. if(!CMD55(TRUE))
  944. return;
  945. if(!ACMD6()) // 4 bit bus width
  946. return;
  947. DETECT_SD_WP();
  948.   }
  949. //Nick061103#1 start
  950. if(gxbSDMMCState&MMC_Ver_40)
  951. {
  952. CMD6(Access_WriteByte, Index_BusWidth, 1, 0);//switch to 4 bit data bus
  954. if(CMD13())
  955. {
  956. if(!(obSDRESP0&0x80))//check if switch error
  957. {
  958. gxbSDMMCState |= MMC_4bit_data_bus;
  959. }
  960. }
  961. }
  962. //Nick061103#1 end
  963. gxbSD_Error=0;
  964. gfR1Err=FALSE;//Vicky041126#2
  966.    gfSDinit = TRUE;
  967. obSDFREQDIV = 0x01;  
  968.    obSDCLOCKWIDTH = 0x00;    
  969. }
  970. //Nick060309#1 mark it and add it. begin
  971. /*
  972. void SD_POWER_ON(void) //Vicky1005 remodify
  973. {
  974. PIN_SD_PDDAT&=SD_PDJ; //SD power on
  975. PIN_SD_PDDIR|=SD_PD; //PDJ(Output)
  976. obMODSEL1|=MOD_SD_EN;
  977. obGPIOGPUEN&=0xA0;
  978. gfSDPowerOn=TRUE;
  979. }
  980. */
  981. void SD_POWER_ON(void) //Vicky1005 remodify 
  982. {
  983. BYTE  j;
  984. WORD i;
  985. PIN_SD_PDDIR|=SD_PD; //PDJ(Output)
  986. for(i=0; i < 0x1FE; i++)
  987. {
  988. PIN_SD_PDDAT&=SD_PDJ; //SD power on
  990. PIN_SD_PDDAT|=SD_PD; //SD power off
  992. for(j = 0; j < 0x5F; j++){}
  993. }
  994. PIN_SD_PDDAT&=SD_PDJ; //SD power on
  995. obGPIOGPUEN &= 0xA0; // disable pull resistor on GPIOG0,1,2,3,4,6
  996. obMODSEL1|=MOD_SD_EN;
  997. gfSDPowerOn=TRUE;
  999. }
  1001. //Nick060309#1 mark it and add it. end
  1002. /*--------------------------------------------------------------------------
  1003. Description:
  1004. Check whether SD Card is write-protected or not.(SD Card Only)
  1006. Global arguments:
  1007. gfSDWP: TRUE, indicate that SD Card is write-protected.
  1009. 2004/08/11: Edit by Vicky
  1010. --------------------------------------------------------------------------*/
  1011. void  DETECT_SD_WP(void) //Vicky01019 //vicky050506#1
  1012. {
  1013. #if(SETTING_FOR_ICE_START|(SD_WP_SWTICH==0)) //allen050628 //Vicky060606#1
  1014. if(DEBUG_SDWP) //050528
  1015. gfSDWP=TRUE;
  1016. else
  1017. gfSDWP=FALSE;
  1018. #else
  1019. #if(_SD_DET_PULL)
  1020. PIN_SD_WPDIR&=(~SD_WP);
  1021. obGPIOHPUEN |=SD_WP; 
  1022. obGPIOHPUHI |=SD_WP; 
  1023. #else
  1024. PIN_SD_WPDAT|=SD_WP;
  1025. PIN_SD_WPDIR|=SD_WP;
  1026. #endif
  1028. gfSDWP=FALSE;
  1029. if(PIN_SD_WPDAT&SD_WP)
  1030. gfSDWP=TRUE;
  1032. #if(_SD_DET_PULL)
  1033. obGPIOHPUEN &=(~SD_WP); 
  1034. #else
  1035. PIN_SD_WPDIR&=(~SD_WP);
  1036. #endif
  1037. #endif
  1038. }
  1039. //Basic command
  1040. bit CMD0(void)
  1041. {
  1042. obSDCMD = 0x00;  // CMD0: GO_IDLE_STATE
  1043. SDStuffArg();  
  1044.      obSDCTRL = 0x01;
  1045.      SD_Delay(1000);//Vicky 0810 del 
  1046.       if(!SD_CheckStatus())
  1047. return FALSE;
  1048.      if(obSDSTS&SD_CRC_ERR) 
  1049. return FALSE;
  1050. return TRUE;
  1051. }
  1052. void CMD1_PRE(void)
  1053. {
  1054. obSDCMD = 0x01;
  1055.    obSDARG3 = 0x00;
  1056.    obSDARG2 = 0xFF;
  1057.    obSDARG1 = 0x00;
  1058.    obSDARG0 = 0x00;
  1059.    obSDCTRL = MMC_MODE&SD_RESP_R3|SD_CMD_BCR|SD_CMD_START;
  1060. }
  1061. bit CMD1(void)
  1062. {
  1063. if(gxbSd_cmd<91)//Vicky0908 add
  1064. {
  1065. obSDCMD = 0x01;  // CMD1: SEND_OP_COND    
  1066.      SDOCRArg();
  1067.      obSDCTRL = MMC_MODE|SD_RESP_R3|SD_CMD_BCR|SD_CMD_START;  //0x33
  1068. }
  1069. else
  1070. CMD1_PRE();
  1072.      if(!SD_CheckStatus())
  1073. return FALSE;
  1074.      if(obSDSTS&SD_CRC_ERR)
  1075. return FALSE;
  1076. return TRUE;
  1077. }
  1078. bit CMD2(void)
  1079. {
  1080. obSDCMD = 0x02;  // CMD2: ALL_SEND_CID
  1081.      SDStuffArg();
  1082.      if(gxbSDCardType == SD_MODE)
  1083. {obSDCTRL = SD_MODE|SD_RESP_R2|SD_CMD_BCR|SD_CMD_START;}
  1084.      else if(gxbSDCardType == MMC_MODE)
  1085.      {obSDCTRL = MMC_MODE&SD_RESP_R2|SD_CMD_BCR|SD_CMD_START;}
  1086.      if(!SD_CheckStatus())
  1087. return FALSE;
  1088.      if(obSDSTS&SD_CRC_ERR)
  1089. return FALSE;
  1090. return TRUE;
  1091. }
  1092. bit CMD3(void)
  1093. {
  1094. obSDCMD = 0x03;  
  1095.      if(gxbSDCardType == SD_MODE)// CMD3: SEND_RELATIVE_ADDR
  1096.      {
  1097.         SDStuffArg();
  1098.         obSDCTRL = SD_MODE|SD_RESP_R6|SD_CMD_BCR|SD_CMD_START;
  1099.      }
  1100.      else if(gxbSDCardType == MMC_MODE)// CMD3: SET_RELATIVE_ADDR
  1101.      {
  1102.         MMCArg();
  1103.         obSDCTRL =MMC_R1_AC_START;
  1104.      }
  1105.      if(!SD_CheckStatus())
  1106. return FALSE;
  1107.      if(obSDSTS&SD_CRC_ERR)
  1108. return FALSE;
  1109. return TRUE;
  1110. }
  1111. //Nick061103#1 start MMC 40 later only
  1112. bit CMD6(BYTE bAccess, BYTE bIndex, BYTE bValue, BYTE CMDSet)
  1113. {
  1114. obSDCMD = 0x06;  // CMD6: switch
  1116.    obSDARG0=CMDSet;
  1117.    obSDARG1=bValue;
  1118.    obSDARG2=bIndex;
  1119.    obSDARG3=bAccess;
  1120.        obSDCTRL =MMC_R1_AC_START;
  1121.    
  1122.      if(!SD_CheckStatus())
  1123. return FALSE;
  1124.      if(obSDSTS&SD_CRC_ERR)
  1125. return FALSE;
  1126. return TRUE;
  1127. }
  1128. //Nick061103#1 end
  1129. bit CMD7(void)
  1130. {
  1131. obSDCMD = 0x07;  // CMD7: SELECT/DESELECT_CARD
  1132.      if(gxbSDCardType == SD_MODE)
  1133.      {
  1134. SDArg();
  1135.         obSDCTRL = SD_R1_AC_START;
  1136.      }
  1137.      else if(gxbSDCardType == MMC_MODE)
  1138.      {
  1139.         MMCArg();
  1140.         obSDCTRL =MMC_R1_AC_START;
  1141.     }
  1142.      if(!SD_CheckStatus())
  1143. return FALSE;
  1144.      if(obSDSTS&SD_CRC_ERR)
  1145. return FALSE;
  1146. return TRUE;
  1147. }
  1148. //Nick061103 start
  1149. bit CMD8(void)
  1150. {
  1151. obSDCMD = 0x08;  // CMD8: send interface condition SEND_IF_COND
  1152.         
  1153. obSDARG0=SD_CMD8_CHECK_PATTERN;//check pattern
  1154.   obSDARG1=0x01; //supply votage 0001b 2.7~3.6V
  1155.   obSDARG2=0x00;//reserved bit
  1156.   obSDARG3=0x00; //reserved bit
  1157. //actually response of CMD9 is R7, but it's 48 bits, the same with R6. 
  1158.     obSDCTRL = SD_MODE|SD_RESP_R6|SD_CMD_BCR|SD_CMD_START;
  1159.     
  1160.      if(!SD_CheckStatus())
  1161. return FALSE;
  1162.      if(obSDSTS&SD_CRC_ERR)
  1163. return FALSE;
  1164. return TRUE;
  1165. }
  1167. //Nick061103 end
  1169. bit CMD9(void)
  1170. {
  1171. obSDCMD = 0x09;  // CMD9: SEND_CSD
  1172.      if(gxbSDCardType == SD_MODE)
  1173.      {
  1174.         SDArg();
  1175.         obSDCTRL = SD_MODE|SD_RESP_R2|SD_CMD_AC_CMD|SD_CMD_START;
  1176.      }
  1177.      else if(gxbSDCardType == MMC_MODE)
  1178.      {
  1179.         MMCArg();
  1180.         obSDCTRL = MMC_MODE&SD_RESP_R2|SD_CMD_AC_CMD|SD_CMD_START;
  1181.      }
  1182.      if(!SD_CheckStatus())
  1183. return FALSE;
  1184.      if(obSDSTS&SD_CRC_ERR)
  1185. return FALSE;
  1186. return TRUE;
  1187. }
  1189. bit CMD16(void)
  1190. {
  1191.     obSDCMD = 0x10;  // CMD16: SET_BLOCKLEN
  1192.     obSDARG3 = 0x00;
  1193.     obSDARG2 = 0x00;
  1194.     obSDARG1 = 0x02;
  1195.     obSDARG0 = 0x00;
  1197.     gxdwSD_Blocknum = gxdwSD_Blocknum * (gxdwSD_Blocklen/512); //Nick060425#1
  1198.     gxdwSD_Blocklen = 512;
  1200.     if(gxbSDCardType == SD_MODE)
  1201.           obSDCTRL = SD_R1_AC_START;    
  1202.     else if(gxbSDCardType == MMC_MODE)
  1203.            obSDCTRL = MMC_R1_AC_START;
  1204.     
  1205.     if(!SD_CheckStatus())
  1206. return FALSE;
  1207.     if(obSDSTS&SD_CRC_ERR)
  1208. return FALSE;
  1209.     return TRUE;
  1210. }
  1212. bit ACMD6(void)
  1213. {
  1214. obSDCMD = 0x06;  // ACMD6: SET_BUS_WIDTH
  1215. obSDARG3 = 0x00;
  1216. obSDARG2 = 0x00;
  1217. obSDARG1 = 0x00;
  1218. obSDARG0 = 0x02;
  1219. obSDCTRL = SD_R1_AC_START;
  1220. if(!SD_CheckStatus())
  1221. return FALSE;
  1222. if(obSDSTS&SD_CRC_ERR)
  1223. return FALSE;
  1224. return TRUE;
  1225. }
  1227. void ACMD41_PRE(void)
  1228. {
  1229. obSDCMD = 0x29;
  1230. if(gxbSDMMCState&SD_20) //Nick061103
  1231. {
  1232.      obSDARG3 = 0x40; //support HCS
  1233.      obSDARG2 = 0xFF; //support votage range 2.7~3.6
  1234.      obSDARG1 = 0x80; //support votage range 2.7~3.6
  1235.      obSDARG0 = 0x00;
  1236. }
  1237. else
  1238. {
  1239.      obSDARG3 = 0x00;
  1240.      obSDARG2 = 0xFF;
  1241.      obSDARG1 = 0x00;
  1242.      obSDARG0 = 0x00;
  1243. }
  1244.      obSDCTRL = SD_MODE|SD_RESP_R3|SD_CMD_BCR|SD_CMD_START;
  1245. }
  1247. bit ACMD41(void)
  1248. {
  1249.     obSDCMD = 0x29;  // ACMD41: SD_APP_OP_COND
  1250.     SDOCRArg();
  1251.     obSDCTRL = SD_MODE|SD_RESP_R3|SD_CMD_BCR|SD_CMD_START;  //0xB3
  1252.     if(!SD_CheckStatus())
  1253. return FALSE;;
  1254.     if(obSDSTS&SD_CRC_ERR)
  1255. return FALSE;
  1256. return TRUE;
  1257. }
  1258. // REG
  1259. //Arg: OCR, Operation Condition REG  
  1260. void SDOCRArg(void)
  1261. {
  1262.    obSDARG0=gxbOCR[0];
  1263.    obSDARG1=gxbOCR[1];
  1264.    obSDARG2=gxbOCR[2];
  1265.    obSDARG3=gxbOCR[3];
  1266. }
  1267. //Nick061103 start
  1268. BYTE SD_CheckR7(void)
  1269. {
  1270.      if(obSDSTS&SD_CRC_ERR)
  1271. return SD_CRC_ERR;
  1272. if(obSDRESP1 != 0xAA)
  1273. return SD_CMD8_CHECK_PATTERN_ERR;
  1274. if((obSDRESP2&0x0F) != 0x01)
  1275. return SD_CMD8_VOTAGE_NOT_SUPPORT;
  1277. return SD_VOTAGE_ACCEPT;
  1278. }
  1279. //Nick061103 end
  1281. //R6 (get card's Relative addr.SD only)
  1282. void SD_CheckR6(void)
  1283. {
  1284. //gbSDLastCardCMD=obSDRESP5;
  1285. gxbSDLastCardState=(obSDRESP2>>1)&0x0F;
  1286.      if(gxbSDCardType==SD_MODE)
  1287.      {             
  1288.      gxbRcaL=obSDRESP3;
  1289.          gxbRcaH=obSDRESP4;
  1290.      } 
  1291. }
  1292. //R3 (OCR, Operation Condition REG)
  1293. void SD_CheckR3(void)
  1294. {
  1295.     gxbOCR[0]=obSDRESP1;  // OCR bit[ 7: 0]
  1296.     gxbOCR[1]=obSDRESP2;  // OCR bit[15: 8]
  1297.     gxbOCR[2]=obSDRESP3;  // OCR bit[23:16]
  1298.     gxbOCR[3]=obSDRESP4;  // OCR bit[31:24]
  1299. }
  1300. //R2 (CSD, Card Specific REG)
  1301. void SD_CheckR2CSD(void) large //Vicky1005 remodify
  1302. { 
  1303. XBYTE c_size_mult;
  1304. //BYTE c_size_mult_0,c_size_mult_1;
  1305. DWORD c_size;
  1306. //WORD c_size_0,c_size_1,c_size_2;
  1307. WORD mult;
  1308. BYTE rd_block_len;
  1309. //BYTE wr_block_len;//Vicky 0812 del 
  1311. //c_size_mult_0=obSDRESP5&0x80;
  1312. //c_size_mult_1=obSDRESP6&0x03;
  1313. //c_size_mult=(c_size_mult_0>>7)|(c_size_mult_1<<1);
  1314. SD_Delay(100);//Vicky1005 add(important, can't del)
  1315. c_size_mult=((obSDRESP5&0x80)>>7)+((obSDRESP6&0x03)<<1);
  1316. //c_size_mult=((0x80)>>7)+((obSDRESP6&0x03)<<1);
  1317. switch(c_size_mult)
  1318. {
  1319. case 0:mult=4;break;
  1320. case 1:mult=8;break;
  1321. case 2:mult=16;break;
  1322. case 3:mult=32;break;
  1323. case 4:mult=64;break;
  1324. case 5:mult=128;break;
  1325. case 6:mult=256;break;
  1326. case 7:mult=512;break;
  1327. default:mult=1024;break;
  1328. }
  1330. //c_size_0=obSDRESP7&0xC0;
  1331. //c_size_1=obSDRESP8;
  1332. //c_size_2=obSDRESP9&0x03;
  1333. //c_size=(c_size_0>>6)|(c_size_1<<2)|(c_size_2<<10);
  1334. if(gxbSDMMCState&SD_HIGH_CAPACITY) //Nick061103 start
  1335. {
  1336. c_size = (((DWORD)(obSDRESP8&0x3F))<<16) |(((DWORD)obSDRESP7)<<8) |((DWORD)obSDRESP6);
  1337. gxdwSD_Blocknum = (c_size+1) << 10;
  1338. }
  1339. else
  1340. {
  1341. c_size=(((WORD)(obSDRESP7&0xC0))>>6)+(((WORD)(obSDRESP8))<<2)+(((WORD)obSDRESP9&0x03)<<10);
  1343. gxdwSD_Blocknum=((DWORD)(c_size+1)*(DWORD)mult); //Vicky051021#1
  1344. }//Nick061103 end
  1346. //gxdwSD_Blocknum=((DWORD)(c_size+1)*(DWORD)mult); //Vicky051021#1 //Nick061103 remove
  1347. rd_block_len=obSDRESPA&0x0F;
  1348. //wr_block_len=((obSDRESP2&0xC0)>>6)|((obSDRESP3&0x03)<<2);//Vicky 0812 del
  1349. //if(rd_block_len!=wr_block_len) gxwSDMaxBlockLength=0x8000;
  1350. //Nick061103 start
  1351. gxdwSD_Blocklen = 1;
  1352. gxdwSD_Blocklen <<= rd_block_len;
  1353. /* switch(rd_block_len)
  1354. {
  1355. case 0:gxdwSD_Blocklen=1;break;
  1356. case 1:gxdwSD_Blocklen=2;break;
  1357. case 2:gxdwSD_Blocklen=4;break;
  1358. case 3:gxdwSD_Blocklen=8;break;
  1359. case 4:gxdwSD_Blocklen=16;break;
  1360. case 5:gxdwSD_Blocklen=32;break;
  1361. case 6:gxdwSD_Blocklen=64;break;
  1362. case 7:gxdwSD_Blocklen=128;break;
  1363. case 8:gxdwSD_Blocklen=256;break;
  1364. case 9:gxdwSD_Blocklen=512;break;
  1365. case 10:gxdwSD_Blocklen=1024;break;
  1366. case 11:gxdwSD_Blocklen=2048;break;
  1367. case 12:
  1368. case 13:
  1369. case 14:
  1370. case 15:gxdwSD_Blocklen=4096;break;
  1371. }*/
  1372. //Nick061103 end
  1374. //gxwSDMaxBlockLength=gxwSDMaxBlockLength|gxdwSD_Blocklen; //Vicky1005
  1375. //Vicky 0812 del
  1376. /*
  1377. gxbSDSmallerBlockAllowed=0;
  1378. if(obSDRESP9&0x80) //Read_BL_partial
  1379. gxbSDSmallerBlockAllowed=0x01;
  1380. if(obSDRESP2&0x20) //Write_BL_partial
  1381. gxbSDSmallerBlockAllowed=gxbSDSmallerBlockAllowed|0x10;
  1382. */
  1383. //gxbSD_TRAN_SPEED=obSDRESPC;//Vicky 0812 del
  1384. //temp1=obSDRESP5;
  1385. if(obSDRESP1&0x20)
  1386. gfSDWP=TRUE;
  1387. //Nick061103#1 start
  1388. if((gxbSDCardType == MMC_MODE) && ((obSDRESPF&0x3C) == 0x10))//check if MMC 4.0
  1389. gxbSDMMCState |= MMC_Ver_40;
  1390. //Nick061103#1 end
  1391. #if(SETTING_FOR_ICE_START|(SD_WP_SWTICH==0)) //allen050628 //Vicky060606#1
  1392. if(DEBUG_SDWP) //050528
  1393. gfSDWP=TRUE;
  1394. else
  1395. gfSDWP=FALSE;
  1396. #endif
  1398. return;
  1399. }
  1400. //Tool
  1401. void SD_Delay(unsigned int DelayCnt) 
  1402. {
  1403. while(DelayCnt) {DelayCnt--;}
  1404. }
  1406. #endif
  1408. //Basic Command
  1409. #if(_SD_READ_|_SD_WRITE_)
  1410. bit CMD12(bit fpolling)  // Stop Command for Write
  1411. {
  1412. obSDCMD = 0x0C;  // CMD12: STOP_TRANSMISSION
  1413.      SDStuffArg();
  1414.      if(gxbSDCardType == SD_MODE)
  1415. {obSDCTRL =SD_R1_AC_START;}  // obSDCTL = 0x95
  1416.      else if(gxbSDCardType == MMC_MODE)
  1417.      {obSDCTRL = MMC_R1_AC_START;}
  1418.      if(!SD_CheckStatus())
  1419.          return FALSE;
  1421. if(fpolling)
  1422. {
  1423. if(!SDpolling(&obSDSTS,SD_DAT_TBUSY,0)) 
  1424. {
  1425. gxbSD_Error=ERR_SD_DAT_TBUSY; 
  1426. return FALSE;
  1427. }
  1428. }
  1430.      if(obSDSTS&SD_CRC_ERR)
  1431. {
  1432. gxbSD_Error=ERR_SD_CRC;
  1433. SD_POWER_OFF();//Vicky 0817 add
  1434. return FALSE;
  1435. }
  1436. return TRUE;
  1437. }
  1438. #endif
  1440. #if(_SD_READ_)
  1441. void CMD18PRE(DWORD dwLBA) large
  1442. {
  1443. obSDCMD = 0x12;
  1444. obSDARG3 = *((BYTE*)&dwLBA + 0);
  1445. obSDARG2 = *((BYTE*)&dwLBA + 1);
  1446. obSDARG1 = *((BYTE*)&dwLBA + 2);
  1447. obSDARG0 = *((BYTE*)&dwLBA + 3);
  1449. if(gxbSDCardType == SD_MODE || gxbSDMMCState&MMC_4bit_data_bus)//Nick061103#1
  1450. {obSDCTRL = SD_MODE|SD_RESP_R1|SD_CMD_ADTC_RD|SD_CMD_START;}
  1451. else if(gxbSDCardType == MMC_MODE)
  1452. {obSDCTRL = MMC_MODE&SD_RESP_R1|SD_CMD_ADTC_RD|SD_CMD_START;}
  1453. }
  1454. #endif
  1456. #if(_SD_WRITE_)
  1457. bit CMD55(bit fRCA)
  1458. {
  1459. obSDCMD = 0x37;  // CMD55: APP_CMD
  1460. if(fRCA)
  1461. SDArg();
  1462. else
  1463. SDStuffArg();   
  1464.   obSDCTRL = SD_R1_AC_START;  //0x95
  1465.      if(!SD_CheckStatus())
  1466. return FALSE;
  1467.      if(obSDSTS&SD_CRC_ERR) 
  1468. {
  1469. gxbSD_Error=ERR_SD_CRC;
  1470. return FALSE;
  1471.      }
  1472. return TRUE;
  1473. }
  1474. bit ACMD23(WORD wlen) large
  1475. {
  1476. obSDCMD = 0x17;  // ACMD23: SET_WR_BLK_ERASE_COUNT
  1477. obSDARG3 = 0x00;
  1478. obSDARG2 = 0x00;
  1479. obSDARG1 = *((BYTE*)&wlen + 0);
  1480. obSDARG0 = *((BYTE*)&wlen + 1);
  1481. obSDCTRL = SD_R1_AC_START;//0x95
  1482. if(!SD_CheckStatus())
  1483. return FALSE;
  1484. if(obSDSTS&SD_CRC_ERR)
  1485. {
  1486. gxbSD_Error=ERR_SD_CRC;
  1487. SD_POWER_OFF();
  1488. return FALSE;
  1489. }
  1490. return TRUE;
  1491. }
  1492. void CMD25PRE(DWORD dwLBA) large
  1493. {
  1494. obSDCMD = 0x19;
  1495. obSDARG3 = *((BYTE*)&dwLBA + 0);
  1496. obSDARG2 = *((BYTE*)&dwLBA + 1);
  1497. obSDARG1 = *((BYTE*)&dwLBA + 2);
  1498. obSDARG0 = *((BYTE*)&dwLBA + 3);
  1500. if(gxbSDCardType == SD_MODE || gxbSDMMCState&MMC_4bit_data_bus)//Nick061103#1
  1501.         {obSDCTRL = SD_MODE|SD_RESP_R1|SD_CMD_ADTC_WR|SD_CMD_START;}
  1502. else if(gxbSDCardType == MMC_MODE)
  1503.         {obSDCTRL = MMC_MODE&SD_RESP_R1|SD_CMD_ADTC_WR|SD_CMD_START;}
  1504. }
  1505. #endif
  1507. #if(_SD_API_ATAPI_)
  1508. API void CardDetach(void) //Vicky1019  //Vicky050506#1
  1509. {
  1510.        #if( _SD_DET_PULL)
  1511.    //Nick060808 start
  1512. PIN_SD_DETDIR&=(~SD_CD);
  1513. PIN_SD_DET_PULL_EN|=SD_CD;
  1514. PIN_SD_DET_PULL_HIGH|=SD_CD;
  1515. //Nick060808 end
  1516. #else
  1517. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:21
  1518. PIN_SD_DETDAT&=~SD_CD;
  1519. PIN_SD_DETDIR&=~SD_CD;
  1520. #else
  1521. PIN_SD_DETDAT|=SD_CD;
  1522. PIN_SD_DETDIR|=SD_CD;
  1523. #endif
  1524. #endif
  1526. if(gfSDPowerOn==TRUE)
  1527. {
  1528. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:21
  1529. if((!(PIN_SD_DETDAT&SD_CD))||(!gfSDinit))//Vicky1005 change
  1530. #else
  1531. if((PIN_SD_DETDAT&SD_CD)||(!gfSDinit))//Vicky1005 change
  1532. #endif
  1533. SD_POWER_OFF();
  1534. }
  1535. else
  1536. {
  1537. #if(COLOR_MODE==3) //modify by Rojam 2007-05-17 17:21
  1538. if(!(PIN_SD_DETDAT&SD_CD))//Vicky1005 change
  1539. #else
  1540. if(PIN_SD_DETDAT&SD_CD)//Vicky1005 change
  1541. #endif
  1542. {
  1543. gfSDinit=FALSE;
  1544. gfSDStop=FALSE;
  1545. }
  1546. }
  1547. #if( _SD_DET_PULL)
  1548. PIN_SD_DET_PULL_EN&=(~SD_CD); //Nick060808  
  1549. #else
  1550. PIN_SD_DETDIR&=(~SD_CD);
  1551. #endif
  1552. }
  1553. /*--------------------------------------------------------------------------
  1554. Description:
  1555. ATAPI FunC.
  1556. (Send 8 bytes data to PC, 
  1557. including the number of blocks in card(4 bytes),the number of bytes in a block(4bytes).)
  1558. when accepted Read-Capacity CMD(opcode=0x25).
  1560. Global arguments:
  1561. gxdwSD_Blocknum: the number of blocks in SD/MMC Card.
  1562. gxdwSD_Blocklen: the number of bytes in a block.
  1564. 2004/08/11: Edit by Vicky
  1565. --------------------------------------------------------------------------*/
  1566. API void SDReadCapa(void) //Vicky051021#1 fix the error capa (Should return the end LBA)
  1567. {
  1568. DWORD dwcapa;
  1570. if(gxdwSD_Blocknum)
  1571. dwcapa=gxdwSD_Blocknum-1;
  1572. else
  1573. dwcapa=0;
  1575. // Logical Block Address (MSB first)
  1576. WaitEPANotFull(); obUSBDEVEPAFIFO = (dwcapa >> 24) & 0xFF;
  1577. WaitEPANotFull(); obUSBDEVEPAFIFO = (dwcapa >> 16) & 0xFF;
  1578. WaitEPANotFull(); obUSBDEVEPAFIFO = (dwcapa >> 8) & 0xFF;
  1579. WaitEPANotFull(); obUSBDEVEPAFIFO = dwcapa & 0xFF;
  1580. // Block Length in Bytes (MSB first)
  1581. WaitEPANotFull(); obUSBDEVEPAFIFO = (gxdwSD_Blocklen >> 24) & 0xFF;
  1582. WaitEPANotFull(); obUSBDEVEPAFIFO = (gxdwSD_Blocklen >> 16) & 0xFF;
  1583. WaitEPANotFull(); obUSBDEVEPAFIFO = (gxdwSD_Blocklen >> 8) & 0xFF;
  1584. WaitEPANotFull(); obUSBDEVEPAFIFO = gxdwSD_Blocklen & 0xFF;
  1585. }
  1587. /*--------------------------------------------------------------------------
  1588. Description:
  1589. ATAPI FunC.(Send 8 bytes data to PC, including card's write-protected information.)
  1590. when accepted Modesense6 CMD(opcode=0x1A).
  1592. Global arguments:
  1593. gxbSDCardType: SD_MODE(SD),MMC_MODE(MMC)
  1594. gfSDWP: TRUE,the SD/MMC card is write-protected.
  1596. 2004/08/11: Edit by Vicky
  1597. --------------------------------------------------------------------------*/
  1598. /*API void SDModeSense6Data(void) //Nick060531 mark it
  1599. {
  1600. //obUSBDEVEPAFIFO = 0x08;
  1601. obUSBDEVEPAFIFO = 0x3E;
  1602. obUSBDEVEPAFIFO = 0x00;
  1604. if( gfSDWP==TRUE )
  1605. obUSBDEVEPAFIFO = 0x80;
  1606. else
  1607. obUSBDEVEPAFIFO = 0x00;
  1608. if(gxbSDCardType == SD_MODE)
  1609. obUSBDEVEPAFIFO = 0x08;
  1610. else
  1611. obUSBDEVEPAFIFO = 0x01;
  1612. obUSBDEVEPAFIFO = 0x00;
  1613. obUSBDEVEPAFIFO = 0x00;
  1614. obUSBDEVEPAFIFO = 0x00;
  1615. }*/
  1616. /*--------------------------------------------------------------------------
  1617. Description:
  1618. Write data to SD. (data Source: USB )
  1620. Arguments:
  1622. Global arguments:
  1623. gdwCBWDataTransferLength: the number of bytes to be transfered.
  1624. gxdwLBA_address:  the LBA of Source  (in SD/MMC Card)
  1625. gxdwSD_Blocknum: the number of blocks in SD/MMC Card.
  1626. gxwSD_SecCnt: the number of Blocks to be transfered everytime ,when SD_USBRead() is called.
  1627. gxbSDCardType: SD_MODE(SD),MMC_MODE(MMC)
  1628. gfSplitCommand: TRUE,the number of Blocks to be transfered is more than 255.
  1629. gfR1Err: TRUE,R1 report error.
  1630. gxbSD_Error:  error code(the most significant nibble:SD CMD,the least significant nibble:error condition)
  1631. Returns: 
  1632. TRUE: all data are transfered to USB.
  1633. FALSE: some error occured.
  1635. 2004/08/11: Edit by Vicky
  1636. --------------------------------------------------------------------------*/
  1638. API bit SD_USBWrite(void)large//Vicky0908 modify //Vicky050506#1
  1639. {
  1640. BYTE SD_SecCnt;
  1642. gxbSD_Error=0;//Vicky0908 add
  1643. if(!SD_Det(SD_DET)) //Nick060808 add SD_DET
  1644. return FALSE;
  1646. if( gbCBWCB[8] == 0 ) 
  1647. {
  1648. gxwSD_SecCnt = 0x100;//256 Block
  1649. SD_SecCnt=0xff;
  1650. gbCBWCB[7]--;
  1651. }
  1652. else 
  1653. {
  1654. gxwSD_SecCnt = (WORD)gbCBWCB[8];
  1655. SD_SecCnt=gbCBWCB[8]-1;
  1656. }
  1657.      obSDBLOCKLENH = 0x02;
  1658.      obSDBLOCKLENL = 0x00;
  1659. if( !gfSplitCommand )
  1660. {
  1661. obUSBOTGDMACLR = *((BYTE *)&gdwCBWDataTransferLength+3);
  1662. obUSBOTGDMACMR = *((BYTE *)&gdwCBWDataTransferLength+2);
  1663. obUSBOTGDMACHR= *((BYTE *)&gdwCBWDataTransferLength+1);
  1664. obUSBOTGSPEED &= TRANSFER_DISJ; //disable DMA
  1665. obMODSEL3 |= BYPASS_RA;     //bypass RA
  1666. obSOURCEPATHCTRL = 0x13; //Source USB
  1667. obTARGETPATHCTRL = 0x10; //Target SD
  1668. obUSBOTGSPEED |= TRANSFER_EN; //Enable DMA
  1669. }
  1670. *((BYTE*)&gxdwLBA_address + 0) = gbCBWCB[2];
  1671. *((BYTE*)&gxdwLBA_address + 1) = gbCBWCB[3];
  1672. *((BYTE*)&gxdwLBA_address + 2) = gbCBWCB[4];
  1673. *((BYTE*)&gxdwLBA_address + 3) = gbCBWCB[5];
  1675. if(   (gxdwLBA_address>gxdwSD_Blocknum) ||  //Vicky051221#3
  1676. ((gxdwLBA_address+(DWORD)SD_SecCnt+1) > gxdwSD_Blocknum)) //Vicky051021#1
  1677. {
  1678. obUSBOTGSPEED &= TRANSFER_DISJ; //disable DMA
  1679. //SDError();//Vicky1005 del
  1680. //SD_POWER_OFF();
  1681. return FALSE;
  1682. }
  1683. if(!(gxbSDMMCState&SD_HIGH_CAPACITY))//Nick061103
  1684. gxdwLBA_address = (gxdwLBA_address<<9);
  1685. if(gxbSDCardType == SD_MODE)
  1686.        {
  1687. if(!CMD55(TRUE))
  1688. {
  1689. gxbSD_Error|=ERR_SD_CMD55;
  1690. return FALSE;
  1691. }
  1692. if(!ACMD23(gxwSD_SecCnt))
  1693. {
  1694. gxbSD_Error|=ERR_SD_ACMD23;
  1695. return FALSE;
  1696. }
  1697.         }
  1698. obSDBLOCKNUM = SD_SecCnt;
  1699. CMD25PRE(gxdwLBA_address);
  1700. if(!SDpolling(&obSDCTRL,SD_CMD_START,0))
  1701. {
  1702. gxbSD_Error=ERR_SD_CMD25|ERR_SD_CMD_START; 
  1703. return FALSE;
  1704. }
  1706. if(!SDpolling(&obSDSTS,SD_CMD_BUSY,0))
  1707. {
  1708. gxbSD_Error=ERR_SD_CMD25|ERR_SD_CMD_BUSY; 
  1709. return FALSE;
  1710. }
  1712. SD_CheckR1();
  1714. if(!SDpolling(&obSDSTS,SD_DAT_TBUSY,0))
  1715. {
  1716. gxbSD_Error=ERR_SD_CMD25|ERR_SD_DAT_TBUSY; 
  1717. return FALSE;
  1718. }
  1720. if(!SDpolling(&obSDSTS,SD_DATLINE_BUSY,1))
  1721. {
  1722. gxbSD_Error=ERR_SD_CMD25|ERR_SD_DATLINE_BUSY; 
  1723. return FALSE;
  1724. }
  1725. if(!CMD12(TRUE))
  1726. {
  1727. gxbSD_Error|=ERR_SD_CMD12;
  1728. return FALSE;
  1729. }
  1730. obSDCLOCKWIDTH |= 0x01;
  1731. if(!SDpolling(&obSDSTS,SD_DATLINE_BUSY,1))
  1732. {
  1733. gxbSD_Error=ERR_SD_CMD12|ERR_SD_DATLINE_BUSY; 
  1734. return FALSE;
  1735. }
  1736.    obSDCLOCKWIDTH &= 0xFE;   
  1737. if(!SD_RESP_DelayCount(SD_STATE_TRAN))
  1738. {
  1739. gxbSD_Error=ERR_SD_CMD12|ERR_SD_STATE; 
  1740. return FALSE;
  1741. }
  1742. if(gfR1Err) //Vicky041126#2
  1743. return FALSE; //Vicky041126#2
  1746. return TRUE;
  1748. }
  1749. /*--------------------------------------------------------------------------
  1750. Description:
  1751. Read data from SD. (data Target: USB )
  1753. Arguments:
  1755. Global arguments:
  1756. gdwCBWDataTransferLength: the number of bytes to be transfered.
  1757. gxdwLBA_address:  the LBA of Source  (in SD/MMC Card)
  1758. gxdwSD_Blocknum: the number of blocks in SD/MMC Card.
  1759. gxwSD_SecCnt: the number of Blocks to be transfered everytime ,when SD_USBRead() is called.
  1760. gxbSDCardType: SD_MODE(SD),MMC_MODE(MMC)
  1761. gfSplitCommand: TRUE,the number of Blocks to be transfered is more than 255.
  1762. gfR1Err: TRUE,R1 report error.
  1763. gxbSD_Error:  error code(the most significant nibble:SD CMD,the least significant nibble:error condition)
  1764. Returns: 
  1765. TRUE: all data are transfered to USB.
  1766. FALSE: some error occured.
  1768. 2004/08/11: Edit by Vicky
  1769. --------------------------------------------------------------------------*/
  1770. API bit SD_USBRead(void) large//Vicky0908 modify
  1771. {
  1772. BYTE SD_SecCnt;
  1774. gxbSD_Error=0;//Vicky0908 add
  1775. if(!SD_Det(SD_DET)) //Nick060808 add SD_DET
  1776. return FALSE;
  1778. if( gbCBWCB[8] == 0 ) 
  1779. {
  1780. gxwSD_SecCnt = 0x100;//256 Block
  1781. SD_SecCnt=0xff;
  1782. gbCBWCB[7]--;
  1783. }
  1784. else 
  1785. {
  1786. gxwSD_SecCnt = (WORD)gbCBWCB[8];
  1787. SD_SecCnt=gbCBWCB[8]-1;
  1788. }
  1790. obSDBLOCKLENH = 0x02;
  1791.        obSDBLOCKLENL = 0x00;
  1792. if(!gfSplitCommand)
  1793. {
  1794. obUSBOTGDMACLR = *((BYTE *)&gdwCBWDataTransferLength+3);
  1795. obUSBOTGDMACMR = *((BYTE *)&gdwCBWDataTransferLength+2);
  1796. obUSBOTGDMACHR= *((BYTE *)&gdwCBWDataTransferLength+1);
  1797. obUSBOTGSPEED &= TRANSFER_DISJ; //disable DMA
  1798. obMODSEL3 |= BYPASS_RA;     //bypass RA
  1799. obSOURCEPATHCTRL = 0x10; //Source SD
  1800. obTARGETPATHCTRL = 0x13; //Target USB
  1801. obUSBOTGSPEED |= TRANSFER_EN; //Enable DMA
  1802. }
  1803. obSDBLOCKNUM = SD_SecCnt;
  1805. *((BYTE*)&gxdwLBA_address + 0) = gbCBWCB[2];
  1806.      *((BYTE*)&gxdwLBA_address + 1) = gbCBWCB[3];
  1807. *((BYTE*)&gxdwLBA_address + 2) = gbCBWCB[4];
  1808.       *((BYTE*)&gxdwLBA_address + 3) = gbCBWCB[5];
  1810. if(  (gxdwLBA_address>gxdwSD_Blocknum) ||  //Vicky051221#3
  1811. ((gxdwLBA_address+(DWORD)SD_SecCnt+1) > gxdwSD_Blocknum)  ) //Vicky051021#1
  1812. {
  1813. //gfMediumChange=TRUE;
  1814. obUSBOTGSPEED &= TRANSFER_DISJ;
  1815. //SD_POWER_OFF();
  1816. return FALSE;
  1817. }
  1818. if(!(gxbSDMMCState&SD_HIGH_CAPACITY))//Nick061103
  1819.      gxdwLBA_address = (gxdwLBA_address<<9);
  1820. CMD18PRE(gxdwLBA_address);
  1821. if(!SDpolling(&obSDCTRL,SD_CMD_START,0)) 
  1822. {
  1823. gxbSD_Error=ERR_SD_CMD18|ERR_SD_CMD_START;
  1824. return FALSE;
  1825. }
  1827. if(!SDpolling(&obSDSTS,SD_CMD_BUSY,0)) 
  1828. {
  1829. gxbSD_Error=ERR_SD_CMD18|ERR_SD_CMD_BUSY; 
  1830. return FALSE;
  1831. }
  1833. if(!SDpolling(&obSDSTS,SD_DAT_TBUSY,0))
  1834. {
  1835. gxbSD_Error=ERR_SD_CMD18|ERR_SD_DAT_TBUSY;
  1836. return FALSE;
  1837. }
  1838. if(!CMD12(FALSE))
  1839. {
  1840. gxbSD_Error|=ERR_SD_CMD12;
  1841. return FALSE;
  1842. }
  1843. if(!SD_RESP_DelayCount(SD_STATE_TRAN))
  1844. {
  1845. gxbSD_Error=ERR_SD_CMD12|ERR_SD_STATE;
  1846. return FALSE;
  1847. }
  1848. if(gfR1Err) //Vicky041126#2
  1849. return FALSE; //Vicky041126#2
  1852. return TRUE;
  1853. }
  1855. #if 0 //v03210 del
  1856. /*--------------------------------------------------------------------------
  1857. Description:
  1858. ATAPI FunC.
  1859. (Send 20 bytes data to PC, 
  1860. including the number of blocks in card(4 bytes),the number of bytes in a block(3bytes).)
  1861. when accepted Read-Format-Capacity CMD(opcode=0x23).
  1863. Global arguments:
  1864. gxbSDCardType: SD_MODE(SD),MMC_MODE(MMC)
  1865. gfSDWP: TRUE,the SD/MMC card is write-protected.
  1866. gxdwSD_Blocknum: the number of blocks in SD/MMC Card.
  1867. gxdwSD_Blocklen: the number of bytes in a block.
  1868. gdwCBWDataTransferLength: the number of bytes that PC requested to transfer. 
  1870. 2004/08/11: Edit by Vicky
  1871. --------------------------------------------------------------------------*/
  1873. bit SDFormatCapa(void) large
  1874. {
  1875. BYTE cbtemp;
  1876. if(gfSDinit)
  1877. {
  1878. //.Capacity header
  1879. WaitEPANotFull();obUSBDEVEPAFIFO = 0x00;//(byte 0) reserved
  1880. WaitEPANotFull();obUSBDEVEPAFIFO = 0x00;//(byte 1) reserved
  1881. WaitEPANotFull();obUSBDEVEPAFIFO = 0x00;//(byte 2) reserved
  1882. WaitEPANotFull();obUSBDEVEPAFIFO = 0x10;//(byte 0) length
  1883. /*Capacity descriptor0*/
  1884. //.Number of blocks
  1885. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum>>24);
  1886. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum>>16);
  1887. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum>>8);
  1888. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum);
  1889. //.Descriptor type
  1890. WaitEPANotFull();obUSBDEVEPAFIFO = 0x02; //TYPE_FORMATTED
  1891. //.Block Length in Bytes (MSB first)
  1892. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocklen>>16);
  1893. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocklen>>8);
  1894. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocklen);
  1895. /*Formattable capacity descriptor*/
  1896. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum>>24);
  1897. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum>>16);
  1898. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum>>8);
  1899. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocknum);
  1900. //.format type
  1901. WaitEPANotFull();obUSBDEVEPAFIFO = 0x00;
  1902. //.Block Length in Bytes (MSB first)
  1903. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocklen>>16);
  1904. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocklen>>8);
  1905. WaitEPANotFull();obUSBDEVEPAFIFO = (gxdwSD_Blocklen);
  1906. return TRUE;
  1907. }
  1908. else
  1909. {
  1910. for(cbtemp = 0; cbtemp < gdwCBWDataTransferLength; cbtemp++)
  1911. {WaitEPANotFull();obUSBDEVEPAFIFO = 0x00;}
  1912. return FALSE;
  1913. }
  1914. }
  1915. #endif
  1916. #endif
  1919. #else //Walace060929#1 start
  1921. #if(!(_PM_PLAY_DATA_RTN_RESTORE_|_PM_FM_)) //modify by Rojam 2007-03-29 17:9
  1923. bit SD_Write(void) large
  1924. {
  1925. return FALSE;
  1926. }
  1927. #if(!(_PM_PLAY_MAIN_|_PM_PLAY_PRC_)) //modify by Rojam 2007-04-12 11:24
  1928. void SDReadCapa(void) 
  1929. {
  1930. ;
  1931. }
  1932. bit SD_Init_400K(void)
  1933. {
  1934. return FALSE;
  1935. }
  1937. bit SD_USBRead(void) large//Vicky0908 modify
  1938. {
  1939. return FALSE;
  1940. }
  1942. bit SD_USBWrite(void) large//Vicky0908 modify
  1943. {
  1944. return FALSE;
  1945. }
  1947. bit SD_Det(BOOL fForceSDRemove) 
  1948. {
  1949. fForceSDRemove=fForceSDRemove; // modify by Rojam 2007-03-29 16:40
  1950. return FALSE;
  1951. }
  1953. void SD_POWER_OFF(void) 
  1954. {
  1955. ;
  1956. }
  1957. #endif
  1958. #endif
  1961. #endif //Walace060929#1 end