drv_sdh.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636
  1. /**************************************************************************//**
  2. *
  3. * @copyright (C) 2020 Nuvoton Technology Corp. All rights reserved.
  4. *
  5. * SPDX-License-Identifier: Apache-2.0
  6. *
  7. * Change Logs:
  8. * Date Author Notes
  9. * 2020-2-7 Wayne First version
  10. *
  11. ******************************************************************************/
  12. #include <rtconfig.h>
  13. #if defined(BSP_USING_SDH)
  14. #include <rtdevice.h>
  15. #include "NuMicro.h"
  16. #include <drv_pdma.h>
  17. #include <string.h>
  18. #include <dfs_fs.h>
  19. #include <dfs_file.h>
  20. #include <unistd.h>
  21. #include <stdio.h>
  22. #include <sys/stat.h>
  23. #include <sys/statfs.h>
  24. /* Private define ---------------------------------------------------------------*/
  25. #if defined(NU_SDH_MOUNT_ON_ROOT)
  26. #if !defined(NU_SDH_MOUNTPOINT_SDH0)
  27. #define NU_SDH_MOUNTPOINT_SDH0 "/"
  28. #endif
  29. #if !defined(NU_SDH_MOUNTPOINT_SDH1)
  30. #define NU_SDH_MOUNTPOINT_SDH1 NU_SDH_MOUNTPOINT_SDH0"/sd1"
  31. #endif
  32. #else
  33. #if !defined(NU_SDH_MOUNTPOINT_ROOT)
  34. #define NU_SDH_MOUNTPOINT_ROOT "/mnt"
  35. #endif
  36. #endif
  37. #if !defined(NU_SDH_MOUNTPOINT_SDH0)
  38. #define NU_SDH_MOUNTPOINT_SDH0 NU_SDH_MOUNTPOINT_ROOT"/sd0"
  39. #endif
  40. #if !defined(NU_SDH_MOUNTPOINT_SDH1)
  41. #define NU_SDH_MOUNTPOINT_SDH1 NU_SDH_MOUNTPOINT_ROOT"/sd1"
  42. #endif
  43. #if defined(NU_SDH_USING_PDMA)
  44. #define NU_SDH_MEMCPY nu_pdma_memcpy
  45. #else
  46. #define NU_SDH_MEMCPY memcpy
  47. #endif
  48. enum
  49. {
  50. SDH_START = -1,
  51. #if defined(BSP_USING_SDH0)
  52. SDH0_IDX,
  53. #endif
  54. #if defined(BSP_USING_SDH1)
  55. SDH1_IDX,
  56. #endif
  57. SDH_CNT
  58. };
  59. #define SDH_BLOCK_SIZE 512ul
  60. #if defined(NU_SDH_HOTPLUG)
  61. #define NU_SDH_TID_STACK_SIZE 1024
  62. #endif
  63. #if defined(NU_SDH_HOTPLUG)
  64. enum
  65. {
  66. NU_SDH_CARD_DETECTED_SD0 = (1 << 0),
  67. NU_SDH_CARD_DETECTED_SD1 = (1 << 1),
  68. NU_SDH_CARD_EVENT_ALL = (NU_SDH_CARD_DETECTED_SD0 | NU_SDH_CARD_DETECTED_SD1)
  69. };
  70. #endif
  71. /* Private typedef --------------------------------------------------------------*/
  72. struct nu_sdh
  73. {
  74. struct rt_device dev;
  75. char *name;
  76. #if defined(NU_SDH_HOTPLUG)
  77. char *mounted_point;
  78. #endif
  79. SDH_T *base;
  80. uint32_t is_card_inserted;
  81. SDH_INFO_T *info;
  82. struct rt_semaphore lock;
  83. uint8_t *pbuf;
  84. };
  85. typedef struct nu_sdh *nu_sdh_t;
  86. #if defined(NU_SDH_HOTPLUG)
  87. static struct rt_thread sdh_tid;
  88. static rt_uint8_t sdh_stack[NU_SDH_TID_STACK_SIZE];
  89. #endif
  90. /* Private functions ------------------------------------------------------------*/
  91. static void nu_sdh_isr(nu_sdh_t sdh);
  92. static rt_err_t nu_sdh_init(rt_device_t dev);
  93. static rt_err_t nu_sdh_open(rt_device_t dev, rt_uint16_t oflag);
  94. static rt_err_t nu_sdh_close(rt_device_t dev);
  95. static rt_size_t nu_sdh_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t blk_nb);
  96. static rt_err_t nu_sdh_control(rt_device_t dev, int cmd, void *args);
  97. static int rt_hw_sdh_init(void);
  98. #if defined(NU_SDH_HOTPLUG)
  99. static rt_bool_t nu_sdh_hotplug_is_mounted(const char *mounting_path);
  100. static void sdh_hotplugger(void *param);
  101. static rt_err_t nu_sdh_hotplug_mount(nu_sdh_t sdh);
  102. static rt_err_t nu_sdh_hotplug_unmount(nu_sdh_t sdh);
  103. #endif
  104. /* Public functions -------------------------------------------------------------*/
  105. /* Private variables ------------------------------------------------------------*/
  106. static struct nu_sdh nu_sdh_arr [] =
  107. {
  108. #if defined(BSP_USING_SDH0)
  109. {
  110. .name = "sdh0",
  111. #if defined(NU_SDH_HOTPLUG)
  112. .mounted_point = NU_SDH_MOUNTPOINT_SDH0,
  113. #endif
  114. .base = SDH0,
  115. .info = &SD0,
  116. },
  117. #endif
  118. #if defined(BSP_USING_SDH1)
  119. {
  120. .name = "sdh1",
  121. #if defined(NU_SDH_HOTPLUG)
  122. .mounted_point = NU_SDH_MOUNTPOINT_SDH1,
  123. #endif
  124. .base = SDH1,
  125. .info = &SD1,
  126. },
  127. #endif
  128. {0}
  129. }; /* struct nu_sdh nu_sdh_arr [] */
  130. static struct rt_event sdh_event;
  131. static void nu_sdh_isr(nu_sdh_t sdh)
  132. {
  133. SDH_T *sdh_base = sdh->base;
  134. unsigned int volatile isr;
  135. unsigned int volatile ier;
  136. SDH_INFO_T *pSD = sdh->info;
  137. // FMI data abort interrupt
  138. if (sdh_base->GINTSTS & SDH_GINTSTS_DTAIF_Msk)
  139. {
  140. /* ResetAllEngine() */
  141. sdh_base->GCTL |= SDH_GCTL_GCTLRST_Msk;
  142. }
  143. //----- SD interrupt status
  144. isr = sdh_base->INTSTS;
  145. if (isr & SDH_INTSTS_BLKDIF_Msk)
  146. {
  147. // block down
  148. pSD->DataReadyFlag = TRUE;
  149. SDH_CLR_INT_FLAG(sdh_base, SDH_INTSTS_BLKDIF_Msk);
  150. }
  151. if (isr & SDH_INTSTS_CDIF_Msk) // card detect
  152. {
  153. #if defined(NU_SDH_HOTPLUG)
  154. if (sdh->base == SDH0)
  155. rt_event_send(&sdh_event, NU_SDH_CARD_DETECTED_SD0);
  156. else if (sdh->base == SDH1)
  157. rt_event_send(&sdh_event, NU_SDH_CARD_DETECTED_SD1);
  158. #endif
  159. /* Clear CDIF interrupt flag */
  160. SDH_CLR_INT_FLAG(sdh_base, SDH_INTSTS_CDIF_Msk);
  161. }
  162. // CRC error interrupt
  163. if (isr & SDH_INTSTS_CRCIF_Msk)
  164. {
  165. if (!(isr & SDH_INTSTS_CRC16_Msk))
  166. {
  167. /* CRC_16 error */
  168. // TODO: handle CRC 16 error
  169. }
  170. else if (!(isr & SDH_INTSTS_CRC7_Msk))
  171. {
  172. if (!pSD->R3Flag)
  173. {
  174. /* CRC_7 error */
  175. // TODO: handle CRC 7 error
  176. }
  177. }
  178. /* Clear CRCIF interrupt flag */
  179. SDH_CLR_INT_FLAG(sdh_base, SDH_INTSTS_CRCIF_Msk);
  180. }
  181. /* Data-in timeout */
  182. if (isr & SDH_INTSTS_DITOIF_Msk)
  183. {
  184. sdh_base->INTSTS |= SDH_INTSTS_DITOIF_Msk;
  185. }
  186. /* Response-in timeout interrupt */
  187. if (isr & SDH_INTSTS_RTOIF_Msk)
  188. {
  189. sdh_base->INTSTS |= SDH_INTSTS_RTOIF_Msk;
  190. }
  191. }
  192. #if defined(BSP_USING_SDH0)
  193. void SDH0_IRQHandler(void)
  194. {
  195. /* enter interrupt */
  196. rt_interrupt_enter();
  197. nu_sdh_isr(&nu_sdh_arr[SDH0_IDX]);
  198. /* leave interrupt */
  199. rt_interrupt_leave();
  200. }
  201. #endif
  202. #if defined(BSP_USING_SDH1)
  203. void SDH1_IRQHandler(void)
  204. {
  205. /* enter interrupt */
  206. rt_interrupt_enter();
  207. nu_sdh_isr(&nu_sdh_arr[SDH1_IDX]);
  208. /* leave interrupt */
  209. rt_interrupt_leave();
  210. }
  211. #endif
  212. /* RT-Thread Device Driver Interface */
  213. static rt_err_t nu_sdh_init(rt_device_t dev)
  214. {
  215. return RT_EOK;
  216. }
  217. static rt_err_t nu_sdh_open(rt_device_t dev, rt_uint16_t oflag)
  218. {
  219. nu_sdh_t sdh = (nu_sdh_t)dev;
  220. RT_ASSERT(dev != RT_NULL);
  221. return (SDH_Probe(sdh->base) == 0) ? RT_EOK : -(RT_ERROR);
  222. }
  223. static rt_err_t nu_sdh_close(rt_device_t dev)
  224. {
  225. return RT_EOK;
  226. }
  227. static rt_size_t nu_sdh_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t blk_nb)
  228. {
  229. rt_uint32_t ret = 0;
  230. nu_sdh_t sdh = (nu_sdh_t)dev;
  231. rt_err_t result;
  232. RT_ASSERT(dev != RT_NULL);
  233. RT_ASSERT(buffer != RT_NULL);
  234. result = rt_sem_take(&sdh->lock, RT_WAITING_FOREVER);
  235. RT_ASSERT(result == RT_EOK);
  236. /* Check alignment. */
  237. if (((uint32_t)buffer & 0x03) != 0)
  238. {
  239. /* Non-aligned. */
  240. uint32_t i;
  241. uint8_t *copy_buffer = (uint8_t *)buffer;
  242. sdh->pbuf = rt_malloc(SDH_BLOCK_SIZE);
  243. if (sdh->pbuf == RT_NULL)
  244. goto exit_nu_sdh_read;
  245. for (i = 0; i < blk_nb; i++)
  246. {
  247. /* Read to temp buffer from specified sector. */
  248. ret = SDH_Read(sdh->base, &sdh->pbuf[0], pos, 1);
  249. if (ret != Successful)
  250. goto exit_nu_sdh_read;
  251. /* Move to user's buffer */
  252. NU_SDH_MEMCPY((void *)copy_buffer, (void *)&sdh->pbuf[0], SDH_BLOCK_SIZE);
  253. pos ++;
  254. copy_buffer += SDH_BLOCK_SIZE;
  255. }
  256. }
  257. else
  258. {
  259. /* Read to user's buffer from specified sector. */
  260. ret = SDH_Read(sdh->base, (uint8_t *)buffer, pos, blk_nb);
  261. }
  262. exit_nu_sdh_read:
  263. if (sdh->pbuf)
  264. {
  265. rt_free(sdh->pbuf);
  266. sdh->pbuf = RT_NULL;
  267. }
  268. result = rt_sem_release(&sdh->lock);
  269. RT_ASSERT(result == RT_EOK);
  270. if (ret == Successful)
  271. return blk_nb;
  272. rt_kprintf("Read failed: %d, buffer 0x%08x\n", ret, buffer);
  273. rt_set_errno(-RT_ENOSYS);
  274. return 0;
  275. }
  276. static rt_size_t nu_sdh_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t blk_nb)
  277. {
  278. rt_uint32_t ret = 0;
  279. nu_sdh_t sdh = (nu_sdh_t)dev;
  280. rt_err_t result;
  281. RT_ASSERT(dev != RT_NULL);
  282. RT_ASSERT(buffer != RT_NULL);
  283. result = rt_sem_take(&sdh->lock, RT_WAITING_FOREVER);
  284. RT_ASSERT(result == RT_EOK);
  285. /* Check alignment. */
  286. if (((uint32_t)buffer & 0x03) != 0)
  287. {
  288. /* Non-aligned. */
  289. uint32_t i;
  290. uint8_t *copy_buffer = (uint8_t *)buffer;
  291. sdh->pbuf = rt_malloc(SDH_BLOCK_SIZE);
  292. if (sdh->pbuf == RT_NULL)
  293. goto exit_nu_sdh_write;
  294. for (i = 0; i < blk_nb; i++)
  295. {
  296. NU_SDH_MEMCPY((void *)&sdh->pbuf[0], copy_buffer, SDH_BLOCK_SIZE);
  297. ret = SDH_Write(sdh->base, (uint8_t *)&sdh->pbuf[0], pos, 1);
  298. if (ret != Successful)
  299. goto exit_nu_sdh_write;
  300. pos++;
  301. copy_buffer += SDH_BLOCK_SIZE;
  302. }
  303. }
  304. else
  305. {
  306. /* Write to device directly. */
  307. ret = SDH_Write(sdh->base, (uint8_t *)buffer, pos, blk_nb);
  308. }
  309. exit_nu_sdh_write:
  310. if (sdh->pbuf)
  311. {
  312. rt_free(sdh->pbuf);
  313. sdh->pbuf = RT_NULL;
  314. }
  315. result = rt_sem_release(&sdh->lock);
  316. RT_ASSERT(result == RT_EOK);
  317. if (ret == Successful) return blk_nb;
  318. rt_kprintf("write failed: %d, buffer 0x%08x\n", ret, buffer);
  319. rt_set_errno(-RT_ENOSYS);
  320. return 0;
  321. }
  322. static rt_err_t nu_sdh_control(rt_device_t dev, int cmd, void *args)
  323. {
  324. nu_sdh_t sdh = (nu_sdh_t)dev;
  325. RT_ASSERT(dev != RT_NULL);
  326. if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME)
  327. {
  328. SDH_INFO_T *sdh_info = sdh->info;
  329. struct rt_device_blk_geometry *geometry;
  330. geometry = (struct rt_device_blk_geometry *)args;
  331. if (geometry == RT_NULL) return -RT_ERROR;
  332. geometry->bytes_per_sector = sdh_info->sectorSize;
  333. geometry->block_size = sdh_info->sectorSize;
  334. geometry->sector_count = sdh_info->totalSectorN;
  335. }
  336. return RT_EOK;
  337. }
  338. static int rt_hw_sdh_init(void)
  339. {
  340. int i;
  341. rt_err_t ret = RT_EOK;
  342. rt_uint32_t flags = RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE;
  343. rt_event_init(&sdh_event, "sdh_event", RT_IPC_FLAG_FIFO);
  344. for (i = (SDH_START + 1); i < SDH_CNT; i++)
  345. {
  346. /* Register sdcard device */
  347. nu_sdh_arr[i].dev.type = RT_Device_Class_Block;
  348. nu_sdh_arr[i].dev.init = nu_sdh_init;
  349. nu_sdh_arr[i].dev.open = nu_sdh_open;
  350. nu_sdh_arr[i].dev.close = nu_sdh_close;
  351. nu_sdh_arr[i].dev.read = nu_sdh_read;
  352. nu_sdh_arr[i].dev.write = nu_sdh_write;
  353. nu_sdh_arr[i].dev.control = nu_sdh_control;
  354. /* Private */
  355. nu_sdh_arr[i].dev.user_data = (void *)&nu_sdh_arr[i];
  356. ret = rt_sem_init(&nu_sdh_arr[i].lock, "sdhlock", 1, RT_IPC_FLAG_FIFO);
  357. RT_ASSERT(ret == RT_EOK);
  358. SDH_Open(nu_sdh_arr[i].base, CardDetect_From_GPIO);
  359. nu_sdh_arr[i].pbuf = RT_NULL;
  360. ret = rt_device_register(&nu_sdh_arr[i].dev, nu_sdh_arr[i].name, flags);
  361. RT_ASSERT(ret == RT_EOK);
  362. }
  363. return (int)ret;
  364. }
  365. INIT_BOARD_EXPORT(rt_hw_sdh_init);
  366. #if defined(NU_SDH_HOTPLUG)
  367. static rt_bool_t nu_sdh_hotplug_is_mounted(const char *mounting_path)
  368. {
  369. rt_bool_t ret = RT_FALSE;
  370. struct dfs_filesystem *psFS = dfs_filesystem_lookup(mounting_path);
  371. if (psFS == RT_NULL)
  372. {
  373. goto exit_nu_sdh_hotplug_is_mounted;
  374. }
  375. else if (!rt_memcmp(psFS->path, mounting_path, rt_strlen(mounting_path)))
  376. {
  377. ret = RT_TRUE;
  378. }
  379. else
  380. {
  381. ret = RT_FALSE;
  382. }
  383. exit_nu_sdh_hotplug_is_mounted:
  384. return ret;
  385. }
  386. static rt_err_t nu_sdh_hotplug_mount(nu_sdh_t sdh)
  387. {
  388. rt_err_t ret = RT_ERROR;
  389. DIR *t;
  390. if (nu_sdh_hotplug_is_mounted(sdh->mounted_point) == RT_TRUE)
  391. {
  392. ret = RT_EOK;
  393. goto exit_nu_sdh_hotplug_mount;
  394. }
  395. /* Check the SD folder path is valid. */
  396. if ((t = opendir(sdh->mounted_point)) != RT_NULL)
  397. {
  398. closedir(t);
  399. }
  400. #if !defined(NU_SDH_MOUNT_ON_ROOT)
  401. else
  402. {
  403. /* Check the ROOT path is valid. */
  404. if ((t = opendir(NU_SDH_MOUNTPOINT_ROOT)) != RT_NULL)
  405. {
  406. closedir(t);
  407. }
  408. else if ((ret = mkdir(NU_SDH_MOUNTPOINT_ROOT, 0)) != RT_EOK)
  409. {
  410. rt_kprintf("Failed to mkdir %s\n", NU_SDH_MOUNTPOINT_ROOT);
  411. goto exit_nu_sdh_hotplug_mount;
  412. }
  413. if ((ret = mkdir(sdh->mounted_point, 0)) != RT_EOK)
  414. {
  415. rt_kprintf("Failed to mkdir %s\n", sdh->mounted_point);
  416. goto exit_nu_sdh_hotplug_mount;
  417. }
  418. } //else
  419. #endif
  420. if ((ret = dfs_mount(sdh->name, sdh->mounted_point, "elm", 0, 0)) == 0)
  421. {
  422. rt_kprintf("Mounted %s on %s\n", sdh->name, sdh->mounted_point);
  423. }
  424. else
  425. {
  426. rt_kprintf("Failed to mount %s on %s\n", sdh->name, sdh->mounted_point);
  427. ret = RT_ERROR;
  428. }
  429. exit_nu_sdh_hotplug_mount:
  430. return -(ret);
  431. }
  432. static rt_err_t nu_sdh_hotplug_unmount(nu_sdh_t sdh)
  433. {
  434. rt_err_t ret = RT_ERROR;
  435. if (nu_sdh_hotplug_is_mounted(sdh->mounted_point) == RT_FALSE)
  436. {
  437. ret = RT_EOK;
  438. goto exit_nu_sdh_hotplug_unmount;
  439. }
  440. ret = dfs_unmount(sdh->mounted_point);
  441. if (ret != RT_EOK)
  442. {
  443. rt_kprintf("Failed to unmount %s.\n", sdh->mounted_point);
  444. }
  445. else
  446. {
  447. rt_kprintf("Succeed to unmount %s.\n", sdh->mounted_point);
  448. ret = RT_EOK;
  449. }
  450. exit_nu_sdh_hotplug_unmount:
  451. return -(ret);
  452. }
  453. static void nu_card_detector(nu_sdh_t sdh)
  454. {
  455. SDH_T *sdh_base = sdh->base;
  456. unsigned int volatile isr = sdh_base->INTSTS;
  457. if (isr & SDH_INTSTS_CDSTS_Msk)
  458. {
  459. /* Card removed */
  460. sdh->info->IsCardInsert = FALSE; // SDISR_CD_Card = 1 means card remove for GPIO mode
  461. rt_memset((void *)sdh->info, 0, sizeof(SDH_INFO_T));
  462. nu_sdh_hotplug_unmount(sdh);
  463. }
  464. else
  465. {
  466. SDH_Open(sdh_base, CardDetect_From_GPIO);
  467. if (!SDH_Probe(sdh_base))
  468. {
  469. /* Card inserted */
  470. nu_sdh_hotplug_mount(sdh);
  471. }
  472. }
  473. }
  474. static void sdh_hotplugger(void *param)
  475. {
  476. rt_uint32_t e;
  477. int i;
  478. for (i = (SDH_START + 1); i < SDH_CNT; i++)
  479. {
  480. if (SDH_IS_CARD_PRESENT(nu_sdh_arr[i].base))
  481. {
  482. nu_sdh_hotplug_mount(&nu_sdh_arr[i]);
  483. }
  484. }
  485. while (1)
  486. {
  487. if (rt_event_recv(&sdh_event, (NU_SDH_CARD_EVENT_ALL),
  488. RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
  489. RT_WAITING_FOREVER, &e) == RT_EOK)
  490. {
  491. /* Debounce */
  492. rt_thread_delay(200);
  493. switch (e)
  494. {
  495. #if defined(BSP_USING_SDH0)
  496. case NU_SDH_CARD_DETECTED_SD0:
  497. nu_card_detector(&nu_sdh_arr[SDH0_IDX]);
  498. break;
  499. #endif
  500. #if defined(BSP_USING_SDH1)
  501. case NU_SDH_CARD_DETECTED_SD1:
  502. nu_card_detector(&nu_sdh_arr[SDH1_IDX]);
  503. break;
  504. #endif
  505. default:
  506. break;
  507. } //switch(e)
  508. } //if
  509. } /* while(1) */
  510. }
  511. int mnt_init_sdcard_hotplug(void)
  512. {
  513. rt_err_t result;
  514. result = rt_thread_init(&sdh_tid, "hotplug", sdh_hotplugger, NULL, sdh_stack, sizeof(sdh_stack), RT_THREAD_PRIORITY_MAX - 2, 10);
  515. RT_ASSERT(result == RT_EOK);
  516. rt_thread_startup(&sdh_tid);
  517. return 0;
  518. }
  519. INIT_ENV_EXPORT(mnt_init_sdcard_hotplug);
  520. #endif
  521. #endif //#if defined(BSP_USING_SDH)