sdcard.c 95 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163
  1. /**
  2. ******************************************************************************
  3. * @file SDIO/sdcard.c
  4. * @author MCD Application Team
  5. * @version V3.1.2
  6. * @date 09/28/2009
  7. * @brief This file provides all the SD Card driver firmware functions.
  8. ******************************************************************************
  9. * @copy
  10. *
  11. * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  12. * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  13. * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  14. * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  15. * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  16. * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  17. *
  18. * <h2><center>&copy; COPYRIGHT 2009 STMicroelectronics</center></h2>
  19. */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "sdcard.h"
  22. #include <rtthread.h>
  23. /** @addtogroup STM32F10x_StdPeriph_Examples
  24. * @{
  25. */
  26. /** @addtogroup SDIO_Example
  27. * @{
  28. */
  29. /* Private typedef -----------------------------------------------------------*/
  30. /* Private define ------------------------------------------------------------*/
  31. #define NULL 0
  32. #define SDIO_STATIC_FLAGS ((uint32_t)0x000005FF)
  33. #define SDIO_CMD0TIMEOUT ((uint32_t)0x00002710)
  34. #define SDIO_FIFO_Address ((uint32_t)0x40018080)
  35. /* Mask for errors Card Status R1 (OCR Register) */
  36. #define SD_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000)
  37. #define SD_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000)
  38. #define SD_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000)
  39. #define SD_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000)
  40. #define SD_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000)
  41. #define SD_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000)
  42. #define SD_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000)
  43. #define SD_OCR_COM_CRC_FAILED ((uint32_t)0x00800000)
  44. #define SD_OCR_ILLEGAL_CMD ((uint32_t)0x00400000)
  45. #define SD_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000)
  46. #define SD_OCR_CC_ERROR ((uint32_t)0x00100000)
  47. #define SD_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000)
  48. #define SD_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000)
  49. #define SD_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000)
  50. #define SD_OCR_CID_CSD_OVERWRIETE ((uint32_t)0x00010000)
  51. #define SD_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000)
  52. #define SD_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000)
  53. #define SD_OCR_ERASE_RESET ((uint32_t)0x00002000)
  54. #define SD_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008)
  55. #define SD_OCR_ERRORBITS ((uint32_t)0xFDFFE008)
  56. /* Masks for R6 Response */
  57. #define SD_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000)
  58. #define SD_R6_ILLEGAL_CMD ((uint32_t)0x00004000)
  59. #define SD_R6_COM_CRC_FAILED ((uint32_t)0x00008000)
  60. #define SD_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000)
  61. #define SD_HIGH_CAPACITY ((uint32_t)0x40000000)
  62. #define SD_STD_CAPACITY ((uint32_t)0x00000000)
  63. #define SD_CHECK_PATTERN ((uint32_t)0x000001AA)
  64. #define SD_VOLTAGE_WINDOW_MMC ((uint32_t)0x80FF8000)
  65. #define SD_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFF)
  66. #define SD_ALLZERO ((uint32_t)0x00000000)
  67. #define SD_WIDE_BUS_SUPPORT ((uint32_t)0x00040000)
  68. #define SD_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000)
  69. #define SD_CARD_LOCKED ((uint32_t)0x02000000)
  70. #define SD_CARD_PROGRAMMING ((uint32_t)0x00000007)
  71. #define SD_CARD_RECEIVING ((uint32_t)0x00000006)
  72. #define SD_DATATIMEOUT ((uint32_t)0x000FFFFF)
  73. #define SD_0TO7BITS ((uint32_t)0x000000FF)
  74. #define SD_8TO15BITS ((uint32_t)0x0000FF00)
  75. #define SD_16TO23BITS ((uint32_t)0x00FF0000)
  76. #define SD_24TO31BITS ((uint32_t)0xFF000000)
  77. #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFF)
  78. #define SD_HALFFIFO ((uint32_t)0x00000008)
  79. #define SD_HALFFIFOBYTES ((uint32_t)0x00000020)
  80. /* Command Class Supported */
  81. #define SD_CCCC_LOCK_UNLOCK ((uint32_t)0x00000080)
  82. #define SD_CCCC_WRITE_PROT ((uint32_t)0x00000040)
  83. #define SD_CCCC_ERASE ((uint32_t)0x00000020)
  84. /* Following commands are SD Card Specific commands.
  85. SDIO_APP_CMD should be sent before sending these commands. */
  86. #define SDIO_SEND_IF_COND ((uint32_t)0x00000008)
  87. #define SDIO_INIT_CLK_DIV ((uint8_t)0xB2)
  88. #define SDIO_TRANSFER_CLK_DIV ((uint8_t)0x1)
  89. /* Private macro -------------------------------------------------------------*/
  90. /* Private variables ---------------------------------------------------------*/
  91. static uint32_t CardType = SDIO_STD_CAPACITY_SD_CARD_V1_1;
  92. static uint32_t CSD_Tab[4], CID_Tab[4], RCA = 0;
  93. static uint32_t DeviceMode = SD_POLLING_MODE;
  94. static uint32_t TotalNumberOfBytes = 0, StopCondition = 0;
  95. uint32_t *SrcBuffer, *DestBuffer;
  96. volatile SD_Error TransferError = SD_OK;
  97. __IO uint32_t TransferEnd = 0;
  98. __IO uint32_t NumberOfBytes = 0;
  99. SDIO_InitTypeDef SDIO_InitStructure;
  100. SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
  101. SDIO_DataInitTypeDef SDIO_DataInitStructure;
  102. /* Private function prototypes -----------------------------------------------*/
  103. static SD_Error CmdError(void);
  104. static SD_Error CmdResp1Error(uint8_t cmd);
  105. static SD_Error CmdResp7Error(void);
  106. static SD_Error CmdResp3Error(void);
  107. static SD_Error CmdResp2Error(void);
  108. static SD_Error CmdResp6Error(uint8_t cmd, uint16_t *prca);
  109. static SD_Error SDEnWideBus(FunctionalState NewState);
  110. static SD_Error IsCardProgramming(uint8_t *pstatus);
  111. static SD_Error FindSCR(uint16_t rca, uint32_t *pscr);
  112. static uint8_t convert_from_bytes_to_power_of_two(uint16_t NumberOfBytes);
  113. static void GPIO_Configuration(void);
  114. static void DMA_TxConfiguration(uint32_t *BufferSRC, uint32_t BufferSize);
  115. static void DMA_RxConfiguration(uint32_t *BufferDST, uint32_t BufferSize);
  116. /* Private functions ---------------------------------------------------------*/
  117. /**
  118. * @brief Initializes the SD Card and put it into StandBy State (Ready
  119. * for data transfer).
  120. * @param None
  121. * @retval SD_Error: SD Card Error code.
  122. */
  123. SD_Error SD_Init(void)
  124. {
  125. SD_Error errorstatus = SD_OK;
  126. /* Configure SDIO interface GPIO */
  127. GPIO_Configuration();
  128. /* Enable the SDIO AHB Clock */
  129. RCC_AHBPeriphClockCmd(RCC_AHBPeriph_SDIO, ENABLE);
  130. /* Enable the DMA2 Clock */
  131. RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE);
  132. SDIO_DeInit();
  133. errorstatus = SD_PowerON();
  134. if (errorstatus != SD_OK)
  135. {
  136. /* CMD Response TimeOut (wait for CMDSENT flag) */
  137. return(errorstatus);
  138. }
  139. errorstatus = SD_InitializeCards();
  140. if (errorstatus != SD_OK)
  141. {
  142. /* CMD Response TimeOut (wait for CMDSENT flag) */
  143. return(errorstatus);
  144. }
  145. /* Configure the SDIO peripheral */
  146. /* HCLK = 72 MHz, SDIOCLK = 72 MHz, SDIO_CK = HCLK/(2 + 1) = 24 MHz */
  147. SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV;
  148. SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
  149. SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
  150. SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
  151. SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
  152. SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
  153. SDIO_Init(&SDIO_InitStructure);
  154. return(errorstatus);
  155. }
  156. /**
  157. * @brief Enquires cards about their operating voltage and configures
  158. * clock controls.
  159. * @param None
  160. * @retval SD_Error: SD Card Error code.
  161. */
  162. SD_Error SD_PowerON(void)
  163. {
  164. SD_Error errorstatus = SD_OK;
  165. uint32_t response = 0, count = 0;
  166. bool validvoltage = FALSE;
  167. uint32_t SDType = SD_STD_CAPACITY;
  168. /* Power ON Sequence -------------------------------------------------------*/
  169. /* Configure the SDIO peripheral */
  170. SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV; /* HCLK = 72MHz, SDIOCLK = 72MHz, SDIO_CK = HCLK/(178 + 2) = 400 KHz */
  171. SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
  172. SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
  173. SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
  174. SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
  175. SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
  176. SDIO_Init(&SDIO_InitStructure);
  177. /* Set Power State to ON */
  178. SDIO_SetPowerState(SDIO_PowerState_ON);
  179. /* Enable SDIO Clock */
  180. SDIO_ClockCmd(ENABLE);
  181. /* CMD0: GO_IDLE_STATE -------------------------------------------------------*/
  182. /* No CMD response required */
  183. SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  184. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_GO_IDLE_STATE;
  185. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No;
  186. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  187. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  188. SDIO_SendCommand(&SDIO_CmdInitStructure);
  189. errorstatus = CmdError();
  190. if (errorstatus != SD_OK)
  191. {
  192. /* CMD Response TimeOut (wait for CMDSENT flag) */
  193. return(errorstatus);
  194. }
  195. /* CMD8: SEND_IF_COND --------------------------------------------------------*/
  196. /* Send CMD8 to verify SD card interface operating condition */
  197. /* Argument: - [31:12]: Reserved (shall be set to '0')
  198. - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
  199. - [7:0]: Check Pattern (recommended 0xAA) */
  200. /* CMD Response: R7 */
  201. SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN;
  202. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND;
  203. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  204. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  205. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  206. SDIO_SendCommand(&SDIO_CmdInitStructure);
  207. errorstatus = CmdResp7Error();
  208. if (errorstatus == SD_OK)
  209. {
  210. CardType = SDIO_STD_CAPACITY_SD_CARD_V2_0; /* SD Card 2.0 */
  211. SDType = SD_HIGH_CAPACITY;
  212. }
  213. else
  214. {
  215. /* CMD55 */
  216. SDIO_CmdInitStructure.SDIO_Argument = 0x00;
  217. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  218. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  219. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  220. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  221. SDIO_SendCommand(&SDIO_CmdInitStructure);
  222. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  223. }
  224. /* CMD55 */
  225. SDIO_CmdInitStructure.SDIO_Argument = 0x00;
  226. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  227. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  228. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  229. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  230. SDIO_SendCommand(&SDIO_CmdInitStructure);
  231. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  232. /* If errorstatus is Command TimeOut, it is a MMC card */
  233. /* If errorstatus is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
  234. or SD card 1.x */
  235. if (errorstatus == SD_OK)
  236. {
  237. /* SD CARD */
  238. /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
  239. while ((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
  240. {
  241. /* SEND CMD55 APP_CMD with RCA as 0 */
  242. SDIO_CmdInitStructure.SDIO_Argument = 0x00;
  243. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  244. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  245. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  246. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  247. SDIO_SendCommand(&SDIO_CmdInitStructure);
  248. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  249. if (errorstatus != SD_OK)
  250. {
  251. return(errorstatus);
  252. }
  253. SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType;
  254. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SD_APP_OP_COND;
  255. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  256. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  257. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  258. SDIO_SendCommand(&SDIO_CmdInitStructure);
  259. errorstatus = CmdResp3Error();
  260. if (errorstatus != SD_OK)
  261. {
  262. return(errorstatus);
  263. }
  264. response = SDIO_GetResponse(SDIO_RESP1);
  265. validvoltage = (bool) (((response >> 31) == 1) ? 1 : 0);
  266. count++;
  267. }
  268. if (count >= SD_MAX_VOLT_TRIAL)
  269. {
  270. errorstatus = SD_INVALID_VOLTRANGE;
  271. return(errorstatus);
  272. }
  273. if (response &= SD_HIGH_CAPACITY)
  274. {
  275. CardType = SDIO_HIGH_CAPACITY_SD_CARD;
  276. }
  277. }/* else MMC Card */
  278. else
  279. {
  280. CardType = SDIO_MULTIMEDIA_CARD;
  281. /* Send CMD1 SEND_OP_COND with Argument 0x80FF8000 */
  282. while ((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
  283. {
  284. /* SEND CMD55 APP_CMD with RCA as 0 */
  285. SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_MMC;
  286. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_OP_COND;
  287. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  288. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  289. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  290. SDIO_SendCommand(&SDIO_CmdInitStructure);
  291. errorstatus = CmdResp3Error();
  292. if (errorstatus != SD_OK)
  293. {
  294. return(errorstatus);
  295. }
  296. response = SDIO_GetResponse(SDIO_RESP1);
  297. validvoltage = (bool) (((response >> 31) == 1) ? 1 : 0);
  298. count++;
  299. }
  300. if (count >= SD_MAX_VOLT_TRIAL)
  301. {
  302. errorstatus = SD_INVALID_VOLTRANGE;
  303. return(errorstatus);
  304. }
  305. }
  306. return(SD_OK);
  307. }
  308. /**
  309. * @brief Turns the SDIO output signals off.
  310. * @param None
  311. * @retval SD_Error: SD Card Error code.
  312. */
  313. SD_Error SD_PowerOFF(void)
  314. {
  315. SD_Error errorstatus = SD_OK;
  316. /* Set Power State to OFF */
  317. SDIO_SetPowerState(SDIO_PowerState_OFF);
  318. return(errorstatus);
  319. }
  320. /**
  321. * @brief Intialises all cards or single card as the case may be.
  322. * Card(s) come into standby state.
  323. * @param None
  324. * @retval SD_Error: SD Card Error code.
  325. */
  326. SD_Error SD_InitializeCards(void)
  327. {
  328. SD_Error errorstatus = SD_OK;
  329. uint16_t rca = 0x01;
  330. if (SDIO_GetPowerState() == SDIO_PowerState_OFF)
  331. {
  332. errorstatus = SD_REQUEST_NOT_APPLICABLE;
  333. return(errorstatus);
  334. }
  335. if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)
  336. {
  337. /* Send CMD2 ALL_SEND_CID */
  338. SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  339. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_ALL_SEND_CID;
  340. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
  341. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  342. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  343. SDIO_SendCommand(&SDIO_CmdInitStructure);
  344. errorstatus = CmdResp2Error();
  345. if (SD_OK != errorstatus)
  346. {
  347. return(errorstatus);
  348. }
  349. CID_Tab[0] = SDIO_GetResponse(SDIO_RESP1);
  350. CID_Tab[1] = SDIO_GetResponse(SDIO_RESP2);
  351. CID_Tab[2] = SDIO_GetResponse(SDIO_RESP3);
  352. CID_Tab[3] = SDIO_GetResponse(SDIO_RESP4);
  353. }
  354. if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_SECURE_DIGITAL_IO_COMBO_CARD == CardType)
  355. || (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
  356. {
  357. /* Send CMD3 SET_REL_ADDR with argument 0 */
  358. /* SD Card publishes its RCA. */
  359. SDIO_CmdInitStructure.SDIO_Argument = 0x00;
  360. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_REL_ADDR;
  361. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  362. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  363. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  364. SDIO_SendCommand(&SDIO_CmdInitStructure);
  365. errorstatus = CmdResp6Error(SDIO_SET_REL_ADDR, &rca);
  366. if (SD_OK != errorstatus)
  367. {
  368. return(errorstatus);
  369. }
  370. }
  371. if (SDIO_MULTIMEDIA_CARD == CardType)
  372. {
  373. /* Send CMD3 SET_REL_ADDR with argument 0 */
  374. /* SD Card publishes its RCA. */
  375. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);
  376. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_REL_ADDR;
  377. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  378. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  379. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  380. SDIO_SendCommand(&SDIO_CmdInitStructure);
  381. errorstatus = CmdResp2Error();
  382. if (SD_OK != errorstatus)
  383. {
  384. return(errorstatus);
  385. }
  386. }
  387. if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)
  388. {
  389. RCA = rca;
  390. /* Send CMD9 SEND_CSD with argument as card's RCA */
  391. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);
  392. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_CSD;
  393. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
  394. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  395. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  396. SDIO_SendCommand(&SDIO_CmdInitStructure);
  397. errorstatus = CmdResp2Error();
  398. if (SD_OK != errorstatus)
  399. {
  400. return(errorstatus);
  401. }
  402. CSD_Tab[0] = SDIO_GetResponse(SDIO_RESP1);
  403. CSD_Tab[1] = SDIO_GetResponse(SDIO_RESP2);
  404. CSD_Tab[2] = SDIO_GetResponse(SDIO_RESP3);
  405. CSD_Tab[3] = SDIO_GetResponse(SDIO_RESP4);
  406. }
  407. errorstatus = SD_OK; /* All cards get intialized */
  408. return(errorstatus);
  409. }
  410. /**
  411. * @brief Returns information about specific card.
  412. * @param cardinfo : pointer to a SD_CardInfo structure
  413. * that contains all SD card information.
  414. * @retval SD_Error: SD Card Error code.
  415. */
  416. SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
  417. {
  418. SD_Error errorstatus = SD_OK;
  419. uint8_t tmp = 0;
  420. cardinfo->CardType = (uint8_t)CardType;
  421. cardinfo->RCA = (uint16_t)RCA;
  422. /* Byte 0 */
  423. tmp = (uint8_t)((CSD_Tab[0] & 0xFF000000) >> 24);
  424. cardinfo->SD_csd.CSDStruct = (tmp & 0xC0) >> 6;
  425. cardinfo->SD_csd.SysSpecVersion = (tmp & 0x3C) >> 2;
  426. cardinfo->SD_csd.Reserved1 = tmp & 0x03;
  427. /* Byte 1 */
  428. tmp = (uint8_t)((CSD_Tab[0] & 0x00FF0000) >> 16);
  429. cardinfo->SD_csd.TAAC = tmp;
  430. /* Byte 2 */
  431. tmp = (uint8_t)((CSD_Tab[0] & 0x0000FF00) >> 8);
  432. cardinfo->SD_csd.NSAC = tmp;
  433. /* Byte 3 */
  434. tmp = (uint8_t)(CSD_Tab[0] & 0x000000FF);
  435. cardinfo->SD_csd.MaxBusClkFrec = tmp;
  436. /* Byte 4 */
  437. tmp = (uint8_t)((CSD_Tab[1] & 0xFF000000) >> 24);
  438. cardinfo->SD_csd.CardComdClasses = tmp << 4;
  439. /* Byte 5 */
  440. tmp = (uint8_t)((CSD_Tab[1] & 0x00FF0000) >> 16);
  441. cardinfo->SD_csd.CardComdClasses |= (tmp & 0xF0) >> 4;
  442. cardinfo->SD_csd.RdBlockLen = tmp & 0x0F;
  443. /* Byte 6 */
  444. tmp = (uint8_t)((CSD_Tab[1] & 0x0000FF00) >> 8);
  445. cardinfo->SD_csd.PartBlockRead = (tmp & 0x80) >> 7;
  446. cardinfo->SD_csd.WrBlockMisalign = (tmp & 0x40) >> 6;
  447. cardinfo->SD_csd.RdBlockMisalign = (tmp & 0x20) >> 5;
  448. cardinfo->SD_csd.DSRImpl = (tmp & 0x10) >> 4;
  449. cardinfo->SD_csd.Reserved2 = 0; /* Reserved */
  450. if ((CardType == SDIO_STD_CAPACITY_SD_CARD_V1_1) || (CardType == SDIO_STD_CAPACITY_SD_CARD_V2_0))
  451. {
  452. cardinfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
  453. /* Byte 7 */
  454. tmp = (uint8_t)(CSD_Tab[1] & 0x000000FF);
  455. cardinfo->SD_csd.DeviceSize |= (tmp) << 2;
  456. /* Byte 8 */
  457. tmp = (uint8_t)((CSD_Tab[2] & 0xFF000000) >> 24);
  458. cardinfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
  459. cardinfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
  460. cardinfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
  461. /* Byte 9 */
  462. tmp = (uint8_t)((CSD_Tab[2] & 0x00FF0000) >> 16);
  463. cardinfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
  464. cardinfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
  465. cardinfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
  466. /* Byte 10 */
  467. tmp = (uint8_t)((CSD_Tab[2] & 0x0000FF00) >> 8);
  468. cardinfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
  469. cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) ;
  470. cardinfo->CardCapacity *= (1 << (cardinfo->SD_csd.DeviceSizeMul + 2));
  471. cardinfo->CardBlockSize = 1 << (cardinfo->SD_csd.RdBlockLen);
  472. cardinfo->CardCapacity *= cardinfo->CardBlockSize;
  473. }
  474. else if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
  475. {
  476. /* Byte 7 */
  477. tmp = (uint8_t)(CSD_Tab[1] & 0x000000FF);
  478. cardinfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
  479. /* Byte 8 */
  480. tmp = (uint8_t)((CSD_Tab[2] & 0xFF000000) >> 24);
  481. cardinfo->SD_csd.DeviceSize |= (tmp << 8);
  482. /* Byte 9 */
  483. tmp = (uint8_t)((CSD_Tab[2] & 0x00FF0000) >> 16);
  484. cardinfo->SD_csd.DeviceSize |= (tmp);
  485. /* Byte 10 */
  486. tmp = (uint8_t)((CSD_Tab[2] & 0x0000FF00) >> 8);
  487. cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) * 512 * 1024;
  488. cardinfo->CardBlockSize = 512;
  489. }
  490. cardinfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
  491. cardinfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
  492. /* Byte 11 */
  493. tmp = (uint8_t)(CSD_Tab[2] & 0x000000FF);
  494. cardinfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
  495. cardinfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
  496. /* Byte 12 */
  497. tmp = (uint8_t)((CSD_Tab[3] & 0xFF000000) >> 24);
  498. cardinfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
  499. cardinfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
  500. cardinfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
  501. cardinfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
  502. /* Byte 13 */
  503. tmp = (uint8_t)((CSD_Tab[3] & 0x00FF0000) >> 16);
  504. cardinfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
  505. cardinfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
  506. cardinfo->SD_csd.Reserved3 = 0;
  507. cardinfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
  508. /* Byte 14 */
  509. tmp = (uint8_t)((CSD_Tab[3] & 0x0000FF00) >> 8);
  510. cardinfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
  511. cardinfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
  512. cardinfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
  513. cardinfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
  514. cardinfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
  515. cardinfo->SD_csd.ECC = (tmp & 0x03);
  516. /* Byte 15 */
  517. tmp = (uint8_t)(CSD_Tab[3] & 0x000000FF);
  518. cardinfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
  519. cardinfo->SD_csd.Reserved4 = 1;
  520. /* Byte 0 */
  521. tmp = (uint8_t)((CID_Tab[0] & 0xFF000000) >> 24);
  522. cardinfo->SD_cid.ManufacturerID = tmp;
  523. /* Byte 1 */
  524. tmp = (uint8_t)((CID_Tab[0] & 0x00FF0000) >> 16);
  525. cardinfo->SD_cid.OEM_AppliID = tmp << 8;
  526. /* Byte 2 */
  527. tmp = (uint8_t)((CID_Tab[0] & 0x000000FF00) >> 8);
  528. cardinfo->SD_cid.OEM_AppliID |= tmp;
  529. /* Byte 3 */
  530. tmp = (uint8_t)(CID_Tab[0] & 0x000000FF);
  531. cardinfo->SD_cid.ProdName1 = tmp << 24;
  532. /* Byte 4 */
  533. tmp = (uint8_t)((CID_Tab[1] & 0xFF000000) >> 24);
  534. cardinfo->SD_cid.ProdName1 |= tmp << 16;
  535. /* Byte 5 */
  536. tmp = (uint8_t)((CID_Tab[1] & 0x00FF0000) >> 16);
  537. cardinfo->SD_cid.ProdName1 |= tmp << 8;
  538. /* Byte 6 */
  539. tmp = (uint8_t)((CID_Tab[1] & 0x0000FF00) >> 8);
  540. cardinfo->SD_cid.ProdName1 |= tmp;
  541. /* Byte 7 */
  542. tmp = (uint8_t)(CID_Tab[1] & 0x000000FF);
  543. cardinfo->SD_cid.ProdName2 = tmp;
  544. /* Byte 8 */
  545. tmp = (uint8_t)((CID_Tab[2] & 0xFF000000) >> 24);
  546. cardinfo->SD_cid.ProdRev = tmp;
  547. /* Byte 9 */
  548. tmp = (uint8_t)((CID_Tab[2] & 0x00FF0000) >> 16);
  549. cardinfo->SD_cid.ProdSN = tmp << 24;
  550. /* Byte 10 */
  551. tmp = (uint8_t)((CID_Tab[2] & 0x0000FF00) >> 8);
  552. cardinfo->SD_cid.ProdSN |= tmp << 16;
  553. /* Byte 11 */
  554. tmp = (uint8_t)(CID_Tab[2] & 0x000000FF);
  555. cardinfo->SD_cid.ProdSN |= tmp << 8;
  556. /* Byte 12 */
  557. tmp = (uint8_t)((CID_Tab[3] & 0xFF000000) >> 24);
  558. cardinfo->SD_cid.ProdSN |= tmp;
  559. /* Byte 13 */
  560. tmp = (uint8_t)((CID_Tab[3] & 0x00FF0000) >> 16);
  561. cardinfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
  562. cardinfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
  563. /* Byte 14 */
  564. tmp = (uint8_t)((CID_Tab[3] & 0x0000FF00) >> 8);
  565. cardinfo->SD_cid.ManufactDate |= tmp;
  566. /* Byte 15 */
  567. tmp = (uint8_t)(CID_Tab[3] & 0x000000FF);
  568. cardinfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
  569. cardinfo->SD_cid.Reserved2 = 1;
  570. return(errorstatus);
  571. }
  572. /**
  573. * @brief Enables wide bus opeartion for the requeseted card if
  574. * supported by card.
  575. * @param WideMode: Specifies the SD card wide bus mode.
  576. * This parameter can be one of the following values:
  577. * @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
  578. * @arg SDIO_BusWide_4b: 4-bit data transfer
  579. * @arg SDIO_BusWide_1b: 1-bit data transfer
  580. * @retval SD_Error: SD Card Error code.
  581. */
  582. SD_Error SD_EnableWideBusOperation(uint32_t WideMode)
  583. {
  584. SD_Error errorstatus = SD_OK;
  585. /* MMC Card doesn't support this feature */
  586. if (SDIO_MULTIMEDIA_CARD == CardType)
  587. {
  588. errorstatus = SD_UNSUPPORTED_FEATURE;
  589. return(errorstatus);
  590. }
  591. else if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
  592. {
  593. if (SDIO_BusWide_8b == WideMode)
  594. {
  595. errorstatus = SD_UNSUPPORTED_FEATURE;
  596. return(errorstatus);
  597. }
  598. else if (SDIO_BusWide_4b == WideMode)
  599. {
  600. errorstatus = SDEnWideBus(ENABLE);
  601. if (SD_OK == errorstatus)
  602. {
  603. /* Configure the SDIO peripheral */
  604. SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV;
  605. SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
  606. SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
  607. SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
  608. SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_4b;
  609. SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
  610. SDIO_Init(&SDIO_InitStructure);
  611. }
  612. }
  613. else
  614. {
  615. errorstatus = SDEnWideBus(DISABLE);
  616. if (SD_OK == errorstatus)
  617. {
  618. /* Configure the SDIO peripheral */
  619. SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV;
  620. SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
  621. SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
  622. SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
  623. SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
  624. SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
  625. SDIO_Init(&SDIO_InitStructure);
  626. }
  627. }
  628. }
  629. return(errorstatus);
  630. }
  631. /**
  632. * @brief Sets device mode whether to operate in Polling, Interrupt or
  633. * DMA mode.
  634. * @param Mode: Specifies the Data Transfer mode.
  635. * This parameter can be one of the following values:
  636. * @arg SD_DMA_MODE: Data transfer using DMA.
  637. * @arg SD_INTERRUPT_MODE: Data transfer using interrupts.
  638. * @arg SD_POLLING_MODE: Data transfer using flags.
  639. * @retval SD_Error: SD Card Error code.
  640. */
  641. SD_Error SD_SetDeviceMode(uint32_t Mode)
  642. {
  643. SD_Error errorstatus = SD_OK;
  644. if ((Mode == SD_DMA_MODE) || (Mode == SD_INTERRUPT_MODE) || (Mode == SD_POLLING_MODE))
  645. {
  646. DeviceMode = Mode;
  647. }
  648. else
  649. {
  650. errorstatus = SD_INVALID_PARAMETER;
  651. }
  652. return(errorstatus);
  653. }
  654. /**
  655. * @brief Selects od Deselects the corresponding card.
  656. * @param addr: Address of the Card to be selected.
  657. * @retval SD_Error: SD Card Error code.
  658. */
  659. SD_Error SD_SelectDeselect(uint32_t addr)
  660. {
  661. SD_Error errorstatus = SD_OK;
  662. /* Send CMD7 SDIO_SEL_DESEL_CARD */
  663. SDIO_CmdInitStructure.SDIO_Argument = addr;
  664. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEL_DESEL_CARD;
  665. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  666. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  667. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  668. SDIO_SendCommand(&SDIO_CmdInitStructure);
  669. errorstatus = CmdResp1Error(SDIO_SEL_DESEL_CARD);
  670. return(errorstatus);
  671. }
  672. /**
  673. * @brief Allows to read one block from a specified address in a card.
  674. * @param addr: Address from where data are to be read.
  675. * @param readbuff: pointer to the buffer that will contain the
  676. * received data
  677. * @param BlockSize: the SD card Data block size.
  678. * @retval SD_Error: SD Card Error code.
  679. */
  680. SD_Error SD_ReadBlock(uint32_t addr, uint32_t *readbuff, uint16_t BlockSize)
  681. {
  682. SD_Error errorstatus = SD_OK;
  683. uint32_t count = 0, *tempbuff = readbuff;
  684. uint8_t power = 0;
  685. if (NULL == readbuff)
  686. {
  687. errorstatus = SD_INVALID_PARAMETER;
  688. return(errorstatus);
  689. }
  690. TransferError = SD_OK;
  691. TransferEnd = 0;
  692. TotalNumberOfBytes = 0;
  693. /* Clear all DPSM configuration */
  694. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  695. SDIO_DataInitStructure.SDIO_DataLength = 0;
  696. SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  697. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
  698. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  699. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Disable;
  700. SDIO_DataConfig(&SDIO_DataInitStructure);
  701. SDIO_DMACmd(DISABLE);
  702. if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
  703. {
  704. errorstatus = SD_LOCK_UNLOCK_FAILED;
  705. return(errorstatus);
  706. }
  707. if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
  708. {
  709. BlockSize = 512;
  710. addr /= 512;
  711. }
  712. if ((BlockSize > 0) && (BlockSize <= 2048) && ((BlockSize & (BlockSize - 1)) == 0))
  713. {
  714. power = convert_from_bytes_to_power_of_two(BlockSize);
  715. /* Set Block Size for Card */
  716. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
  717. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_BLOCKLEN;
  718. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  719. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  720. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  721. SDIO_SendCommand(&SDIO_CmdInitStructure);
  722. errorstatus = CmdResp1Error(SDIO_SET_BLOCKLEN);
  723. if (SD_OK != errorstatus)
  724. {
  725. return(errorstatus);
  726. }
  727. }
  728. else
  729. {
  730. errorstatus = SD_INVALID_PARAMETER;
  731. return(errorstatus);
  732. }
  733. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  734. SDIO_DataInitStructure.SDIO_DataLength = BlockSize;
  735. SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) power << 4;
  736. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
  737. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  738. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  739. SDIO_DataConfig(&SDIO_DataInitStructure);
  740. TotalNumberOfBytes = BlockSize;
  741. StopCondition = 0;
  742. DestBuffer = readbuff;
  743. /* Send CMD17 READ_SINGLE_BLOCK */
  744. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)addr;
  745. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_READ_SINGLE_BLOCK;
  746. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  747. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  748. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  749. SDIO_SendCommand(&SDIO_CmdInitStructure);
  750. errorstatus = CmdResp1Error(SDIO_READ_SINGLE_BLOCK);
  751. if (errorstatus != SD_OK)
  752. {
  753. return(errorstatus);
  754. }
  755. /* In case of single block transfer, no need of stop transfer at all.*/
  756. if (DeviceMode == SD_POLLING_MODE)
  757. {
  758. /* Polling mode */
  759. while (!(SDIO->STA &(SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR)))
  760. {
  761. if (SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)
  762. {
  763. for (count = 0; count < 8; count++)
  764. {
  765. *(tempbuff + count) = SDIO_ReadData();
  766. }
  767. tempbuff += 8;
  768. }
  769. }
  770. if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
  771. {
  772. SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
  773. errorstatus = SD_DATA_TIMEOUT;
  774. return(errorstatus);
  775. }
  776. else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
  777. {
  778. SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
  779. errorstatus = SD_DATA_CRC_FAIL;
  780. return(errorstatus);
  781. }
  782. else if (SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)
  783. {
  784. SDIO_ClearFlag(SDIO_FLAG_RXOVERR);
  785. errorstatus = SD_RX_OVERRUN;
  786. return(errorstatus);
  787. }
  788. else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
  789. {
  790. SDIO_ClearFlag(SDIO_FLAG_STBITERR);
  791. errorstatus = SD_START_BIT_ERR;
  792. return(errorstatus);
  793. }
  794. while (SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)
  795. {
  796. *tempbuff = SDIO_ReadData();
  797. tempbuff++;
  798. }
  799. /* Clear all the static flags */
  800. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  801. }
  802. else if (DeviceMode == SD_INTERRUPT_MODE)
  803. {
  804. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_RXFIFOHF | SDIO_IT_STBITERR, ENABLE);
  805. while ((TransferEnd == 0) && (TransferError == SD_OK))
  806. {}
  807. if (TransferError != SD_OK)
  808. {
  809. return(TransferError);
  810. }
  811. }
  812. else if (DeviceMode == SD_DMA_MODE)
  813. {
  814. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_STBITERR, ENABLE);
  815. SDIO_DMACmd(ENABLE);
  816. DMA_RxConfiguration(readbuff, BlockSize);
  817. while (DMA_GetFlagStatus(DMA2_FLAG_TC4) == RESET)
  818. {}
  819. }
  820. return(errorstatus);
  821. }
  822. /**
  823. * @brief Allows to read blocks from a specified address in a card.
  824. * @param addr: Address from where data are to be read.
  825. * @param readbuff: pointer to the buffer that will contain the
  826. * received data.
  827. * @param BlockSize: the SD card Data block size.
  828. * @param NumberOfBlocks: number of blocks to be read.
  829. * @retval SD_Error: SD Card Error code.
  830. */
  831. SD_Error SD_ReadMultiBlocks(uint32_t addr, uint32_t *readbuff, uint16_t BlockSize, uint32_t NumberOfBlocks)
  832. {
  833. SD_Error errorstatus = SD_OK;
  834. uint32_t count = 0, *tempbuff = readbuff;
  835. uint8_t power = 0;
  836. if (NULL == readbuff)
  837. {
  838. errorstatus = SD_INVALID_PARAMETER;
  839. return(errorstatus);
  840. }
  841. TransferError = SD_OK;
  842. TransferEnd = 0;
  843. TotalNumberOfBytes = 0;
  844. /* Clear all DPSM configuration */
  845. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  846. SDIO_DataInitStructure.SDIO_DataLength = 0;
  847. SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  848. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
  849. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  850. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Disable;
  851. SDIO_DataConfig(&SDIO_DataInitStructure);
  852. SDIO_DMACmd(DISABLE);
  853. if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
  854. {
  855. errorstatus = SD_LOCK_UNLOCK_FAILED;
  856. return(errorstatus);
  857. }
  858. if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
  859. {
  860. BlockSize = 512;
  861. addr /= 512;
  862. }
  863. if ((BlockSize > 0) && (BlockSize <= 2048) && (0 == (BlockSize & (BlockSize - 1))))
  864. {
  865. power = convert_from_bytes_to_power_of_two(BlockSize);
  866. /* Set Block Size for Card */
  867. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
  868. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_BLOCKLEN;
  869. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  870. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  871. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  872. SDIO_SendCommand(&SDIO_CmdInitStructure);
  873. errorstatus = CmdResp1Error(SDIO_SET_BLOCKLEN);
  874. if (SD_OK != errorstatus)
  875. {
  876. return(errorstatus);
  877. }
  878. }
  879. else
  880. {
  881. errorstatus = SD_INVALID_PARAMETER;
  882. return(errorstatus);
  883. }
  884. if (NumberOfBlocks > 1)
  885. {
  886. /* Common to all modes */
  887. if (NumberOfBlocks * BlockSize > SD_MAX_DATA_LENGTH)
  888. {
  889. errorstatus = SD_INVALID_PARAMETER;
  890. return(errorstatus);
  891. }
  892. TotalNumberOfBytes = NumberOfBlocks * BlockSize;
  893. StopCondition = 1;
  894. DestBuffer = readbuff;
  895. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  896. SDIO_DataInitStructure.SDIO_DataLength = NumberOfBlocks * BlockSize;
  897. SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) power << 4;
  898. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
  899. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  900. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  901. SDIO_DataConfig(&SDIO_DataInitStructure);
  902. /* Send CMD18 READ_MULT_BLOCK with argument data address */
  903. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)addr;
  904. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_READ_MULT_BLOCK;
  905. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  906. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  907. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  908. SDIO_SendCommand(&SDIO_CmdInitStructure);
  909. errorstatus = CmdResp1Error(SDIO_READ_MULT_BLOCK);
  910. if (errorstatus != SD_OK)
  911. {
  912. return(errorstatus);
  913. }
  914. if (DeviceMode == SD_POLLING_MODE)
  915. {
  916. /* Polling mode */
  917. while (!(SDIO->STA &(SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DATAEND | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_STBITERR)))
  918. {
  919. if (SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)
  920. {
  921. for (count = 0; count < SD_HALFFIFO; count++)
  922. {
  923. *(tempbuff + count) = SDIO_ReadData();
  924. }
  925. tempbuff += SD_HALFFIFO;
  926. }
  927. }
  928. if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
  929. {
  930. SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
  931. errorstatus = SD_DATA_TIMEOUT;
  932. return(errorstatus);
  933. }
  934. else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
  935. {
  936. SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
  937. errorstatus = SD_DATA_CRC_FAIL;
  938. return(errorstatus);
  939. }
  940. else if (SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)
  941. {
  942. SDIO_ClearFlag(SDIO_FLAG_RXOVERR);
  943. errorstatus = SD_RX_OVERRUN;
  944. return(errorstatus);
  945. }
  946. else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
  947. {
  948. SDIO_ClearFlag(SDIO_FLAG_STBITERR);
  949. errorstatus = SD_START_BIT_ERR;
  950. return(errorstatus);
  951. }
  952. while (SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)
  953. {
  954. *tempbuff = SDIO_ReadData();
  955. tempbuff++;
  956. }
  957. if (SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)
  958. {
  959. /* In Case Of SD-CARD Send Command STOP_TRANSMISSION */
  960. if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_HIGH_CAPACITY_SD_CARD == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType))
  961. {
  962. /* Send CMD12 STOP_TRANSMISSION */
  963. SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  964. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_STOP_TRANSMISSION;
  965. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  966. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  967. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  968. SDIO_SendCommand(&SDIO_CmdInitStructure);
  969. errorstatus = CmdResp1Error(SDIO_STOP_TRANSMISSION);
  970. if (errorstatus != SD_OK)
  971. {
  972. return(errorstatus);
  973. }
  974. }
  975. }
  976. /* Clear all the static flags */
  977. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  978. }
  979. else if (DeviceMode == SD_INTERRUPT_MODE)
  980. {
  981. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_RXFIFOHF | SDIO_IT_STBITERR, ENABLE);
  982. while ((TransferEnd == 0) && (TransferError == SD_OK))
  983. {}
  984. if (TransferError != SD_OK)
  985. {
  986. return(TransferError);
  987. }
  988. }
  989. else if (DeviceMode == SD_DMA_MODE)
  990. {
  991. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_STBITERR, ENABLE);
  992. SDIO_DMACmd(ENABLE);
  993. DMA_RxConfiguration(readbuff, (NumberOfBlocks * BlockSize));
  994. while (DMA_GetFlagStatus(DMA2_FLAG_TC4) == RESET)
  995. {}
  996. while ((TransferEnd == 0) && (TransferError == SD_OK))
  997. {}
  998. if (TransferError != SD_OK)
  999. {
  1000. return(TransferError);
  1001. }
  1002. }
  1003. }
  1004. return(errorstatus);
  1005. }
  1006. /**
  1007. * @brief Allows to write one block starting from a specified address
  1008. * in a card.
  1009. * @param addr: Address from where data are to be read.
  1010. * @param writebuff: pointer to the buffer that contain the data to be
  1011. * transferred.
  1012. * @param BlockSize: the SD card Data block size.
  1013. * @retval SD_Error: SD Card Error code.
  1014. */
  1015. SD_Error SD_WriteBlock(uint32_t addr, uint32_t *writebuff, uint16_t BlockSize)
  1016. {
  1017. SD_Error errorstatus = SD_OK;
  1018. uint8_t power = 0, cardstate = 0;
  1019. uint32_t timeout = 0, bytestransferred = 0;
  1020. uint32_t cardstatus = 0, count = 0, restwords = 0;
  1021. uint32_t *tempbuff = writebuff;
  1022. if (writebuff == NULL)
  1023. {
  1024. errorstatus = SD_INVALID_PARAMETER;
  1025. return(errorstatus);
  1026. }
  1027. TransferError = SD_OK;
  1028. TransferEnd = 0;
  1029. TotalNumberOfBytes = 0;
  1030. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  1031. SDIO_DataInitStructure.SDIO_DataLength = 0;
  1032. SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  1033. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
  1034. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  1035. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Disable;
  1036. SDIO_DataConfig(&SDIO_DataInitStructure);
  1037. SDIO_DMACmd(DISABLE);
  1038. if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
  1039. {
  1040. errorstatus = SD_LOCK_UNLOCK_FAILED;
  1041. return(errorstatus);
  1042. }
  1043. if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
  1044. {
  1045. BlockSize = 512;
  1046. addr /= 512;
  1047. }
  1048. /* Set the block size, both on controller and card */
  1049. if ((BlockSize > 0) && (BlockSize <= 2048) && ((BlockSize & (BlockSize - 1)) == 0))
  1050. {
  1051. power = convert_from_bytes_to_power_of_two(BlockSize);
  1052. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
  1053. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_BLOCKLEN;
  1054. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1055. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1056. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1057. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1058. errorstatus = CmdResp1Error(SDIO_SET_BLOCKLEN);
  1059. if (errorstatus != SD_OK)
  1060. {
  1061. return(errorstatus);
  1062. }
  1063. }
  1064. else
  1065. {
  1066. errorstatus = SD_INVALID_PARAMETER;
  1067. return(errorstatus);
  1068. }
  1069. /* Wait till card is ready for data Added */
  1070. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) (RCA << 16);
  1071. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_STATUS;
  1072. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1073. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1074. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1075. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1076. errorstatus = CmdResp1Error(SDIO_SEND_STATUS);
  1077. if (errorstatus != SD_OK)
  1078. {
  1079. return(errorstatus);
  1080. }
  1081. cardstatus = SDIO_GetResponse(SDIO_RESP1);
  1082. timeout = SD_DATATIMEOUT;
  1083. while (((cardstatus & 0x00000100) == 0) && (timeout > 0))
  1084. {
  1085. timeout--;
  1086. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) (RCA << 16);
  1087. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_STATUS;
  1088. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1089. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1090. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1091. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1092. errorstatus = CmdResp1Error(SDIO_SEND_STATUS);
  1093. if (errorstatus != SD_OK)
  1094. {
  1095. return(errorstatus);
  1096. }
  1097. cardstatus = SDIO_GetResponse(SDIO_RESP1);
  1098. }
  1099. if (timeout == 0)
  1100. {
  1101. return(SD_ERROR);
  1102. }
  1103. /* Send CMD24 WRITE_SINGLE_BLOCK */
  1104. SDIO_CmdInitStructure.SDIO_Argument = addr;
  1105. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_WRITE_SINGLE_BLOCK;
  1106. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1107. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1108. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1109. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1110. errorstatus = CmdResp1Error(SDIO_WRITE_SINGLE_BLOCK);
  1111. if (errorstatus != SD_OK)
  1112. {
  1113. return(errorstatus);
  1114. }
  1115. TotalNumberOfBytes = BlockSize;
  1116. StopCondition = 0;
  1117. SrcBuffer = writebuff;
  1118. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  1119. SDIO_DataInitStructure.SDIO_DataLength = BlockSize;
  1120. SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) power << 4;
  1121. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
  1122. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  1123. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  1124. SDIO_DataConfig(&SDIO_DataInitStructure);
  1125. /* In case of single data block transfer no need of stop command at all */
  1126. if (DeviceMode == SD_POLLING_MODE)
  1127. {
  1128. while (!(SDIO->STA & (SDIO_FLAG_DBCKEND | SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_STBITERR)))
  1129. {
  1130. if (SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)
  1131. {
  1132. if ((TotalNumberOfBytes - bytestransferred) < 32)
  1133. {
  1134. restwords = ((TotalNumberOfBytes - bytestransferred) % 4 == 0) ? ((TotalNumberOfBytes - bytestransferred) / 4) : (( TotalNumberOfBytes - bytestransferred) / 4 + 1);
  1135. for (count = 0; count < restwords; count++, tempbuff++, bytestransferred += 4)
  1136. {
  1137. SDIO_WriteData(*tempbuff);
  1138. }
  1139. }
  1140. else
  1141. {
  1142. for (count = 0; count < 8; count++)
  1143. {
  1144. SDIO_WriteData(*(tempbuff + count));
  1145. }
  1146. tempbuff += 8;
  1147. bytestransferred += 32;
  1148. }
  1149. }
  1150. }
  1151. if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
  1152. {
  1153. SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
  1154. errorstatus = SD_DATA_TIMEOUT;
  1155. return(errorstatus);
  1156. }
  1157. else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
  1158. {
  1159. SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
  1160. errorstatus = SD_DATA_CRC_FAIL;
  1161. return(errorstatus);
  1162. }
  1163. else if (SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)
  1164. {
  1165. SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);
  1166. errorstatus = SD_TX_UNDERRUN;
  1167. return(errorstatus);
  1168. }
  1169. else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
  1170. {
  1171. SDIO_ClearFlag(SDIO_FLAG_STBITERR);
  1172. errorstatus = SD_START_BIT_ERR;
  1173. return(errorstatus);
  1174. }
  1175. }
  1176. else if (DeviceMode == SD_INTERRUPT_MODE)
  1177. {
  1178. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE);
  1179. while ((TransferEnd == 0) && (TransferError == SD_OK))
  1180. {}
  1181. if (TransferError != SD_OK)
  1182. {
  1183. return(TransferError);
  1184. }
  1185. }
  1186. else if (DeviceMode == SD_DMA_MODE)
  1187. {
  1188. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE);
  1189. DMA_TxConfiguration(writebuff, BlockSize);
  1190. SDIO_DMACmd(ENABLE);
  1191. while (DMA_GetFlagStatus(DMA2_FLAG_TC4) == RESET)
  1192. {}
  1193. while ((TransferEnd == 0) && (TransferError == SD_OK))
  1194. {}
  1195. if (TransferError != SD_OK)
  1196. {
  1197. return(TransferError);
  1198. }
  1199. }
  1200. /* Clear all the static flags */
  1201. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  1202. /* Wait till the card is in programming state */
  1203. errorstatus = IsCardProgramming(&cardstate);
  1204. while ((errorstatus == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
  1205. {
  1206. errorstatus = IsCardProgramming(&cardstate);
  1207. }
  1208. return(errorstatus);
  1209. }
  1210. /**
  1211. * @brief Allows to write blocks starting from a specified address in
  1212. * a card.
  1213. * @param addr: Address from where data are to be read.
  1214. * @param writebuff: pointer to the buffer that contain the data to be
  1215. * transferred.
  1216. * @param BlockSize: the SD card Data block size.
  1217. * @param NumberOfBlocks: number of blocks to be written.
  1218. * @retval SD_Error: SD Card Error code.
  1219. */
  1220. SD_Error SD_WriteMultiBlocks(uint32_t addr, uint32_t *writebuff, uint16_t BlockSize, uint32_t NumberOfBlocks)
  1221. {
  1222. SD_Error errorstatus = SD_OK;
  1223. uint8_t power = 0, cardstate = 0;
  1224. uint32_t bytestransferred = 0;
  1225. uint32_t count = 0, restwords = 0;
  1226. uint32_t *tempbuff = writebuff;
  1227. if (writebuff == NULL)
  1228. {
  1229. errorstatus = SD_INVALID_PARAMETER;
  1230. return(errorstatus);
  1231. }
  1232. TransferError = SD_OK;
  1233. TransferEnd = 0;
  1234. TotalNumberOfBytes = 0;
  1235. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  1236. SDIO_DataInitStructure.SDIO_DataLength = 0;
  1237. SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_1b;
  1238. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
  1239. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  1240. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Disable;
  1241. SDIO_DataConfig(&SDIO_DataInitStructure);
  1242. SDIO_DMACmd(DISABLE);
  1243. if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
  1244. {
  1245. errorstatus = SD_LOCK_UNLOCK_FAILED;
  1246. return(errorstatus);
  1247. }
  1248. if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
  1249. {
  1250. BlockSize = 512;
  1251. addr /= 512;
  1252. }
  1253. /* Set the block size, both on controller and card */
  1254. if ((BlockSize > 0) && (BlockSize <= 2048) && ((BlockSize & (BlockSize - 1)) == 0))
  1255. {
  1256. power = convert_from_bytes_to_power_of_two(BlockSize);
  1257. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
  1258. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_BLOCKLEN;
  1259. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1260. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1261. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1262. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1263. errorstatus = CmdResp1Error(SDIO_SET_BLOCKLEN);
  1264. if (errorstatus != SD_OK)
  1265. {
  1266. return(errorstatus);
  1267. }
  1268. }
  1269. else
  1270. {
  1271. errorstatus = SD_INVALID_PARAMETER;
  1272. return(errorstatus);
  1273. }
  1274. /* Wait till card is ready for data Added */
  1275. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) (RCA << 16);
  1276. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_STATUS;
  1277. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1278. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1279. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1280. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1281. errorstatus = CmdResp1Error(SDIO_SEND_STATUS);
  1282. if (errorstatus != SD_OK)
  1283. {
  1284. return(errorstatus);
  1285. }
  1286. if (NumberOfBlocks > 1)
  1287. {
  1288. /* Common to all modes */
  1289. if (NumberOfBlocks * BlockSize > SD_MAX_DATA_LENGTH)
  1290. {
  1291. errorstatus = SD_INVALID_PARAMETER;
  1292. return(errorstatus);
  1293. }
  1294. if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
  1295. {
  1296. /* To improve performance */
  1297. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) (RCA << 16);
  1298. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  1299. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1300. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1301. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1302. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1303. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  1304. if (errorstatus != SD_OK)
  1305. {
  1306. return(errorstatus);
  1307. }
  1308. /* To improve performance */
  1309. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)NumberOfBlocks;
  1310. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_BLOCK_COUNT;
  1311. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1312. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1313. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1314. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1315. errorstatus = CmdResp1Error(SDIO_SET_BLOCK_COUNT);
  1316. if (errorstatus != SD_OK)
  1317. {
  1318. return(errorstatus);
  1319. }
  1320. }
  1321. /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
  1322. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)addr;
  1323. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_WRITE_MULT_BLOCK;
  1324. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1325. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1326. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1327. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1328. errorstatus = CmdResp1Error(SDIO_WRITE_MULT_BLOCK);
  1329. if (SD_OK != errorstatus)
  1330. {
  1331. return(errorstatus);
  1332. }
  1333. TotalNumberOfBytes = NumberOfBlocks * BlockSize;
  1334. StopCondition = 1;
  1335. SrcBuffer = writebuff;
  1336. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  1337. SDIO_DataInitStructure.SDIO_DataLength = NumberOfBlocks * BlockSize;
  1338. SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) power << 4;
  1339. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
  1340. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  1341. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  1342. SDIO_DataConfig(&SDIO_DataInitStructure);
  1343. if (DeviceMode == SD_POLLING_MODE)
  1344. {
  1345. while (!(SDIO->STA & (SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DATAEND | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_STBITERR)))
  1346. {
  1347. if (SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)
  1348. {
  1349. if (!((TotalNumberOfBytes - bytestransferred) < SD_HALFFIFOBYTES))
  1350. {
  1351. for (count = 0; count < SD_HALFFIFO; count++)
  1352. {
  1353. SDIO_WriteData(*(tempbuff + count));
  1354. }
  1355. tempbuff += SD_HALFFIFO;
  1356. bytestransferred += SD_HALFFIFOBYTES;
  1357. }
  1358. else
  1359. {
  1360. restwords = ((TotalNumberOfBytes - bytestransferred) % 4 == 0) ? ((TotalNumberOfBytes - bytestransferred) / 4) :
  1361. ((TotalNumberOfBytes - bytestransferred) / 4 + 1);
  1362. for (count = 0; count < restwords; count++, tempbuff++, bytestransferred += 4)
  1363. {
  1364. SDIO_WriteData(*tempbuff);
  1365. }
  1366. }
  1367. }
  1368. }
  1369. if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
  1370. {
  1371. SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
  1372. errorstatus = SD_DATA_TIMEOUT;
  1373. return(errorstatus);
  1374. }
  1375. else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
  1376. {
  1377. SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
  1378. errorstatus = SD_DATA_CRC_FAIL;
  1379. return(errorstatus);
  1380. }
  1381. else if (SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)
  1382. {
  1383. SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);
  1384. errorstatus = SD_TX_UNDERRUN;
  1385. return(errorstatus);
  1386. }
  1387. else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
  1388. {
  1389. SDIO_ClearFlag(SDIO_FLAG_STBITERR);
  1390. errorstatus = SD_START_BIT_ERR;
  1391. return(errorstatus);
  1392. }
  1393. if (SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)
  1394. {
  1395. if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
  1396. {
  1397. /* Send CMD12 STOP_TRANSMISSION */
  1398. SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  1399. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_STOP_TRANSMISSION;
  1400. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1401. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1402. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1403. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1404. errorstatus = CmdResp1Error(SDIO_STOP_TRANSMISSION);
  1405. if (errorstatus != SD_OK)
  1406. {
  1407. return(errorstatus);
  1408. }
  1409. }
  1410. }
  1411. }
  1412. else if (DeviceMode == SD_INTERRUPT_MODE)
  1413. {
  1414. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_TXFIFOHE | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE);
  1415. while ((TransferEnd == 0) && (TransferError == SD_OK))
  1416. {}
  1417. if (TransferError != SD_OK)
  1418. {
  1419. return(TransferError);
  1420. }
  1421. }
  1422. else if (DeviceMode == SD_DMA_MODE)
  1423. {
  1424. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR, ENABLE);
  1425. SDIO_DMACmd(ENABLE);
  1426. DMA_TxConfiguration(writebuff, (NumberOfBlocks * BlockSize));
  1427. while (DMA_GetFlagStatus(DMA2_FLAG_TC4) == RESET)
  1428. {}
  1429. while ((TransferEnd == 0) && (TransferError == SD_OK))
  1430. {}
  1431. if (TransferError != SD_OK)
  1432. {
  1433. return(TransferError);
  1434. }
  1435. }
  1436. }
  1437. /* Clear all the static flags */
  1438. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  1439. /* Wait till the card is in programming state */
  1440. errorstatus = IsCardProgramming(&cardstate);
  1441. while ((errorstatus == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
  1442. {
  1443. errorstatus = IsCardProgramming(&cardstate);
  1444. }
  1445. return(errorstatus);
  1446. }
  1447. /**
  1448. * @brief Gets the cuurent data transfer state.
  1449. * @param None
  1450. * @retval SDTransferState: Data Transfer state.
  1451. * This value can be:
  1452. * - SD_NO_TRANSFER: No data transfer is acting
  1453. * - SD_TRANSFER_IN_PROGRESS: Data transfer is acting
  1454. */
  1455. SDTransferState SD_GetTransferState(void)
  1456. {
  1457. if (SDIO->STA & (SDIO_FLAG_TXACT | SDIO_FLAG_RXACT))
  1458. {
  1459. return(SD_TRANSFER_IN_PROGRESS);
  1460. }
  1461. else
  1462. {
  1463. return(SD_NO_TRANSFER);
  1464. }
  1465. }
  1466. /**
  1467. * @brief Aborts an ongoing data transfer.
  1468. * @param None
  1469. * @retval SD_Error: SD Card Error code.
  1470. */
  1471. SD_Error SD_StopTransfer(void)
  1472. {
  1473. SD_Error errorstatus = SD_OK;
  1474. /* Send CMD12 STOP_TRANSMISSION */
  1475. SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  1476. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_STOP_TRANSMISSION;
  1477. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1478. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1479. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1480. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1481. errorstatus = CmdResp1Error(SDIO_STOP_TRANSMISSION);
  1482. return(errorstatus);
  1483. }
  1484. /**
  1485. * @brief Allows to erase memory area specified for the given card.
  1486. * @param startaddr: the start address.
  1487. * @param endaddr: the end address.
  1488. * @retval SD_Error: SD Card Error code.
  1489. */
  1490. SD_Error SD_Erase(uint32_t startaddr, uint32_t endaddr)
  1491. {
  1492. SD_Error errorstatus = SD_OK;
  1493. uint32_t delay = 0;
  1494. __IO uint32_t maxdelay = 0;
  1495. uint8_t cardstate = 0;
  1496. /* Check if the card coomnd class supports erase command */
  1497. if (((CSD_Tab[1] >> 20) & SD_CCCC_ERASE) == 0)
  1498. {
  1499. errorstatus = SD_REQUEST_NOT_APPLICABLE;
  1500. return(errorstatus);
  1501. }
  1502. maxdelay = 72000 / ((SDIO->CLKCR & 0xFF) + 2);
  1503. if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
  1504. {
  1505. errorstatus = SD_LOCK_UNLOCK_FAILED;
  1506. return(errorstatus);
  1507. }
  1508. if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
  1509. {
  1510. startaddr /= 512;
  1511. endaddr /= 512;
  1512. }
  1513. /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
  1514. if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
  1515. {
  1516. /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
  1517. SDIO_CmdInitStructure.SDIO_Argument = startaddr;
  1518. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SD_ERASE_GRP_START;
  1519. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1520. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1521. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1522. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1523. errorstatus = CmdResp1Error(SDIO_SD_ERASE_GRP_START);
  1524. if (errorstatus != SD_OK)
  1525. {
  1526. return(errorstatus);
  1527. }
  1528. /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
  1529. SDIO_CmdInitStructure.SDIO_Argument = endaddr;
  1530. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SD_ERASE_GRP_END;
  1531. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1532. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1533. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1534. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1535. errorstatus = CmdResp1Error(SDIO_SD_ERASE_GRP_END);
  1536. if (errorstatus != SD_OK)
  1537. {
  1538. return(errorstatus);
  1539. }
  1540. }
  1541. /* Send CMD38 ERASE */
  1542. SDIO_CmdInitStructure.SDIO_Argument = 0;
  1543. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_ERASE;
  1544. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1545. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1546. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1547. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1548. errorstatus = CmdResp1Error(SDIO_ERASE);
  1549. if (errorstatus != SD_OK)
  1550. {
  1551. return(errorstatus);
  1552. }
  1553. for (delay = 0; delay < maxdelay; delay++)
  1554. {}
  1555. /* Wait till the card is in programming state */
  1556. errorstatus = IsCardProgramming(&cardstate);
  1557. while ((errorstatus == SD_OK) && ((SD_CARD_PROGRAMMING == cardstate) || (SD_CARD_RECEIVING == cardstate)))
  1558. {
  1559. errorstatus = IsCardProgramming(&cardstate);
  1560. }
  1561. return(errorstatus);
  1562. }
  1563. /**
  1564. * @brief Returns the current card's status.
  1565. * @param pcardstatus: pointer to the buffer that will contain the SD
  1566. * card status (Card Status register).
  1567. * @retval SD_Error: SD Card Error code.
  1568. */
  1569. SD_Error SD_SendStatus(uint32_t *pcardstatus)
  1570. {
  1571. SD_Error errorstatus = SD_OK;
  1572. if (pcardstatus == NULL)
  1573. {
  1574. errorstatus = SD_INVALID_PARAMETER;
  1575. return(errorstatus);
  1576. }
  1577. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  1578. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_STATUS;
  1579. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1580. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1581. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1582. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1583. errorstatus = CmdResp1Error(SDIO_SEND_STATUS);
  1584. if (errorstatus != SD_OK)
  1585. {
  1586. return(errorstatus);
  1587. }
  1588. *pcardstatus = SDIO_GetResponse(SDIO_RESP1);
  1589. return(errorstatus);
  1590. }
  1591. /**
  1592. * @brief Returns the current SD card's status.
  1593. * @param psdstatus: pointer to the buffer that will contain the SD
  1594. * card status (SD Status register).
  1595. * @retval SD_Error: SD Card Error code.
  1596. */
  1597. SD_Error SD_SendSDStatus(uint32_t *psdstatus)
  1598. {
  1599. SD_Error errorstatus = SD_OK;
  1600. uint32_t count = 0;
  1601. if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
  1602. {
  1603. errorstatus = SD_LOCK_UNLOCK_FAILED;
  1604. return(errorstatus);
  1605. }
  1606. /* Set block size for card if it is not equal to current block size for card. */
  1607. SDIO_CmdInitStructure.SDIO_Argument = 64;
  1608. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_BLOCKLEN;
  1609. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1610. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1611. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1612. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1613. errorstatus = CmdResp1Error(SDIO_SET_BLOCKLEN);
  1614. if (errorstatus != SD_OK)
  1615. {
  1616. return(errorstatus);
  1617. }
  1618. /* CMD55 */
  1619. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  1620. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  1621. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1622. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1623. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1624. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1625. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  1626. if (errorstatus != SD_OK)
  1627. {
  1628. return(errorstatus);
  1629. }
  1630. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  1631. SDIO_DataInitStructure.SDIO_DataLength = 64;
  1632. SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_64b;
  1633. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
  1634. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  1635. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  1636. SDIO_DataConfig(&SDIO_DataInitStructure);
  1637. /* Send ACMD13 SD_APP_STAUS with argument as card's RCA.*/
  1638. SDIO_CmdInitStructure.SDIO_Argument = 0;
  1639. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SD_APP_STAUS;
  1640. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1641. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1642. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1643. SDIO_SendCommand(&SDIO_CmdInitStructure);
  1644. errorstatus = CmdResp1Error(SDIO_SD_APP_STAUS);
  1645. if (errorstatus != SD_OK)
  1646. {
  1647. return(errorstatus);
  1648. }
  1649. while (!(SDIO->STA &(SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR)))
  1650. {
  1651. if (SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)
  1652. {
  1653. for (count = 0; count < 8; count++)
  1654. {
  1655. *(psdstatus + count) = SDIO_ReadData();
  1656. }
  1657. psdstatus += 8;
  1658. }
  1659. }
  1660. if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
  1661. {
  1662. SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
  1663. errorstatus = SD_DATA_TIMEOUT;
  1664. return(errorstatus);
  1665. }
  1666. else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
  1667. {
  1668. SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
  1669. errorstatus = SD_DATA_CRC_FAIL;
  1670. return(errorstatus);
  1671. }
  1672. else if (SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)
  1673. {
  1674. SDIO_ClearFlag(SDIO_FLAG_RXOVERR);
  1675. errorstatus = SD_RX_OVERRUN;
  1676. return(errorstatus);
  1677. }
  1678. else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
  1679. {
  1680. SDIO_ClearFlag(SDIO_FLAG_STBITERR);
  1681. errorstatus = SD_START_BIT_ERR;
  1682. return(errorstatus);
  1683. }
  1684. while (SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)
  1685. {
  1686. *psdstatus = SDIO_ReadData();
  1687. psdstatus++;
  1688. }
  1689. /* Clear all the static status flags*/
  1690. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  1691. psdstatus -= 16;
  1692. for (count = 0; count < 16; count++)
  1693. {
  1694. psdstatus[count] = ((psdstatus[count] & SD_0TO7BITS) << 24) |((psdstatus[count] & SD_8TO15BITS) << 8) |
  1695. ((psdstatus[count] & SD_16TO23BITS) >> 8) |((psdstatus[count] & SD_24TO31BITS) >> 24);
  1696. }
  1697. return(errorstatus);
  1698. }
  1699. /**
  1700. * @brief Allows to process all the interrupts that are high.
  1701. * @param None
  1702. * @retval SD_Error: SD Card Error code.
  1703. */
  1704. SD_Error SD_ProcessIRQSrc(void)
  1705. {
  1706. uint32_t count = 0, restwords = 0;
  1707. if (DeviceMode == SD_INTERRUPT_MODE)
  1708. {
  1709. if (SDIO_GetITStatus(SDIO_IT_RXFIFOHF) != RESET)
  1710. {
  1711. for (count = 0; count < SD_HALFFIFO; count++)
  1712. {
  1713. *(DestBuffer + count) = SDIO_ReadData();
  1714. }
  1715. DestBuffer += SD_HALFFIFO;
  1716. NumberOfBytes += SD_HALFFIFOBYTES;
  1717. }
  1718. else if (SDIO_GetITStatus(SDIO_IT_TXFIFOHE) != RESET)
  1719. {
  1720. if ((TotalNumberOfBytes - NumberOfBytes) < SD_HALFFIFOBYTES)
  1721. {
  1722. restwords = ((TotalNumberOfBytes - NumberOfBytes) % 4 == 0) ?
  1723. ((TotalNumberOfBytes - NumberOfBytes) / 4) :
  1724. ((TotalNumberOfBytes - NumberOfBytes) / 4 + 1);
  1725. for (count = 0; count < restwords; count++, SrcBuffer++, NumberOfBytes += 4)
  1726. {
  1727. SDIO_WriteData(*SrcBuffer);
  1728. }
  1729. }
  1730. else
  1731. {
  1732. for (count = 0; count < SD_HALFFIFO; count++)
  1733. {
  1734. SDIO_WriteData(*(SrcBuffer + count));
  1735. }
  1736. SrcBuffer += SD_HALFFIFO;
  1737. NumberOfBytes += SD_HALFFIFOBYTES;
  1738. }
  1739. }
  1740. }
  1741. if (SDIO_GetITStatus(SDIO_IT_DATAEND) != RESET)
  1742. {
  1743. if (DeviceMode != SD_DMA_MODE)
  1744. {
  1745. while ((SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) && (NumberOfBytes < TotalNumberOfBytes))
  1746. {
  1747. *DestBuffer = SDIO_ReadData();
  1748. DestBuffer++;
  1749. NumberOfBytes += 4;
  1750. }
  1751. }
  1752. if (StopCondition == 1)
  1753. {
  1754. TransferError = SD_StopTransfer();
  1755. }
  1756. else
  1757. {
  1758. TransferError = SD_OK;
  1759. }
  1760. SDIO_ClearITPendingBit(SDIO_IT_DATAEND);
  1761. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
  1762. SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |
  1763. SDIO_IT_RXOVERR | SDIO_IT_STBITERR, DISABLE);
  1764. TransferEnd = 1;
  1765. NumberOfBytes = 0;
  1766. return(TransferError);
  1767. }
  1768. if (SDIO_GetITStatus(SDIO_IT_DCRCFAIL) != RESET)
  1769. {
  1770. SDIO_ClearITPendingBit(SDIO_IT_DCRCFAIL);
  1771. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
  1772. SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |
  1773. SDIO_IT_RXOVERR | SDIO_IT_STBITERR, DISABLE);
  1774. NumberOfBytes = 0;
  1775. TransferError = SD_DATA_CRC_FAIL;
  1776. return(SD_DATA_CRC_FAIL);
  1777. }
  1778. if (SDIO_GetITStatus(SDIO_IT_DTIMEOUT) != RESET)
  1779. {
  1780. SDIO_ClearITPendingBit(SDIO_IT_DTIMEOUT);
  1781. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
  1782. SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |
  1783. SDIO_IT_RXOVERR | SDIO_IT_STBITERR, DISABLE);
  1784. NumberOfBytes = 0;
  1785. TransferError = SD_DATA_TIMEOUT;
  1786. return(SD_DATA_TIMEOUT);
  1787. }
  1788. if (SDIO_GetITStatus(SDIO_IT_RXOVERR) != RESET)
  1789. {
  1790. SDIO_ClearITPendingBit(SDIO_IT_RXOVERR);
  1791. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
  1792. SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |
  1793. SDIO_IT_RXOVERR | SDIO_IT_STBITERR, DISABLE);
  1794. NumberOfBytes = 0;
  1795. TransferError = SD_RX_OVERRUN;
  1796. return(SD_RX_OVERRUN);
  1797. }
  1798. if (SDIO_GetITStatus(SDIO_IT_TXUNDERR) != RESET)
  1799. {
  1800. SDIO_ClearITPendingBit(SDIO_IT_TXUNDERR);
  1801. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
  1802. SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |
  1803. SDIO_IT_RXOVERR | SDIO_IT_STBITERR, DISABLE);
  1804. NumberOfBytes = 0;
  1805. TransferError = SD_TX_UNDERRUN;
  1806. return(SD_TX_UNDERRUN);
  1807. }
  1808. if (SDIO_GetITStatus(SDIO_IT_STBITERR) != RESET)
  1809. {
  1810. SDIO_ClearITPendingBit(SDIO_IT_STBITERR);
  1811. SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
  1812. SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |
  1813. SDIO_IT_RXOVERR | SDIO_IT_STBITERR, DISABLE);
  1814. NumberOfBytes = 0;
  1815. TransferError = SD_START_BIT_ERR;
  1816. return(SD_START_BIT_ERR);
  1817. }
  1818. return(SD_OK);
  1819. }
  1820. /**
  1821. * @brief Checks for error conditions for CMD0.
  1822. * @param None
  1823. * @retval SD_Error: SD Card Error code.
  1824. */
  1825. static SD_Error CmdError(void)
  1826. {
  1827. SD_Error errorstatus = SD_OK;
  1828. uint32_t timeout;
  1829. timeout = SDIO_CMD0TIMEOUT; /* 10000 */
  1830. while ((timeout > 0) && (SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) == RESET))
  1831. {
  1832. timeout--;
  1833. }
  1834. if (timeout == 0)
  1835. {
  1836. errorstatus = SD_CMD_RSP_TIMEOUT;
  1837. return(errorstatus);
  1838. }
  1839. /* Clear all the static flags */
  1840. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  1841. return(errorstatus);
  1842. }
  1843. /**
  1844. * @brief Checks for error conditions for R7.
  1845. * response.
  1846. * @param None
  1847. * @retval SD_Error: SD Card Error code.
  1848. */
  1849. static SD_Error CmdResp7Error(void)
  1850. {
  1851. SD_Error errorstatus = SD_OK;
  1852. uint32_t status;
  1853. uint32_t timeout = SDIO_CMD0TIMEOUT;
  1854. status = SDIO->STA;
  1855. while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) && (timeout > 0))
  1856. {
  1857. timeout--;
  1858. status = SDIO->STA;
  1859. }
  1860. if ((timeout == 0) || (status & SDIO_FLAG_CTIMEOUT))
  1861. {
  1862. /* Card is not V2.0 complient or card does not support the set voltage range */
  1863. errorstatus = SD_CMD_RSP_TIMEOUT;
  1864. SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
  1865. return(errorstatus);
  1866. }
  1867. if (status & SDIO_FLAG_CMDREND)
  1868. {
  1869. /* Card is SD V2.0 compliant */
  1870. errorstatus = SD_OK;
  1871. SDIO_ClearFlag(SDIO_FLAG_CMDREND);
  1872. return(errorstatus);
  1873. }
  1874. return(errorstatus);
  1875. }
  1876. /**
  1877. * @brief Checks for error conditions for R1.
  1878. * response
  1879. * @param cmd: The sent command index.
  1880. * @retval SD_Error: SD Card Error code.
  1881. */
  1882. static SD_Error CmdResp1Error(uint8_t cmd)
  1883. {
  1884. SD_Error errorstatus = SD_OK;
  1885. uint32_t status;
  1886. uint32_t response_r1;
  1887. status = SDIO->STA;
  1888. while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
  1889. {
  1890. status = SDIO->STA;
  1891. }
  1892. if (status & SDIO_FLAG_CTIMEOUT)
  1893. {
  1894. errorstatus = SD_CMD_RSP_TIMEOUT;
  1895. SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
  1896. return(errorstatus);
  1897. }
  1898. else if (status & SDIO_FLAG_CCRCFAIL)
  1899. {
  1900. errorstatus = SD_CMD_CRC_FAIL;
  1901. SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
  1902. return(errorstatus);
  1903. }
  1904. /* Check response received is of desired command */
  1905. if (SDIO_GetCommandResponse() != cmd)
  1906. {
  1907. errorstatus = SD_ILLEGAL_CMD;
  1908. return(errorstatus);
  1909. }
  1910. /* Clear all the static flags */
  1911. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  1912. /* We have received response, retrieve it for analysis */
  1913. response_r1 = SDIO_GetResponse(SDIO_RESP1);
  1914. if ((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
  1915. {
  1916. return(errorstatus);
  1917. }
  1918. if (response_r1 & SD_OCR_ADDR_OUT_OF_RANGE)
  1919. {
  1920. return(SD_ADDR_OUT_OF_RANGE);
  1921. }
  1922. if (response_r1 & SD_OCR_ADDR_MISALIGNED)
  1923. {
  1924. return(SD_ADDR_MISALIGNED);
  1925. }
  1926. if (response_r1 & SD_OCR_BLOCK_LEN_ERR)
  1927. {
  1928. return(SD_BLOCK_LEN_ERR);
  1929. }
  1930. if (response_r1 & SD_OCR_ERASE_SEQ_ERR)
  1931. {
  1932. return(SD_ERASE_SEQ_ERR);
  1933. }
  1934. if (response_r1 & SD_OCR_BAD_ERASE_PARAM)
  1935. {
  1936. return(SD_BAD_ERASE_PARAM);
  1937. }
  1938. if (response_r1 & SD_OCR_WRITE_PROT_VIOLATION)
  1939. {
  1940. return(SD_WRITE_PROT_VIOLATION);
  1941. }
  1942. if (response_r1 & SD_OCR_LOCK_UNLOCK_FAILED)
  1943. {
  1944. return(SD_LOCK_UNLOCK_FAILED);
  1945. }
  1946. if (response_r1 & SD_OCR_COM_CRC_FAILED)
  1947. {
  1948. return(SD_COM_CRC_FAILED);
  1949. }
  1950. if (response_r1 & SD_OCR_ILLEGAL_CMD)
  1951. {
  1952. return(SD_ILLEGAL_CMD);
  1953. }
  1954. if (response_r1 & SD_OCR_CARD_ECC_FAILED)
  1955. {
  1956. return(SD_CARD_ECC_FAILED);
  1957. }
  1958. if (response_r1 & SD_OCR_CC_ERROR)
  1959. {
  1960. return(SD_CC_ERROR);
  1961. }
  1962. if (response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR)
  1963. {
  1964. return(SD_GENERAL_UNKNOWN_ERROR);
  1965. }
  1966. if (response_r1 & SD_OCR_STREAM_READ_UNDERRUN)
  1967. {
  1968. return(SD_STREAM_READ_UNDERRUN);
  1969. }
  1970. if (response_r1 & SD_OCR_STREAM_WRITE_OVERRUN)
  1971. {
  1972. return(SD_STREAM_WRITE_OVERRUN);
  1973. }
  1974. if (response_r1 & SD_OCR_CID_CSD_OVERWRIETE)
  1975. {
  1976. return(SD_CID_CSD_OVERWRITE);
  1977. }
  1978. if (response_r1 & SD_OCR_WP_ERASE_SKIP)
  1979. {
  1980. return(SD_WP_ERASE_SKIP);
  1981. }
  1982. if (response_r1 & SD_OCR_CARD_ECC_DISABLED)
  1983. {
  1984. return(SD_CARD_ECC_DISABLED);
  1985. }
  1986. if (response_r1 & SD_OCR_ERASE_RESET)
  1987. {
  1988. return(SD_ERASE_RESET);
  1989. }
  1990. if (response_r1 & SD_OCR_AKE_SEQ_ERROR)
  1991. {
  1992. return(SD_AKE_SEQ_ERROR);
  1993. }
  1994. return(errorstatus);
  1995. }
  1996. /**
  1997. * @brief Checks for error conditions for R3 (OCR).
  1998. * response.
  1999. * @param None
  2000. * @retval SD_Error: SD Card Error code.
  2001. */
  2002. static SD_Error CmdResp3Error(void)
  2003. {
  2004. SD_Error errorstatus = SD_OK;
  2005. uint32_t status;
  2006. status = SDIO->STA;
  2007. while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
  2008. {
  2009. status = SDIO->STA;
  2010. }
  2011. if (status & SDIO_FLAG_CTIMEOUT)
  2012. {
  2013. errorstatus = SD_CMD_RSP_TIMEOUT;
  2014. SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
  2015. return(errorstatus);
  2016. }
  2017. /* Clear all the static flags */
  2018. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  2019. return(errorstatus);
  2020. }
  2021. /**
  2022. * @brief Checks for error conditions for R2 (CID or CSD).
  2023. * response.
  2024. * @param None
  2025. * @retval SD_Error: SD Card Error code.
  2026. */
  2027. static SD_Error CmdResp2Error(void)
  2028. {
  2029. SD_Error errorstatus = SD_OK;
  2030. uint32_t status;
  2031. status = SDIO->STA;
  2032. while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT | SDIO_FLAG_CMDREND)))
  2033. {
  2034. status = SDIO->STA;
  2035. }
  2036. if (status & SDIO_FLAG_CTIMEOUT)
  2037. {
  2038. errorstatus = SD_CMD_RSP_TIMEOUT;
  2039. SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
  2040. return(errorstatus);
  2041. }
  2042. else if (status & SDIO_FLAG_CCRCFAIL)
  2043. {
  2044. errorstatus = SD_CMD_CRC_FAIL;
  2045. SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
  2046. return(errorstatus);
  2047. }
  2048. /* Clear all the static flags */
  2049. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  2050. return(errorstatus);
  2051. }
  2052. /**
  2053. * @brief Checks for error conditions for R6 (RCA).
  2054. * response.
  2055. * @param cmd: The sent command index.
  2056. * @param prca: pointer to the variable that will contain the SD
  2057. * card relative address RCA.
  2058. * @retval SD_Error: SD Card Error code.
  2059. */
  2060. static SD_Error CmdResp6Error(uint8_t cmd, uint16_t *prca)
  2061. {
  2062. SD_Error errorstatus = SD_OK;
  2063. uint32_t status;
  2064. uint32_t response_r1;
  2065. status = SDIO->STA;
  2066. while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT | SDIO_FLAG_CMDREND)))
  2067. {
  2068. status = SDIO->STA;
  2069. }
  2070. if (status & SDIO_FLAG_CTIMEOUT)
  2071. {
  2072. errorstatus = SD_CMD_RSP_TIMEOUT;
  2073. SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
  2074. return(errorstatus);
  2075. }
  2076. else if (status & SDIO_FLAG_CCRCFAIL)
  2077. {
  2078. errorstatus = SD_CMD_CRC_FAIL;
  2079. SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
  2080. return(errorstatus);
  2081. }
  2082. /* Check response received is of desired command */
  2083. if (SDIO_GetCommandResponse() != cmd)
  2084. {
  2085. errorstatus = SD_ILLEGAL_CMD;
  2086. return(errorstatus);
  2087. }
  2088. /* Clear all the static flags */
  2089. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  2090. /* We have received response, retrieve it. */
  2091. response_r1 = SDIO_GetResponse(SDIO_RESP1);
  2092. if (SD_ALLZERO == (response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)))
  2093. {
  2094. *prca = (uint16_t) (response_r1 >> 16);
  2095. return(errorstatus);
  2096. }
  2097. if (response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR)
  2098. {
  2099. return(SD_GENERAL_UNKNOWN_ERROR);
  2100. }
  2101. if (response_r1 & SD_R6_ILLEGAL_CMD)
  2102. {
  2103. return(SD_ILLEGAL_CMD);
  2104. }
  2105. if (response_r1 & SD_R6_COM_CRC_FAILED)
  2106. {
  2107. return(SD_COM_CRC_FAILED);
  2108. }
  2109. return(errorstatus);
  2110. }
  2111. /**
  2112. * @brief Enables or disables the SDIO wide bus mode.
  2113. * @param NewState: new state of the SDIO wide bus mode.
  2114. * This parameter can be: ENABLE or DISABLE.
  2115. * @retval SD_Error: SD Card Error code.
  2116. */
  2117. static SD_Error SDEnWideBus(FunctionalState NewState)
  2118. {
  2119. SD_Error errorstatus = SD_OK;
  2120. uint32_t scr[2] = {0, 0};
  2121. if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
  2122. {
  2123. errorstatus = SD_LOCK_UNLOCK_FAILED;
  2124. return(errorstatus);
  2125. }
  2126. /* Get SCR Register */
  2127. errorstatus = FindSCR(RCA, scr);
  2128. if (errorstatus != SD_OK)
  2129. {
  2130. return(errorstatus);
  2131. }
  2132. /* If wide bus operation to be enabled */
  2133. if (NewState == ENABLE)
  2134. {
  2135. /* If requested card supports wide bus operation */
  2136. if ((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
  2137. {
  2138. /* Send CMD55 APP_CMD with argument as card's RCA.*/
  2139. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  2140. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  2141. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2142. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2143. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2144. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2145. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  2146. if (errorstatus != SD_OK)
  2147. {
  2148. return(errorstatus);
  2149. }
  2150. /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
  2151. SDIO_CmdInitStructure.SDIO_Argument = 0x2;
  2152. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_SD_SET_BUSWIDTH;
  2153. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2154. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2155. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2156. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2157. errorstatus = CmdResp1Error(SDIO_APP_SD_SET_BUSWIDTH);
  2158. if (errorstatus != SD_OK)
  2159. {
  2160. return(errorstatus);
  2161. }
  2162. return(errorstatus);
  2163. }
  2164. else
  2165. {
  2166. errorstatus = SD_REQUEST_NOT_APPLICABLE;
  2167. return(errorstatus);
  2168. }
  2169. } /* If wide bus operation to be disabled */
  2170. else
  2171. {
  2172. /* If requested card supports 1 bit mode operation */
  2173. if ((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
  2174. {
  2175. /* Send CMD55 APP_CMD with argument as card's RCA.*/
  2176. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  2177. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  2178. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2179. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2180. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2181. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2182. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  2183. if (errorstatus != SD_OK)
  2184. {
  2185. return(errorstatus);
  2186. }
  2187. /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
  2188. SDIO_CmdInitStructure.SDIO_Argument = 0x00;
  2189. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_SD_SET_BUSWIDTH;
  2190. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2191. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2192. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2193. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2194. errorstatus = CmdResp1Error(SDIO_APP_SD_SET_BUSWIDTH);
  2195. if (errorstatus != SD_OK)
  2196. {
  2197. return(errorstatus);
  2198. }
  2199. return(errorstatus);
  2200. }
  2201. else
  2202. {
  2203. errorstatus = SD_REQUEST_NOT_APPLICABLE;
  2204. return(errorstatus);
  2205. }
  2206. }
  2207. }
  2208. /**
  2209. * @brief Checks if the SD card is in programming state.
  2210. * @param pstatus: pointer to the variable that will contain the SD
  2211. * card state.
  2212. * @retval SD_Error: SD Card Error code.
  2213. */
  2214. static SD_Error IsCardProgramming(uint8_t *pstatus)
  2215. {
  2216. SD_Error errorstatus = SD_OK;
  2217. __IO uint32_t respR1 = 0, status = 0;
  2218. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  2219. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_STATUS;
  2220. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2221. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2222. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2223. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2224. status = SDIO->STA;
  2225. while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
  2226. {
  2227. status = SDIO->STA;
  2228. }
  2229. if (status & SDIO_FLAG_CTIMEOUT)
  2230. {
  2231. errorstatus = SD_CMD_RSP_TIMEOUT;
  2232. SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
  2233. return(errorstatus);
  2234. }
  2235. else if (status & SDIO_FLAG_CCRCFAIL)
  2236. {
  2237. errorstatus = SD_CMD_CRC_FAIL;
  2238. SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
  2239. return(errorstatus);
  2240. }
  2241. status = (uint32_t)SDIO_GetCommandResponse();
  2242. /* Check response received is of desired command */
  2243. if (status != SDIO_SEND_STATUS)
  2244. {
  2245. errorstatus = SD_ILLEGAL_CMD;
  2246. return(errorstatus);
  2247. }
  2248. /* Clear all the static flags */
  2249. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  2250. /* We have received response, retrieve it for analysis */
  2251. respR1 = SDIO_GetResponse(SDIO_RESP1);
  2252. /* Find out card status */
  2253. *pstatus = (uint8_t) ((respR1 >> 9) & 0x0000000F);
  2254. if ((respR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
  2255. {
  2256. return(errorstatus);
  2257. }
  2258. if (respR1 & SD_OCR_ADDR_OUT_OF_RANGE)
  2259. {
  2260. return(SD_ADDR_OUT_OF_RANGE);
  2261. }
  2262. if (respR1 & SD_OCR_ADDR_MISALIGNED)
  2263. {
  2264. return(SD_ADDR_MISALIGNED);
  2265. }
  2266. if (respR1 & SD_OCR_BLOCK_LEN_ERR)
  2267. {
  2268. return(SD_BLOCK_LEN_ERR);
  2269. }
  2270. if (respR1 & SD_OCR_ERASE_SEQ_ERR)
  2271. {
  2272. return(SD_ERASE_SEQ_ERR);
  2273. }
  2274. if (respR1 & SD_OCR_BAD_ERASE_PARAM)
  2275. {
  2276. return(SD_BAD_ERASE_PARAM);
  2277. }
  2278. if (respR1 & SD_OCR_WRITE_PROT_VIOLATION)
  2279. {
  2280. return(SD_WRITE_PROT_VIOLATION);
  2281. }
  2282. if (respR1 & SD_OCR_LOCK_UNLOCK_FAILED)
  2283. {
  2284. return(SD_LOCK_UNLOCK_FAILED);
  2285. }
  2286. if (respR1 & SD_OCR_COM_CRC_FAILED)
  2287. {
  2288. return(SD_COM_CRC_FAILED);
  2289. }
  2290. if (respR1 & SD_OCR_ILLEGAL_CMD)
  2291. {
  2292. return(SD_ILLEGAL_CMD);
  2293. }
  2294. if (respR1 & SD_OCR_CARD_ECC_FAILED)
  2295. {
  2296. return(SD_CARD_ECC_FAILED);
  2297. }
  2298. if (respR1 & SD_OCR_CC_ERROR)
  2299. {
  2300. return(SD_CC_ERROR);
  2301. }
  2302. if (respR1 & SD_OCR_GENERAL_UNKNOWN_ERROR)
  2303. {
  2304. return(SD_GENERAL_UNKNOWN_ERROR);
  2305. }
  2306. if (respR1 & SD_OCR_STREAM_READ_UNDERRUN)
  2307. {
  2308. return(SD_STREAM_READ_UNDERRUN);
  2309. }
  2310. if (respR1 & SD_OCR_STREAM_WRITE_OVERRUN)
  2311. {
  2312. return(SD_STREAM_WRITE_OVERRUN);
  2313. }
  2314. if (respR1 & SD_OCR_CID_CSD_OVERWRIETE)
  2315. {
  2316. return(SD_CID_CSD_OVERWRITE);
  2317. }
  2318. if (respR1 & SD_OCR_WP_ERASE_SKIP)
  2319. {
  2320. return(SD_WP_ERASE_SKIP);
  2321. }
  2322. if (respR1 & SD_OCR_CARD_ECC_DISABLED)
  2323. {
  2324. return(SD_CARD_ECC_DISABLED);
  2325. }
  2326. if (respR1 & SD_OCR_ERASE_RESET)
  2327. {
  2328. return(SD_ERASE_RESET);
  2329. }
  2330. if (respR1 & SD_OCR_AKE_SEQ_ERROR)
  2331. {
  2332. return(SD_AKE_SEQ_ERROR);
  2333. }
  2334. return(errorstatus);
  2335. }
  2336. /**
  2337. * @brief Find the SD card SCR register value.
  2338. * @param rca: selected card address.
  2339. * @param pscr: pointer to the buffer that will contain the SCR value.
  2340. * @retval SD_Error: SD Card Error code.
  2341. */
  2342. static SD_Error FindSCR(uint16_t rca, uint32_t *pscr)
  2343. {
  2344. uint32_t index = 0;
  2345. SD_Error errorstatus = SD_OK;
  2346. uint32_t tempscr[2] = {0, 0};
  2347. /* Set Block Size To 8 Bytes */
  2348. /* Send CMD55 APP_CMD with argument as card's RCA */
  2349. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)8;
  2350. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SET_BLOCKLEN;
  2351. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2352. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2353. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2354. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2355. errorstatus = CmdResp1Error(SDIO_SET_BLOCKLEN);
  2356. if (errorstatus != SD_OK)
  2357. {
  2358. return(errorstatus);
  2359. }
  2360. /* Send CMD55 APP_CMD with argument as card's RCA */
  2361. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  2362. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_APP_CMD;
  2363. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2364. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2365. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2366. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2367. errorstatus = CmdResp1Error(SDIO_APP_CMD);
  2368. if (errorstatus != SD_OK)
  2369. {
  2370. return(errorstatus);
  2371. }
  2372. SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  2373. SDIO_DataInitStructure.SDIO_DataLength = 8;
  2374. SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b;
  2375. SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
  2376. SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  2377. SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  2378. SDIO_DataConfig(&SDIO_DataInitStructure);
  2379. /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
  2380. SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  2381. SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SD_APP_SEND_SCR;
  2382. SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  2383. SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  2384. SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  2385. SDIO_SendCommand(&SDIO_CmdInitStructure);
  2386. errorstatus = CmdResp1Error(SDIO_SD_APP_SEND_SCR);
  2387. if (errorstatus != SD_OK)
  2388. {
  2389. return(errorstatus);
  2390. }
  2391. while (!(SDIO->STA & (SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR)))
  2392. {
  2393. if (SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)
  2394. {
  2395. *(tempscr + index) = SDIO_ReadData();
  2396. index++;
  2397. }
  2398. }
  2399. if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
  2400. {
  2401. SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
  2402. errorstatus = SD_DATA_TIMEOUT;
  2403. return(errorstatus);
  2404. }
  2405. else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
  2406. {
  2407. SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
  2408. errorstatus = SD_DATA_CRC_FAIL;
  2409. return(errorstatus);
  2410. }
  2411. else if (SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)
  2412. {
  2413. SDIO_ClearFlag(SDIO_FLAG_RXOVERR);
  2414. errorstatus = SD_RX_OVERRUN;
  2415. return(errorstatus);
  2416. }
  2417. else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
  2418. {
  2419. SDIO_ClearFlag(SDIO_FLAG_STBITERR);
  2420. errorstatus = SD_START_BIT_ERR;
  2421. return(errorstatus);
  2422. }
  2423. /* Clear all the static flags */
  2424. SDIO_ClearFlag(SDIO_STATIC_FLAGS);
  2425. *(pscr + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) | ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
  2426. *(pscr) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) | ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
  2427. return(errorstatus);
  2428. }
  2429. /**
  2430. * @brief Converts the number of bytes in power of two and returns the
  2431. * power.
  2432. * @param NumberOfBytes: number of bytes.
  2433. * @retval None
  2434. */
  2435. static uint8_t convert_from_bytes_to_power_of_two(uint16_t NumberOfBytes)
  2436. {
  2437. uint8_t count = 0;
  2438. while (NumberOfBytes != 1)
  2439. {
  2440. NumberOfBytes >>= 1;
  2441. count++;
  2442. }
  2443. return(count);
  2444. }
  2445. /**
  2446. * @brief Configures the SDIO Corresponding GPIO Ports
  2447. * @param None
  2448. * @retval None
  2449. */
  2450. static void GPIO_Configuration(void)
  2451. {
  2452. GPIO_InitTypeDef GPIO_InitStructure;
  2453. /* GPIOC and GPIOD Periph clock enable */
  2454. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE);
  2455. /* Configure PC.08, PC.09, PC.10, PC.11, PC.12 pin: D0, D1, D2, D3, CLK pin */
  2456. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
  2457. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  2458. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  2459. GPIO_Init(GPIOC, &GPIO_InitStructure);
  2460. /* Configure PD.02 CMD line */
  2461. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  2462. GPIO_Init(GPIOD, &GPIO_InitStructure);
  2463. }
  2464. /**
  2465. * @brief Configures the DMA2 Channel4 for SDIO Tx request.
  2466. * @param BufferSRC: pointer to the source buffer
  2467. * @param BufferSize: buffer size
  2468. * @retval None
  2469. */
  2470. static void DMA_TxConfiguration(uint32_t *BufferSRC, uint32_t BufferSize)
  2471. {
  2472. DMA_InitTypeDef DMA_InitStructure;
  2473. DMA_ClearFlag(DMA2_FLAG_TC4 | DMA2_FLAG_TE4 | DMA2_FLAG_HT4 | DMA2_FLAG_GL4);
  2474. /* DMA2 Channel4 disable */
  2475. DMA_Cmd(DMA2_Channel4, DISABLE);
  2476. /* DMA2 Channel4 Config */
  2477. DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SDIO_FIFO_Address;
  2478. DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)BufferSRC;
  2479. DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  2480. DMA_InitStructure.DMA_BufferSize = BufferSize / 4;
  2481. DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  2482. DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  2483. DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
  2484. DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
  2485. DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  2486. DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  2487. DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  2488. DMA_Init(DMA2_Channel4, &DMA_InitStructure);
  2489. /* DMA2 Channel4 enable */
  2490. DMA_Cmd(DMA2_Channel4, ENABLE);
  2491. }
  2492. /**
  2493. * @brief Configures the DMA2 Channel4 for SDIO Rx request.
  2494. * @param BufferDST: pointer to the destination buffer
  2495. * @param BufferSize: buffer size
  2496. * @retval None
  2497. */
  2498. static void DMA_RxConfiguration(uint32_t *BufferDST, uint32_t BufferSize)
  2499. {
  2500. DMA_InitTypeDef DMA_InitStructure;
  2501. DMA_ClearFlag(DMA2_FLAG_TC4 | DMA2_FLAG_TE4 | DMA2_FLAG_HT4 | DMA2_FLAG_GL4);
  2502. /* DMA2 Channel4 disable */
  2503. DMA_Cmd(DMA2_Channel4, DISABLE);
  2504. /* DMA2 Channel4 Config */
  2505. DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SDIO_FIFO_Address;
  2506. DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)BufferDST;
  2507. DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  2508. DMA_InitStructure.DMA_BufferSize = BufferSize / 4;
  2509. DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  2510. DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  2511. DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
  2512. DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
  2513. DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  2514. DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  2515. DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  2516. DMA_Init(DMA2_Channel4, &DMA_InitStructure);
  2517. /* DMA2 Channel4 enable */
  2518. DMA_Cmd(DMA2_Channel4, ENABLE);
  2519. }
  2520. /**
  2521. * @}
  2522. */
  2523. /**
  2524. * @}
  2525. */
  2526. /******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/
  2527. /*
  2528. * RT-Thread SD Card Driver
  2529. * 20090417 Bernard
  2530. */
  2531. #include <rtthread.h>
  2532. #include <dfs_fs.h>
  2533. /* set sector size to 512 */
  2534. #define SECTOR_SIZE 512
  2535. static struct rt_device sdcard_device;
  2536. static SD_CardInfo SDCardInfo;
  2537. static struct dfs_partition part;
  2538. static struct rt_semaphore sd_lock;
  2539. static rt_uint8_t _sdcard_buffer[SECTOR_SIZE];
  2540. /* RT-Thread Device Driver Interface */
  2541. static rt_err_t rt_sdcard_init(rt_device_t dev)
  2542. {
  2543. NVIC_InitTypeDef NVIC_InitStructure;
  2544. NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
  2545. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  2546. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  2547. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  2548. NVIC_Init(&NVIC_InitStructure);
  2549. if (rt_sem_init(&sd_lock, "sdlock", 1, RT_IPC_FLAG_FIFO) != RT_EOK)
  2550. {
  2551. rt_kprintf("init sd lock semaphore failed\n");
  2552. }
  2553. return RT_EOK;
  2554. }
  2555. static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag)
  2556. {
  2557. return RT_EOK;
  2558. }
  2559. static rt_err_t rt_sdcard_close(rt_device_t dev)
  2560. {
  2561. return RT_EOK;
  2562. }
  2563. static rt_size_t rt_sdcard_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
  2564. {
  2565. SD_Error status;
  2566. rt_uint32_t nr = size / SECTOR_SIZE;
  2567. rt_sem_take(&sd_lock, RT_WAITING_FOREVER);
  2568. /* read all sectors */
  2569. if (((rt_uint32_t)buffer % 4 != 0) ||
  2570. ((rt_uint32_t)buffer > 0x20080000))
  2571. {
  2572. rt_uint32_t index;
  2573. /* which is not alignment with 4 or chip SRAM */
  2574. for (index = 0; index < nr; index ++)
  2575. {
  2576. status = SD_ReadBlock((part.offset + index) * SECTOR_SIZE + pos,
  2577. (uint32_t*)_sdcard_buffer, SECTOR_SIZE);
  2578. if (status != SD_OK) break;
  2579. /* copy to the buffer */
  2580. rt_memcpy(((rt_uint8_t*)buffer + index * SECTOR_SIZE), _sdcard_buffer, SECTOR_SIZE);
  2581. }
  2582. }
  2583. else
  2584. {
  2585. if (nr == 1)
  2586. {
  2587. status = SD_ReadBlock(part.offset * SECTOR_SIZE + pos,
  2588. (uint32_t*)buffer, SECTOR_SIZE);
  2589. }
  2590. else
  2591. {
  2592. status = SD_ReadMultiBlocks(part.offset * SECTOR_SIZE + pos,
  2593. (uint32_t*)buffer, SECTOR_SIZE, nr);
  2594. }
  2595. }
  2596. rt_sem_release(&sd_lock);
  2597. if (status == SD_OK) return size;
  2598. rt_kprintf("read failed: %d, buffer 0x%08x\n", status, buffer);
  2599. return 0;
  2600. }
  2601. static rt_size_t rt_sdcard_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
  2602. {
  2603. SD_Error status;
  2604. rt_uint32_t nr = size / SECTOR_SIZE;
  2605. rt_sem_take(&sd_lock, RT_WAITING_FOREVER);
  2606. /* read all sectors */
  2607. if (((rt_uint32_t)buffer % 4 != 0) ||
  2608. ((rt_uint32_t)buffer > 0x20080000))
  2609. {
  2610. rt_uint32_t index;
  2611. /* which is not alignment with 4 or chip SRAM */
  2612. for (index = 0; index < nr; index ++)
  2613. {
  2614. /* copy to the buffer */
  2615. rt_memcpy(_sdcard_buffer, ((rt_uint8_t*)buffer + index * SECTOR_SIZE), SECTOR_SIZE);
  2616. status = SD_WriteBlock((part.offset + index) * SECTOR_SIZE + pos,
  2617. (uint32_t*)_sdcard_buffer, SECTOR_SIZE);
  2618. if (status != SD_OK) break;
  2619. }
  2620. }
  2621. else
  2622. {
  2623. if (nr == 1)
  2624. {
  2625. status = SD_WriteBlock(part.offset * SECTOR_SIZE + pos,
  2626. (uint32_t*)buffer, SECTOR_SIZE);
  2627. }
  2628. else
  2629. {
  2630. status = SD_WriteMultiBlocks(part.offset * SECTOR_SIZE + pos,
  2631. (uint32_t*)buffer, SECTOR_SIZE, nr);
  2632. }
  2633. }
  2634. rt_sem_release(&sd_lock);
  2635. if (status == SD_OK) return size;
  2636. rt_kprintf("write failed: %d, buffer 0x%08x\n", status, buffer);
  2637. return 0;
  2638. }
  2639. static rt_err_t rt_sdcard_control(rt_device_t dev, rt_uint8_t cmd, void *args)
  2640. {
  2641. return RT_EOK;
  2642. }
  2643. void rt_hw_sdcard_init()
  2644. {
  2645. if (SD_Init() == SD_OK)
  2646. {
  2647. SD_Error status;
  2648. rt_uint8_t *sector;
  2649. status = SD_GetCardInfo(&SDCardInfo);
  2650. if (status != SD_OK) goto __return;
  2651. status = SD_SelectDeselect((u32) (SDCardInfo.RCA << 16));
  2652. if (status != SD_OK) goto __return;
  2653. SD_EnableWideBusOperation(SDIO_BusWide_4b);
  2654. SD_SetDeviceMode(SD_DMA_MODE);
  2655. /* get the first sector to read partition table */
  2656. sector = (rt_uint8_t*) rt_malloc (512);
  2657. if (sector == RT_NULL)
  2658. {
  2659. rt_kprintf("allocate partition sector buffer failed\n");
  2660. return;
  2661. }
  2662. status = SD_ReadBlock(0, (uint32_t*)sector, 512);
  2663. if (status == SD_OK)
  2664. {
  2665. /* get the first partition */
  2666. if (dfs_filesystem_get_partition(&part, sector, 0) != 0)
  2667. {
  2668. /* there is no partition */
  2669. part.offset = 0;
  2670. part.size = 0;
  2671. }
  2672. }
  2673. else
  2674. {
  2675. /* there is no partition table */
  2676. part.offset = 0;
  2677. part.size = 0;
  2678. }
  2679. /* release sector buffer */
  2680. rt_free(sector);
  2681. /* register sdcard device */
  2682. sdcard_device.init = rt_sdcard_init;
  2683. sdcard_device.open = rt_sdcard_open;
  2684. sdcard_device.close = rt_sdcard_close;
  2685. sdcard_device.read = rt_sdcard_read;
  2686. sdcard_device.write = rt_sdcard_write;
  2687. sdcard_device.control = rt_sdcard_control;
  2688. /* no private */
  2689. sdcard_device.private = &SDCardInfo;
  2690. rt_device_register(&sdcard_device, "sd0",
  2691. RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
  2692. return;
  2693. }
  2694. __return:
  2695. rt_kprintf("sdcard init failed\n");
  2696. }