RL-FlashFS V6.X提供的H7版CMSIS-Driver驱动并不支持eMMC，得自己修改实现

eric2013

当前提供的这个MCI_STM32H7XXX驱动文件仅支持SD卡，实际测试并不支持eMMC。

这个自己修改还是有点难度的，而使用老版本的RL-FlashFS好修改些。

之前F4的驱动写法：

1. #define __DRV_ID   mci0_drv
   
2. #define __SDIOCLK  48000000
   
3. #define __CPUCLK  168000000
   
4. 
   
5. /* MCI Driver Interface functions */
   
6. static BOOL Init (void);
   
7. static BOOL UnInit (void);
   
8. static void Delay (U32 us);
   
9. static BOOL BusMode (U32 mode);
   
10. static BOOL BusWidth (U32 width);
    
11. static BOOL BusSpeed (U32 kbaud);
    
12. static BOOL Command (U8 cmd, U32 arg, U32 resp_type, U32 *rp);
    
13. static BOOL ReadBlock (U32 bl, U8 *buf, U32 cnt);
    
14. static BOOL WriteBlock (U32 bl, U8 *buf, U32 cnt);
    
15. static BOOL SetDma (U32 mode, U8 *buf, U32 cnt);
    
16. static U32  CheckMedia (void);        /* Optional function for SD card check  */
    
17. void SD_Link_EXTIConfig(void);
    
18. 
    
19. /* MCI Device Driver Control Block */
    
20. MCI_DRV __DRV_ID = {
    
21.   Init,
    
22.   UnInit,
    
23.   Delay,
    
24.   BusMode,
    
25.   BusWidth,
    
26.   BusSpeed,
    
27.   Command,
    
28.   ReadBlock,
    
29.   WriteBlock,
    
30.   SetDma,
    
31.   CheckMedia                            /* Can be NULL if not existing        */
    
32. };
    
33. 
    
34. 
    
35. /* Wait time in for loop cycles */
    
36. #define DMA_TOUT  10000000
    
37. 
    
38. /*--------------------------- Init -------------------------------------------*/
    
39. 
    
40. static BOOL Init (void) {
    
41.   /* Initialize SDIO interface. */
    
42.   /* Enable GPIOE (card detect), GPIOD (command), GPIOC (data) clock */
    
43.   RCC->AHB1ENR |= RCC_AHB1ENR_GPIOEEN |
    
44.                   RCC_AHB1ENR_GPIODEN |
    
45.                   RCC_AHB1ENR_GPIOCEN;
    
46. 
    
47.   RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
    
48.   /* Enable IO compensation cell */
    
49.   SYSCFG->CMPCR |= SYSCFG_CMPCR_CMP_PD;
    
50.   while (!(SYSCFG->CMPCR & SYSCFG_CMPCR_READY));
    
51. 
    
52.   /* PC.08, PC.09, PC.10, PC.11, PC.12 pin: D0, D1, D2, D3, CLK pin */
    
53.   GPIOC->MODER   &= ~0x03FF0000;
    
54.   GPIOC->MODER   |=  0x02AA0000;        /* Pins to alternate function         */
    
55.   GPIOC->OTYPER  &= ~0x00001F00;        /* Configure as push-pull pins        */
    
56.   GPIOC->PUPDR   &= ~0x03FF0000;
    
57.   GPIOC->PUPDR   |=  0x01550000;        /* Pull-ups on pins                   */
    
58.   GPIOC->OSPEEDR |=  0x03FF0000;        /* Pins output speed to 100MHz        */
    
59. 
    
60.   GPIOC->AFR[1]  &= ~0x000FFFFF;
    
61.   GPIOC->AFR[1]  |=  0x000CCCCC;        /* Pins assigned to AF12 (SDIO)       */
    
62. 
    
63.   /* Configure PD.02 CMD line */
    
64.   GPIOD->MODER   &= ~0x0000030;
    
65.   GPIOD->MODER   |=  0x0000020;         /* Pins to alternate function         */
    
66.   GPIOD->OTYPER  &= ~0x0000004;         /* Configure as push-pull pin         */
    
67.   GPIOD->PUPDR   &= ~0x0000030;
    
68.   GPIOD->PUPDR   |=  0x0000010;         /* Pull-up on pin                     */      
    
69.   GPIOD->OSPEEDR |=  0x0000030;         /* Pins output speed to 100MHz        */
    
70. 
    
71.   GPIOD->AFR[0]  &= ~0x00000F00;
    
72.   GPIOD->AFR[0]  |=  0x00000C00;        /* Pin assigned to AF12 (SDIO)        */
    
73. 
    
74.   /* Configure PE.2 Card Detect input */
    
75.   SD_Link_EXTIConfig();
    
76. 
    
77.   /* Enable SDIO clock */
    
78.   RCC->APB2ENR  |=  RCC_APB2ENR_SDIOEN;
    
79. 
    
80.   /* Reset/Dereset SDIO */
    
81.   RCC->APB2RSTR |=  RCC_APB2RSTR_SDIORST;
    
82.   RCC->APB2RSTR &= ~RCC_APB2RSTR_SDIORST;
    
83. 
    
84.   /* Power-on, the card is clocked */
    
85.   SDIO->POWER  = SDIO_POWER_PWRCTRL_1 | SDIO_POWER_PWRCTRL_0;
    
86. 
    
87.     /* Enable DMA2 clock */
    
88.   RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;
    
89. 
    
90.   /* Success, SDIO initialized. */
    
91.   return (__TRUE);
    
92. }
    
