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