nu_sdh.c 29 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181
  1. /**************************************************************************//**
  2. * @file SDH.c
  3. * @brief SDH driver source file
  4. *
  5. * SPDX-License-Identifier: Apache-2.0
  6. * @copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
  7. *****************************************************************************/
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include "nuc980.h"
  12. #include "nu_sdh.h"
  13. /** @addtogroup Standard_Driver Standard Driver
  14. @{
  15. */
  16. /** @addtogroup SDH_Driver SDH Driver
  17. @{
  18. */
  19. /** @addtogroup SDH_EXPORTED_FUNCTIONS SDH Exported Functions
  20. @{
  21. */
  22. #define SDH_BLOCK_SIZE 512ul
  23. /** @cond HIDDEN_SYMBOLS */
  24. /* global variables */
  25. /* For response R3 (such as ACMD41, CRC-7 is invalid; but SD controller will still */
  26. /* calculate CRC-7 and get an error result, software should ignore this error and clear SDISR [CRC_IF] flag */
  27. /* _sd_uR3_CMD is the flag for it. 1 means software should ignore CRC-7 error */
  28. #ifdef __ICCARM__
  29. #pragma data_alignment = 32
  30. static uint8_t _SDH0_ucSDHCBuffer[512];
  31. static uint8_t _SDH1_ucSDHCBuffer[512];
  32. #else
  33. static uint8_t _SDH0_ucSDHCBuffer[512] __attribute__((aligned(32)));
  34. static uint8_t _SDH1_ucSDHCBuffer[512] __attribute__((aligned(32)));
  35. #endif
  36. SDH_INFO_T SD0, SD1;
  37. void SDH_CheckRB(SDH_T *sdh)
  38. {
  39. while (1)
  40. {
  41. sdh->CTL |= SDH_CTL_CLK8OEN_Msk;
  42. while ((sdh->CTL & SDH_CTL_CLK8OEN_Msk) == SDH_CTL_CLK8OEN_Msk)
  43. {
  44. }
  45. if ((sdh->INTSTS & SDH_INTSTS_DAT0STS_Msk) == SDH_INTSTS_DAT0STS_Msk)
  46. {
  47. break;
  48. }
  49. }
  50. }
  51. uint32_t SDH_SDCommand(SDH_T *sdh, uint32_t ucCmd, uint32_t uArg)
  52. {
  53. volatile uint32_t buf, val = 0ul;
  54. SDH_INFO_T *pSD;
  55. if (sdh == SDH0)
  56. {
  57. pSD = &SD0;
  58. }
  59. else
  60. {
  61. pSD = &SD1;
  62. }
  63. sdh->CMDARG = uArg;
  64. buf = (sdh->CTL & (~SDH_CTL_CMDCODE_Msk)) | (ucCmd << 8ul) | (SDH_CTL_COEN_Msk);
  65. sdh->CTL = buf;
  66. while ((sdh->CTL & SDH_CTL_COEN_Msk) == SDH_CTL_COEN_Msk)
  67. {
  68. if (pSD->IsCardInsert == 0ul)
  69. {
  70. val = SDH_NO_SD_CARD;
  71. }
  72. }
  73. return val;
  74. }
  75. uint32_t SDH_SDCmdAndRsp(SDH_T *sdh, uint32_t ucCmd, uint32_t uArg, uint32_t ntickCount)
  76. {
  77. volatile uint32_t buf;
  78. SDH_INFO_T *pSD;
  79. if (sdh == SDH0)
  80. {
  81. pSD = &SD0;
  82. }
  83. else
  84. {
  85. pSD = &SD1;
  86. }
  87. sdh->CMDARG = uArg;
  88. buf = (sdh->CTL & (~SDH_CTL_CMDCODE_Msk)) | (ucCmd << 8ul) | (SDH_CTL_COEN_Msk | SDH_CTL_RIEN_Msk);
  89. sdh->CTL = buf;
  90. if (ntickCount > 0ul)
  91. {
  92. while ((sdh->CTL & SDH_CTL_RIEN_Msk) == SDH_CTL_RIEN_Msk)
  93. {
  94. if (ntickCount-- == 0ul)
  95. {
  96. sdh->CTL |= SDH_CTL_CTLRST_Msk; /* reset SD engine */
  97. return 2ul;
  98. }
  99. if (pSD->IsCardInsert == FALSE)
  100. {
  101. return SDH_NO_SD_CARD;
  102. }
  103. }
  104. }
  105. else
  106. {
  107. while ((sdh->CTL & SDH_CTL_RIEN_Msk) == SDH_CTL_RIEN_Msk)
  108. {
  109. if (pSD->IsCardInsert == FALSE)
  110. {
  111. return SDH_NO_SD_CARD;
  112. }
  113. }
  114. }
  115. if (pSD->R7Flag)
  116. {
  117. uint32_t tmp0 = 0ul, tmp1 = 0ul;
  118. tmp1 = sdh->RESP1 & 0xfful;
  119. tmp0 = sdh->RESP0 & 0xful;
  120. if ((tmp1 != 0x55ul) && (tmp0 != 0x01ul))
  121. {
  122. pSD->R7Flag = 0ul;
  123. return SDH_CMD8_ERROR;
  124. }
  125. }
  126. if (!pSD->R3Flag)
  127. {
  128. if ((sdh->INTSTS & SDH_INTSTS_CRC7_Msk) == SDH_INTSTS_CRC7_Msk) /* check CRC7 */
  129. {
  130. return Successful;
  131. }
  132. else
  133. {
  134. return SDH_CRC7_ERROR;
  135. }
  136. }
  137. else
  138. {
  139. /* ignore CRC error for R3 case */
  140. pSD->R3Flag = 0ul;
  141. sdh->INTSTS = SDH_INTSTS_CRCIF_Msk;
  142. return Successful;
  143. }
  144. }
  145. uint32_t SDH_Swap32(uint32_t val)
  146. {
  147. uint32_t buf;
  148. buf = val;
  149. val <<= 24;
  150. val |= (buf << 8) & 0xff0000ul;
  151. val |= (buf >> 8) & 0xff00ul;
  152. val |= (buf >> 24) & 0xfful;
  153. return val;
  154. }
  155. /* Get 16 bytes CID or CSD */
  156. uint32_t SDH_SDCmdAndRsp2(SDH_T *sdh, uint32_t ucCmd, uint32_t uArg, uint32_t puR2ptr[])
  157. {
  158. uint32_t i, buf;
  159. uint32_t tmpBuf[5];
  160. SDH_INFO_T *pSD;
  161. if (sdh == SDH0)
  162. {
  163. pSD = &SD0;
  164. }
  165. else
  166. {
  167. pSD = &SD1;
  168. }
  169. sdh->CMDARG = uArg;
  170. buf = (sdh->CTL & (~SDH_CTL_CMDCODE_Msk)) | (ucCmd << 8) | (SDH_CTL_COEN_Msk | SDH_CTL_R2EN_Msk);
  171. sdh->CTL = buf;
  172. while ((sdh->CTL & SDH_CTL_R2EN_Msk) == SDH_CTL_R2EN_Msk)
  173. {
  174. if (pSD->IsCardInsert == FALSE)
  175. {
  176. return SDH_NO_SD_CARD;
  177. }
  178. }
  179. if ((sdh->INTSTS & SDH_INTSTS_CRC7_Msk) == SDH_INTSTS_CRC7_Msk)
  180. {
  181. for (i = 0ul; i < 5ul; i++)
  182. {
  183. tmpBuf[i] = SDH_Swap32(sdh->FB[i]);
  184. }
  185. for (i = 0ul; i < 4ul; i++)
  186. {
  187. puR2ptr[i] = ((tmpBuf[i] & 0x00fffffful) << 8) | ((tmpBuf[i + 1ul] & 0xff000000ul) >> 24);
  188. }
  189. }
  190. else
  191. {
  192. return SDH_CRC7_ERROR;
  193. }
  194. return Successful;
  195. }
  196. uint32_t SDH_SDCmdAndRspDataIn(SDH_T *sdh, uint32_t ucCmd, uint32_t uArg)
  197. {
  198. volatile uint32_t buf;
  199. SDH_INFO_T *pSD;
  200. if (sdh == SDH0)
  201. {
  202. pSD = &SD0;
  203. }
  204. else
  205. {
  206. pSD = &SD1;
  207. }
  208. sdh->CMDARG = uArg;
  209. buf = (sdh->CTL & (~SDH_CTL_CMDCODE_Msk)) | (ucCmd << 8ul) |
  210. (SDH_CTL_COEN_Msk | SDH_CTL_RIEN_Msk | SDH_CTL_DIEN_Msk);
  211. sdh->CTL = buf;
  212. while ((sdh->CTL & SDH_CTL_RIEN_Msk) == SDH_CTL_RIEN_Msk)
  213. {
  214. if (pSD->IsCardInsert == FALSE)
  215. {
  216. return SDH_NO_SD_CARD;
  217. }
  218. }
  219. while ((sdh->CTL & SDH_CTL_DIEN_Msk) == SDH_CTL_DIEN_Msk)
  220. {
  221. if (pSD->IsCardInsert == FALSE)
  222. {
  223. return SDH_NO_SD_CARD;
  224. }
  225. }
  226. if ((sdh->INTSTS & SDH_INTSTS_CRC7_Msk) != SDH_INTSTS_CRC7_Msk)
  227. {
  228. /* check CRC7 */
  229. return SDH_CRC7_ERROR;
  230. }
  231. if ((sdh->INTSTS & SDH_INTSTS_CRC16_Msk) != SDH_INTSTS_CRC16_Msk)
  232. {
  233. /* check CRC16 */
  234. return SDH_CRC16_ERROR;
  235. }
  236. return 0ul;
  237. }
  238. /* there are 8 bits for divider0, maximum is 256 */
  239. #define SDH_CLK_DIV0_MAX 256ul
  240. void SDH_Set_clock(SDH_T *sdh, uint32_t sd_clock_khz)
  241. {
  242. UINT32 div;
  243. uint32_t SDH_ReferenceClock;
  244. if (sd_clock_khz <= 2000)
  245. {
  246. SDH_ReferenceClock = 12000;
  247. if (sdh == SDH0)
  248. {
  249. outpw(REG_CLK_DIVCTL9, (inpw(REG_CLK_DIVCTL9) & ~0x18) | (0x0 << 3)); // SD clock from XIN [4:3]
  250. }
  251. else
  252. {
  253. //fixme outpw(REG_CLK_DIVCTL9, (inpw(REG_CLK_DIVCTL9) & ~0x18) | (0x0 << 3)); // SD clock from XIN [4:3]
  254. }
  255. }
  256. else
  257. {
  258. SDH_ReferenceClock = 300000;
  259. if (sdh == SDH0)
  260. {
  261. outpw(REG_CLK_DIVCTL9, (inpw(REG_CLK_DIVCTL9) & ~0x18) | (0x3 << 3)); // SD clock from UPLL [4:3]
  262. }
  263. else
  264. {
  265. //fixme outpw(REG_CLK_DIVCTL9, (inpw(REG_CLK_DIVCTL9) & ~0x18) | (0x3 << 3)); // SD clock from UPLL [4:3]
  266. }
  267. }
  268. div = (SDH_ReferenceClock / sd_clock_khz) - 1;
  269. if (div >= SDH_CLK_DIV0_MAX)
  270. {
  271. div = 0xff;
  272. }
  273. outpw(REG_CLK_DIVCTL9, (inpw(REG_CLK_DIVCTL9) & ~0xff00) | ((div) << 8)); // SD clock divided by CLKDIV3[SD_N] [15:8]
  274. }
  275. uint32_t SDH_CardDetection(SDH_T *sdh)
  276. {
  277. uint32_t i, val = TRUE;
  278. SDH_INFO_T *pSD;
  279. if (sdh == SDH0)
  280. {
  281. pSD = &SD0;
  282. }
  283. else
  284. {
  285. pSD = &SD1;
  286. }
  287. if ((sdh->INTEN & SDH_INTEN_CDSRC_Msk) == SDH_INTEN_CDSRC_Msk) /* Card detect pin from GPIO */
  288. {
  289. if ((sdh->INTSTS & SDH_INTSTS_CDSTS_Msk) == SDH_INTSTS_CDSTS_Msk) /* Card remove */
  290. {
  291. pSD->IsCardInsert = (uint8_t)FALSE;
  292. val = FALSE;
  293. }
  294. else
  295. {
  296. pSD->IsCardInsert = (uint8_t)TRUE;
  297. }
  298. }
  299. else if ((sdh->INTEN & SDH_INTEN_CDSRC_Msk) != SDH_INTEN_CDSRC_Msk)
  300. {
  301. sdh->CTL |= SDH_CTL_CLKKEEP_Msk;
  302. for (i = 0ul; i < 5000ul; i++)
  303. {
  304. }
  305. if ((sdh->INTSTS & SDH_INTSTS_CDSTS_Msk) == SDH_INTSTS_CDSTS_Msk) /* Card insert */
  306. {
  307. pSD->IsCardInsert = (uint8_t)TRUE;
  308. }
  309. else
  310. {
  311. pSD->IsCardInsert = (uint8_t)FALSE;
  312. val = FALSE;
  313. }
  314. sdh->CTL &= ~SDH_CTL_CLKKEEP_Msk;
  315. }
  316. return val;
  317. }
  318. uint32_t SDH_Init(SDH_T *sdh)
  319. {
  320. uint32_t volatile i, status;
  321. uint32_t resp;
  322. uint32_t CIDBuffer[4];
  323. uint32_t volatile u32CmdTimeOut;
  324. SDH_INFO_T *pSD;
  325. if (sdh == SDH0)
  326. {
  327. pSD = &SD0;
  328. }
  329. else
  330. {
  331. pSD = &SD1;
  332. }
  333. /* set the clock to 300KHz */
  334. SDH_Set_clock(sdh, 300ul);
  335. /* power ON 74 clock */
  336. sdh->CTL |= SDH_CTL_CLK74OEN_Msk;
  337. while ((sdh->CTL & SDH_CTL_CLK74OEN_Msk) == SDH_CTL_CLK74OEN_Msk)
  338. {
  339. if (pSD->IsCardInsert == FALSE)
  340. {
  341. return SDH_NO_SD_CARD;
  342. }
  343. }
  344. SDH_SDCommand(sdh, 0ul, 0ul); /* reset all cards */
  345. for (i = 0x1000ul; i > 0ul; i--)
  346. {
  347. }
  348. /* initial SDHC */
  349. pSD->R7Flag = 1ul;
  350. u32CmdTimeOut = 0xFFFFFul;
  351. i = SDH_SDCmdAndRsp(sdh, 8ul, 0x00000155ul, u32CmdTimeOut);
  352. if (i == Successful)
  353. {
  354. /* SD 2.0 */
  355. SDH_SDCmdAndRsp(sdh, 55ul, 0x00ul, u32CmdTimeOut);
  356. pSD->R3Flag = 1ul;
  357. SDH_SDCmdAndRsp(sdh, 41ul, 0x40ff8000ul, u32CmdTimeOut); /* 2.7v-3.6v */
  358. resp = sdh->RESP0;
  359. while ((resp & 0x00800000ul) != 0x00800000ul) /* check if card is ready */
  360. {
  361. SDH_SDCmdAndRsp(sdh, 55ul, 0x00ul, u32CmdTimeOut);
  362. pSD->R3Flag = 1ul;
  363. SDH_SDCmdAndRsp(sdh, 41ul, 0x40ff8000ul, u32CmdTimeOut); /* 3.0v-3.4v */
  364. resp = sdh->RESP0;
  365. }
  366. if ((resp & 0x00400000ul) == 0x00400000ul)
  367. {
  368. pSD->CardType = SDH_TYPE_SD_HIGH;
  369. }
  370. else
  371. {
  372. pSD->CardType = SDH_TYPE_SD_LOW;
  373. }
  374. }
  375. else
  376. {
  377. /* SD 1.1 */
  378. SDH_SDCommand(sdh, 0ul, 0ul); /* reset all cards */
  379. for (i = 0x100ul; i > 0ul; i--)
  380. {
  381. }
  382. i = SDH_SDCmdAndRsp(sdh, 55ul, 0x00ul, u32CmdTimeOut);
  383. if (i == 2ul) /* MMC memory */
  384. {
  385. SDH_SDCommand(sdh, 0ul, 0ul); /* reset */
  386. for (i = 0x100ul; i > 0ul; i--)
  387. {
  388. }
  389. pSD->R3Flag = 1ul;
  390. if (SDH_SDCmdAndRsp(sdh, 1ul, 0x40ff8000ul, u32CmdTimeOut) != 2ul) /* eMMC memory */
  391. {
  392. resp = sdh->RESP0;
  393. while ((resp & 0x00800000ul) != 0x00800000ul)
  394. {
  395. /* check if card is ready */
  396. pSD->R3Flag = 1ul;
  397. SDH_SDCmdAndRsp(sdh, 1ul, 0x40ff8000ul, u32CmdTimeOut); /* high voltage */
  398. resp = sdh->RESP0;
  399. }
  400. if ((resp & 0x00400000ul) == 0x00400000ul)
  401. {
  402. pSD->CardType = SDH_TYPE_EMMC;
  403. }
  404. else
  405. {
  406. pSD->CardType = SDH_TYPE_MMC;
  407. }
  408. }
  409. else
  410. {
  411. pSD->CardType = SDH_TYPE_UNKNOWN;
  412. return SDH_ERR_DEVICE;
  413. }
  414. }
  415. else if (i == 0ul) /* SD Memory */
  416. {
  417. pSD->R3Flag = 1ul;
  418. SDH_SDCmdAndRsp(sdh, 41ul, 0x00ff8000ul, u32CmdTimeOut); /* 3.0v-3.4v */
  419. resp = sdh->RESP0;
  420. while ((resp & 0x00800000ul) != 0x00800000ul) /* check if card is ready */
  421. {
  422. SDH_SDCmdAndRsp(sdh, 55ul, 0x00ul, u32CmdTimeOut);
  423. pSD->R3Flag = 1ul;
  424. SDH_SDCmdAndRsp(sdh, 41ul, 0x00ff8000ul, u32CmdTimeOut); /* 3.0v-3.4v */
  425. resp = sdh->RESP0;
  426. }
  427. pSD->CardType = SDH_TYPE_SD_LOW;
  428. }
  429. else
  430. {
  431. pSD->CardType = SDH_TYPE_UNKNOWN;
  432. return SDH_INIT_ERROR;
  433. }
  434. }
  435. if (pSD->CardType != SDH_TYPE_UNKNOWN)
  436. {
  437. SDH_SDCmdAndRsp2(sdh, 2ul, 0x00ul, CIDBuffer);
  438. if ((pSD->CardType == SDH_TYPE_MMC) || (pSD->CardType == SDH_TYPE_EMMC))
  439. {
  440. if ((status = SDH_SDCmdAndRsp(sdh, 3ul, 0x10000ul, 0ul)) != Successful) /* set RCA */
  441. {
  442. return status;
  443. }
  444. pSD->RCA = 0x10000ul;
  445. }
  446. else
  447. {
  448. if ((status = SDH_SDCmdAndRsp(sdh, 3ul, 0x00ul, 0ul)) != Successful) /* get RCA */
  449. {
  450. return status;
  451. }
  452. else
  453. {
  454. pSD->RCA = (sdh->RESP0 << 8) & 0xffff0000;
  455. }
  456. }
  457. }
  458. return Successful;
  459. }
  460. uint32_t SDH_SwitchToHighSpeed(SDH_T *sdh, SDH_INFO_T *pSD)
  461. {
  462. uint32_t volatile status = 0ul;
  463. uint16_t current_comsumption, busy_status0;
  464. sdh->DMASA = (uint32_t)pSD->dmabuf;
  465. sdh->BLEN = 63ul;
  466. if ((status = SDH_SDCmdAndRspDataIn(sdh, 6ul, 0x00ffff01ul)) != Successful)
  467. {
  468. return Fail;
  469. }
  470. current_comsumption = (uint16_t)(*pSD->dmabuf) << 8;
  471. current_comsumption |= (uint16_t)(*(pSD->dmabuf + 1));
  472. if (!current_comsumption)
  473. {
  474. return Fail;
  475. }
  476. busy_status0 = (uint16_t)(*(pSD->dmabuf + 28)) << 8;
  477. busy_status0 |= (uint16_t)(*(pSD->dmabuf + 29));
  478. if (!busy_status0) /* function ready */
  479. {
  480. sdh->DMASA = (uint32_t)pSD->dmabuf;
  481. sdh->BLEN = 63ul; /* 512 bit */
  482. if ((status = SDH_SDCmdAndRspDataIn(sdh, 6ul, 0x80ffff01ul)) != Successful)
  483. {
  484. return Fail;
  485. }
  486. /* function change timing: 8 clocks */
  487. sdh->CTL |= SDH_CTL_CLK8OEN_Msk;
  488. while ((sdh->CTL & SDH_CTL_CLK8OEN_Msk) == SDH_CTL_CLK8OEN_Msk)
  489. {
  490. }
  491. current_comsumption = (uint16_t)(*pSD->dmabuf) << 8;
  492. current_comsumption |= (uint16_t)(*(pSD->dmabuf + 1));
  493. if (!current_comsumption)
  494. {
  495. return Fail;
  496. }
  497. return Successful;
  498. }
  499. else
  500. {
  501. return Fail;
  502. }
  503. }
  504. uint32_t SDH_SelectCardType(SDH_T *sdh)
  505. {
  506. uint32_t volatile status = 0ul;
  507. uint32_t param;
  508. SDH_INFO_T *pSD;
  509. if (sdh == SDH0)
  510. {
  511. pSD = &SD0;
  512. }
  513. else
  514. {
  515. pSD = &SD1;
  516. }
  517. if ((status = SDH_SDCmdAndRsp(sdh, 7ul, pSD->RCA, 0ul)) != Successful)
  518. {
  519. return status;
  520. }
  521. SDH_CheckRB(sdh);
  522. /* if SD card set 4bit */
  523. if (pSD->CardType == SDH_TYPE_SD_HIGH)
  524. {
  525. sdh->DMASA = (uint32_t)pSD->dmabuf;
  526. sdh->BLEN = 0x07ul; /* 64 bit */
  527. sdh->DMACTL |= SDH_DMACTL_DMARST_Msk;
  528. while ((sdh->DMACTL & SDH_DMACTL_DMARST_Msk) == 0x2);
  529. if ((status = SDH_SDCmdAndRsp(sdh, 55ul, pSD->RCA, 0ul)) != Successful)
  530. {
  531. return status;
  532. }
  533. if ((status = SDH_SDCmdAndRspDataIn(sdh, 51ul, 0x00ul)) != Successful)
  534. {
  535. return status;
  536. }
  537. if ((*pSD->dmabuf & 0xful) == 0x2ul)
  538. {
  539. status = SDH_SwitchToHighSpeed(sdh, pSD);
  540. if (status == Successful)
  541. {
  542. /* divider */
  543. SDH_Set_clock(sdh, SDHC_FREQ);
  544. }
  545. }
  546. if ((status = SDH_SDCmdAndRsp(sdh, 55ul, pSD->RCA, 0ul)) != Successful)
  547. {
  548. return status;
  549. }
  550. if ((status = SDH_SDCmdAndRsp(sdh, 6ul, 0x02ul, 0ul)) != Successful) /* set bus width */
  551. {
  552. return status;
  553. }
  554. sdh->CTL |= SDH_CTL_DBW_Msk;
  555. }
  556. else if (pSD->CardType == SDH_TYPE_SD_LOW)
  557. {
  558. sdh->DMASA = (uint32_t)pSD->dmabuf;;
  559. sdh->BLEN = 0x07ul;
  560. if ((status = SDH_SDCmdAndRsp(sdh, 55ul, pSD->RCA, 0ul)) != Successful)
  561. {
  562. return status;
  563. }
  564. if ((status = SDH_SDCmdAndRspDataIn(sdh, 51ul, 0x00ul)) != Successful)
  565. {
  566. return status;
  567. }
  568. /* set data bus width. ACMD6 for SD card, SDCR_DBW for host. */
  569. if ((status = SDH_SDCmdAndRsp(sdh, 55ul, pSD->RCA, 0ul)) != Successful)
  570. {
  571. return status;
  572. }
  573. if ((status = SDH_SDCmdAndRsp(sdh, 6ul, 0x02ul, 0ul)) != Successful)
  574. {
  575. return status;
  576. }
  577. sdh->CTL |= SDH_CTL_DBW_Msk;
  578. }
  579. else if ((pSD->CardType == SDH_TYPE_MMC) || (pSD->CardType == SDH_TYPE_EMMC))
  580. {
  581. if (pSD->CardType == SDH_TYPE_MMC)
  582. {
  583. sdh->CTL &= ~SDH_CTL_DBW_Msk;
  584. }
  585. /*--- sent CMD6 to MMC card to set bus width to 4 bits mode */
  586. /* set CMD6 argument Access field to 3, Index to 183, Value to 1 (4-bit mode) */
  587. param = (3ul << 24) | (183ul << 16) | (1ul << 8);
  588. if ((status = SDH_SDCmdAndRsp(sdh, 6ul, param, 0ul)) != Successful)
  589. {
  590. return status;
  591. }
  592. SDH_CheckRB(sdh);
  593. sdh->CTL |= SDH_CTL_DBW_Msk; /* set bus width to 4-bit mode for SD host controller */
  594. }
  595. if ((status = SDH_SDCmdAndRsp(sdh, 16ul, SDH_BLOCK_SIZE, 0ul)) != Successful)
  596. {
  597. return status;
  598. }
  599. sdh->BLEN = SDH_BLOCK_SIZE - 1ul;
  600. SDH_SDCommand(sdh, 7ul, 0ul);
  601. sdh->CTL |= SDH_CTL_CLK8OEN_Msk;
  602. while ((sdh->CTL & SDH_CTL_CLK8OEN_Msk) == SDH_CTL_CLK8OEN_Msk)
  603. {
  604. }
  605. sdh->INTEN |= SDH_INTEN_BLKDIEN_Msk;
  606. return Successful;
  607. }
  608. void SDH_Get_SD_info(SDH_T *sdh)
  609. {
  610. unsigned int R_LEN, C_Size, MULT, size;
  611. uint32_t Buffer[4];
  612. //unsigned char *ptr;
  613. SDH_INFO_T *pSD;
  614. if (sdh == SDH0)
  615. {
  616. pSD = &SD0;
  617. }
  618. else
  619. {
  620. pSD = &SD1;
  621. }
  622. SDH_SDCmdAndRsp2(sdh, 9ul, pSD->RCA, Buffer);
  623. if ((pSD->CardType == SDH_TYPE_MMC) || (pSD->CardType == SDH_TYPE_EMMC))
  624. {
  625. /* for MMC/eMMC card */
  626. if ((Buffer[0] & 0xc0000000) == 0xc0000000)
  627. {
  628. /* CSD_STRUCTURE [127:126] is 3 */
  629. /* CSD version depend on EXT_CSD register in eMMC v4.4 for card size > 2GB */
  630. SDH_SDCmdAndRsp(sdh, 7ul, pSD->RCA, 0ul);
  631. //ptr = (uint8_t *)((uint32_t)_SDH_ucSDHCBuffer );
  632. sdh->DMASA = (uint32_t)pSD->dmabuf;;
  633. sdh->BLEN = 511ul; /* read 512 bytes for EXT_CSD */
  634. if (SDH_SDCmdAndRspDataIn(sdh, 8ul, 0x00ul) == Successful)
  635. {
  636. SDH_SDCommand(sdh, 7ul, 0ul);
  637. sdh->CTL |= SDH_CTL_CLK8OEN_Msk;
  638. while ((sdh->CTL & SDH_CTL_CLK8OEN_Msk) == SDH_CTL_CLK8OEN_Msk)
  639. {
  640. }
  641. pSD->totalSectorN = (uint32_t)(*(pSD->dmabuf + 215)) << 24;
  642. pSD->totalSectorN |= (uint32_t)(*(pSD->dmabuf + 214)) << 16;
  643. pSD->totalSectorN |= (uint32_t)(*(pSD->dmabuf + 213)) << 8;
  644. pSD->totalSectorN |= (uint32_t)(*(pSD->dmabuf + 212));
  645. pSD->diskSize = pSD->totalSectorN / 2ul;
  646. }
  647. }
  648. else
  649. {
  650. /* CSD version v1.0/1.1/1.2 in eMMC v4.4 spec for card size <= 2GB */
  651. R_LEN = (Buffer[1] & 0x000f0000ul) >> 16;
  652. C_Size = ((Buffer[1] & 0x000003fful) << 2) | ((Buffer[2] & 0xc0000000ul) >> 30);
  653. MULT = (Buffer[2] & 0x00038000ul) >> 15;
  654. size = (C_Size + 1ul) * (1ul << (MULT + 2ul)) * (1ul << R_LEN);
  655. pSD->diskSize = size / 1024ul;
  656. pSD->totalSectorN = size / 512ul;
  657. }
  658. }
  659. else
  660. {
  661. if ((Buffer[0] & 0xc0000000) != 0x0ul)
  662. {
  663. C_Size = ((Buffer[1] & 0x0000003ful) << 16) | ((Buffer[2] & 0xffff0000ul) >> 16);
  664. size = (C_Size + 1ul) * 512ul; /* Kbytes */
  665. pSD->diskSize = size;
  666. pSD->totalSectorN = size << 1;
  667. }
  668. else
  669. {
  670. R_LEN = (Buffer[1] & 0x000f0000ul) >> 16;
  671. C_Size = ((Buffer[1] & 0x000003fful) << 2) | ((Buffer[2] & 0xc0000000ul) >> 30);
  672. MULT = (Buffer[2] & 0x00038000ul) >> 15;
  673. size = (C_Size + 1ul) * (1ul << (MULT + 2ul)) * (1ul << R_LEN);
  674. pSD->diskSize = size / 1024ul;
  675. pSD->totalSectorN = size / 512ul;
  676. }
  677. }
  678. pSD->sectorSize = (int)512;
  679. // printf("The size is %d KB\n", pSD->diskSize);
  680. }
  681. /** @endcond HIDDEN_SYMBOLS */
  682. /**
  683. * @brief This function use to reset SD function and select card detection source and pin.
  684. *
  685. * @param[in] sdh Select SDH0 or SDH1.
  686. * @param[in] u32CardDetSrc Select card detection pin from GPIO or DAT3 pin. ( \ref CardDetect_From_GPIO / \ref CardDetect_From_DAT3)
  687. *
  688. * @return None
  689. */
  690. void SDH_Open(SDH_T *sdh, uint32_t u32CardDetSrc)
  691. {
  692. volatile int i;
  693. sdh->DMACTL = SDH_DMACTL_DMARST_Msk;
  694. while ((sdh->DMACTL & SDH_DMACTL_DMARST_Msk) == SDH_DMACTL_DMARST_Msk)
  695. {
  696. }
  697. sdh->DMACTL = SDH_DMACTL_DMAEN_Msk;
  698. sdh->GCTL = SDH_GCTL_GCTLRST_Msk | SDH_GCTL_SDEN_Msk;
  699. while ((sdh->GCTL & SDH_GCTL_GCTLRST_Msk) == SDH_GCTL_GCTLRST_Msk)
  700. {
  701. }
  702. if (sdh == SDH0)
  703. {
  704. memset(&SD0, 0, sizeof(SDH_INFO_T));
  705. SD0.dmabuf = (unsigned char *)((uint32_t)_SDH0_ucSDHCBuffer | 0x80000000);
  706. }
  707. else if (sdh == SDH1)
  708. {
  709. memset(&SD1, 0, sizeof(SDH_INFO_T));
  710. SD1.dmabuf = (unsigned char *)((uint32_t)_SDH1_ucSDHCBuffer | 0x80000000);
  711. }
  712. else
  713. {
  714. }
  715. sdh->GCTL = SDH_GCTL_SDEN_Msk;
  716. if ((u32CardDetSrc & CardDetect_From_DAT3) == CardDetect_From_DAT3)
  717. {
  718. sdh->INTEN &= ~SDH_INTEN_CDSRC_Msk;
  719. }
  720. else
  721. {
  722. sdh->INTEN |= SDH_INTEN_CDSRC_Msk;
  723. }
  724. for (i = 0; i < 0x100; i++);
  725. sdh->INTSTS = SDH_INTSTS_CDIF_Msk;
  726. sdh->INTEN |= SDH_INTEN_CDIEN_Msk;
  727. sdh->CTL |= SDH_CTL_CTLRST_Msk;
  728. while ((sdh->CTL & SDH_CTL_CTLRST_Msk) == SDH_CTL_CTLRST_Msk)
  729. {
  730. }
  731. }
  732. /**
  733. * @brief This function use to initial SD card.
  734. *
  735. * @param[in] sdh Select SDH0 or SDH1.
  736. *
  737. * @return None
  738. *
  739. * @details This function is used to initial SD card.
  740. * SD initial state needs 400KHz clock output, driver will use HIRC for SD initial clock source.
  741. * And then switch back to the user's setting.
  742. */
  743. uint32_t SDH_Probe(SDH_T *sdh)
  744. {
  745. uint32_t val;
  746. sdh->GINTEN = 0ul;
  747. sdh->CTL &= ~SDH_CTL_SDNWR_Msk;
  748. sdh->CTL |= 0x09ul << SDH_CTL_SDNWR_Pos; /* set SDNWR = 9 */
  749. sdh->CTL &= ~SDH_CTL_BLKCNT_Msk;
  750. sdh->CTL |= 0x01ul << SDH_CTL_BLKCNT_Pos; /* set BLKCNT = 1 */
  751. sdh->CTL &= ~SDH_CTL_DBW_Msk; /* SD 1-bit data bus */
  752. if (!(SDH_CardDetection(sdh)))
  753. {
  754. return SDH_NO_SD_CARD;
  755. }
  756. if ((val = SDH_Init(sdh)) != 0ul)
  757. {
  758. return val;
  759. }
  760. /* divider */
  761. if ((SD0.CardType == SDH_TYPE_MMC) || (SD1.CardType == SDH_TYPE_MMC))
  762. {
  763. SDH_Set_clock(sdh, MMC_FREQ);
  764. }
  765. else
  766. {
  767. SDH_Set_clock(sdh, SD_FREQ);
  768. }
  769. SDH_Get_SD_info(sdh);
  770. if ((val = SDH_SelectCardType(sdh)) != 0ul)
  771. {
  772. return val;
  773. }
  774. return 0ul;
  775. }
  776. /**
  777. * @brief This function use to read data from SD card.
  778. *
  779. * @param[in] sdh Select SDH0 or SDH1.
  780. * @param[out] pu8BufAddr The buffer to receive the data from SD card.
  781. * @param[in] u32StartSec The start read sector address.
  782. * @param[in] u32SecCount The the read sector number of data
  783. *
  784. * @return None
  785. */
  786. uint32_t SDH_Read(SDH_T *sdh, uint8_t *pu8BufAddr, uint32_t u32StartSec, uint32_t u32SecCount)
  787. {
  788. uint32_t volatile bIsSendCmd = FALSE, buf;
  789. uint32_t volatile reg;
  790. uint32_t volatile i, loop, status;
  791. uint32_t blksize = SDH_BLOCK_SIZE;
  792. SDH_INFO_T *pSD;
  793. if (sdh == SDH0)
  794. {
  795. pSD = &SD0;
  796. }
  797. else
  798. {
  799. pSD = &SD1;
  800. }
  801. if (u32SecCount == 0ul)
  802. {
  803. return SDH_SELECT_ERROR;
  804. }
  805. if ((status = SDH_SDCmdAndRsp(sdh, 7ul, pSD->RCA, 0ul)) != Successful)
  806. {
  807. return status;
  808. }
  809. SDH_CheckRB(sdh);
  810. sdh->BLEN = blksize - 1ul; /* the actual byte count is equal to (SDBLEN+1) */
  811. if ((pSD->CardType == SDH_TYPE_SD_HIGH) || (pSD->CardType == SDH_TYPE_EMMC))
  812. {
  813. sdh->CMDARG = u32StartSec;
  814. }
  815. else
  816. {
  817. sdh->CMDARG = u32StartSec * blksize;
  818. }
  819. sdh->DMASA = (uint32_t)pu8BufAddr;
  820. loop = u32SecCount / 255ul;
  821. for (i = 0ul; i < loop; i++)
  822. {
  823. pSD->DataReadyFlag = (uint8_t)FALSE;
  824. reg = sdh->CTL & ~SDH_CTL_CMDCODE_Msk;
  825. reg = reg | 0xff0000ul; /* set BLK_CNT to 255 */
  826. if (bIsSendCmd == FALSE)
  827. {
  828. sdh->CTL = reg | (18ul << 8) | (SDH_CTL_COEN_Msk | SDH_CTL_RIEN_Msk | SDH_CTL_DIEN_Msk);
  829. bIsSendCmd = TRUE;
  830. }
  831. else
  832. {
  833. sdh->CTL = reg | SDH_CTL_DIEN_Msk;
  834. }
  835. while (!pSD->DataReadyFlag)
  836. {
  837. if (pSD->DataReadyFlag)
  838. {
  839. break;
  840. }
  841. if (pSD->IsCardInsert == FALSE)
  842. {
  843. return SDH_NO_SD_CARD;
  844. }
  845. }
  846. if ((sdh->INTSTS & SDH_INTSTS_CRC7_Msk) != SDH_INTSTS_CRC7_Msk) /* check CRC7 */
  847. {
  848. return SDH_CRC7_ERROR;
  849. }
  850. if ((sdh->INTSTS & SDH_INTSTS_CRC16_Msk) != SDH_INTSTS_CRC16_Msk) /* check CRC16 */
  851. {
  852. return SDH_CRC16_ERROR;
  853. }
  854. }
  855. loop = u32SecCount % 255ul;
  856. if (loop != 0ul)
  857. {
  858. pSD->DataReadyFlag = (uint8_t)FALSE;
  859. reg = sdh->CTL & (~SDH_CTL_CMDCODE_Msk);
  860. reg = reg & (~SDH_CTL_BLKCNT_Msk);
  861. reg |= (loop << 16); /* setup SDCR_BLKCNT */
  862. if (bIsSendCmd == FALSE)
  863. {
  864. sdh->CTL = reg | (18ul << 8) | (SDH_CTL_COEN_Msk | SDH_CTL_RIEN_Msk | SDH_CTL_DIEN_Msk);
  865. bIsSendCmd = TRUE;
  866. }
  867. else
  868. {
  869. sdh->CTL = reg | SDH_CTL_DIEN_Msk;
  870. }
  871. while (!pSD->DataReadyFlag)
  872. {
  873. if (pSD->IsCardInsert == FALSE)
  874. {
  875. return SDH_NO_SD_CARD;
  876. }
  877. }
  878. if ((sdh->INTSTS & SDH_INTSTS_CRC7_Msk) != SDH_INTSTS_CRC7_Msk) /* check CRC7 */
  879. {
  880. return SDH_CRC7_ERROR;
  881. }
  882. if ((sdh->INTSTS & SDH_INTSTS_CRC16_Msk) != SDH_INTSTS_CRC16_Msk) /* check CRC16 */
  883. {
  884. return SDH_CRC16_ERROR;
  885. }
  886. }
  887. if (SDH_SDCmdAndRsp(sdh, 12ul, 0ul, 0ul)) /* stop command */
  888. {
  889. return SDH_CRC7_ERROR;
  890. }
  891. SDH_CheckRB(sdh);
  892. SDH_SDCommand(sdh, 7ul, 0ul);
  893. sdh->CTL |= SDH_CTL_CLK8OEN_Msk;
  894. while ((sdh->CTL & SDH_CTL_CLK8OEN_Msk) == SDH_CTL_CLK8OEN_Msk)
  895. {
  896. }
  897. return Successful;
  898. }
  899. /**
  900. * @brief This function use to write data to SD card.
  901. *
  902. * @param[in] sdh Select SDH0 or SDH1.
  903. * @param[in] pu8BufAddr The buffer to send the data to SD card.
  904. * @param[in] u32StartSec The start write sector address.
  905. * @param[in] u32SecCount The the write sector number of data.
  906. *
  907. * @return \ref SDH_SELECT_ERROR : u32SecCount is zero. \n
  908. * \ref SDH_NO_SD_CARD : SD card be removed. \n
  909. * \ref SDH_CRC_ERROR : CRC error happen. \n
  910. * \ref SDH_CRC7_ERROR : CRC7 error happen. \n
  911. * \ref Successful : Write data to SD card success.
  912. */
  913. uint32_t SDH_Write(SDH_T *sdh, uint8_t *pu8BufAddr, uint32_t u32StartSec, uint32_t u32SecCount)
  914. {
  915. uint32_t volatile bIsSendCmd = FALSE;
  916. uint32_t volatile reg;
  917. uint32_t volatile i, loop, status;
  918. SDH_INFO_T *pSD;
  919. if (sdh == SDH0)
  920. {
  921. pSD = &SD0;
  922. }
  923. else
  924. {
  925. pSD = &SD1;
  926. }
  927. if (u32SecCount == 0ul)
  928. {
  929. return SDH_SELECT_ERROR;
  930. }
  931. if ((status = SDH_SDCmdAndRsp(sdh, 7ul, pSD->RCA, 0ul)) != Successful)
  932. {
  933. return status;
  934. }
  935. SDH_CheckRB(sdh);
  936. /* According to SD Spec v2.0, the write CMD block size MUST be 512, and the start address MUST be 512*n. */
  937. sdh->BLEN = SDH_BLOCK_SIZE - 1ul;
  938. if ((pSD->CardType == SDH_TYPE_SD_HIGH) || (pSD->CardType == SDH_TYPE_EMMC))
  939. {
  940. sdh->CMDARG = u32StartSec;
  941. }
  942. else
  943. {
  944. sdh->CMDARG = u32StartSec * SDH_BLOCK_SIZE; /* set start address for SD CMD */
  945. }
  946. sdh->DMASA = (uint32_t)pu8BufAddr;
  947. loop = u32SecCount / 255ul; /* the maximum block count is 0xFF=255 for register SDCR[BLK_CNT] */
  948. for (i = 0ul; i < loop; i++)
  949. {
  950. pSD->DataReadyFlag = (uint8_t)FALSE;
  951. reg = sdh->CTL & 0xff00c080;
  952. reg = reg | 0xff0000ul; /* set BLK_CNT to 0xFF=255 */
  953. if (!bIsSendCmd)
  954. {
  955. sdh->CTL = reg | (25ul << 8) | (SDH_CTL_COEN_Msk | SDH_CTL_RIEN_Msk | SDH_CTL_DOEN_Msk);
  956. bIsSendCmd = TRUE;
  957. }
  958. else
  959. {
  960. sdh->CTL = reg | SDH_CTL_DOEN_Msk;
  961. }
  962. while (!pSD->DataReadyFlag)
  963. {
  964. if (pSD->IsCardInsert == FALSE)
  965. {
  966. return SDH_NO_SD_CARD;
  967. }
  968. }
  969. if ((sdh->INTSTS & SDH_INTSTS_CRCIF_Msk) != 0ul)
  970. {
  971. sdh->INTSTS = SDH_INTSTS_CRCIF_Msk;
  972. return SDH_CRC_ERROR;
  973. }
  974. }
  975. loop = u32SecCount % 255ul;
  976. if (loop != 0ul)
  977. {
  978. pSD->DataReadyFlag = (uint8_t)FALSE;
  979. reg = (sdh->CTL & 0xff00c080) | (loop << 16);
  980. if (!bIsSendCmd)
  981. {
  982. sdh->CTL = reg | (25ul << 8) | (SDH_CTL_COEN_Msk | SDH_CTL_RIEN_Msk | SDH_CTL_DOEN_Msk);
  983. bIsSendCmd = TRUE;
  984. }
  985. else
  986. {
  987. sdh->CTL = reg | SDH_CTL_DOEN_Msk;
  988. }
  989. while (!pSD->DataReadyFlag)
  990. {
  991. if (pSD->IsCardInsert == FALSE)
  992. {
  993. return SDH_NO_SD_CARD;
  994. }
  995. }
  996. if ((sdh->INTSTS & SDH_INTSTS_CRCIF_Msk) != 0ul)
  997. {
  998. sdh->INTSTS = SDH_INTSTS_CRCIF_Msk;
  999. return SDH_CRC_ERROR;
  1000. }
  1001. }
  1002. sdh->INTSTS = SDH_INTSTS_CRCIF_Msk;
  1003. if (SDH_SDCmdAndRsp(sdh, 12ul, 0ul, 0ul)) /* stop command */
  1004. {
  1005. return SDH_CRC7_ERROR;
  1006. }
  1007. SDH_CheckRB(sdh);
  1008. SDH_SDCommand(sdh, 7ul, 0ul);
  1009. sdh->CTL |= SDH_CTL_CLK8OEN_Msk;
  1010. while ((sdh->CTL & SDH_CTL_CLK8OEN_Msk) == SDH_CTL_CLK8OEN_Msk)
  1011. {
  1012. }
  1013. return Successful;
  1014. }
  1015. /*@}*/ /* end of group SDH_EXPORTED_FUNCTIONS */
  1016. /*@}*/ /* end of group SDH_Driver */
  1017. /*@}*/ /* end of group Device_Driver */