RT-Thread-stm32f207ve+spi+dma驱动求帮助RT-Thread问答社区

stm32f207ve+spi+dma驱动求帮助

发布于 2016-09-08 18:51:15 浏览：3566 订阅该版

这几天在调试spi dma驱动，flash是sst25vf016b，直接while读写都没有问题，但是dma就是不行，
搞了几天没有思路来，希望有高手有空帮忙看看代码指点一下。
```
#include <rtthread.h>
#include <string.h>
#include <stm32f2xx_gpio.h>
#include <stm32f2xx_spi.h>

/* 定义操作SST25VF016B所需的数据 */
typedef enum ERTYPE{Sec1,Sec8,Sec16,Chip} ErType;  
typedef enum IDTYPE{Manu_ID,Dev_ID,Jedec_ID} idtype;
DMA_InitTypeDef  SPIDMA_InitStructure;
static int dma_lock = 1;
uint8_t rx_buffer[128],tx_buffer[128]={1,2,3,4,5,6,7,8,9,0,0,9,8,7,6,5,4,3,2,1};

/* Private define ------------------------------------------------------------*/
#define MAX_ADDR		0x1FFFFF	/* 定义芯片内部最大地址 */
#define	SEC_MAX     	511         /* 定义最大扇区号 */
#define SEC_SIZE		0x1000      /* 扇区大小	*/

#define DMA_FLAG_ALL5			(DMA_FLAG_FEIF5|DMA_FLAG_DMEIF5|DMA_FLAG_TEIF5|DMA_FLAG_TCIF5)
#define DMA_FLAG_ALL0			(DMA_FLAG_FEIF0|DMA_FLAG_DMEIF0|DMA_FLAG_TEIF0|DMA_FLAG_TCIF0)
#define DMA_IT_ALL 				(DMA_IT_TC|DMA_IT_TE|DMA_IT_DME|DMA_IT_TE)
#define SST_SPI_DMA_Channel		DMA_Channel_0
#define SST_SPI_RX_DMA_Stream	DMA1_Stream0
#define SST_SPI_RX_DMA_IRQ  	DMA1_Stream0_IRQn
#define SST_SPI_RX_DMA_FLAG    	DMA_IT_TCIF0
#define SST_SPI_TX_DMA_Stream	DMA1_Stream5
#define SST_SPI_TX_DMA_IRQ  	DMA1_Stream5_IRQn
#define SST_SPI_TX_DMA_FLAG    	DMA_IT_TCIF5
#define SST_SPI_DR_Address     	(uint32_t)(SPI3_BASE+0x0C)

//SPI片选
#define SPI_FLASH_CS_LOW()     {GPIO_ResetBits(GPIOC, GPIO_Pin_2);}
#define SPI_FLASH_CS_HIGH()     {GPIO_SetBits(GPIOC, GPIO_Pin_2);}

void dump_spi3(void)
{
	rt_kprintf("SPI register:
");
	rt_kprintf("CR1:    %04x
",SPI3->CR1);
	rt_kprintf("CR2:    %04x
",SPI3->CR2);
	rt_kprintf("SR:     %04x
",SPI3->SR);
	rt_kprintf("DR:     %04x
",SPI3->DR);
	rt_kprintf("CRCPR:  %04x
",SPI3->CRCPR);
	rt_kprintf("RXCRCR: %04x
",SPI3->RXCRCR);
	rt_kprintf("TXCRCR: %04x
",SPI3->TXCRCR);
	rt_kprintf("I2SCFGR:%04x
",SPI3->I2SCFGR);
	rt_kprintf("I2SPR:  %04x
",SPI3->I2SPR);	
}

void dump_dma_rxtx(DMA_Stream_TypeDef* DMAy_Streamx)
{
	rt_kprintf("CR:  %08x
",DMAy_Streamx->CR);
	rt_kprintf("NDTR:%08x
",DMAy_Streamx->NDTR);
	rt_kprintf("PAR: %08x
",DMAy_Streamx->PAR);
	rt_kprintf("M0AR:%08x
",DMAy_Streamx->M0AR);
	rt_kprintf("M1AR:%08x
",DMAy_Streamx->M1AR);
	rt_kprintf("FCR: %08x
",DMAy_Streamx->FCR);
}
void dump_dma(void)
{
	rt_kprintf("DMA register:
");
	rt_kprintf("LISR: %08x
",DMA1->LISR);
	rt_kprintf("HISR: %08x
",DMA1->HISR);
	rt_kprintf("LIFCR:%08x
",DMA1->LIFCR);
	rt_kprintf("HIFCR:%08x
",DMA1->HIFCR);

rt_kprintf("TXStream register:
");
	dump_dma_rxtx(SST_SPI_TX_DMA_Stream);
	
	rt_kprintf("RXStream register:
");
	dump_dma_rxtx(SST_SPI_RX_DMA_Stream);
}
void dump_reg(void)
{	
	dump_spi3();
	dump_dma();
}
/*******************************************************************************
* Function Name  : SPI_FLASH_Init
* Description    : 初始化控制SSI的管脚
* Input          : None
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
void spi_dma_flash_init(void)
{
	SPI_InitTypeDef  SPI_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	
    // Enable SPI and GPIO clocks
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
	
	GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SPI3);        
	GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SPI3); 
	GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SPI3); 
    //SPI口初始化 Set PC10,11,12 as Output push-pull - SCK, MISO and MOSI
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_UP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);   //使能GPIO的时钟
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;      
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
	SPI_FLASH_CS_HIGH();	//拉高片选信号
	
	/* SPI Config -------------------------------------------------------------*/ 	
	SPI_DeInit(SPI3);	
	SPI_Cmd(SPI3, DISABLE);
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; 
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; 
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
	SPI_InitStructure.SPI_CRCPolynomial = 7;
	SPI_Init(SPI3, &SPI_InitStructure);
	SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Rx, ENABLE);
	SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Tx, ENABLE);
	
	/* Enable SPI3 */ 
	SPI_Cmd(SPI3, ENABLE); 
	dump_spi3();

/* Configure and enable I2C1 DMA interrupt -------------------------------*/  
	NVIC_InitStructure.NVIC_IRQChannel = SST_SPI_RX_DMA_IRQ;
	NVIC_Init(&NVIC_InitStructure);

NVIC_InitStructure.NVIC_IRQChannel = SST_SPI_TX_DMA_IRQ;
	NVIC_Init(&NVIC_InitStructure);
	
	/* Enable the DMA1 clock */
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
	
	/* SPI3 TX DMA Channel configuration */
	DMA_Cmd(SST_SPI_RX_DMA_Stream, DISABLE);
    DMA_DeInit(SST_SPI_RX_DMA_Stream);
	SPIDMA_InitStructure.DMA_Channel = SST_SPI_DMA_Channel;
    SPIDMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SST_SPI_DR_Address;
    SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)0;   /* This parameter will be configured durig communication */
    SPIDMA_InitStructure.DMA_BufferSize = 0;            /* This parameter will be configured durig communication */
    SPIDMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;    
    SPIDMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    SPIDMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    SPIDMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;	
    SPIDMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    SPIDMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    SPIDMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
	SPIDMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
	SPIDMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;
	SPIDMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
	SPIDMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    DMA_Init(SST_SPI_RX_DMA_Stream, &SPIDMA_InitStructure);
	DMA_ITConfig( SST_SPI_RX_DMA_Stream, DMA_IT_ALL, ENABLE);
	rt_kprintf("RXStream register:
");
	dump_dma_rxtx(SST_SPI_RX_DMA_Stream);

/* SPI3 RX DMA Channel configuration */
	DMA_Cmd(SST_SPI_TX_DMA_Stream, DISABLE);
    DMA_DeInit(SST_SPI_TX_DMA_Stream);
	SPIDMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
	SPIDMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_Init(SST_SPI_TX_DMA_Stream, &SPIDMA_InitStructure); 
	DMA_ITConfig( SST_SPI_TX_DMA_Stream, DMA_IT_ALL, ENABLE);
	rt_kprintf("TXStream register:
");
	dump_dma_rxtx(SST_SPI_TX_DMA_Stream);

rt_kprintf("spi_dma_flash_init
");
}

void spi_dma_start(DMA_Stream_TypeDef* DMAy_Streamx, uint8_t* pBuffer, uint32_t BufferSize)
{
	SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)pBuffer;   /* This parameter will be configured durig communication */
    SPIDMA_InitStructure.DMA_BufferSize = BufferSize;            	/* This parameter will be configured durig communication */
	DMA_Init(DMAy_Streamx, &SPIDMA_InitStructure);
	DMA_Cmd(DMAy_Streamx, ENABLE);
	dma_lock = 1;
}
/*******************************************************************************
* Function Name  : Flash_ReadWriteByte
* Description    : 通过硬件SPI发送一个字节到SST25VF016B
* Input          : - data: 发送的数据
* Output         : None
* Return         : SST25VF016B 返回的数据
* Attention		 : None
*******************************************************************************/
static uint8_t flash_read_write(uint8_t data)		
{
  /* Loop while DR register in not emplty */
  while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_TXE) == RESET);

/* Send byte through the SPI3 peripheral */
  SPI_I2S_SendData(SPI3, data);
    
  /* Wait to receive a byte */
  while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_RXNE) == RESET);

/* Return the byte read from the SPI bus */
  return SPI_I2S_ReceiveData(SPI3);                                              
}

void DMA1_Stream0_IRQHandler(void)
{
	rt_interrupt_enter();
	if (DMA_GetITStatus(SST_SPI_RX_DMA_Stream, DMA_IT_TCIF0))
    {
	    rt_kprintf("RXTC
");
		DMA_Cmd(SST_SPI_RX_DMA_Stream, DISABLE);
		
    } else
		rt_kprintf("Unknow S0 IRQ
");

/* clear DMA flag */
	DMA_ClearFlag(SST_SPI_RX_DMA_Stream, DMA_FLAG_ALL0);
	rt_interrupt_leave();
	dma_lock = 0;
}

void DMA1_Stream5_IRQHandler(void)
{
	rt_interrupt_enter();
	if (DMA_GetITStatus(SST_SPI_TX_DMA_Stream, DMA_IT_TCIF5))
    {
		rt_kprintf("TXTC
");
		DMA_Cmd(SST_SPI_TX_DMA_Stream, DISABLE);
    } else
		rt_kprintf("Unknow S5 IRQ
");

/* clear DMA flag */
	DMA_ClearFlag(SST_SPI_TX_DMA_Stream, DMA_FLAG_ALL5);
	rt_interrupt_leave();
	dma_lock = 0;
}

uint8_t sst_dma_rd(uint32_t Dst, uint8_t* RcvBufPt ,uint32_t NByte)
{
//	uint32_t wait = 10;
	SPI_InitTypeDef  SPI_InitStructure;
	
	if ((Dst+NByte > MAX_ADDR)||(NByte == 0))	return (ERROR);	 /*	检查入口参数 */
	
    SPI_FLASH_CS_LOW();
	flash_read_write(0x0B); 						/* 发送读命令 */
	flash_read_write(((Dst & 0xFFFFFF) >> 16));	/* 发送地址信息:该地址由3个字节组成	*/
	flash_read_write(((Dst & 0xFFFF) >> 8));
	flash_read_write(Dst & 0xFF);	
	flash_read_write(0xFF);						/* 发送一个哑字节以读取数据	*/
	
	dump_reg();
	spi_dma_start(SST_SPI_RX_DMA_Stream,RcvBufPt,NByte);
	spi_dma_start(SST_SPI_TX_DMA_Stream,tx_buffer,NByte);	
	while(dma_lock)
		rt_thread_delay(1);	
        SPI_FLASH_CS_HIGH();
	dump_reg();
	
	return (ENABLE);
}

uint8_t sst_dma_wr(uint32_t Dst, uint8_t* SndbufPt,uint32_t NByte)
{
	uint8_t temp = 0,StatRgVal = 0;
	uint32_t i = 0;
	
	if (( (Dst+NByte-1 > MAX_ADDR)||(NByte == 0) ))
	{
		return (ERROR);	 /*	检查入口参数 */
	}
	
	SPI_FLASH_CS_LOW();				 
	flash_read_write(0x05);							    /* 发送读状态寄存器命令	*/
	temp = flash_read_write(0xFF);					    /* 保存读得的状态寄存器值 */
	SPI_FLASH_CS_HIGH();

SPI_FLASH_CS_LOW();				
	flash_read_write(0x50);							    /* 使状态寄存器可写	*/
	SPI_FLASH_CS_HIGH();	
		
	SPI_FLASH_CS_LOW();				
	flash_read_write(0x01);							    /* 发送写状态寄存器指令 */
	flash_read_write(0);								    /* 清0BPx位，使Flash芯片全区可写 */
	SPI_FLASH_CS_HIGH();			
	
	for(i = 0; i < NByte; i++)
	{
		SPI_FLASH_CS_LOW();				
		flash_read_write(0x06);						    /* 发送写使能命令 */
		SPI_FLASH_CS_HIGH();

SPI_FLASH_CS_LOW();					
		flash_read_write(0x02); 						    /* 发送字节数据烧写命令	*/
		flash_read_write((((Dst+i) & 0xFFFFFF) >> 16));  /* 发送3个字节的地址信息 */
		flash_read_write((((Dst+i) & 0xFFFF) >> 8));
		flash_read_write((Dst+i) & 0xFF);
		flash_read_write(SndbufPt*);					/* 发送被烧写的数据	*/
		SPI_FLASH_CS_HIGH();

do
		{
		  	SPI_FLASH_CS_LOW();					 
			flash_read_write(0x05);					    /* 发送读状态寄存器命令 */
			StatRgVal = flash_read_write(0xFF);			/* 保存读得的状态寄存器值 */
			SPI_FLASH_CS_HIGH();							
  		}
		while (StatRgVal == 0x03 );					          /* 一直等待，直到芯片空闲	*/

}

SPI_FLASH_CS_LOW();					
	flash_read_write(0x06);							    /* 发送写使能命令 */
	SPI_FLASH_CS_HIGH();

SPI_FLASH_CS_LOW();					
	flash_read_write(0x50);							    /* 使状态寄存器可写	*/
	SPI_FLASH_CS_HIGH();
			
	SPI_FLASH_CS_LOW();				
	flash_read_write(0x01);							    /* 发送写状态寄存器指令 */
	flash_read_write(temp);						     	/* 恢复状态寄存器设置信息 */
	SPI_FLASH_CS_HIGH();

return (ENABLE);		
}

void sst_dma_read(int len)
{
	int i;

if(len >= 128){
		rt_kprintf("there is no enough buffer.
");
	}

sst_dma_rd(0,rx_buffer,len);
	rx_buffer[len] = 0;
	//rt_kprintf("%d bytes:%s
",len,buffer);
	rt_kprintf("%d bytes:",len);
	for(i = 0; i < len; i++)
		rt_kprintf("%x",rx_buffer*);
	rt_kprintf("
**");
}

extern uint8_t SSTF016B_Erase(uint32_t sec1, uint32_t sec2);
void sst_dma_write(char *str)
{
	int len;
	len = strlen(str);

SSTF016B_Erase(0, len/SEC_SIZE + 1);
	sst_dma_wr(0, str, len);
	rt_kprintf("write finish.
");
}

#ifdef RT_USING_FINSH
#include <finsh.h>
FINSH_FUNCTION_EXPORT(dump_reg, read spi register);
FINSH_FUNCTION_EXPORT(sst_dma_read, read SST25 data);
FINSH_FUNCTION_EXPORT(sst_dma_write, write SST25 data);
#endif
```