1. #include <stdio.h>
   
2. #include <stm32f4xx.h>
   
3. #include <string.h>
   
4. 
   
5. #define USE_DMA
   
6. 
   
7. int fputc(int ch, FILE *fp)
   
8. {
   
9.   if (fp == stdout)
   
10.   {
    
11.     if (ch == '\n')
    
12.     {
    
13.       while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    
14.       USART_SendData(USART1, '\r');
    
15.     }
    
16.     while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    
17.     USART_SendData(USART1, ch);
    
18.   }
    
19.   return ch;
    
20. }
    
21. 
    
22. int main(void)
    
23. {
    
24.   char *src = "01234567890123456789012345678901"; // 32个字符
    
25.   
    
26. #ifdef USE_DMA
    
27.   DMA_InitTypeDef dma;
    
28. #else
    
29.   uint8_t i;
    
30. #endif
    
31.   GPIO_InitTypeDef gpio;
    
32.   SDIO_InitTypeDef sdio;
    
33.   SDIO_DataInitTypeDef sdio_data;
    
34.   USART_InitTypeDef usart;
    
35.   
    
36.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 | RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
    
37.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO | RCC_APB2Periph_USART1, ENABLE);
    
38.   
    
39.   GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);
    
40.   GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);
    
41.   GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_SDIO);
    
42.   GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_SDIO);
    
43.   GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SDIO);
    
44.   GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_SDIO);
    
45.   GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SDIO);
    
46.   GPIO_PinAFConfig(GPIOD, GPIO_PinSource2, GPIO_AF_SDIO);
    
47.   
    
48.   gpio.GPIO_Mode = GPIO_Mode_AF;
    
49.   gpio.GPIO_OType = GPIO_OType_PP;
    
50.   gpio.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
    
51.   gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
52.   gpio.GPIO_Speed = GPIO_High_Speed;
    
53.   GPIO_Init(GPIOA, &gpio);
    
54.   
    
55.   gpio.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
    
56.   GPIO_Init(GPIOC, &gpio);
    
57.   gpio.GPIO_Pin = GPIO_Pin_2;
    
58.   GPIO_Init(GPIOD, &gpio);
    
59.   
    
60.   USART_StructInit(&usart);
    
61.   usart.USART_BaudRate = 115200;
    
62.   USART_Init(USART1, &usart);
    
63.   USART_Cmd(USART1, ENABLE);
    
64.   printf("STM32F407VE DMA\n");
    
65.   printf("strlen=%d\n", strlen(src));
    
66.   
    
67.   SDIO_SetPowerState(SDIO_PowerState_ON);
    
68.   SDIO_StructInit(&sdio);
    
69.   sdio.SDIO_BusWide = SDIO_BusWide_4b;
    
70.   sdio.SDIO_ClockDiv = 255;
    
71.   //sdio.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Enable;
    
72.   SDIO_Init(&sdio);
    
73.   SDIO_ClockCmd(ENABLE);
    
74.   //SDIO_SetSDIOOperation(ENABLE);
    
75.   
    
76. #ifdef USE_DMA
    
77.   dma.DMA_BufferSize = 8;
    
78.   dma.DMA_Channel = DMA_Channel_4;
    
79.   dma.DMA_DIR = DMA_DIR_MemoryToPeripheral;
    
80.   dma.DMA_FIFOMode = DMA_FIFOMode_Enable;
    
81.   dma.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
    
82.   dma.DMA_Memory0BaseAddr = (uint32_t)src;
    
83.   dma.DMA_MemoryBurst = DMA_MemoryBurst_INC4;
    
84.   dma.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
    
85.   dma.DMA_MemoryInc = DMA_MemoryInc_Enable;
    
86.   dma.DMA_Mode = DMA_Mode_Normal;
    
87.   dma.DMA_PeripheralBaseAddr = (uint32_t)&SDIO->FIFO;
    
88.   dma.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;
    
89.   dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
    
90.   dma.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    
91.   dma.DMA_Priority = DMA_Priority_VeryHigh;
    
92.   DMA_Init(DMA2_Stream3, &dma);
    
93.   //DMA_FlowControllerConfig(DMA2_Stream3, DMA_FlowCtrl_Peripheral);
    
94.   DMA_Cmd(DMA2_Stream3, ENABLE);
    
95. #endif
    
96.   
    
97.   sdio_data.SDIO_DataBlockSize = SDIO_DataBlockSize_32b;
    
98.   sdio_data.SDIO_DataLength = 32;
    
99.   sdio_data.SDIO_DataTimeOut = 1000000;
    
100.   sdio_data.SDIO_DPSM = SDIO_DPSM_Enable;
     
101.   sdio_data.SDIO_TransferDir = SDIO_TransferDir_ToCard;
     
102.   sdio_data.SDIO_TransferMode = SDIO_TransferMode_Block;
     
103.   SDIO_DataConfig(&sdio_data);
     
104.   
     
105. #ifdef USE_DMA
     
106.   SDIO_DMACmd(ENABLE);
     
107. #else
     
108.   for (i = 0; i < 8; i++)
     
109.   {
     
110.     while (SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) == RESET);
     
111.     SDIO_WriteData(*(uint32_t *)(src + 4 * i));
     
112.   }
     
113. #endif
     
114.   
     
115.   while (1)
     