93. 
    
94. 
    
95. /*--------------------------- UnInit -----------------------------------------*/
    
96. 
    
97. static BOOL UnInit (void) {
    
98. 
    
99.   /* Reset PC.8, PC.9, PC.10, PC.11, PC.12 pins */
    
100.   GPIOC->MODER &= ~0x03FF0000;
     
101.   /* Reset PD.2 */
     
102.   GPIOD->MODER &= ~(3 <<  4);
     
103. 
     
104.   /* Disable SDIO module clock */
     
105.   RCC->APB2ENR &= ~RCC_APB2ENR_SDIOEN;
     
106. 
     
107.   return (__TRUE);
     
108. }
     
109. 
     
110. 
     
111. /*--------------------------- Delay ------------------------------------------*/
     
112. 
     
113. static void Delay (U32 us) {
     
114.   /* Approximate delay in micro seconds. */
     
115.   U32 i;
     
116. 
     
117.   for (i = WAIT_CNT(__CPUCLK, us); i; i--);
     
118. }
     
119. 
     
120. 
     
121. /*--------------------------- BusMode ----------------------------------------*/
     
122. 
     
123. static BOOL BusMode (U32 mode) {
     
124.   /* Set SDIO Bus mode to Open Drain or Push Pull. */
     
125. 
     
126.   switch (mode) {
     
127.     case BUS_OPEN_DRAIN:
     
128.       GPIOD->OTYPER  |=  0x00000010;    /* Configure as open-drain            */
     
129.       return (__TRUE);
     
130. 
     
131.     case BUS_PUSH_PULL:
     
132.       GPIOD->OTYPER  &= ~0x00000010;    /* Configure as push-pull pin         */
     
133.       return (__TRUE);
     
134.    
     
135.     default:
     
136.       return (__FALSE);
     
137.   }
     
138. }
     
139. 
     
140. 
     
141. /*--------------------------- BusWidth ---------------------------------------*/
     
142. 
     
143. static BOOL BusWidth (U32 width) {
     
144.   /* Set SDIO Bus width. */
     
145. 
     
146.   switch (width) {
     
147.     case 1:
     
148.       SDIO->CLKCR &= ~SDIO_CLKCR_WIDBUS;
     
149.       return (__TRUE);
     
150. 
     
151.     case 4:
     
152. #ifdef __XYNERGY
     
153.       return (__FALSE);
     
154. #else
     
155.       SDIO->CLKCR |=  SDIO_CLKCR_WIDBUS_0;
     
156.       return (__TRUE);
     
157. #endif
     
158.    
     
159.     default:
     
160.       return (__FALSE);
     
161.   }
     
162. }
     
163. 
     
164. 
     
165. /*--------------------------- BusSpeed ---------------------------------------*/
     
166. 
     
167. static BOOL BusSpeed (U32 kbaud) {
     
168.   /* Set SDIO clock speed to desired value. */
     
169.   U32 div;
     
170. 
     
171.   /* baud = SDIOCLK / (div + 2) */
     
172.   div = (__SDIOCLK/1000 + kbaud - 1) / kbaud;
     
173.   if (div < 2)    div  = 0;
     
174.   else            div -= 2;
     
175.   if (div > 0xFF) div  = 0xFF;
     
176.   SDIO->CLKCR = (SDIO->CLKCR & ~0xFF) | SDIO_CLKCR_PWRSAV | SDIO_CLKCR_CLKEN | div;
     
177.   return (__TRUE);
     
178. }
     
179. 
     
180. 
     
181. /*--------------------------- Command ----------------------------------------*/
     
182. 
     
