sdcard.c 94 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442
  1. /*!
  2. \file sdcard.c
  3. \brief SD card driver
  4. \version 2017-02-10, V1.0.0, firmware for GD32F30x
  5. \version 2018-10-10, V1.1.0, firmware for GD32F30x
  6. \version 2018-12-25, V2.0.0, firmware for GD32F30x
  7. \version 2020-09-30, V2.1.0, firmware for GD32F30x
  8. */
  9. /*
  10. Copyright (c) 2020, GigaDevice Semiconductor Inc.
  11. Redistribution and use in source and binary forms, with or without modification,
  12. are permitted provided that the following conditions are met:
  13. 1. Redistributions of source code must retain the above copyright notice, this
  14. list of conditions and the following disclaimer.
  15. 2. Redistributions in binary form must reproduce the above copyright notice,
  16. this list of conditions and the following disclaimer in the documentation
  17. and/or other materials provided with the distribution.
  18. 3. Neither the name of the copyright holder nor the names of its contributors
  19. may be used to endorse or promote products derived from this software without
  20. specific prior written permission.
  21. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22. AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23. WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25. INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26. NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  27. PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28. WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29. ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  30. OF SUCH DAMAGE.
  31. */
  32. #include "sdcard.h"
  33. #include "gd32f30x_sdio.h"
  34. #include "gd32f30x_dma.h"
  35. #include <stddef.h>
  36. /* card status of R1 definitions */
  37. #define SD_R1_OUT_OF_RANGE BIT(31) /* command's argument was out of the allowed range */
  38. #define SD_R1_ADDRESS_ERROR BIT(30) /* misaligned address which did not match the block length */
  39. #define SD_R1_BLOCK_LEN_ERROR BIT(29) /* transferred block length is not allowed */
  40. #define SD_R1_ERASE_SEQ_ERROR BIT(28) /* an error in the sequence of erase commands occurred */
  41. #define SD_R1_ERASE_PARAM BIT(27) /* an invalid selection of write-blocks for erase occurred */
  42. #define SD_R1_WP_VIOLATION BIT(26) /* the host attempts to write to a protected block or to the temporary or permanent write protected card */
  43. #define SD_R1_CARD_IS_LOCKED BIT(25) /* the card is locked by the host */
  44. #define SD_R1_LOCK_UNLOCK_FAILED BIT(24) /* a sequence or password error has been detected in lock/unlock card command */
  45. #define SD_R1_COM_CRC_ERROR BIT(23) /* CRC check of the previous command failed */
  46. #define SD_R1_ILLEGAL_COMMAND BIT(22) /* command not legal for the card state */
  47. #define SD_R1_CARD_ECC_FAILED BIT(21) /* card internal ECC was applied but failed to correct the data */
  48. #define SD_R1_CC_ERROR BIT(20) /* internal card controller error */
  49. #define SD_R1_GENERAL_UNKNOWN_ERROR BIT(19) /* a general or an unknown error occurred during the operation */
  50. #define SD_R1_CSD_OVERWRITE BIT(16) /* read only section of the CSD does not match or attempt to reverse the copy or permanent WP bits */
  51. #define SD_R1_WP_ERASE_SKIP BIT(15) /* partial address space was erased */
  52. #define SD_R1_CARD_ECC_DISABLED BIT(14) /* command has been executed without using the internal ECC */
  53. #define SD_R1_ERASE_RESET BIT(13) /* an erase sequence was cleared before executing */
  54. #define SD_R1_READY_FOR_DATA BIT(8) /* correspond to buffer empty signaling on the bus */
  55. #define SD_R1_APP_CMD BIT(5) /* card will expect ACMD */
  56. #define SD_R1_AKE_SEQ_ERROR BIT(3) /* error in the sequence of the authentication process */
  57. #define SD_R1_ERROR_BITS (uint32_t)0xFDF9E008 /* all the R1 error bits */
  58. /* card status of R6 definitions */
  59. #define SD_R6_COM_CRC_ERROR BIT(15) /* CRC check of the previous command failed */
  60. #define SD_R6_ILLEGAL_COMMAND BIT(14) /* command not legal for the card state */
  61. #define SD_R6_GENERAL_UNKNOWN_ERROR BIT(13) /* a general or an unknown error occurred during the operation */
  62. /* card state */
  63. #define SD_CARDSTATE_IDLE ((uint8_t)0x00) /* card is in idle state */
  64. #define SD_CARDSTATE_READY ((uint8_t)0x01) /* card is in ready state */
  65. #define SD_CARDSTATE_IDENTIFICAT ((uint8_t)0x02) /* card is in identificat state */
  66. #define SD_CARDSTATE_STANDBY ((uint8_t)0x03) /* card is in standby state */
  67. #define SD_CARDSTATE_TRANSFER ((uint8_t)0x04) /* card is in transfer state */
  68. #define SD_CARDSTATE_DATA ((uint8_t)0x05) /* card is in data sending state */
  69. #define SD_CARDSTATE_RECEIVING ((uint8_t)0x06) /* card is in receiving state */
  70. #define SD_CARDSTATE_PROGRAMMING ((uint8_t)0x07) /* card is in programming state */
  71. #define SD_CARDSTATE_DISCONNECT ((uint8_t)0x08) /* card is in disconnect state */
  72. #define SD_CARDSTATE_LOCKED ((uint32_t)0x02000000) /* card is in locked state */
  73. #define SD_CHECK_PATTERN ((uint32_t)0x000001AA) /* check pattern for CMD8 */
  74. #define SD_VOLTAGE_WINDOW ((uint32_t)0x80100000) /* host 3.3V request in ACMD41 */
  75. /* parameters for ACMD41(voltage validation) */
  76. #define SD_HIGH_CAPACITY ((uint32_t)0x40000000) /* high capacity SD memory card */
  77. #define SD_STD_CAPACITY ((uint32_t)0x00000000) /* standard capacity SD memory card */
  78. /* SD bus width, check SCR register */
  79. #define SD_BUS_WIDTH_4BIT ((uint32_t)0x00040000) /* 4-bit width bus mode */
  80. #define SD_BUS_WIDTH_1BIT ((uint32_t)0x00010000) /* 1-bit width bus mode */
  81. /* masks for SCR register */
  82. #define SD_MASK_0_7BITS ((uint32_t)0x000000FF) /* mask [7:0] bits */
  83. #define SD_MASK_8_15BITS ((uint32_t)0x0000FF00) /* mask [15:8] bits */
  84. #define SD_MASK_16_23BITS ((uint32_t)0x00FF0000) /* mask [23:16] bits */
  85. #define SD_MASK_24_31BITS ((uint32_t)0xFF000000) /* mask [31:24] bits */
  86. #define SDIO_FIFO_ADDR ((uint32_t)SDIO + 0x80U) /* address of SDIO_FIFO */
  87. #define SD_FIFOHALF_WORDS ((uint32_t)0x00000008) /* words of FIFO half full/empty */
  88. #define SD_FIFOHALF_BYTES ((uint32_t)0x00000020) /* bytes of FIFO half full/empty */
  89. #define SD_DATATIMEOUT ((uint32_t)0xFFFFFFFF) /* DSM data timeout */
  90. #define SD_MAX_VOLT_VALIDATION ((uint32_t)0x0000FFFF) /* the maximum times of voltage validation */
  91. #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFF) /* the maximum length of data */
  92. #define SD_ALLZERO ((uint32_t)0x00000000) /* all zero */
  93. #define SD_RCA_SHIFT ((uint8_t)0x10) /* RCA shift bits */
  94. #define SD_CLK_DIV_INIT ((uint16_t)0x012A) /* SD clock division in initilization phase */
  95. #define SD_CLK_DIV_TRANS ((uint16_t)0x0009) /* SD clock division in transmission phase */
  96. #define SDIO_MASK_INTC_FLAGS ((uint32_t)0x00C007FF) /* mask flags of SDIO_INTC */
  97. uint32_t sd_scr[2] = {0,0}; /* content of SCR register */
  98. static sdio_card_type_enum cardtype = SDIO_STD_CAPACITY_SD_CARD_V1_1; /* SD card type */
  99. static uint32_t sd_csd[4] = {0,0,0,0}; /* content of CSD register */
  100. static uint32_t sd_cid[4] = {0,0,0,0}; /* content of CID register */
  101. static uint16_t sd_rca = 0; /* RCA of SD card */
  102. static uint32_t transmode = SD_POLLING_MODE;
  103. static uint32_t totalnumber_bytes = 0, stopcondition = 0;
  104. static __IO sd_error_enum transerror = SD_OK;
  105. static __IO uint32_t transend = 0, number_bytes = 0;
  106. /* check if the command sent error occurs */
  107. static sd_error_enum cmdsent_error_check(void);
  108. /* check if error occurs for R1 response */
  109. static sd_error_enum r1_error_check(uint8_t cmdindex);
  110. /* check if error type for R1 response */
  111. static sd_error_enum r1_error_type_check(uint32_t resp);
  112. /* check if error occurs for R2 response */
  113. static sd_error_enum r2_error_check(void);
  114. /* check if error occurs for R3 response */
  115. static sd_error_enum r3_error_check(void);
  116. /* check if error occurs for R6 response */
  117. static sd_error_enum r6_error_check(uint8_t cmdindex, uint16_t *prca);
  118. /* check if error occurs for R7 response */
  119. static sd_error_enum r7_error_check(void);
  120. /* get the state which the card is in */
  121. static sd_error_enum sd_card_state_get(uint8_t *pcardstate);
  122. /* configure the bus width mode */
  123. static sd_error_enum sd_bus_width_config(uint32_t buswidth);
  124. /* get the SCR of corresponding card */
  125. static sd_error_enum sd_scr_get(uint16_t rca, uint32_t *pscr);
  126. /* get the data block size */
  127. static uint32_t sd_datablocksize_get(uint16_t bytesnumber);
  128. /* configure the GPIO of SDIO interface */
  129. static void gpio_config(void);
  130. /* configure the RCU of SDIO and DMA */
  131. static void rcu_config(void);
  132. /* configure the DMA for SDIO transfer request */
  133. static void dma_transfer_config(uint32_t *srcbuf, uint32_t bufsize);
  134. /* configure the DMA for SDIO reveive request */
  135. static void dma_receive_config(uint32_t *dstbuf, uint32_t bufsize);
  136. /*!
  137. \brief initialize the SD card and make it in standby state
  138. \param[in] none
  139. \param[out] none
  140. \retval sd_error_enum
  141. */
  142. sd_error_enum sd_init(void)
  143. {
  144. sd_error_enum status = SD_OK;
  145. /* configure the RCU and GPIO, deinitialize the SDIO */
  146. rcu_config();
  147. gpio_config();
  148. sdio_deinit();
  149. /* configure the clock and work voltage */
  150. status = sd_power_on();
  151. if(SD_OK != status){
  152. return status;
  153. }
  154. /* initialize the card and get CID and CSD of the card */
  155. status = sd_card_init();
  156. if(SD_OK != status){
  157. return status;
  158. }
  159. /* configure the SDIO peripheral */
  160. sdio_clock_config(SDIO_SDIOCLKEDGE_RISING, SDIO_CLOCKBYPASS_DISABLE, SDIO_CLOCKPWRSAVE_DISABLE, SD_CLK_DIV_TRANS);
  161. sdio_bus_mode_set(SDIO_BUSMODE_1BIT);
  162. sdio_hardware_clock_disable();
  163. return status;
  164. }
  165. /*!
  166. \brief initialize the card and get CID and CSD of the card
  167. \param[in] none
  168. \param[out] none
  169. \retval sd_error_enum
  170. */
  171. sd_error_enum sd_card_init(void)
  172. {
  173. sd_error_enum status = SD_OK;
  174. uint16_t temp_rca = 0x01;
  175. if(SDIO_POWER_OFF == sdio_power_state_get()){
  176. status = SD_OPERATION_IMPROPER;
  177. return status;
  178. }
  179. /* the card is not I/O only card */
  180. if(SDIO_SECURE_DIGITAL_IO_CARD != cardtype){
  181. /* send CMD2(SD_CMD_ALL_SEND_CID) to get the CID numbers */
  182. sdio_command_response_config(SD_CMD_ALL_SEND_CID, (uint32_t)0x0, SDIO_RESPONSETYPE_LONG);
  183. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  184. sdio_csm_enable();
  185. /* check if some error occurs */
  186. status = r2_error_check();
  187. if(SD_OK != status){
  188. return status;
  189. }
  190. /* store the CID numbers */
  191. sd_cid[0] = sdio_response_get(SDIO_RESPONSE0);
  192. sd_cid[1] = sdio_response_get(SDIO_RESPONSE1);
  193. sd_cid[2] = sdio_response_get(SDIO_RESPONSE2);
  194. sd_cid[3] = sdio_response_get(SDIO_RESPONSE3);
  195. }
  196. /* the card is SD memory card or the I/O card has the memory portion */
  197. if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype) ||
  198. (SDIO_HIGH_CAPACITY_SD_CARD == cardtype) || (SDIO_SECURE_DIGITAL_IO_COMBO_CARD == cardtype)){
  199. /* send CMD3(SEND_RELATIVE_ADDR) to ask the card to publish a new relative address (RCA) */
  200. sdio_command_response_config(SD_CMD_SEND_RELATIVE_ADDR, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  201. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  202. sdio_csm_enable();
  203. /* check if some error occurs */
  204. status = r6_error_check(SD_CMD_SEND_RELATIVE_ADDR, &temp_rca);
  205. if(SD_OK != status){
  206. return status;
  207. }
  208. }
  209. if(SDIO_SECURE_DIGITAL_IO_CARD != cardtype){
  210. /* the card is not I/O only card */
  211. sd_rca = temp_rca;
  212. /* send CMD9(SEND_CSD) to get the addressed card's card-specific data (CSD) */
  213. sdio_command_response_config(SD_CMD_SEND_CSD, (uint32_t)(temp_rca << SD_RCA_SHIFT), SDIO_RESPONSETYPE_LONG);
  214. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  215. sdio_csm_enable();
  216. /* check if some error occurs */
  217. status = r2_error_check();
  218. if(SD_OK != status){
  219. return status;
  220. }
  221. /* store the card-specific data (CSD) */
  222. sd_csd[0] = sdio_response_get(SDIO_RESPONSE0);
  223. sd_csd[1] = sdio_response_get(SDIO_RESPONSE1);
  224. sd_csd[2] = sdio_response_get(SDIO_RESPONSE2);
  225. sd_csd[3] = sdio_response_get(SDIO_RESPONSE3);
  226. }
  227. return status;
  228. }
  229. /*!
  230. \brief configure the clock and the work voltage, and get the card type
  231. \param[in] none
  232. \param[out] none
  233. \retval sd_error_enum
  234. */
  235. sd_error_enum sd_power_on(void)
  236. {
  237. sd_error_enum status = SD_OK;
  238. uint32_t sdcardtype = SD_STD_CAPACITY, response = 0, count = 0;
  239. uint8_t busyflag = 0;
  240. /* configure the SDIO peripheral */
  241. sdio_clock_config(SDIO_SDIOCLKEDGE_RISING, SDIO_CLOCKBYPASS_DISABLE, SDIO_CLOCKPWRSAVE_DISABLE, SD_CLK_DIV_INIT);
  242. sdio_bus_mode_set(SDIO_BUSMODE_1BIT);
  243. sdio_hardware_clock_disable();
  244. sdio_power_state_set(SDIO_POWER_ON);
  245. /* enable SDIO_CLK clock output */
  246. sdio_clock_enable();
  247. /* send CMD0(GO_IDLE_STATE) to reset the card */
  248. sdio_command_response_config(SD_CMD_GO_IDLE_STATE, (uint32_t)0x0, SDIO_RESPONSETYPE_NO);
  249. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  250. /* enable the CSM */
  251. sdio_csm_enable();
  252. /* check if command sent error occurs */
  253. status = cmdsent_error_check();
  254. if(SD_OK != status){
  255. return status;
  256. }
  257. /* send CMD8(SEND_IF_COND) to get SD memory card interface condition */
  258. sdio_command_response_config(SD_CMD_SEND_IF_COND, SD_CHECK_PATTERN, SDIO_RESPONSETYPE_SHORT);
  259. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  260. sdio_csm_enable();
  261. if(SD_OK == r7_error_check()){
  262. /* SD Card 2.0 */
  263. cardtype = SDIO_STD_CAPACITY_SD_CARD_V2_0;
  264. sdcardtype = SD_HIGH_CAPACITY;
  265. }
  266. /* send CMD55(APP_CMD) to indicate next command is application specific command */
  267. sdio_command_response_config(SD_CMD_APP_CMD, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  268. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  269. sdio_csm_enable();
  270. if(SD_OK == r1_error_check(SD_CMD_APP_CMD)){
  271. /* SD memory card */
  272. while((!busyflag) && (count < SD_MAX_VOLT_VALIDATION)){
  273. /* send CMD55(APP_CMD) to indicate next command is application specific command */
  274. sdio_command_response_config(SD_CMD_APP_CMD, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  275. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  276. sdio_csm_enable();
  277. /* check if some error occurs */
  278. status = r1_error_check(SD_CMD_APP_CMD);
  279. if(SD_OK != status){
  280. return status;
  281. }
  282. /* send ACMD41(SD_SEND_OP_COND) to get host capacity support information (HCS) and OCR content */
  283. sdio_command_response_config(SD_APPCMD_SD_SEND_OP_COND, (SD_VOLTAGE_WINDOW | sdcardtype), SDIO_RESPONSETYPE_SHORT);
  284. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  285. sdio_csm_enable();
  286. /* check if some error occurs */
  287. status = r3_error_check();
  288. if(SD_OK != status){
  289. return status;
  290. }
  291. /* get the response and check card power up status bit(busy) */
  292. response = sdio_response_get(SDIO_RESPONSE0);
  293. busyflag = (uint8_t)((response >> 31)&(uint32_t)0x01);
  294. ++count;
  295. }
  296. if(count >= SD_MAX_VOLT_VALIDATION){
  297. status = SD_VOLTRANGE_INVALID;
  298. return status;
  299. }
  300. if(response &= SD_HIGH_CAPACITY){
  301. /* SDHC card */
  302. cardtype = SDIO_HIGH_CAPACITY_SD_CARD;
  303. }
  304. }
  305. return status;
  306. }
  307. /*!
  308. \brief close the power of SDIO
  309. \param[in] none
  310. \param[out] none
  311. \retval sd_error_enum
  312. */
  313. sd_error_enum sd_power_off(void)
  314. {
  315. sd_error_enum status = SD_OK;
  316. sdio_power_state_set(SDIO_POWER_OFF);
  317. return status;
  318. }
  319. /*!
  320. \brief configure the bus mode
  321. \param[in] busmode: the bus mode
  322. \arg SDIO_BUSMODE_1BIT: 1-bit SDIO card bus mode
  323. \arg SDIO_BUSMODE_4BIT: 4-bit SDIO card bus mode
  324. \arg SDIO_BUSMODE_8BIT: 8-bit SDIO card bus mode (MMC only)
  325. \param[out] none
  326. \retval sd_error_enum
  327. */
  328. sd_error_enum sd_bus_mode_config(uint32_t busmode)
  329. {
  330. sd_error_enum status = SD_OK;
  331. if(SDIO_MULTIMEDIA_CARD == cardtype){
  332. /* MMC card doesn't support this function */
  333. status = SD_FUNCTION_UNSUPPORTED;
  334. return status;
  335. }else if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype) ||
  336. (SDIO_HIGH_CAPACITY_SD_CARD == cardtype)){
  337. if(SDIO_BUSMODE_8BIT == busmode){
  338. /* 8 bit bus mode doesn't support */
  339. status = SD_FUNCTION_UNSUPPORTED;
  340. return status;
  341. }else if(SDIO_BUSMODE_4BIT == busmode){
  342. /* configure SD bus width and the SDIO */
  343. status = sd_bus_width_config(SD_BUS_WIDTH_4BIT);
  344. if(SD_OK == status){
  345. sdio_clock_config(SDIO_SDIOCLKEDGE_RISING, SDIO_CLOCKBYPASS_DISABLE,
  346. SDIO_CLOCKPWRSAVE_DISABLE, SD_CLK_DIV_TRANS);
  347. sdio_bus_mode_set(busmode);
  348. sdio_hardware_clock_disable();
  349. }
  350. }else if(SDIO_BUSMODE_1BIT == busmode){
  351. /* configure SD bus width and the SDIO */
  352. status = sd_bus_width_config(SD_BUS_WIDTH_1BIT);
  353. if(SD_OK == status){
  354. sdio_clock_config(SDIO_SDIOCLKEDGE_RISING, SDIO_CLOCKBYPASS_DISABLE,
  355. SDIO_CLOCKPWRSAVE_DISABLE, SD_CLK_DIV_TRANS);
  356. sdio_bus_mode_set(busmode);
  357. sdio_hardware_clock_disable();
  358. }
  359. }else{
  360. status = SD_PARAMETER_INVALID;
  361. }
  362. }
  363. return status;
  364. }
  365. /*!
  366. \brief configure the mode of transmission
  367. \param[in] txmode: transfer mode
  368. \arg SD_DMA_MODE: DMA mode
  369. \arg SD_POLLING_MODE: polling mode
  370. \param[out] none
  371. \retval sd_error_enum
  372. */
  373. sd_error_enum sd_transfer_mode_config(uint32_t txmode)
  374. {
  375. sd_error_enum status = SD_OK;
  376. /* set the transfer mode */
  377. if((SD_DMA_MODE == txmode) || (SD_POLLING_MODE == txmode)){
  378. transmode = txmode;
  379. }else{
  380. status = SD_PARAMETER_INVALID;
  381. }
  382. return status;
  383. }
  384. /*!
  385. \brief read a block data into a buffer from the specified address of a card
  386. \param[out] preadbuffer: a pointer that store a block read data
  387. \param[in] readaddr: the read data address
  388. \param[in] blocksize: the data block size
  389. \retval sd_error_enum
  390. */
  391. sd_error_enum sd_block_read(uint32_t *preadbuffer, uint32_t readaddr, uint16_t blocksize)
  392. {
  393. /* initialize the variables */
  394. sd_error_enum status = SD_OK;
  395. uint32_t count = 0, align = 0, datablksize = SDIO_DATABLOCKSIZE_1BYTE, *ptempbuff = preadbuffer;
  396. __IO uint32_t timeout = 0;
  397. if(NULL == preadbuffer){
  398. status = SD_PARAMETER_INVALID;
  399. return status;
  400. }
  401. transerror = SD_OK;
  402. transend = 0;
  403. totalnumber_bytes = 0;
  404. /* clear all DSM configuration */
  405. sdio_data_config(0, 0, SDIO_DATABLOCKSIZE_1BYTE);
  406. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  407. sdio_dsm_disable();
  408. sdio_dma_disable();
  409. /* check whether the card is locked */
  410. if(sdio_response_get(SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED){
  411. status = SD_LOCK_UNLOCK_FAILED;
  412. return status;
  413. }
  414. /* blocksize is fixed in 512B for SDHC card */
  415. if(SDIO_HIGH_CAPACITY_SD_CARD == cardtype){
  416. blocksize = 512;
  417. readaddr /= 512;
  418. }
  419. align = blocksize & (blocksize - 1);
  420. if((blocksize > 0) && (blocksize <= 2048) && (0 == align)){
  421. datablksize = sd_datablocksize_get(blocksize);
  422. /* send CMD16(SET_BLOCKLEN) to set the block length */
  423. sdio_command_response_config(SD_CMD_SET_BLOCKLEN, (uint32_t)blocksize, SDIO_RESPONSETYPE_SHORT);
  424. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  425. sdio_csm_enable();
  426. /* check if some error occurs */
  427. status = r1_error_check(SD_CMD_SET_BLOCKLEN);
  428. if(SD_OK != status){
  429. return status;
  430. }
  431. }else{
  432. status = SD_PARAMETER_INVALID;
  433. return status;
  434. }
  435. stopcondition = 0;
  436. totalnumber_bytes = blocksize;
  437. /* configure SDIO data transmission */
  438. sdio_data_config(SD_DATATIMEOUT, totalnumber_bytes, datablksize);
  439. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOSDIO);
  440. sdio_dsm_enable();
  441. /* send CMD17(READ_SINGLE_BLOCK) to read a block */
  442. sdio_command_response_config(SD_CMD_READ_SINGLE_BLOCK, (uint32_t)readaddr, SDIO_RESPONSETYPE_SHORT);
  443. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  444. sdio_csm_enable();
  445. /* check if some error occurs */
  446. status = r1_error_check(SD_CMD_READ_SINGLE_BLOCK);
  447. if(SD_OK != status){
  448. return status;
  449. }
  450. if(SD_POLLING_MODE == transmode){
  451. /* polling mode */
  452. while(!sdio_flag_get(SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_RXORE | SDIO_FLAG_DTBLKEND | SDIO_FLAG_STBITE)){
  453. if(RESET != sdio_flag_get(SDIO_FLAG_RFH)){
  454. /* at least 8 words can be read in the FIFO */
  455. for(count = 0; count < SD_FIFOHALF_WORDS; count++){
  456. *(ptempbuff + count) = sdio_data_read();
  457. }
  458. ptempbuff += SD_FIFOHALF_WORDS;
  459. }
  460. }
  461. /* whether some error occurs and return it */
  462. if(RESET != sdio_flag_get(SDIO_FLAG_DTCRCERR)){
  463. status = SD_DATA_CRC_ERROR;
  464. sdio_flag_clear(SDIO_FLAG_DTCRCERR);
  465. return status;
  466. }else if(RESET != sdio_flag_get(SDIO_FLAG_DTTMOUT)){
  467. status = SD_DATA_TIMEOUT;
  468. sdio_flag_clear(SDIO_FLAG_DTTMOUT);
  469. return status;
  470. }else if(RESET != sdio_flag_get(SDIO_FLAG_RXORE)){
  471. status = SD_RX_OVERRUN_ERROR;
  472. sdio_flag_clear(SDIO_FLAG_RXORE);
  473. return status;
  474. }else if(RESET != sdio_flag_get(SDIO_FLAG_STBITE)){
  475. status = SD_START_BIT_ERROR;
  476. sdio_flag_clear(SDIO_FLAG_STBITE);
  477. return status;
  478. }
  479. while(RESET != sdio_flag_get(SDIO_FLAG_RXDTVAL)){
  480. *ptempbuff = sdio_data_read();
  481. ++ptempbuff;
  482. }
  483. /* clear the SDIO_INTC flags */
  484. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  485. }else if(SD_DMA_MODE == transmode){
  486. /* DMA mode */
  487. /* enable the SDIO corresponding interrupts and DMA function */
  488. sdio_interrupt_enable(SDIO_INT_CCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_RXORE | SDIO_INT_DTEND | SDIO_INT_STBITE);
  489. sdio_dma_enable();
  490. dma_receive_config(preadbuffer, blocksize);
  491. timeout = 100000;
  492. while((RESET == dma_flag_get(DMA1, DMA_CH3, DMA_FLAG_FTF)) && (timeout > 0)){
  493. timeout--;
  494. if(0 == timeout){
  495. return SD_ERROR;
  496. }
  497. }
  498. }else{
  499. status = SD_PARAMETER_INVALID;
  500. }
  501. return status;
  502. }
  503. /*!
  504. \brief read multiple blocks data into a buffer from the specified address of a card
  505. \param[out] preadbuffer: a pointer that store multiple blocks read data
  506. \param[in] readaddr: the read data address
  507. \param[in] blocksize: the data block size
  508. \param[in] blocksnumber: number of blocks that will be read
  509. \retval sd_error_enum
  510. */
  511. sd_error_enum sd_multiblocks_read(uint32_t *preadbuffer, uint32_t readaddr, uint16_t blocksize, uint32_t blocksnumber)
  512. {
  513. /* initialize the variables */
  514. sd_error_enum status = SD_OK;
  515. uint32_t count = 0, align = 0, datablksize = SDIO_DATABLOCKSIZE_1BYTE, *ptempbuff = preadbuffer;
  516. __IO uint32_t timeout = 0;
  517. if(NULL == preadbuffer){
  518. status = SD_PARAMETER_INVALID;
  519. return status;
  520. }
  521. transerror = SD_OK;
  522. transend = 0;
  523. totalnumber_bytes = 0;
  524. /* clear all DSM configuration */
  525. sdio_data_config(0, 0, SDIO_DATABLOCKSIZE_1BYTE);
  526. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  527. sdio_dsm_disable();
  528. sdio_dma_disable();
  529. /* check whether the card is locked */
  530. if(sdio_response_get(SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED){
  531. status = SD_LOCK_UNLOCK_FAILED;
  532. return status;
  533. }
  534. /* blocksize is fixed in 512B for SDHC card */
  535. if(SDIO_HIGH_CAPACITY_SD_CARD == cardtype){
  536. blocksize = 512;
  537. readaddr /= 512;
  538. }
  539. align = blocksize & (blocksize - 1);
  540. if((blocksize > 0) && (blocksize <= 2048) && (0 == align)){
  541. datablksize = sd_datablocksize_get(blocksize);
  542. /* send CMD16(SET_BLOCKLEN) to set the block length */
  543. sdio_command_response_config(SD_CMD_SET_BLOCKLEN, (uint32_t)blocksize, SDIO_RESPONSETYPE_SHORT);
  544. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  545. sdio_csm_enable();
  546. /* check if some error occurs */
  547. status = r1_error_check(SD_CMD_SET_BLOCKLEN);
  548. if(SD_OK != status){
  549. return status;
  550. }
  551. }else{
  552. status = SD_PARAMETER_INVALID;
  553. return status;
  554. }
  555. if(blocksnumber > 1){
  556. if(blocksnumber * blocksize > SD_MAX_DATA_LENGTH){
  557. /* exceeds the maximum length */
  558. status = SD_PARAMETER_INVALID;
  559. return status;
  560. }
  561. stopcondition = 1;
  562. totalnumber_bytes = blocksnumber * blocksize;
  563. /* configure the SDIO data transmission */
  564. sdio_data_config(SD_DATATIMEOUT, totalnumber_bytes, datablksize);
  565. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOSDIO);
  566. sdio_dsm_enable();
  567. /* send CMD18(READ_MULTIPLE_BLOCK) to read multiple blocks */
  568. sdio_command_response_config(SD_CMD_READ_MULTIPLE_BLOCK, readaddr, SDIO_RESPONSETYPE_SHORT);
  569. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  570. sdio_csm_enable();
  571. /* check if some error occurs */
  572. status = r1_error_check(SD_CMD_READ_MULTIPLE_BLOCK);
  573. if(SD_OK != status){
  574. return status;
  575. }
  576. if(SD_POLLING_MODE == transmode){
  577. /* polling mode */
  578. while(!sdio_flag_get(SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_RXORE | SDIO_FLAG_DTEND | SDIO_FLAG_STBITE)){
  579. if(RESET != sdio_flag_get(SDIO_FLAG_RFH)){
  580. /* at least 8 words can be read in the FIFO */
  581. for(count = 0; count < SD_FIFOHALF_WORDS; count++){
  582. *(ptempbuff + count) = sdio_data_read();
  583. }
  584. ptempbuff += SD_FIFOHALF_WORDS;
  585. }
  586. }
  587. /* whether some error occurs and return it */
  588. if(RESET != sdio_flag_get(SDIO_FLAG_DTCRCERR)){
  589. status = SD_DATA_CRC_ERROR;
  590. sdio_flag_clear(SDIO_FLAG_DTCRCERR);
  591. return status;
  592. }else if(RESET != sdio_flag_get(SDIO_FLAG_DTTMOUT)){
  593. status = SD_DATA_TIMEOUT;
  594. sdio_flag_clear(SDIO_FLAG_DTTMOUT);
  595. return status;
  596. }else if(RESET != sdio_flag_get(SDIO_FLAG_RXORE)){
  597. status = SD_RX_OVERRUN_ERROR;
  598. sdio_flag_clear(SDIO_FLAG_RXORE);
  599. return status;
  600. }else if(RESET != sdio_flag_get(SDIO_FLAG_STBITE)){
  601. status = SD_START_BIT_ERROR;
  602. sdio_flag_clear(SDIO_FLAG_STBITE);
  603. return status;
  604. }
  605. while(RESET != sdio_flag_get(SDIO_FLAG_RXDTVAL)){
  606. *ptempbuff = sdio_data_read();
  607. ++ptempbuff;
  608. }
  609. if(RESET != sdio_flag_get(SDIO_FLAG_DTEND)){
  610. if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype) ||
  611. (SDIO_HIGH_CAPACITY_SD_CARD == cardtype)){
  612. /* send CMD12(STOP_TRANSMISSION) to stop transmission */
  613. sdio_command_response_config(SD_CMD_STOP_TRANSMISSION, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  614. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  615. sdio_csm_enable();
  616. /* check if some error occurs */
  617. status = r1_error_check(SD_CMD_STOP_TRANSMISSION);
  618. if(SD_OK != status){
  619. return status;
  620. }
  621. }
  622. }
  623. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  624. }else if(SD_DMA_MODE == transmode){
  625. /* DMA mode */
  626. /* enable the SDIO corresponding interrupts and DMA function */
  627. sdio_interrupt_enable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_RXORE | SDIO_INT_DTEND | SDIO_INT_STBITE);
  628. sdio_dma_enable();
  629. dma_receive_config(preadbuffer, totalnumber_bytes);
  630. timeout = 100000;
  631. while((RESET == dma_flag_get(DMA1, DMA_CH3, DMA_FLAG_FTF)) && (timeout > 0)){
  632. timeout--;
  633. if(0 == timeout){
  634. return SD_ERROR;
  635. }
  636. }
  637. while((0 == transend) && (SD_OK == transerror)){
  638. }
  639. if(SD_OK != transerror){
  640. return transerror;
  641. }
  642. }else{
  643. status = SD_PARAMETER_INVALID;
  644. }
  645. }
  646. return status;
  647. }
  648. /*!
  649. \brief write a block data to the specified address of a card
  650. \param[in] pwritebuffer: a pointer that store a block data to be transferred
  651. \param[in] writeaddr: the read data address
  652. \param[in] blocksize: the data block size
  653. \param[out] none
  654. \retval sd_error_enum
  655. */
  656. sd_error_enum sd_block_write(uint32_t *pwritebuffer, uint32_t writeaddr, uint16_t blocksize)
  657. {
  658. /* initialize the variables */
  659. sd_error_enum status = SD_OK;
  660. uint8_t cardstate = 0;
  661. uint32_t count = 0, align = 0, datablksize = SDIO_DATABLOCKSIZE_1BYTE, *ptempbuff = pwritebuffer;
  662. uint32_t transbytes = 0, restwords = 0, response = 0;
  663. __IO uint32_t timeout = 0;
  664. if(NULL == pwritebuffer){
  665. status = SD_PARAMETER_INVALID;
  666. return status;
  667. }
  668. transerror = SD_OK;
  669. transend = 0;
  670. totalnumber_bytes = 0;
  671. /* clear all DSM configuration */
  672. sdio_data_config(0, 0, SDIO_DATABLOCKSIZE_1BYTE);
  673. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  674. sdio_dsm_disable();
  675. sdio_dma_disable();
  676. /* check whether the card is locked */
  677. if(sdio_response_get(SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED){
  678. status = SD_LOCK_UNLOCK_FAILED;
  679. return status;
  680. }
  681. /* blocksize is fixed in 512B for SDHC card */
  682. if(SDIO_HIGH_CAPACITY_SD_CARD == cardtype){
  683. blocksize = 512;
  684. writeaddr /= 512;
  685. }
  686. align = blocksize & (blocksize - 1);
  687. if((blocksize > 0) && (blocksize <= 2048) && (0 == align)){
  688. datablksize = sd_datablocksize_get(blocksize);
  689. /* send CMD16(SET_BLOCKLEN) to set the block length */
  690. sdio_command_response_config(SD_CMD_SET_BLOCKLEN, (uint32_t)blocksize, SDIO_RESPONSETYPE_SHORT);
  691. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  692. sdio_csm_enable();
  693. /* check if some error occurs */
  694. status = r1_error_check(SD_CMD_SET_BLOCKLEN);
  695. if(SD_OK != status){
  696. return status;
  697. }
  698. }else{
  699. status = SD_PARAMETER_INVALID;
  700. return status;
  701. }
  702. /* send CMD13(SEND_STATUS), addressed card sends its status registers */
  703. sdio_command_response_config(SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  704. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  705. sdio_csm_enable();
  706. /* check if some error occurs */
  707. status = r1_error_check(SD_CMD_SEND_STATUS);
  708. if(SD_OK != status){
  709. return status;
  710. }
  711. response = sdio_response_get(SDIO_RESPONSE0);
  712. timeout = 100000;
  713. while((0 == (response & SD_R1_READY_FOR_DATA)) && (timeout > 0)){
  714. /* continue to send CMD13 to polling the state of card until buffer empty or timeout */
  715. --timeout;
  716. /* send CMD13(SEND_STATUS), addressed card sends its status registers */
  717. sdio_command_response_config(SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  718. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  719. sdio_csm_enable();
  720. /* check if some error occurs */
  721. status = r1_error_check(SD_CMD_SEND_STATUS);
  722. if(SD_OK != status){
  723. return status;
  724. }
  725. response = sdio_response_get(SDIO_RESPONSE0);
  726. }
  727. if(0 == timeout){
  728. return SD_ERROR;
  729. }
  730. /* send CMD24(WRITE_BLOCK) to write a block */
  731. sdio_command_response_config(SD_CMD_WRITE_BLOCK, writeaddr, SDIO_RESPONSETYPE_SHORT);
  732. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  733. sdio_csm_enable();
  734. /* check if some error occurs */
  735. status = r1_error_check(SD_CMD_WRITE_BLOCK);
  736. if(SD_OK != status){
  737. return status;
  738. }
  739. stopcondition = 0;
  740. totalnumber_bytes = blocksize;
  741. /* configure the SDIO data transmission */
  742. sdio_data_config(SD_DATATIMEOUT, totalnumber_bytes, datablksize);
  743. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  744. sdio_dsm_enable();
  745. if(SD_POLLING_MODE == transmode){
  746. /* polling mode */
  747. while(!sdio_flag_get(SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_TXURE | SDIO_FLAG_DTBLKEND | SDIO_FLAG_STBITE)){
  748. if(RESET != sdio_flag_get(SDIO_FLAG_TFH)){
  749. /* at least 8 words can be written into the FIFO */
  750. if((totalnumber_bytes - transbytes) < SD_FIFOHALF_BYTES){
  751. restwords = (totalnumber_bytes - transbytes)/4 + (((totalnumber_bytes - transbytes)%4 == 0) ? 0 : 1);
  752. for(count = 0; count < restwords; count++){
  753. sdio_data_write(*ptempbuff);
  754. ++ptempbuff;
  755. transbytes += 4;
  756. }
  757. }else{
  758. for(count = 0; count < SD_FIFOHALF_WORDS; count++){
  759. sdio_data_write(*(ptempbuff + count));
  760. }
  761. /* 8 words(32 bytes) has been transferred */
  762. ptempbuff += SD_FIFOHALF_WORDS;
  763. transbytes += SD_FIFOHALF_BYTES;
  764. }
  765. }
  766. }
  767. /* whether some error occurs and return it */
  768. if(RESET != sdio_flag_get(SDIO_FLAG_DTCRCERR)){
  769. status = SD_DATA_CRC_ERROR;
  770. sdio_flag_clear(SDIO_FLAG_DTCRCERR);
  771. return status;
  772. }else if(RESET != sdio_flag_get(SDIO_FLAG_DTTMOUT)){
  773. status = SD_DATA_TIMEOUT;
  774. sdio_flag_clear(SDIO_FLAG_DTTMOUT);
  775. return status;
  776. }else if(RESET != sdio_flag_get(SDIO_FLAG_TXURE)){
  777. status = SD_TX_UNDERRUN_ERROR;
  778. sdio_flag_clear(SDIO_FLAG_TXURE);
  779. return status;
  780. }else if(RESET != sdio_flag_get(SDIO_FLAG_STBITE)){
  781. status = SD_START_BIT_ERROR;
  782. sdio_flag_clear(SDIO_FLAG_STBITE);
  783. return status;
  784. }
  785. }else if(SD_DMA_MODE == transmode){
  786. /* DMA mode */
  787. /* enable the SDIO corresponding interrupts and DMA */
  788. sdio_interrupt_enable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_TXURE | SDIO_INT_DTEND | SDIO_INT_STBITE);
  789. dma_transfer_config(pwritebuffer, blocksize);
  790. sdio_dma_enable();
  791. timeout = 100000;
  792. while((RESET == dma_flag_get(DMA1, DMA_CH3, DMA_FLAG_FTF)) && (timeout > 0)){
  793. timeout--;
  794. if(0 == timeout){
  795. return SD_ERROR;
  796. }
  797. }
  798. while ((0 == transend) && (SD_OK == transerror)){
  799. }
  800. if(SD_OK != transerror){
  801. return transerror;
  802. }
  803. }else{
  804. status = SD_PARAMETER_INVALID;
  805. return status;
  806. }
  807. /* clear the SDIO_INTC flags */
  808. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  809. /* get the card state and wait the card is out of programming and receiving state */
  810. status = sd_card_state_get(&cardstate);
  811. while((SD_OK == status) && ((SD_CARDSTATE_PROGRAMMING == cardstate) || (SD_CARDSTATE_RECEIVING == cardstate))){
  812. status = sd_card_state_get(&cardstate);
  813. }
  814. return status;
  815. }
  816. /*!
  817. \brief write multiple blocks data to the specified address of a card
  818. \param[in] pwritebuffer: a pointer that store multiple blocks data to be transferred
  819. \param[in] writeaddr: the read data address
  820. \param[in] blocksize: the data block size
  821. \param[in] blocksnumber: number of blocks that will be written
  822. \param[out] none
  823. \retval sd_error_enum
  824. */
  825. sd_error_enum sd_multiblocks_write(uint32_t *pwritebuffer, uint32_t writeaddr, uint16_t blocksize, uint32_t blocksnumber)
  826. {
  827. /* initialize the variables */
  828. sd_error_enum status = SD_OK;
  829. uint8_t cardstate = 0;
  830. uint32_t count = 0, align = 0, datablksize = SDIO_DATABLOCKSIZE_1BYTE, *ptempbuff = pwritebuffer;
  831. uint32_t transbytes = 0, restwords = 0;
  832. __IO uint32_t timeout = 0;
  833. if(NULL == pwritebuffer){
  834. status = SD_PARAMETER_INVALID;
  835. return status;
  836. }
  837. transerror = SD_OK;
  838. transend = 0;
  839. totalnumber_bytes = 0;
  840. /* clear all DSM configuration */
  841. sdio_data_config(0, 0, SDIO_DATABLOCKSIZE_1BYTE);
  842. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  843. sdio_dsm_disable();
  844. sdio_dma_disable();
  845. /* check whether the card is locked */
  846. if(sdio_response_get(SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED){
  847. status = SD_LOCK_UNLOCK_FAILED;
  848. return status;
  849. }
  850. /* blocksize is fixed in 512B for SDHC card */
  851. if(SDIO_HIGH_CAPACITY_SD_CARD == cardtype){
  852. blocksize = 512;
  853. writeaddr /= 512;
  854. }
  855. align = blocksize & (blocksize - 1);
  856. if((blocksize > 0) && (blocksize <= 2048) && (0 == align)){
  857. datablksize = sd_datablocksize_get(blocksize);
  858. /* send CMD16(SET_BLOCKLEN) to set the block length */
  859. sdio_command_response_config(SD_CMD_SET_BLOCKLEN, (uint32_t)blocksize, SDIO_RESPONSETYPE_SHORT);
  860. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  861. sdio_csm_enable();
  862. /* check if some error occurs */
  863. status = r1_error_check(SD_CMD_SET_BLOCKLEN);
  864. if(SD_OK != status){
  865. return status;
  866. }
  867. }else{
  868. status = SD_PARAMETER_INVALID;
  869. return status;
  870. }
  871. /* send CMD13(SEND_STATUS), addressed card sends its status registers */
  872. sdio_command_response_config(SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  873. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  874. sdio_csm_enable();
  875. /* check if some error occurs */
  876. status = r1_error_check(SD_CMD_SEND_STATUS);
  877. if(SD_OK != status){
  878. return status;
  879. }
  880. if(blocksnumber > 1){
  881. if(blocksnumber * blocksize > SD_MAX_DATA_LENGTH){
  882. status = SD_PARAMETER_INVALID;
  883. return status;
  884. }
  885. if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype) ||
  886. (SDIO_HIGH_CAPACITY_SD_CARD == cardtype)){
  887. /* send CMD55(APP_CMD) to indicate next command is application specific command */
  888. sdio_command_response_config(SD_CMD_APP_CMD, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  889. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  890. sdio_csm_enable();
  891. /* check if some error occurs */
  892. status = r1_error_check(SD_CMD_APP_CMD);
  893. if(SD_OK != status){
  894. return status;
  895. }
  896. /* send ACMD23(SET_WR_BLK_ERASE_COUNT) to set the number of write blocks to be preerased before writing */
  897. sdio_command_response_config(SD_APPCMD_SET_WR_BLK_ERASE_COUNT, blocksnumber, SDIO_RESPONSETYPE_SHORT);
  898. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  899. sdio_csm_enable();
  900. /* check if some error occurs */
  901. status = r1_error_check(SD_APPCMD_SET_WR_BLK_ERASE_COUNT);
  902. if(SD_OK != status){
  903. return status;
  904. }
  905. }
  906. /* send CMD25(WRITE_MULTIPLE_BLOCK) to continuously write blocks of data */
  907. sdio_command_response_config(SD_CMD_WRITE_MULTIPLE_BLOCK, writeaddr, SDIO_RESPONSETYPE_SHORT);
  908. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  909. sdio_csm_enable();
  910. /* check if some error occurs */
  911. status = r1_error_check(SD_CMD_WRITE_MULTIPLE_BLOCK);
  912. if(SD_OK != status){
  913. return status;
  914. }
  915. stopcondition = 1;
  916. totalnumber_bytes = blocksnumber * blocksize;
  917. /* configure the SDIO data transmission */
  918. sdio_data_config(SD_DATATIMEOUT, totalnumber_bytes, datablksize);
  919. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  920. sdio_dsm_enable();
  921. if(SD_POLLING_MODE == transmode){
  922. /* polling mode */
  923. while(!sdio_flag_get(SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_TXURE | SDIO_FLAG_DTEND | SDIO_FLAG_STBITE)){
  924. if(RESET != sdio_flag_get(SDIO_FLAG_TFH)){
  925. /* at least 8 words can be written into the FIFO */
  926. if(!((totalnumber_bytes - transbytes) < SD_FIFOHALF_BYTES)){
  927. for(count = 0; count < SD_FIFOHALF_WORDS; count++){
  928. sdio_data_write(*(ptempbuff + count));
  929. }
  930. /* 8 words(32 bytes) has been transferred */
  931. ptempbuff += SD_FIFOHALF_WORDS;
  932. transbytes += SD_FIFOHALF_BYTES;
  933. }else{
  934. restwords = (totalnumber_bytes - transbytes)/4 + (((totalnumber_bytes - transbytes)%4 == 0) ? 0 : 1);
  935. for(count = 0; count < restwords; count++){
  936. sdio_data_write(*ptempbuff);
  937. ++ptempbuff;
  938. transbytes += 4;
  939. }
  940. }
  941. }
  942. }
  943. /* whether some error occurs and return it */
  944. if(RESET != sdio_flag_get(SDIO_FLAG_DTCRCERR)){
  945. status = SD_DATA_CRC_ERROR;
  946. sdio_flag_clear(SDIO_FLAG_DTCRCERR);
  947. return status;
  948. }else if(RESET != sdio_flag_get(SDIO_FLAG_DTTMOUT)){
  949. status = SD_DATA_TIMEOUT;
  950. sdio_flag_clear(SDIO_FLAG_DTTMOUT);
  951. return status;
  952. }else if(RESET != sdio_flag_get(SDIO_FLAG_TXURE)){
  953. status = SD_TX_UNDERRUN_ERROR;
  954. sdio_flag_clear(SDIO_FLAG_TXURE);
  955. return status;
  956. }else if(RESET != sdio_flag_get(SDIO_FLAG_STBITE)){
  957. status = SD_START_BIT_ERROR;
  958. sdio_flag_clear(SDIO_FLAG_STBITE);
  959. return status;
  960. }
  961. if(RESET != sdio_flag_get(SDIO_FLAG_DTEND)){
  962. if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype) ||
  963. (SDIO_HIGH_CAPACITY_SD_CARD == cardtype)){
  964. /* send CMD12(STOP_TRANSMISSION) to stop transmission */
  965. sdio_command_response_config(SD_CMD_STOP_TRANSMISSION, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  966. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  967. sdio_csm_enable();
  968. /* check if some error occurs */
  969. status = r1_error_check(SD_CMD_STOP_TRANSMISSION);
  970. if(SD_OK != status){
  971. return status;
  972. }
  973. }
  974. }
  975. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  976. }else if(SD_DMA_MODE == transmode){
  977. /* DMA mode */
  978. /* enable SDIO corresponding interrupts and DMA */
  979. sdio_interrupt_enable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_TXURE | SDIO_INT_DTEND | SDIO_INT_STBITE);
  980. sdio_dma_enable();
  981. dma_transfer_config(pwritebuffer, totalnumber_bytes);
  982. timeout = 100000;
  983. while((RESET == dma_flag_get(DMA1, DMA_CH3, DMA_FLAG_FTF) && (timeout > 0))){
  984. timeout--;
  985. if(0 == timeout){
  986. return SD_ERROR;
  987. }
  988. }
  989. while((0 == transend) && (SD_OK == transerror)){
  990. }
  991. if(SD_OK != transerror){
  992. return transerror;
  993. }
  994. }else{
  995. status = SD_PARAMETER_INVALID;
  996. return status;
  997. }
  998. }
  999. /* clear the SDIO_INTC flags */
  1000. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1001. /* get the card state and wait the card is out of programming and receiving state */
  1002. status = sd_card_state_get(&cardstate);
  1003. while((SD_OK == status) && ((SD_CARDSTATE_PROGRAMMING == cardstate) || (SD_CARDSTATE_RECEIVING == cardstate))){
  1004. status = sd_card_state_get(&cardstate);
  1005. }
  1006. return status;
  1007. }
  1008. /*!
  1009. \brief erase a continuous area of a card
  1010. \param[in] startaddr: the start address
  1011. \param[in] endaddr: the end address
  1012. \param[out] none
  1013. \retval sd_error_enum
  1014. */
  1015. sd_error_enum sd_erase(uint32_t startaddr, uint32_t endaddr)
  1016. {
  1017. /* initialize the variables */
  1018. sd_error_enum status = SD_OK;
  1019. uint32_t count = 0, clkdiv = 0;
  1020. __IO uint32_t delay = 0;
  1021. uint8_t cardstate = 0, tempbyte = 0;
  1022. uint16_t tempccc = 0;
  1023. /* get the card command classes from CSD */
  1024. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_24_31BITS) >> 24);
  1025. tempccc = (uint16_t)((uint16_t)tempbyte << 4);
  1026. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_16_23BITS) >> 16);
  1027. tempccc |= (uint16_t)((uint16_t)(tempbyte & 0xF0) >> 4);
  1028. if(0 == (tempccc & SD_CCC_ERASE)){
  1029. /* don't support the erase command */
  1030. status = SD_FUNCTION_UNSUPPORTED;
  1031. return status;
  1032. }
  1033. clkdiv = (SDIO_CLKCTL & SDIO_CLKCTL_DIV);
  1034. clkdiv += ((SDIO_CLKCTL & SDIO_CLKCTL_DIV8)>>31)*256;
  1035. clkdiv += 2;
  1036. delay = 120000 / clkdiv;
  1037. /* check whether the card is locked */
  1038. if (sdio_response_get(SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED){
  1039. status = SD_LOCK_UNLOCK_FAILED;
  1040. return(status);
  1041. }
  1042. /* blocksize is fixed in 512B for SDHC card */
  1043. if (SDIO_HIGH_CAPACITY_SD_CARD == cardtype){
  1044. startaddr /= 512;
  1045. endaddr /= 512;
  1046. }
  1047. if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype) ||
  1048. (SDIO_HIGH_CAPACITY_SD_CARD == cardtype)){
  1049. /* send CMD32(ERASE_WR_BLK_START) to set the address of the first write block to be erased */
  1050. sdio_command_response_config(SD_CMD_ERASE_WR_BLK_START, startaddr, SDIO_RESPONSETYPE_SHORT);
  1051. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1052. sdio_csm_enable();
  1053. /* check if some error occurs */
  1054. status = r1_error_check(SD_CMD_ERASE_WR_BLK_START);
  1055. if(SD_OK != status){
  1056. return status;
  1057. }
  1058. /* send CMD33(ERASE_WR_BLK_END) to set the address of the last write block of the continuous range to be erased */
  1059. sdio_command_response_config(SD_CMD_ERASE_WR_BLK_END, endaddr, SDIO_RESPONSETYPE_SHORT);
  1060. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1061. sdio_csm_enable();
  1062. /* check if some error occurs */
  1063. status = r1_error_check(SD_CMD_ERASE_WR_BLK_END);
  1064. if(SD_OK != status){
  1065. return status;
  1066. }
  1067. }
  1068. /* send CMD38(ERASE) to set the address of the first write block to be erased */
  1069. sdio_command_response_config(SD_CMD_ERASE, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  1070. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1071. sdio_csm_enable();
  1072. /* check if some error occurs */
  1073. status = r1_error_check(SD_CMD_ERASE);
  1074. if(SD_OK != status){
  1075. return status;
  1076. }
  1077. /* loop until the counter is reach to the calculated time */
  1078. for(count = 0; count < delay; count++){
  1079. }
  1080. /* get the card state and wait the card is out of programming and receiving state */
  1081. status = sd_card_state_get(&cardstate);
  1082. while((SD_OK == status) && ((SD_CARDSTATE_PROGRAMMING == cardstate) || (SD_CARDSTATE_RECEIVING == cardstate))){
  1083. status = sd_card_state_get(&cardstate);
  1084. }
  1085. return status;
  1086. }
  1087. /*!
  1088. \brief process all the interrupts which the corresponding flags are set
  1089. \param[in] none
  1090. \param[out] none
  1091. \retval sd_error_enum
  1092. */
  1093. sd_error_enum sd_interrupts_process(void)
  1094. {
  1095. transerror = SD_OK;
  1096. if(RESET != sdio_interrupt_flag_get(SDIO_INT_FLAG_DTEND)){
  1097. /* send CMD12 to stop data transfer in multipule blocks operation */
  1098. if(1 == stopcondition){
  1099. transerror = sd_transfer_stop();
  1100. }else{
  1101. transerror = SD_OK;
  1102. }
  1103. sdio_interrupt_flag_clear(SDIO_INT_DTEND);
  1104. /* disable all the interrupts */
  1105. sdio_interrupt_disable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_DTEND | SDIO_INT_STBITE |
  1106. SDIO_INT_TFH | SDIO_INT_RFH | SDIO_INT_TXURE | SDIO_INT_RXORE);
  1107. transend = 1;
  1108. number_bytes = 0;
  1109. return transerror;
  1110. }
  1111. if(RESET != sdio_interrupt_flag_get(SDIO_INT_FLAG_DTCRCERR)){
  1112. sdio_interrupt_flag_clear(SDIO_INT_DTCRCERR);
  1113. /* disable all the interrupts */
  1114. sdio_interrupt_disable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_DTEND | SDIO_INT_STBITE |
  1115. SDIO_INT_TFH | SDIO_INT_RFH | SDIO_INT_TXURE | SDIO_INT_RXORE);
  1116. number_bytes = 0;
  1117. transerror = SD_DATA_CRC_ERROR;
  1118. return transerror;
  1119. }
  1120. if(RESET != sdio_interrupt_flag_get(SDIO_INT_FLAG_DTTMOUT)){
  1121. sdio_interrupt_flag_clear(SDIO_INT_DTTMOUT);
  1122. /* disable all the interrupts */
  1123. sdio_interrupt_disable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_DTEND | SDIO_INT_STBITE |
  1124. SDIO_INT_TFH | SDIO_INT_RFH | SDIO_INT_TXURE | SDIO_INT_RXORE);
  1125. number_bytes = 0;
  1126. transerror = SD_DATA_TIMEOUT;
  1127. return transerror;
  1128. }
  1129. if(RESET != sdio_interrupt_flag_get(SDIO_INT_FLAG_STBITE)){
  1130. sdio_interrupt_flag_clear(SDIO_INT_STBITE);
  1131. /* disable all the interrupts */
  1132. sdio_interrupt_disable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_DTEND | SDIO_INT_STBITE |
  1133. SDIO_INT_TFH | SDIO_INT_RFH | SDIO_INT_TXURE | SDIO_INT_RXORE);
  1134. number_bytes = 0;
  1135. transerror = SD_START_BIT_ERROR;
  1136. return transerror;
  1137. }
  1138. if(RESET != sdio_interrupt_flag_get(SDIO_INT_FLAG_TXURE)){
  1139. sdio_interrupt_flag_clear(SDIO_INT_TXURE);
  1140. /* disable all the interrupts */
  1141. sdio_interrupt_disable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_DTEND | SDIO_INT_STBITE |
  1142. SDIO_INT_TFH | SDIO_INT_RFH | SDIO_INT_TXURE | SDIO_INT_RXORE);
  1143. number_bytes = 0;
  1144. transerror = SD_TX_UNDERRUN_ERROR;
  1145. return transerror;
  1146. }
  1147. if(RESET != sdio_interrupt_flag_get(SDIO_INT_FLAG_RXORE)){
  1148. sdio_interrupt_flag_clear(SDIO_INT_RXORE);
  1149. /* disable all the interrupts */
  1150. sdio_interrupt_disable(SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_DTEND | SDIO_INT_STBITE |
  1151. SDIO_INT_TFH | SDIO_INT_RFH | SDIO_INT_TXURE | SDIO_INT_RXORE);
  1152. number_bytes = 0;
  1153. transerror = SD_RX_OVERRUN_ERROR;
  1154. return transerror;
  1155. }
  1156. return transerror;
  1157. }
  1158. /*!
  1159. \brief select or deselect a card
  1160. \param[in] cardrca: the RCA of a card
  1161. \param[out] none
  1162. \retval sd_error_enum
  1163. */
  1164. sd_error_enum sd_card_select_deselect(uint16_t cardrca)
  1165. {
  1166. sd_error_enum status = SD_OK;
  1167. /* send CMD7(SELECT/DESELECT_CARD) to select or deselect the card */
  1168. sdio_command_response_config(SD_CMD_SELECT_DESELECT_CARD, (uint32_t)(cardrca << SD_RCA_SHIFT), SDIO_RESPONSETYPE_SHORT);
  1169. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1170. sdio_csm_enable();
  1171. status = r1_error_check(SD_CMD_SELECT_DESELECT_CARD);
  1172. return status;
  1173. }
  1174. /*!
  1175. \brief get the card status whose response format R1 contains a 32-bit field
  1176. \param[in] none
  1177. \param[out] pcardstatus: a pointer that store card status
  1178. \retval sd_error_enum
  1179. */
  1180. sd_error_enum sd_cardstatus_get(uint32_t *pcardstatus)
  1181. {
  1182. sd_error_enum status = SD_OK;
  1183. if(NULL == pcardstatus){
  1184. status = SD_PARAMETER_INVALID;
  1185. return status;
  1186. }
  1187. /* send CMD13(SEND_STATUS), addressed card sends its status register */
  1188. sdio_command_response_config(SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  1189. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1190. sdio_csm_enable();
  1191. /* check if some error occurs */
  1192. status = r1_error_check(SD_CMD_SEND_STATUS);
  1193. if(SD_OK != status){
  1194. return status;
  1195. }
  1196. *pcardstatus = sdio_response_get(SDIO_RESPONSE0);
  1197. return status;
  1198. }
  1199. /*!
  1200. \brief get the SD status, the size of the SD status is one data block of 512 bit
  1201. \param[in] none
  1202. \param[out] psdstatus: a pointer that store SD card status
  1203. \retval sd_error_enum
  1204. */
  1205. sd_error_enum sd_sdstatus_get(uint32_t *psdstatus)
  1206. {
  1207. sd_error_enum status = SD_OK;
  1208. uint32_t count = 0;
  1209. /* check whether the card is locked */
  1210. if (sdio_response_get(SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED){
  1211. status = SD_LOCK_UNLOCK_FAILED;
  1212. return(status);
  1213. }
  1214. /* send CMD16(SET_BLOCKLEN) to set the block length */
  1215. sdio_command_response_config(SD_CMD_SET_BLOCKLEN, (uint32_t)64, SDIO_RESPONSETYPE_SHORT);
  1216. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1217. sdio_csm_enable();
  1218. /* check if some error occurs */
  1219. status = r1_error_check(SD_CMD_SET_BLOCKLEN);
  1220. if(SD_OK != status){
  1221. return status;
  1222. }
  1223. /* send CMD55(APP_CMD) to indicate next command is application specific command */
  1224. sdio_command_response_config(SD_CMD_APP_CMD, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  1225. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1226. sdio_csm_enable();
  1227. /* check if some error occurs */
  1228. status = r1_error_check(SD_CMD_APP_CMD);
  1229. if(SD_OK != status){
  1230. return status;
  1231. }
  1232. /* configure the SDIO data transmission */
  1233. sdio_data_config(SD_DATATIMEOUT, (uint32_t)64, SDIO_DATABLOCKSIZE_64BYTES);
  1234. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOSDIO);
  1235. sdio_dsm_enable();
  1236. /* send ACMD13(SD_STATUS) to get the SD status */
  1237. sdio_command_response_config(SD_APPCMD_SD_STATUS, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  1238. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1239. sdio_csm_enable();
  1240. /* check if some error occurs */
  1241. status = r1_error_check(SD_APPCMD_SD_STATUS);
  1242. if(SD_OK != status){
  1243. return status;
  1244. }
  1245. while(!sdio_flag_get(SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_RXORE | SDIO_FLAG_DTBLKEND | SDIO_FLAG_STBITE)){
  1246. if(RESET != sdio_flag_get(SDIO_FLAG_RFH)){
  1247. for(count = 0; count < SD_FIFOHALF_WORDS; count++){
  1248. *(psdstatus + count) = sdio_data_read();
  1249. }
  1250. psdstatus += SD_FIFOHALF_WORDS;
  1251. }
  1252. }
  1253. /* whether some error occurs and return it */
  1254. if(RESET != sdio_flag_get(SDIO_FLAG_DTCRCERR)){
  1255. status = SD_DATA_CRC_ERROR;
  1256. sdio_flag_clear(SDIO_FLAG_DTCRCERR);
  1257. return status;
  1258. }else if(RESET != sdio_flag_get(SDIO_FLAG_DTTMOUT)){
  1259. status = SD_DATA_TIMEOUT;
  1260. sdio_flag_clear(SDIO_FLAG_DTTMOUT);
  1261. return status;
  1262. }else if(RESET != sdio_flag_get(SDIO_FLAG_RXORE)){
  1263. status = SD_RX_OVERRUN_ERROR;
  1264. sdio_flag_clear(SDIO_FLAG_RXORE);
  1265. return status;
  1266. }else if(RESET != sdio_flag_get(SDIO_FLAG_STBITE)){
  1267. status = SD_START_BIT_ERROR;
  1268. sdio_flag_clear(SDIO_FLAG_STBITE);
  1269. return status;
  1270. }
  1271. while(RESET != sdio_flag_get(SDIO_FLAG_RXDTVAL)){
  1272. *psdstatus = sdio_data_read();
  1273. ++psdstatus;
  1274. }
  1275. /* clear the SDIO_INTC flags */
  1276. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1277. psdstatus -= 16;
  1278. for(count = 0; count < 16; count++){
  1279. psdstatus[count] = ((psdstatus[count] & SD_MASK_0_7BITS) << 24) |((psdstatus[count] & SD_MASK_8_15BITS) << 8) |
  1280. ((psdstatus[count] & SD_MASK_16_23BITS) >> 8) |((psdstatus[count] & SD_MASK_24_31BITS) >> 24);
  1281. }
  1282. return status;
  1283. }
  1284. /*!
  1285. \brief stop an ongoing data transfer
  1286. \param[in] none
  1287. \param[out] none
  1288. \retval sd_error_enum
  1289. */
  1290. sd_error_enum sd_transfer_stop(void)
  1291. {
  1292. sd_error_enum status = SD_OK;
  1293. /* send CMD12(STOP_TRANSMISSION) to stop transmission */
  1294. sdio_command_response_config(SD_CMD_STOP_TRANSMISSION, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  1295. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1296. sdio_csm_enable();
  1297. /* check if some error occurs */
  1298. status = r1_error_check(SD_CMD_STOP_TRANSMISSION);
  1299. return status;
  1300. }
  1301. /*!
  1302. \brief lock or unlock a card
  1303. \param[in] lockstate: the lock state
  1304. \arg SD_LOCK: lock the SD card
  1305. \arg SD_UNLOCK: unlock the SD card
  1306. \param[out] none
  1307. \retval sd_error_enum
  1308. */
  1309. sd_error_enum sd_lock_unlock(uint8_t lockstate)
  1310. {
  1311. sd_error_enum status = SD_OK;
  1312. uint8_t cardstate = 0, tempbyte = 0;
  1313. uint32_t pwd1 = 0, pwd2 = 0, response = 0;
  1314. __IO uint32_t timeout = 0;
  1315. uint16_t tempccc = 0;
  1316. /* get the card command classes from CSD */
  1317. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_24_31BITS) >> 24);
  1318. tempccc = (uint16_t)((uint16_t)tempbyte << 4);
  1319. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_16_23BITS) >> 16);
  1320. tempccc |= (uint16_t)((uint16_t)(tempbyte & 0xF0) >> 4);
  1321. if(0 == (tempccc & SD_CCC_LOCK_CARD)){
  1322. /* don't support the lock command */
  1323. status = SD_FUNCTION_UNSUPPORTED;
  1324. return status;
  1325. }
  1326. /* password pattern */
  1327. pwd1 = (0x01020600|lockstate);
  1328. pwd2 = 0x03040506;
  1329. /* clear all DSM configuration */
  1330. sdio_data_config(0, 0, SDIO_DATABLOCKSIZE_1BYTE);
  1331. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  1332. sdio_dsm_disable();
  1333. sdio_dma_disable();
  1334. /* send CMD16(SET_BLOCKLEN) to set the block length */
  1335. sdio_command_response_config(SD_CMD_SET_BLOCKLEN, (uint32_t)8, SDIO_RESPONSETYPE_SHORT);
  1336. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1337. sdio_csm_enable();
  1338. /* check if some error occurs */
  1339. status = r1_error_check(SD_CMD_SET_BLOCKLEN);
  1340. if(SD_OK != status){
  1341. return status;
  1342. }
  1343. /* send CMD13(SEND_STATUS), addressed card sends its status register */
  1344. sdio_command_response_config(SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  1345. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1346. sdio_csm_enable();
  1347. /* check if some error occurs */
  1348. status = r1_error_check(SD_CMD_SEND_STATUS);
  1349. if(SD_OK != status){
  1350. return status;
  1351. }
  1352. response = sdio_response_get(SDIO_RESPONSE0);
  1353. timeout = 100000;
  1354. while((0 == (response & SD_R1_READY_FOR_DATA)) && (timeout > 0)){
  1355. /* continue to send CMD13 to polling the state of card until buffer empty or timeout */
  1356. --timeout;
  1357. /* send CMD13(SEND_STATUS), addressed card sends its status registers */
  1358. sdio_command_response_config(SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  1359. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1360. sdio_csm_enable();
  1361. /* check if some error occurs */
  1362. status = r1_error_check(SD_CMD_SEND_STATUS);
  1363. if(SD_OK != status){
  1364. return status;
  1365. }
  1366. response = sdio_response_get(SDIO_RESPONSE0);
  1367. }
  1368. if(0 == timeout){
  1369. return SD_ERROR;
  1370. }
  1371. /* send CMD42(LOCK_UNLOCK) to set/reset the password or lock/unlock the card */
  1372. sdio_command_response_config(SD_CMD_LOCK_UNLOCK, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  1373. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1374. sdio_csm_enable();
  1375. /* check if some error occurs */
  1376. status = r1_error_check(SD_CMD_LOCK_UNLOCK);
  1377. if(SD_OK != status){
  1378. return status;
  1379. }
  1380. response = sdio_response_get(SDIO_RESPONSE0);
  1381. /* configure the SDIO data transmission */
  1382. sdio_data_config(SD_DATATIMEOUT, (uint32_t)8, SDIO_DATABLOCKSIZE_8BYTES);
  1383. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOCARD);
  1384. sdio_dsm_enable();
  1385. /* write password pattern */
  1386. sdio_data_write(pwd1);
  1387. sdio_data_write(pwd2);
  1388. /* whether some error occurs and return it */
  1389. if(RESET != sdio_flag_get(SDIO_FLAG_DTCRCERR)){
  1390. status = SD_DATA_CRC_ERROR;
  1391. sdio_flag_clear(SDIO_FLAG_DTCRCERR);
  1392. return status;
  1393. }else if(RESET != sdio_flag_get(SDIO_FLAG_DTTMOUT)){
  1394. status = SD_DATA_TIMEOUT;
  1395. sdio_flag_clear(SDIO_FLAG_DTTMOUT);
  1396. return status;
  1397. }else if(RESET != sdio_flag_get(SDIO_FLAG_TXURE)){
  1398. status = SD_TX_UNDERRUN_ERROR;
  1399. sdio_flag_clear(SDIO_FLAG_TXURE);
  1400. return status;
  1401. }else if(RESET != sdio_flag_get(SDIO_FLAG_STBITE)){
  1402. status = SD_START_BIT_ERROR;
  1403. sdio_flag_clear(SDIO_FLAG_STBITE);
  1404. return status;
  1405. }
  1406. /* clear the SDIO_INTC flags */
  1407. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1408. /* get the card state and wait the card is out of programming and receiving state */
  1409. status = sd_card_state_get(&cardstate);
  1410. while((SD_OK == status) && ((SD_CARDSTATE_PROGRAMMING == cardstate) || (SD_CARDSTATE_RECEIVING == cardstate))){
  1411. status = sd_card_state_get(&cardstate);
  1412. }
  1413. return status;
  1414. }
  1415. /*!
  1416. \brief get the data transfer state
  1417. \param[in] none
  1418. \param[out] none
  1419. \retval sd_error_enum
  1420. */
  1421. sd_transfer_state_enum sd_transfer_state_get(void)
  1422. {
  1423. sd_transfer_state_enum transtate = SD_NO_TRANSFER;
  1424. if(RESET != sdio_flag_get(SDIO_FLAG_TXRUN | SDIO_FLAG_RXRUN)){
  1425. transtate = SD_TRANSFER_IN_PROGRESS;
  1426. }
  1427. return transtate;
  1428. }
  1429. /*!
  1430. \brief get SD card capacity
  1431. \param[in] none
  1432. \param[out] none
  1433. \retval capacity of the card(KB)
  1434. */
  1435. uint32_t sd_card_capacity_get(void)
  1436. {
  1437. uint8_t tempbyte = 0, devicesize_mult = 0, readblklen = 0;
  1438. uint32_t capacity = 0, devicesize = 0;
  1439. if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype)){
  1440. /* calculate the c_size(device size) */
  1441. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_8_15BITS) >> 8);
  1442. devicesize |= (uint32_t)((uint32_t)(tempbyte & 0x03) << 10);
  1443. tempbyte = (uint8_t)(sd_csd[1] & SD_MASK_0_7BITS);
  1444. devicesize |= (uint32_t)((uint32_t)tempbyte << 2);
  1445. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_24_31BITS) >> 24);
  1446. devicesize |= (uint32_t)((uint32_t)(tempbyte & 0xC0) >> 6);
  1447. /* calculate the c_size_mult(device size multiplier) */
  1448. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_16_23BITS) >> 16);
  1449. devicesize_mult = (tempbyte & 0x03) << 1;
  1450. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_8_15BITS) >> 8);
  1451. devicesize_mult |= (tempbyte & 0x80) >> 7;
  1452. /* calculate the read_bl_len */
  1453. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_16_23BITS) >> 16);
  1454. readblklen = tempbyte & 0x0F;
  1455. /* capacity = BLOCKNR*BLOCK_LEN, BLOCKNR = (C_SIZE+1)*MULT, MULT = 2^(C_SIZE_MULT+2), BLOCK_LEN = 2^READ_BL_LEN */
  1456. capacity = (devicesize + 1)*(1 << (devicesize_mult + 2));
  1457. capacity *= (1 << readblklen);
  1458. /* change the unit of capacity to KByte */
  1459. capacity /= 1024;
  1460. }else if(SDIO_HIGH_CAPACITY_SD_CARD == cardtype){
  1461. /* calculate the c_size */
  1462. tempbyte = (uint8_t)(sd_csd[1] & SD_MASK_0_7BITS);
  1463. devicesize = (uint32_t)((uint32_t)(tempbyte & 0x3F) << 16);
  1464. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_24_31BITS) >> 24);
  1465. devicesize |= (uint32_t)((uint32_t)tempbyte << 8);
  1466. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_16_23BITS) >> 16);
  1467. devicesize |= (uint32_t)tempbyte;
  1468. /* capacity = (c_size+1)*512KByte */
  1469. capacity = (devicesize + 1)*512;
  1470. }
  1471. return capacity;
  1472. }
  1473. /*!
  1474. \brief get the detailed information of the SD card based on received CID and CSD
  1475. \param[in] none
  1476. \param[out] pcardinfo: a pointer that store the detailed card information
  1477. \retval sd_error_enum
  1478. */
  1479. sd_error_enum sd_card_information_get(sd_card_info_struct *pcardinfo)
  1480. {
  1481. sd_error_enum status = SD_OK;
  1482. uint8_t tempbyte = 0;
  1483. if(NULL == pcardinfo){
  1484. status = SD_PARAMETER_INVALID;
  1485. return status;
  1486. }
  1487. /* store the card type and RCA */
  1488. pcardinfo->card_type = cardtype;
  1489. pcardinfo->card_rca = sd_rca;
  1490. /* CID byte 0 */
  1491. tempbyte = (uint8_t)((sd_cid[0] & SD_MASK_24_31BITS) >> 24);
  1492. pcardinfo->card_cid.mid = tempbyte;
  1493. /* CID byte 1 */
  1494. tempbyte = (uint8_t)((sd_cid[0] & SD_MASK_16_23BITS) >> 16);
  1495. pcardinfo->card_cid.oid = (uint16_t)((uint16_t)tempbyte << 8);
  1496. /* CID byte 2 */
  1497. tempbyte = (uint8_t)((sd_cid[0] & SD_MASK_8_15BITS) >> 8);
  1498. pcardinfo->card_cid.oid |= (uint16_t)tempbyte;
  1499. /* CID byte 3 */
  1500. tempbyte = (uint8_t)(sd_cid[0] & SD_MASK_0_7BITS);
  1501. pcardinfo->card_cid.pnm0 = (uint32_t)((uint32_t)tempbyte << 24);
  1502. /* CID byte 4 */
  1503. tempbyte = (uint8_t)((sd_cid[1] & SD_MASK_24_31BITS) >> 24);
  1504. pcardinfo->card_cid.pnm0 |= (uint32_t)((uint32_t)tempbyte << 16);
  1505. /* CID byte 5 */
  1506. tempbyte = (uint8_t)((sd_cid[1] & SD_MASK_16_23BITS) >> 16);
  1507. pcardinfo->card_cid.pnm0 |= (uint32_t)((uint32_t)tempbyte << 8);
  1508. /* CID byte 6 */
  1509. tempbyte = (uint8_t)((sd_cid[1] & SD_MASK_8_15BITS) >> 8);
  1510. pcardinfo->card_cid.pnm0 |= (uint32_t)(tempbyte);
  1511. /* CID byte 7 */
  1512. tempbyte = (uint8_t)(sd_cid[1] & SD_MASK_0_7BITS);
  1513. pcardinfo->card_cid.pnm1 = tempbyte;
  1514. /* CID byte 8 */
  1515. tempbyte = (uint8_t)((sd_cid[2] & SD_MASK_24_31BITS) >> 24);
  1516. pcardinfo->card_cid.prv = tempbyte;
  1517. /* CID byte 9 */
  1518. tempbyte = (uint8_t)((sd_cid[2] & SD_MASK_16_23BITS) >> 16);
  1519. pcardinfo->card_cid.psn = (uint32_t)((uint32_t)tempbyte << 24);
  1520. /* CID byte 10 */
  1521. tempbyte = (uint8_t)((sd_cid[2] & SD_MASK_8_15BITS) >> 8);
  1522. pcardinfo->card_cid.psn |= (uint32_t)((uint32_t)tempbyte << 16);
  1523. /* CID byte 11 */
  1524. tempbyte = (uint8_t)(sd_cid[2] & SD_MASK_0_7BITS);
  1525. pcardinfo->card_cid.psn |= (uint32_t)tempbyte;
  1526. /* CID byte 12 */
  1527. tempbyte = (uint8_t)((sd_cid[3] & SD_MASK_24_31BITS) >> 24);
  1528. pcardinfo->card_cid.psn |= (uint32_t)tempbyte;
  1529. /* CID byte 13 */
  1530. tempbyte = (uint8_t)((sd_cid[3] & SD_MASK_16_23BITS) >> 16);
  1531. pcardinfo->card_cid.mdt = (uint16_t)((uint16_t)(tempbyte & 0x0F) << 8);
  1532. /* CID byte 14 */
  1533. tempbyte = (uint8_t)((sd_cid[3] & SD_MASK_8_15BITS) >> 8);
  1534. pcardinfo->card_cid.mdt |= (uint16_t)tempbyte;
  1535. /* CID byte 15 */
  1536. tempbyte = (uint8_t)(sd_cid[3] & SD_MASK_0_7BITS);
  1537. pcardinfo->card_cid.cid_crc = (tempbyte & 0xFE) >> 1;
  1538. /* CSD byte 0 */
  1539. tempbyte = (uint8_t)((sd_csd[0] & SD_MASK_24_31BITS) >> 24);
  1540. pcardinfo->card_csd.csd_struct = (tempbyte & 0xC0) >> 6;
  1541. /* CSD byte 1 */
  1542. tempbyte = (uint8_t)((sd_csd[0] & SD_MASK_16_23BITS) >> 16);
  1543. pcardinfo->card_csd.taac = tempbyte;
  1544. /* CSD byte 2 */
  1545. tempbyte = (uint8_t)((sd_csd[0] & SD_MASK_8_15BITS) >> 8);
  1546. pcardinfo->card_csd.nsac = tempbyte;
  1547. /* CSD byte 3 */
  1548. tempbyte = (uint8_t)(sd_csd[0] & SD_MASK_0_7BITS);
  1549. pcardinfo->card_csd.tran_speed = tempbyte;
  1550. /* CSD byte 4 */
  1551. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_24_31BITS) >> 24);
  1552. pcardinfo->card_csd.ccc = (uint16_t)((uint16_t)tempbyte << 4);
  1553. /* CSD byte 5 */
  1554. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_16_23BITS) >> 16);
  1555. pcardinfo->card_csd.ccc |= (uint16_t)((uint16_t)(tempbyte & 0xF0) >> 4);
  1556. pcardinfo->card_csd.read_bl_len = tempbyte & 0x0F;
  1557. /* CSD byte 6 */
  1558. tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_8_15BITS) >> 8);
  1559. pcardinfo->card_csd.read_bl_partial = (tempbyte & 0x80) >> 7;
  1560. pcardinfo->card_csd.write_blk_misalign = (tempbyte & 0x40) >> 6;
  1561. pcardinfo->card_csd.read_blk_misalign = (tempbyte & 0x20) >> 5;
  1562. pcardinfo->card_csd.dsp_imp = (tempbyte & 0x10) >> 4;
  1563. if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype)){
  1564. /* card is SDSC card, CSD version 1.0 */
  1565. pcardinfo->card_csd.c_size = (uint32_t)((uint32_t)(tempbyte & 0x03) << 10);
  1566. /* CSD byte 7 */
  1567. tempbyte = (uint8_t)(sd_csd[1] & SD_MASK_0_7BITS);
  1568. pcardinfo->card_csd.c_size |= (uint32_t)((uint32_t)tempbyte << 2);
  1569. /* CSD byte 8 */
  1570. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_24_31BITS) >> 24);
  1571. pcardinfo->card_csd.c_size |= (uint32_t)((uint32_t)(tempbyte & 0xC0) >> 6);
  1572. pcardinfo->card_csd.vdd_r_curr_min = (tempbyte & 0x38) >> 3;
  1573. pcardinfo->card_csd.vdd_r_curr_max = tempbyte & 0x07;
  1574. /* CSD byte 9 */
  1575. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_16_23BITS) >> 16);
  1576. pcardinfo->card_csd.vdd_w_curr_min = (tempbyte & 0xE0) >> 5;
  1577. pcardinfo->card_csd.vdd_w_curr_max = (tempbyte & 0x1C) >> 2;
  1578. pcardinfo->card_csd.c_size_mult = (tempbyte & 0x03) << 1;
  1579. /* CSD byte 10 */
  1580. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_8_15BITS) >> 8);
  1581. pcardinfo->card_csd.c_size_mult |= (tempbyte & 0x80) >> 7;
  1582. /* calculate the card block size and capacity */
  1583. pcardinfo->card_blocksize = 1 << (pcardinfo->card_csd.read_bl_len);
  1584. pcardinfo->card_capacity = pcardinfo->card_csd.c_size + 1;
  1585. pcardinfo->card_capacity *= (1 << (pcardinfo->card_csd.c_size_mult + 2));
  1586. pcardinfo->card_capacity *= pcardinfo->card_blocksize;
  1587. }else if(SDIO_HIGH_CAPACITY_SD_CARD == cardtype){
  1588. /* card is SDHC card, CSD version 2.0 */
  1589. /* CSD byte 7 */
  1590. tempbyte = (uint8_t)(sd_csd[1] & SD_MASK_0_7BITS);
  1591. pcardinfo->card_csd.c_size = (uint32_t)((uint32_t)(tempbyte & 0x3F) << 16);
  1592. /* CSD byte 8 */
  1593. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_24_31BITS) >> 24);
  1594. pcardinfo->card_csd.c_size |= (uint32_t)((uint32_t)tempbyte << 8);
  1595. /* CSD byte 9 */
  1596. tempbyte = (uint8_t)((sd_csd[2] & SD_MASK_16_23BITS) >> 16);
  1597. pcardinfo->card_csd.c_size |= (uint32_t)tempbyte;
  1598. /* calculate the card block size and capacity */
  1599. pcardinfo->card_blocksize = 512;
  1600. pcardinfo->card_capacity = (pcardinfo->card_csd.c_size + 1) * 512 *1024;
  1601. }
  1602. pcardinfo->card_csd.erase_blk_en = (tempbyte & 0x40) >> 6;
  1603. pcardinfo->card_csd.sector_size = (tempbyte & 0x3F) << 1;
  1604. /* CSD byte 11 */
  1605. tempbyte = (uint8_t)(sd_csd[2] & SD_MASK_0_7BITS);
  1606. pcardinfo->card_csd.sector_size |= (tempbyte & 0x80) >> 7;
  1607. pcardinfo->card_csd.wp_grp_size = (tempbyte & 0x7F);
  1608. /* CSD byte 12 */
  1609. tempbyte = (uint8_t)((sd_csd[3] & SD_MASK_24_31BITS) >> 24);
  1610. pcardinfo->card_csd.wp_grp_enable = (tempbyte & 0x80) >> 7;
  1611. pcardinfo->card_csd.r2w_factor = (tempbyte & 0x1C) >> 2;
  1612. pcardinfo->card_csd.write_bl_len = (tempbyte & 0x03) << 2;
  1613. /* CSD byte 13 */
  1614. tempbyte = (uint8_t)((sd_csd[3] & SD_MASK_16_23BITS) >> 16);
  1615. pcardinfo->card_csd.write_bl_len |= (tempbyte & 0xC0) >> 6;
  1616. pcardinfo->card_csd.write_bl_partial = (tempbyte & 0x20) >> 5;
  1617. /* CSD byte 14 */
  1618. tempbyte = (uint8_t)((sd_csd[3] & SD_MASK_8_15BITS) >> 8);
  1619. pcardinfo->card_csd.file_format_grp = (tempbyte & 0x80) >> 7;
  1620. pcardinfo->card_csd.copy_flag = (tempbyte & 0x40) >> 6;
  1621. pcardinfo->card_csd.perm_write_protect = (tempbyte & 0x20) >> 5;
  1622. pcardinfo->card_csd.tmp_write_protect = (tempbyte & 0x10) >> 4;
  1623. pcardinfo->card_csd.file_format = (tempbyte & 0x0C) >> 2;
  1624. /* CSD byte 15 */
  1625. tempbyte = (uint8_t)(sd_csd[3] & SD_MASK_0_7BITS);
  1626. pcardinfo->card_csd.csd_crc = (tempbyte & 0xFE) >> 1;
  1627. return status;
  1628. }
  1629. /*!
  1630. \brief check if the command sent error occurs
  1631. \param[in] none
  1632. \param[out] none
  1633. \retval sd_error_enum
  1634. */
  1635. static sd_error_enum cmdsent_error_check(void)
  1636. {
  1637. sd_error_enum status = SD_OK;
  1638. __IO uint32_t timeout = 100000;
  1639. /* check command sent flag */
  1640. while((RESET == sdio_flag_get(SDIO_FLAG_CMDSEND)) && (timeout > 0)){
  1641. --timeout;
  1642. }
  1643. /* command response is timeout */
  1644. if(0 == timeout){
  1645. status = SD_CMD_RESP_TIMEOUT;
  1646. return status;
  1647. }
  1648. /* if the command is sent, clear the SDIO_INTC flags */
  1649. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1650. return status;
  1651. }
  1652. /*!
  1653. \brief check if error type for R1 response
  1654. \param[in] resp: content of response
  1655. \param[out] none
  1656. \retval sd_error_enum
  1657. */
  1658. static sd_error_enum r1_error_type_check(uint32_t resp)
  1659. {
  1660. sd_error_enum status = SD_ERROR;
  1661. /* check which error occurs */
  1662. if(resp & SD_R1_OUT_OF_RANGE){
  1663. status = SD_OUT_OF_RANGE;
  1664. }else if(resp & SD_R1_ADDRESS_ERROR){
  1665. status = SD_ADDRESS_ERROR;
  1666. }else if(resp & SD_R1_BLOCK_LEN_ERROR){
  1667. status = SD_BLOCK_LEN_ERROR;
  1668. }else if(resp & SD_R1_ERASE_SEQ_ERROR){
  1669. status = SD_ERASE_SEQ_ERROR;
  1670. }else if(resp & SD_R1_ERASE_PARAM){
  1671. status = SD_ERASE_PARAM;
  1672. }else if(resp & SD_R1_WP_VIOLATION){
  1673. status = SD_WP_VIOLATION;
  1674. }else if(resp & SD_R1_LOCK_UNLOCK_FAILED){
  1675. status = SD_LOCK_UNLOCK_FAILED;
  1676. }else if(resp & SD_R1_COM_CRC_ERROR){
  1677. status = SD_COM_CRC_ERROR;
  1678. }else if(resp & SD_R1_ILLEGAL_COMMAND){
  1679. status = SD_ILLEGAL_COMMAND;
  1680. }else if(resp & SD_R1_CARD_ECC_FAILED){
  1681. status = SD_CARD_ECC_FAILED;
  1682. }else if(resp & SD_R1_CC_ERROR){
  1683. status = SD_CC_ERROR;
  1684. }else if(resp & SD_R1_GENERAL_UNKNOWN_ERROR){
  1685. status = SD_GENERAL_UNKNOWN_ERROR;
  1686. }else if(resp & SD_R1_CSD_OVERWRITE){
  1687. status = SD_CSD_OVERWRITE;
  1688. }else if(resp & SD_R1_WP_ERASE_SKIP){
  1689. status = SD_WP_ERASE_SKIP;
  1690. }else if(resp & SD_R1_CARD_ECC_DISABLED){
  1691. status = SD_CARD_ECC_DISABLED;
  1692. }else if(resp & SD_R1_ERASE_RESET){
  1693. status = SD_ERASE_RESET;
  1694. }else if(resp & SD_R1_AKE_SEQ_ERROR){
  1695. status = SD_AKE_SEQ_ERROR;
  1696. }
  1697. return status;
  1698. }
  1699. /*!
  1700. \brief check if error occurs for R1 response
  1701. \param[in] cmdindex: the index of command
  1702. \param[out] none
  1703. \retval sd_error_enum
  1704. */
  1705. static sd_error_enum r1_error_check(uint8_t cmdindex)
  1706. {
  1707. sd_error_enum status = SD_OK;
  1708. uint32_t reg_status = 0, resp_r1 = 0;
  1709. /* store the content of SDIO_STAT */
  1710. reg_status = SDIO_STAT;
  1711. while(!(reg_status & (SDIO_FLAG_CCRCERR | SDIO_FLAG_CMDTMOUT | SDIO_FLAG_CMDRECV))){
  1712. reg_status = SDIO_STAT;
  1713. }
  1714. /* check whether an error or timeout occurs or command response received */
  1715. if(reg_status & SDIO_FLAG_CCRCERR){
  1716. status = SD_CMD_CRC_ERROR;
  1717. sdio_flag_clear(SDIO_FLAG_CCRCERR);
  1718. return status;
  1719. }else if(reg_status & SDIO_FLAG_CMDTMOUT){
  1720. status = SD_CMD_RESP_TIMEOUT;
  1721. sdio_flag_clear(SDIO_FLAG_CMDTMOUT);
  1722. return status;
  1723. }
  1724. /* check whether the last response command index is the desired one */
  1725. if(sdio_command_index_get() != cmdindex){
  1726. status = SD_ILLEGAL_COMMAND;
  1727. return status;
  1728. }
  1729. /* clear all the SDIO_INTC flags */
  1730. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1731. /* get the SDIO response register 0 for checking */
  1732. resp_r1 = sdio_response_get(SDIO_RESPONSE0);
  1733. if(SD_ALLZERO == (resp_r1 & SD_R1_ERROR_BITS)){
  1734. /* no error occurs, return SD_OK */
  1735. status = SD_OK;
  1736. return status;
  1737. }
  1738. /* if some error occurs, return the error type */
  1739. status = r1_error_type_check(resp_r1);
  1740. return status;
  1741. }
  1742. /*!
  1743. \brief check if error occurs for R2 response
  1744. \param[in] none
  1745. \param[out] none
  1746. \retval sd_error_enum
  1747. */
  1748. static sd_error_enum r2_error_check(void)
  1749. {
  1750. sd_error_enum status = SD_OK;
  1751. uint32_t reg_status = 0;
  1752. /* store the content of SDIO_STAT */
  1753. reg_status = SDIO_STAT;
  1754. while(!(reg_status & (SDIO_FLAG_CCRCERR | SDIO_FLAG_CMDTMOUT | SDIO_FLAG_CMDRECV))){
  1755. reg_status = SDIO_STAT;
  1756. }
  1757. /* check whether an error or timeout occurs or command response received */
  1758. if(reg_status & SDIO_FLAG_CCRCERR){
  1759. status = SD_CMD_CRC_ERROR;
  1760. sdio_flag_clear(SDIO_FLAG_CCRCERR);
  1761. return status;
  1762. }else if(reg_status & SDIO_FLAG_CMDTMOUT){
  1763. status = SD_CMD_RESP_TIMEOUT;
  1764. sdio_flag_clear(SDIO_FLAG_CMDTMOUT);
  1765. return status;
  1766. }
  1767. /* clear all the SDIO_INTC flags */
  1768. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1769. return status;
  1770. }
  1771. /*!
  1772. \brief check if error occurs for R3 response
  1773. \param[in] none
  1774. \param[out] none
  1775. \retval sd_error_enum
  1776. */
  1777. static sd_error_enum r3_error_check(void)
  1778. {
  1779. sd_error_enum status = SD_OK;
  1780. uint32_t reg_status = 0;
  1781. /* store the content of SDIO_STAT */
  1782. reg_status = SDIO_STAT;
  1783. while(!(reg_status & (SDIO_FLAG_CCRCERR | SDIO_FLAG_CMDTMOUT | SDIO_FLAG_CMDRECV))){
  1784. reg_status = SDIO_STAT;
  1785. }
  1786. if(reg_status & SDIO_FLAG_CMDTMOUT){
  1787. status = SD_CMD_RESP_TIMEOUT;
  1788. sdio_flag_clear(SDIO_FLAG_CMDTMOUT);
  1789. return status;
  1790. }
  1791. /* clear all the SDIO_INTC flags */
  1792. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1793. return status;
  1794. }
  1795. /*!
  1796. \brief check if error occurs for R6 response
  1797. \param[in] cmdindex: the index of command
  1798. \param[out] prca: a pointer that store the RCA of card
  1799. \retval sd_error_enum
  1800. */
  1801. static sd_error_enum r6_error_check(uint8_t cmdindex, uint16_t *prca)
  1802. {
  1803. sd_error_enum status = SD_OK;
  1804. uint32_t reg_status = 0, response = 0;
  1805. /* store the content of SDIO_STAT */
  1806. reg_status = SDIO_STAT;
  1807. while(!(reg_status & (SDIO_FLAG_CCRCERR | SDIO_FLAG_CMDTMOUT | SDIO_FLAG_CMDRECV))){
  1808. reg_status = SDIO_STAT;
  1809. }
  1810. /* check whether an error or timeout occurs or command response received */
  1811. if(reg_status & SDIO_FLAG_CCRCERR){
  1812. status = SD_CMD_CRC_ERROR;
  1813. sdio_flag_clear(SDIO_FLAG_CCRCERR);
  1814. return status;
  1815. }else if(reg_status & SDIO_FLAG_CMDTMOUT){
  1816. status = SD_CMD_RESP_TIMEOUT;
  1817. sdio_flag_clear(SDIO_FLAG_CMDTMOUT);
  1818. return status;
  1819. }
  1820. /* check whether the last response command index is the desired one */
  1821. if(sdio_command_index_get() != cmdindex){
  1822. status = SD_ILLEGAL_COMMAND;
  1823. return status;
  1824. }
  1825. /* clear all the SDIO_INTC flags */
  1826. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1827. /* get the SDIO response register 0 for checking */
  1828. response = sdio_response_get(SDIO_RESPONSE0);
  1829. if(SD_ALLZERO == (response & (SD_R6_COM_CRC_ERROR | SD_R6_ILLEGAL_COMMAND | SD_R6_GENERAL_UNKNOWN_ERROR))){
  1830. *prca = (uint16_t)(response >> 16);
  1831. return status;
  1832. }
  1833. /* if some error occurs, return the error type */
  1834. if(response & SD_R6_COM_CRC_ERROR){
  1835. status = SD_COM_CRC_ERROR;
  1836. }else if(response & SD_R6_ILLEGAL_COMMAND){
  1837. status = SD_ILLEGAL_COMMAND;
  1838. }else if(response & SD_R6_GENERAL_UNKNOWN_ERROR){
  1839. status = SD_GENERAL_UNKNOWN_ERROR;
  1840. }
  1841. return status;
  1842. }
  1843. /*!
  1844. \brief check if error occurs for R7 response
  1845. \param[in] none
  1846. \param[out] none
  1847. \retval sd_error_enum
  1848. */
  1849. static sd_error_enum r7_error_check(void)
  1850. {
  1851. sd_error_enum status = SD_ERROR;
  1852. uint32_t reg_status = 0;
  1853. __IO uint32_t timeout = 100000;
  1854. /* store the content of SDIO_STAT */
  1855. reg_status = SDIO_STAT;
  1856. while(!(reg_status & (SDIO_FLAG_CCRCERR | SDIO_FLAG_CMDTMOUT | SDIO_FLAG_CMDRECV)) && (timeout > 0)){
  1857. reg_status = SDIO_STAT;
  1858. --timeout;
  1859. }
  1860. /* check the flags */
  1861. if((reg_status & SDIO_FLAG_CMDTMOUT) || (0 == timeout)){
  1862. status = SD_CMD_RESP_TIMEOUT;
  1863. sdio_flag_clear(SDIO_FLAG_CMDTMOUT);
  1864. return status;
  1865. }
  1866. if(reg_status & SDIO_FLAG_CMDRECV){
  1867. status = SD_OK;
  1868. sdio_flag_clear(SDIO_FLAG_CMDRECV);
  1869. return status;
  1870. }
  1871. return status;
  1872. }
  1873. /*!
  1874. \brief get the state which the card is in
  1875. \param[in] none
  1876. \param[out] pcardstate: a pointer that store the card state
  1877. \arg SD_CARDSTATE_IDLE: card is in idle state
  1878. \arg SD_CARDSTATE_READY: card is in ready state
  1879. \arg SD_CARDSTATE_IDENTIFICAT: card is in identificat state
  1880. \arg SD_CARDSTATE_STANDBY: card is in standby state
  1881. \arg SD_CARDSTATE_TRANSFER: card is in transfer state
  1882. \arg SD_CARDSTATE_DATA: card is in data state
  1883. \arg SD_CARDSTATE_RECEIVING: card is in receiving state
  1884. \arg SD_CARDSTATE_PROGRAMMING: card is in programming state
  1885. \arg SD_CARDSTATE_DISCONNECT: card is in disconnect state
  1886. \arg SD_CARDSTATE_LOCKED: card is in locked state
  1887. \retval sd_error_enum
  1888. */
  1889. static sd_error_enum sd_card_state_get(uint8_t *pcardstate)
  1890. {
  1891. sd_error_enum status = SD_OK;
  1892. __IO uint32_t reg_status = 0, response = 0;
  1893. /* send CMD13(SEND_STATUS), addressed card sends its status register */
  1894. sdio_command_response_config(SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  1895. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1896. sdio_csm_enable();
  1897. /* store the content of SDIO_STAT */
  1898. reg_status = SDIO_STAT;
  1899. while(!(reg_status & (SDIO_FLAG_CCRCERR | SDIO_FLAG_CMDTMOUT | SDIO_FLAG_CMDRECV))){
  1900. reg_status = SDIO_STAT;
  1901. }
  1902. /* check whether an error or timeout occurs or command response received */
  1903. if(reg_status & SDIO_FLAG_CCRCERR){
  1904. status = SD_CMD_CRC_ERROR;
  1905. sdio_flag_clear(SDIO_FLAG_CCRCERR);
  1906. return status;
  1907. }else if(reg_status & SDIO_FLAG_CMDTMOUT){
  1908. status = SD_CMD_RESP_TIMEOUT;
  1909. sdio_flag_clear(SDIO_FLAG_CMDTMOUT);
  1910. return status;
  1911. }
  1912. /* command response received, store the response command index */
  1913. reg_status = (uint32_t)sdio_command_index_get();
  1914. if(reg_status != (uint32_t)SD_CMD_SEND_STATUS){
  1915. status = SD_ILLEGAL_COMMAND;
  1916. return status;
  1917. }
  1918. /* clear all the SDIO_INTC flags */
  1919. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  1920. /* get the SDIO response register 0 for checking */
  1921. response = sdio_response_get(SDIO_RESPONSE0);
  1922. *pcardstate = (uint8_t)((response >> 9) & 0x0000000F);
  1923. if(SD_ALLZERO == (response & SD_R1_ERROR_BITS)){
  1924. /* no error occurs, return SD_OK */
  1925. status = SD_OK;
  1926. return status;
  1927. }
  1928. /* if some error occurs, return the error type */
  1929. status = r1_error_type_check(response);
  1930. return status;
  1931. }
  1932. /*!
  1933. \brief configure the bus width mode
  1934. \param[in] buswidth: the bus width
  1935. \arg SD_BUS_WIDTH_1BIT: 1-bit bus width
  1936. \arg SD_BUS_WIDTH_4BIT: 4-bit bus width
  1937. \param[out] none
  1938. \retval sd_error_enum
  1939. */
  1940. static sd_error_enum sd_bus_width_config(uint32_t buswidth)
  1941. {
  1942. sd_error_enum status = SD_OK;
  1943. /* check whether the card is locked */
  1944. if(sdio_response_get(SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED){
  1945. status = SD_LOCK_UNLOCK_FAILED;
  1946. return status;
  1947. }
  1948. /* get the SCR register */
  1949. status = sd_scr_get(sd_rca, sd_scr);
  1950. if(SD_OK != status){
  1951. return status;
  1952. }
  1953. if(SD_BUS_WIDTH_1BIT == buswidth){
  1954. if(SD_ALLZERO != (sd_scr[1] & buswidth)){
  1955. /* send CMD55(APP_CMD) to indicate next command is application specific command */
  1956. sdio_command_response_config(SD_CMD_APP_CMD, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  1957. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1958. sdio_csm_enable();
  1959. /* check if some error occurs */
  1960. status = r1_error_check(SD_CMD_APP_CMD);
  1961. if(SD_OK != status){
  1962. return status;
  1963. }
  1964. /* send ACMD6(SET_BUS_WIDTH) to define the data bus width */
  1965. sdio_command_response_config(SD_APPCMD_SET_BUS_WIDTH, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  1966. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1967. sdio_csm_enable();
  1968. /* check if some error occurs */
  1969. status = r1_error_check(SD_APPCMD_SET_BUS_WIDTH);
  1970. if(SD_OK != status){
  1971. return status;
  1972. }
  1973. }else{
  1974. status = SD_OPERATION_IMPROPER;
  1975. }
  1976. return status;
  1977. }else if(SD_BUS_WIDTH_4BIT == buswidth){
  1978. if(SD_ALLZERO != (sd_scr[1] & buswidth)){
  1979. /* send CMD55(APP_CMD) to indicate next command is application specific command */
  1980. sdio_command_response_config(SD_CMD_APP_CMD, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  1981. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1982. sdio_csm_enable();
  1983. /* check if some error occurs */
  1984. status = r1_error_check(SD_CMD_APP_CMD);
  1985. if(SD_OK != status){
  1986. return status;
  1987. }
  1988. /* send ACMD6(SET_BUS_WIDTH) to define the data bus width */
  1989. sdio_command_response_config(SD_APPCMD_SET_BUS_WIDTH, (uint32_t)0x2, SDIO_RESPONSETYPE_SHORT);
  1990. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  1991. sdio_csm_enable();
  1992. /* check if some error occurs */
  1993. status = r1_error_check(SD_APPCMD_SET_BUS_WIDTH);
  1994. if(SD_OK != status){
  1995. return status;
  1996. }
  1997. }else{
  1998. status = SD_OPERATION_IMPROPER;
  1999. }
  2000. return status;
  2001. }else{
  2002. status = SD_PARAMETER_INVALID;
  2003. return status;
  2004. }
  2005. }
  2006. /*!
  2007. \brief get the SCR of corresponding card
  2008. \param[in] rca: RCA of a card
  2009. \param[out] pscr: a pointer that store the SCR content
  2010. \retval sd_error_enum
  2011. */
  2012. static sd_error_enum sd_scr_get(uint16_t rca, uint32_t *pscr)
  2013. {
  2014. sd_error_enum status = SD_OK;
  2015. uint32_t temp_scr[2] = {0, 0}, idx_scr = 0;
  2016. /* send CMD16(SET_BLOCKLEN) to set block length */
  2017. sdio_command_response_config(SD_CMD_SET_BLOCKLEN, (uint32_t)8, SDIO_RESPONSETYPE_SHORT);
  2018. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  2019. sdio_csm_enable();
  2020. /* check if some error occurs */
  2021. status = r1_error_check(SD_CMD_SET_BLOCKLEN);
  2022. if(SD_OK != status){
  2023. return status;
  2024. }
  2025. /* send CMD55(APP_CMD) to indicate next command is application specific command */
  2026. sdio_command_response_config(SD_CMD_APP_CMD, (uint32_t)rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
  2027. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  2028. sdio_csm_enable();
  2029. /* check if some error occurs */
  2030. status = r1_error_check(SD_CMD_APP_CMD);
  2031. if(SD_OK != status){
  2032. return status;
  2033. }
  2034. /* configure SDIO data */
  2035. sdio_data_config(SD_DATATIMEOUT, (uint32_t)8, SDIO_DATABLOCKSIZE_8BYTES);
  2036. sdio_data_transfer_config(SDIO_TRANSMODE_BLOCK, SDIO_TRANSDIRECTION_TOSDIO);
  2037. sdio_dsm_enable();
  2038. /* send ACMD51(SEND_SCR) to read the SD configuration register */
  2039. sdio_command_response_config(SD_APPCMD_SEND_SCR, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
  2040. sdio_wait_type_set(SDIO_WAITTYPE_NO);
  2041. sdio_csm_enable();
  2042. /* check if some error occurs */
  2043. status = r1_error_check(SD_APPCMD_SEND_SCR);
  2044. if(SD_OK != status){
  2045. return status;
  2046. }
  2047. /* store the received SCR */
  2048. while(!sdio_flag_get(SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_RXORE | SDIO_FLAG_DTBLKEND | SDIO_FLAG_STBITE)){
  2049. if(RESET != sdio_flag_get(SDIO_FLAG_RXDTVAL)){
  2050. *(temp_scr + idx_scr) = sdio_data_read();
  2051. ++idx_scr;
  2052. }
  2053. }
  2054. /* check whether some error occurs */
  2055. if(RESET != sdio_flag_get(SDIO_FLAG_DTCRCERR)){
  2056. status = SD_DATA_CRC_ERROR;
  2057. sdio_flag_clear(SDIO_FLAG_DTCRCERR);
  2058. return status;
  2059. }else if(RESET != sdio_flag_get(SDIO_FLAG_DTTMOUT)){
  2060. status = SD_DATA_TIMEOUT;
  2061. sdio_flag_clear(SDIO_FLAG_DTTMOUT);
  2062. return status;
  2063. }else if(RESET != sdio_flag_get(SDIO_FLAG_RXORE)){
  2064. status = SD_RX_OVERRUN_ERROR;
  2065. sdio_flag_clear(SDIO_FLAG_RXORE);
  2066. return status;
  2067. }else if(RESET != sdio_flag_get(SDIO_FLAG_STBITE)){
  2068. status = SD_START_BIT_ERROR;
  2069. sdio_flag_clear(SDIO_FLAG_STBITE);
  2070. return status;
  2071. }
  2072. /* clear all the SDIO_INTC flags */
  2073. sdio_flag_clear(SDIO_MASK_INTC_FLAGS);
  2074. /* readjust the temp SCR value */
  2075. *(pscr) = ((temp_scr[1] & SD_MASK_0_7BITS) << 24) | ((temp_scr[1] & SD_MASK_8_15BITS) << 8) |
  2076. ((temp_scr[1] & SD_MASK_16_23BITS) >> 8) | ((temp_scr[1] & SD_MASK_24_31BITS) >> 24);
  2077. *(pscr + 1) = ((temp_scr[0] & SD_MASK_0_7BITS) << 24) | ((temp_scr[0] & SD_MASK_8_15BITS) << 8) |
  2078. ((temp_scr[0] & SD_MASK_16_23BITS) >> 8) | ((temp_scr[0] & SD_MASK_24_31BITS) >> 24);
  2079. return status;
  2080. }
  2081. /*!
  2082. \brief get the data block size
  2083. \param[in] bytesnumber: the number of bytes
  2084. \param[out] none
  2085. \retval data block size
  2086. \arg SDIO_DATABLOCKSIZE_1BYTE: block size = 1 byte
  2087. \arg SDIO_DATABLOCKSIZE_2BYTES: block size = 2 bytes
  2088. \arg SDIO_DATABLOCKSIZE_4BYTES: block size = 4 bytes
  2089. \arg SDIO_DATABLOCKSIZE_8BYTES: block size = 8 bytes
  2090. \arg SDIO_DATABLOCKSIZE_16BYTES: block size = 16 bytes
  2091. \arg SDIO_DATABLOCKSIZE_32BYTES: block size = 32 bytes
  2092. \arg SDIO_DATABLOCKSIZE_64BYTES: block size = 64 bytes
  2093. \arg SDIO_DATABLOCKSIZE_128BYTES: block size = 128 bytes
  2094. \arg SDIO_DATABLOCKSIZE_256BYTES: block size = 256 bytes
  2095. \arg SDIO_DATABLOCKSIZE_512BYTES: block size = 512 bytes
  2096. \arg SDIO_DATABLOCKSIZE_1024BYTES: block size = 1024 bytes
  2097. \arg SDIO_DATABLOCKSIZE_2048BYTES: block size = 2048 bytes
  2098. \arg SDIO_DATABLOCKSIZE_4096BYTES: block size = 4096 bytes
  2099. \arg SDIO_DATABLOCKSIZE_8192BYTES: block size = 8192 bytes
  2100. \arg SDIO_DATABLOCKSIZE_16384BYTES: block size = 16384 bytes
  2101. */
  2102. static uint32_t sd_datablocksize_get(uint16_t bytesnumber)
  2103. {
  2104. uint8_t exp_val = 0;
  2105. /* calculate the exponent of 2 */
  2106. while(1 != bytesnumber){
  2107. bytesnumber >>= 1;
  2108. ++exp_val;
  2109. }
  2110. return DATACTL_BLKSZ(exp_val);
  2111. }
  2112. /*!
  2113. \brief configure the GPIO of SDIO interface
  2114. \param[in] none
  2115. \param[out] none
  2116. \retval none
  2117. */
  2118. static void gpio_config(void)
  2119. {
  2120. /* configure the SDIO_DAT0(PC8), SDIO_DAT1(PC9), SDIO_DAT2(PC10), SDIO_DAT3(PC11), SDIO_CLK(PC12) and SDIO_CMD(PD2) */
  2121. gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12);
  2122. gpio_init(GPIOD, GPIO_MODE_AF_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_2);
  2123. }
  2124. /*!
  2125. \brief configure the RCU of SDIO and DMA
  2126. \param[in] none
  2127. \param[out] none
  2128. \retval none
  2129. */
  2130. static void rcu_config(void)
  2131. {
  2132. rcu_periph_clock_enable(RCU_GPIOC);
  2133. rcu_periph_clock_enable(RCU_GPIOD);
  2134. rcu_periph_clock_enable(RCU_AF);
  2135. rcu_periph_clock_enable(RCU_SDIO);
  2136. rcu_periph_clock_enable(RCU_DMA1);
  2137. }
  2138. /*!
  2139. \brief configure the DMA1 channel 3 for transferring data
  2140. \param[in] srcbuf: a pointer point to a buffer which will be transferred
  2141. \param[in] bufsize: the size of buffer(not used in flow controller is peripheral)
  2142. \param[out] none
  2143. \retval none
  2144. */
  2145. static void dma_transfer_config(uint32_t *srcbuf, uint32_t bufsize)
  2146. {
  2147. dma_parameter_struct dma_struct;
  2148. /* clear all the interrupt flags */
  2149. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_G);
  2150. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_FTF);
  2151. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_HTF);
  2152. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_ERR);
  2153. dma_channel_disable(DMA1, DMA_CH3);
  2154. dma_deinit(DMA1, DMA_CH3);
  2155. /* configure the DMA1 channel 3 */
  2156. dma_struct.periph_addr = (uint32_t)SDIO_FIFO_ADDR;
  2157. dma_struct.memory_addr = (uint32_t)srcbuf;
  2158. dma_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
  2159. dma_struct.number = bufsize / 4;
  2160. dma_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
  2161. dma_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  2162. dma_struct.periph_width = DMA_PERIPHERAL_WIDTH_32BIT;
  2163. dma_struct.memory_width = DMA_MEMORY_WIDTH_32BIT;
  2164. dma_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
  2165. dma_init(DMA1, DMA_CH3, &dma_struct);
  2166. dma_circulation_disable(DMA1, DMA_CH3);
  2167. dma_channel_enable(DMA1, DMA_CH3);
  2168. }
  2169. /*!
  2170. \brief configure the DMA1 channel 3 for receiving data
  2171. \param[in] dstbuf: a pointer point to a buffer which will receive data
  2172. \param[in] bufsize: the size of buffer(not used in flow controller is peripheral)
  2173. \param[out] none
  2174. \retval none
  2175. */
  2176. static void dma_receive_config(uint32_t *dstbuf, uint32_t bufsize)
  2177. {
  2178. dma_parameter_struct dma_struct;
  2179. /* clear all the interrupt flags */
  2180. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_G);
  2181. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_FTF);
  2182. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_HTF);
  2183. dma_flag_clear(DMA1, DMA_CH3, DMA_FLAG_ERR);
  2184. dma_channel_disable(DMA1, DMA_CH3);
  2185. dma_deinit(DMA1, DMA_CH3);
  2186. /* configure the DMA1 channel 3 */
  2187. dma_struct.periph_addr = (uint32_t)SDIO_FIFO_ADDR;
  2188. dma_struct.memory_addr = (uint32_t)dstbuf;
  2189. dma_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
  2190. dma_struct.number = bufsize / 4;
  2191. dma_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
  2192. dma_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  2193. dma_struct.periph_width = DMA_PERIPHERAL_WIDTH_32BIT;
  2194. dma_struct.memory_width = DMA_MEMORY_WIDTH_32BIT;
  2195. dma_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
  2196. dma_init(DMA1, DMA_CH3, &dma_struct);
  2197. dma_circulation_disable(DMA1, DMA_CH3);
  2198. dma_channel_enable(DMA1, DMA_CH3);
  2199. }