116.   {
     
117.     if (DMA_GetFlagStatus(DMA2_Stream3, DMA_FLAG_HTIF3) == SET)
     
118.     {
     
119.       DMA_ClearFlag(DMA2_Stream3, DMA_FLAG_HTIF3);
     
120.       printf("Half transfer! remaining=%d\n", DMA_GetCurrDataCounter(DMA2_Stream3));
     
121.     }
     
122.    
     
123.     if (DMA_GetFlagStatus(DMA2_Stream3, DMA_FLAG_TCIF3) == SET)
     
124.     {
     
125.       DMA_ClearFlag(DMA2_Stream3, DMA_FLAG_TCIF3);
     
126.       printf("Transfer complete! remaining=%d\n", DMA_GetCurrDataCounter(DMA2_Stream3));
     
127.     }
     
128.    
     
129.     if (DMA_GetFlagStatus(DMA2_Stream3, DMA_FLAG_FEIF3) == SET)
     
130.     {
     
131.       DMA_ClearFlag(DMA2_Stream3, DMA_FLAG_FEIF3);
     
132.       printf("FIFO error! remaining=%d\n", DMA_GetCurrDataCounter(DMA2_Stream3));
     
133.     }
     
134.    
     
135.     if (DMA_GetFlagStatus(DMA2_Stream3, DMA_FLAG_DMEIF3) == SET)
     
136.     {
     
137.       DMA_ClearFlag(DMA2_Stream3, DMA_FLAG_DMEIF3);
     
138.       printf("Direct mode error!\n");
     
139.     }
     
140.    
     
141.     if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) == SET)
     
142.     {
     
143.       SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
     
144.       printf("SDIO data CRC failed!\n");
     
145.     }
     
146.    
     
147.     if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) == SET)
     
148.     {
     
149.       SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
     
150.       printf("SDIO data timeout!\n");
     
151.     }
     
152.    
     
153.     if (SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) == SET)
     
154.     {
     
155.       SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);
     
156.       printf("SDIO data underrun! DCOUNT=%d, NDT=%d\n", SDIO_GetDataCounter(), DMA_GetCurrDataCounter(DMA2_Stream3));
     
157.     }
     
158.   }
     
159. }
     

复制代码

注释掉USE_DMA宏定义（不使用DMA模式），数据能够发送成功，并输出：
STM32F407VE DMA
strlen=32
SDIO data timeout!
（或SDIO data CRC failed!）

但如果使用DMA方式（定义了USE_DMA），则会输出：
STM32F407VE DMA
strlen=32
Half transfer! remaining=4
SDIO data underrun! DCOUNT=16, NDT=4
也就是说，DMA在还有16字节的时候就停止工作了。这是怎么回事？

有没有谁在STM32F4单片机上成功用DMA驱动了SD卡的？

看看学习下，谢谢      

找到解决办法了。修改如下两行：

1. dma.DMA_BufferSize = 0;
   
2. 
   
3. DMA_FlowControllerConfig(DMA2_Stream3, DMA_FlowCtrl_Peripheral);
   

复制代码

也就是说，必须由SDIO来控制DMA的数据传输量。

程序运行结果为：
STM32F407VE DMA
strlen=32
Transfer complete! remaining=65527
FIFO error! remaining=65527
SDIO data CRC failed!
成功触发了TCIF中断，且(65535-65527)×4=32字节。
同时还触发了FEIF中断，提示FIFO error。

STM32F4xx_DSP_StdPeriph_Lib_V1.8.0标准外设库里面有一个SD卡的例程程序stm324x7i_eval_sdio_sd.c，其中处理DMA中断的SD_ProcessDMAIRQ函数实现如下：

/**
  * @brief  This function waits until the SDIO DMA data transfer is finished.
  * @param  None.
  * @retval None.
  */
void SD_ProcessDMAIRQ(void)
{
  if(DMA2->LISR & SD_SDIO_DMA_FLAG_TCIF)
  {
    DMAEndOfTransfer = 0x01;
    DMA_ClearFlag(SD_SDIO_DMA_STREAM, SD_SDIO_DMA_FLAG_TCIF|SD_SDIO_DMA_FLAG_FEIF);
  }
}

程序在处理TCIF中断的时候，将FEIF标志位也直接清除掉了。所以从这里可以得出结论：FIFO error错误信息可以直接忽略。


看了一下STM32F4的参考手册，里面有这两段话：
If the DMEIFx or the FEIFx flag is set due to an overrun or underrun condition, the faulty
stream is not automatically disabled and it is up to the software to disable or not the stream
by resetting the EN bit in the DMA_SxCR register. This is because there is no data loss
when this kind of errors occur.
When a FIFO overrun or underrun condition occurs, the data are not lost because the
peripheral request is not acknowledged by the stream until the overrun or underrun
condition is cleared. If this acknowledge takes too much time, the peripheral itself may
detect an overrun or underrun condition of its internal buffer and data might be lost.
所以，FIFO error错误的产生原因是DMA本身的FIFO暂时出现了underrun/overrun的错误，此时DMA不会对SDIO的DMA请求发出确认，这是一个可自恢复的、不会影响数据传输的错误。

接收数据时，除了dma.DMA_DIR = DMA_DIR_PeripheralToMemory外，其他的配置都是一样的，也是必须由SDIO来控制DMA传输量。接收数据不会导致FIFO error错误，所以不需要清除FEIF标志位。

mark mark