183. static BOOL Command (U8 cmd, U32 arg, U32 resp_type, U32 *rp) {
     
184.   /* Send a Command to Flash card and get a Response. */
     
185.   U32 cmdval,stat;
     
186. 
     
187.   cmd   &= SDIO_CMD_CMDINDEX;
     
188.   cmdval = SDIO_CMD_CPSMEN | cmd;
     
189.   switch (resp_type) {
     
190.     case RESP_SHORT:
     
191.       cmdval |= SDIO_CMD_WAITRESP_0;
     
192.       break;
     
193.     case RESP_LONG:
     
194.       cmdval |= SDIO_CMD_WAITRESP_1 | SDIO_CMD_WAITRESP_0;
     
195.       break;
     
196.   }
     
197.   /* Send the command. */
     
198.   SDIO->ARG = arg;
     
199.   SDIO->CMD = cmdval;
     
200. 
     
201.   if (resp_type == RESP_NONE) {
     
202.     /* Wait until command finished. */
     
203.     while (SDIO->STA & SDIO_STA_CMDACT);
     
204.     stat = SDIO->STA;
     
205.     SDIO->ICR = 0x00C007FF;
     
206.     if (stat & SDIO_STA_CMDSENT) {
     
207.       return (__TRUE);
     
208.     }
     
209.     return (__FALSE);   
     
210.   }
     
211. 
     
212.   for (;;) {
     
213.     stat = SDIO->STA;
     
214.     if (stat & SDIO_STA_CTIMEOUT) {
     
215.       SDIO->ICR = stat & SDIO_STA_CLEAR_MASK;
     
216.       return (__FALSE);
     
217.     }
     
218.     if (stat & SDIO_STA_CCRCFAIL) {
     
219.       SDIO->ICR = stat & SDIO_STA_CLEAR_MASK;
     
220.       if ((cmd == SEND_OP_COND)      ||
     
221.           (cmd == SEND_APP_OP_COND)  ||
     
222.           (cmd == STOP_TRANS)) {
     
223.         SDIO->CMD = 0;
     
224.         break;
     
225.       }
     
226.       return (__FALSE);
     
227.     }
     
228.     if (stat & SDIO_STA_CMDREND) {
     
229.       SDIO->ICR = stat & SDIO_STA_CLEAR_MASK;
     
230.       break;
     
231.     }
     
232.   }
     
233.   if ((SDIO->RESPCMD & 0x3F) != cmd) {
     
234.     if ((SDIO->RESPCMD & 0x3F) != 0x3F) {
     
235.       return (__FALSE);
     
236.     }
     
237.   }
     
238.   /* Read MCI response registers */
     
239.   rp[0] = SDIO->RESP1;
     
240.   if (resp_type == RESP_LONG) {
     
241.     rp[1] = SDIO->RESP2;
     
242.     rp[2] = SDIO->RESP3;
     
243.     rp[3] = SDIO->RESP4;
     
244.   }
     
245.   return (__TRUE);
     
246. }
     
247. 
     
248. 
     
249. /*--------------------------- ReadBlock --------------------------------------*/
     
250. 
     
251. static BOOL ReadBlock (U32 bl, U8 *buf, U32 cnt) {
     
252.   /* Read one or more 512 byte blocks from Flash Card. */
     
253.   U32 i;
     
254. 
     
255.   SDIO->DLEN    = cnt * 512;
     
256.   SDIO->DTIMER  = cnt * DATA_RD_TOUT_VALUE;
     
257. 
     
258.   SDIO->DCTRL   = SDIO_DCTRL_DBLOCKSIZE_3 | SDIO_DCTRL_DBLOCKSIZE_0 |
     
259.                   SDIO_DCTRL_DMAEN        | SDIO_DCTRL_DTDIR        |
     
260.                   SDIO_DCTRL_DTEN         ;
     
261. 
     
262.   for (i = DMA_TOUT; i; i--) {   
     
263.     if (DMA2->LISR & DMA_LISR_TEIF3) {
     
264.       break;
     
265.     }
     
266.    
     
267.     if (DMA2->LISR & DMA_LISR_TCIF3) {
     
268.       if ((SDIO->STA & (SDIO_STA_DBCKEND|SDIO_STA_DATAEND)) == (SDIO_STA_DBCKEND|SDIO_STA_DATAEND)) {
     
269.         /* Data transfer finished. */
     
270.         return (__TRUE);
     
271.       }
     
272.     }
     
273.   }
     
274.   /* DMA Transfer timeout. */
     
275.   return (__FALSE);
     
276. }
     
277. 
     
278. 
     
279. /*--------------------------- WriteBlock -------------------------------------*/
     
280. 
     
281. static BOOL WriteBlock (U32 bl, U8 *buf, U32 cnt) {
     
282.   /* Write a cnt number of 512 byte blocks to Flash Card. */
     
283.   U32 i;
     
284. 
     
285.   SDIO->DLEN    = cnt * 512;
     
286.   SDIO->DTIMER  = cnt * DATA_WR_TOUT_VALUE;
     
287.   SDIO->DCTRL   = SDIO_DCTRL_DBLOCKSIZE_3 | SDIO_DCTRL_DBLOCKSIZE_0 |
     
288.                   SDIO_DCTRL_DMAEN        | SDIO_DCTRL_DTEN         ;
     
289. 
     
290.   for (i = DMA_TOUT; i; i--) {
     
291.     if (DMA2->LISR & DMA_LISR_TEIF3) {
     
292.       break;
     
293.     }
     
294.    
     
295.     if (DMA2->LISR & DMA_LISR_TCIF3) {
     
296.       if ((SDIO->STA & (SDIO_STA_DBCKEND|SDIO_STA_DATAEND)) == (SDIO_STA_DBCKEND|SDIO_STA_DATAEND)) {
     
297.         /* Data transfer finished. */
     
298.         return (__TRUE);
     
299.       }
     
300.     }
     
301.   }
     
302.   /* DMA Transfer timeout. */
     
303.   return (__FALSE);
     
304. }
     
305. 
     
306. 
     
307. /*--------------------------- DmaStart ---------------------------------------*/
     
308. 
     
309. static BOOL SetDma (U32 mode, U8 *buf, U32 cnt) {
     
310.   /* Configure DMA Channel 4, Stream 3 for read or write */
     
311. 
     
312.   DMA2->LIFCR = 0x0F4 << 20;                   /* Clear all IRQs              */
     
313. 
     
314.   DMA2_Stream3->CR  &= ~DMA_SxCR_EN;           /* Disable stream 3            */
     
315.   while (DMA2_Stream3->CR & DMA_SxCR_EN);      /* Wait until stream disabled  */
     
316. 
     
317.   DMA2_Stream3->FCR |=  DMA_SxFCR_DMDIS |      /* Disable direct mode         */
     
318.                         DMA_SxFCR_FTH   ;      /* FIFO threshold full         */
     
319. 
     
320.   DMA2_Stream3->PAR  = (U32)&(SDIO->FIFO);
     
321.   DMA2_Stream3->M0AR = (U32)buf;
     
322. 
     
323.   if (mode == DMA_READ) {
     
324.     /* Transfer from SDIO-FIFO to memory. */
     
325.     DMA2_Stream3->CR = (4 << 25) |             /* Use channel 4               */
     
326.                        (1 << 23) |             /* Memory burst 4 beats        */
     
327.                        (1 << 21) |             /* Peripheral burst 4 beats    */
     
328.                        (3 << 16) |             /* Priority level high         */
     
329.                        (2 << 13) |             /* Memory size 32-bits         */
     
330.                        (2 << 11) |             /* Peripheral size 32-bits     */
     
331.                        (1 << 10) |             /* Memory addr increment       */
     
332.                        (1 <<  5) ;             /* Peripheral flow control     */
     
333.   }
     
334.   else {
     
335.     /* Transfer from memory to SDIO-FIFO. */
     
336.     DMA2_Stream3->CR = (4 << 25) |             /* Use channel 4               */
     
337.                        (1 << 23) |             /* Memory burst 4 beats        */
     
338.                        (1 << 21) |             /* Peripheral burst 4 beats    */
     
339.                        (3 << 16) |             /* Priority level very high    */
     
340.                        (2 << 13) |             /* Memory size 32-bits         */
     
341.                        (2 << 11) |             /* Peripheral size 32-bits     */
     
342.                        (1 << 10) |             /* Memory addr increment       */
     
343.                        (1 <<  6) |             /* Memory-to-peripheral        */
     
344.                        (1 <<  5) ;             /* Peripheral flow control     */
     
345.   }
     
346. 
     
347.   /* Enable DMA channels, little endian */
     
348.   DMA2_Stream3->CR  |= DMA_SxCR_EN;            /* Enable stream 3             */
     
349.   return __TRUE;
     
350. }
     
351. 
     
352. 
     
353. /*--------------------------- CheckMedia -------------------------------------*/
     
354. 
     
355. static U32 CheckMedia (void) {
     
356.   /* Read CardDetect and WriteProtect SD card socket pins. */
     
357.   U32 stat = 0;
     
358. 
     
359.   if (!(GPIOE->IDR & (1 << 2))) {
     
360.     /* Card is inserted (CD=0). */
     
361.     stat |= M_INSERTED;
     
362.   }
     
363. 
     
364. #if 0
     
365.   if (/* Write protect switch is active */) {
     
366.     stat |= M_PROTECTED;
     
367.   }
     
368. #endif
     
369. 
     
370.   return (stat);
     
371. }

复制代码

chengying

后续不知道会不会支持这个emmc

eric2013

chengying 发表于 2019-12-24 14:26
后续不知道会不会支持这个emmc

我已经改用fatfs做eMMC的fat了。

CMSIS-Driver当前提供的这个驱动接口，不太好修改，改了一次没成功。