stm32f407硬件spi读写sst25vf闪存flash代码

1. #ifndef __SPI_FLASH_H
   
2. #define __SPI_FLASH_H
   
3. 
   
4. /* Includes ------------------------------------------------------------------*/
   
5. #include "stm324xg_eval.h"
   
6. 
   
7. 
   
8. /* Private typedef -----------------------------------------------------------*/
   
9. #define SPI_FLASH_PageSize    0x100
   
10. 
    
11. /* Private define ------------------------------------------------------------*/
    
12. #define WRITE      0x02  /* Write to Memory instruction */
    
13. #define WRSR       0x01  /* Write Status Register instruction */
    
14. #define WREN       0x06  /* Write enable instruction */
    
15. #define WRDI       0x04  /* Write disable instruction */
    
16. 
    
17. #define READ       0x03  /* Read from Memory instruction */
    
18. #define RDSR       0x05  /* Read Status Register instruction  */
    
19. #define RDID       0x9F  /* Read identification */
    
20. #define SE         0xD8  /* Sector Erase instruction */
    
21. #define BE         0xC7  /* Bulk Erase instruction */
    
22. #define CE         0x60  /* Chip Erase instruction */
    
23. #define EWSR       0x50  /* Enable Write Status Register instruction */
    
24. 
    
25. #define WIP_Flag   0x01  /* Write In Progress (WIP) flag */
    
26. 
    
27. #define Dummy_Byte 0xA5
    
28. 
    
29. #define countof(a) (sizeof(a) / sizeof(*(a)))
    
30. /*for M25P64 SERIAL FLASH---------------------------------------------------*/
    
31. #define  FLASH_WriteAddress     0x700000
    
32. #define  FLASH_ReadAddress      FLASH_WriteAddress
    
33. #define  FLASH_SectorToErase    FLASH_WriteAddress
    
34. #define  M25P64_FLASH_ID        0x202017
    
35. #define  BufferSize (countof(Tx_Buffer)-1)
    
36. 
    
37. #define FLASH_SPI                       SPI1
    
38. #define FLASH_SPI_CLK                   RCC_APB2Periph_SPI1
    
39. 
    
40. #define FLASH_SPI_SCK_PIN               GPIO_Pin_5                  /* PA.05 */
    
41. #define FLASH_SPI_SCK_GPIO_PORT         GPIOA                       /* GPIOA */
    
42. #define FLASH_SPI_SCK_GPIO_CLK          RCC_AHB1Periph_GPIOA
    
43. #define FLASH_SPI_SCK_SOURCE            GPIO_PinSource5
    
44. #define FLASH_SPI_SCK_AF                GPIO_AF_SPI1
    
45. 
    
46. #define FLASH_SPI_MISO_PIN              GPIO_Pin_6                  
    
47. #define FLASH_SPI_MISO_GPIO_PORT        GPIOA                     
    
48. #define FLASH_SPI_MISO_GPIO_CLK         RCC_AHB1Periph_GPIOA
    
49. #define FLASH_SPI_MISO_SOURCE           GPIO_PinSource6
    
50. #define FLASH_SPI_MISO_AF               GPIO_AF_SPI1
    
51. 
    
52. #define FLASH_SPI_MOSI_PIN              GPIO_Pin_5                  /* PB.5 */
    
53. #define FLASH_SPI_MOSI_GPIO_PORT        GPIOB                       /* GPIOB */
    
54. #define FLASH_SPI_MOSI_GPIO_CLK         RCC_AHB1Periph_GPIOB
    
55. #define FLASH_SPI_MOSI_SOURCE           GPIO_PinSource5
    
56. #define FLASH_SPI_MOSI_AF               GPIO_AF_SPI1
    
57. 
    
58. #define FLASH_SPI_CS_PIN                GPIO_Pin_7/* PB.00 */
    
59. #define FLASH_SPI_CS_GPIO_PORT          GPIOE                       /* GPIOB */
    
60. #define FLASH_SPI_CS_GPIO_CLK           RCC_AHB1Periph_GPIOE
    
61. 
    
62. #define FLASH_SPI_157_PIN                GPIO_Pin_1                  /* PB.01 */
    
63. #define FLASH_SPI_157_GPIO_PORT          GPIOB                       /* GPIOB */
    
64. #define FLASH_SPI_157_GPIO_CLK           RCC_AHB1Periph_GPIOB
    
65. 
    
66. /* Exported macro ------------------------------------------------------------*/
    
67. /* Select SPI FLASH: Chip Select pin low  */
    
68. #define SPI_FLASH_CS_LOW()       GPIO_ResetBits(FLASH_SPI_CS_GPIO_PORT, FLASH_SPI_CS_PIN)
    
69. /* Deselect SPI FLASH: Chip Select pin high */
    
70. #define SPI_FLASH_CS_HIGH()      GPIO_SetBits(FLASH_SPI_CS_GPIO_PORT, FLASH_SPI_CS_PIN)
    
71. 
    
72. #define SPI_FLASH_157_EN()    GPIO_ResetBits(FLASH_SPI_157_GPIO_PORT, FLASH_SPI_157_PIN) //高选通
    
73. #define SPI_FLASH_157_DIS()     GPIO_SetBits(FLASH_SPI_157_GPIO_PORT, FLASH_SPI_157_PIN)
    
74. 
    
75. /* Exported functions ------------------------------------------------------- */
    
76. /*----- High layer function -----*/
    
77. 
    
78. #define TIME_PAGE_PROGRAME                        3//5MS
    
79. #define TIME_BULK_ERASE                                200//100000//160S
    
80. extern uint64_t        flash_wait;
    
81. 
    
82. void SPI_FLASH_Init(void);
    
83. //void SPI_FLASH_SectorErase(u32 SectorAddr);
    
84. //void SPI_FLASH_BulkErase(void);
    
85. //void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
    
86. //void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
    
87. //void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
    
88. //u32 SPI_FLASH_ReadID(void);
    
89. //void SPI_FLASH_StartReadSequence(u32 ReadAddr);
    
90. 
    
91. /*----- Low layer function -----*/
    
92. //u8 SPI_FLASH_ReadByte(void);
    
93. u8 SPI_FLASH_SendByte(u8 byte);
    
94. //u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
    
95. void SPI_FLASH_WriteEnable();
    
96. void SPI_FLASH_WriteDisable();
    
97. void SPI_FLASH_WaitForWriteEnd();
    
98. void SPI_FLASH_Wait(uint64_t time);
    
99. 
    
100. //void SPI_FLASH_ByteWrite(u32 WriteAddr);
     
101. //u8 SPI_FLASH_ByteRead(u32 ReadAddr);
     
102. u32 SPI_FLASH_Read_ID();
     
103. u32 SPI_FLASH_ReadID();
     
104. void SPI_FLASH_ChipErase();
     
105. //void SPI_FLASH_4KByteErase(u32 SectorAddr);
     
106. void SPI_FLASH_PageWrite(unsigned int Addr, unsigned char *buf, unsigned int num);
     
107. 
     
108. 
     
109. void SPI_FLASH_PageWriteEnd(unsigned int Addr, unsigned char *buf, unsigned int num);
     
110. void SPI_FLASH_PageRead(unsigned int Addr,unsigned char *buf);
     
111. void SPI_FLASH_Writebyte(unsigned int Addr, unsigned char *buf);
     
112. void SPI_FLASH_Readnbyte(unsigned int Addr,unsigned char *buf,u16 num);
     
113. void SPI_FLASH_Writenbyte(unsigned int Addr, unsigned char *buf,u16 num);
     
114. #endif /* __SPI_FLASH_H */

复制代码

1. /************************************************************
   
2.   Description:    FPGA和FLI32626的Flash操作      
   
3.   Version:        Flash使用ssT25VF032B
   
4.   Function List:  适用于stm32f4  自带硬件spi
   
5.     1. -------
   
6.   History:         
   
7.       <author>          <time>     <version >   <desc>
   
8.       lide           2012.5.22      1.0      创建模块  
   
9. ***********************************************************/
   
10. 
    
11. /* Includes ------------------------------------------------------------------*/
    
12. #include "spi_flash.h"
    
13. #include "stm32_delay.h"
    
14. 
    
15. //#define SPI1DMA_RX 0
    
16. uint64_t        flash_wait = 0;
    
17. extern unsigned char time_is_up;
    
18. /*******************************************************************************
    
19. * Function Name  : SPI_FLASH_Init
    
20. * Description    : Initializes the peripherals used by the SPI FLASH driver.
    
21. * Input          : None
    
22. * Output         : None
    
23. * Return         : None
    
24. *******************************************************************************/
    
25. void delay_nus(unsigned short n)
    
26. {
    
27.     unsigned char i;
    
28.    
    
29.     while(n--)
    
30.     {
    
31.         for(i=0;i<26;i++);              //i=26 刚好1us
    
32.     }
    
33. }
    
34. 
    
35. void SPI_FLASH_Init(void)
    
36. {
    
37.     GPIO_InitTypeDef GPIO_InitStructure;
    
38.     SPI_InitTypeDef  SPI_InitStructure;
    
39.     NVIC_InitTypeDef   NVIC_InitStructure;
    
40. 
    
41.     /* Enable the SPI periph */
    
42.     RCC_APB2PeriphClockCmd(FLASH_SPI_CLK, ENABLE);
    
43. 
    
44.     /* Enable SCK, MOSI and MISO GPIO clocks */
    
45.     RCC_AHB1PeriphClockCmd(FLASH_SPI_SCK_GPIO_CLK | FLASH_SPI_MOSI_GPIO_CLK | FLASH_SPI_MISO_GPIO_CLK, ENABLE);//FLASH_SPI_MISO_GPIO_CLK
    
46. 
    
47.     /* Enable CS  GPIO clock */
    
48.     RCC_AHB1PeriphClockCmd(FLASH_SPI_CS_GPIO_CLK, ENABLE);
    
49.    
    
50.     /* Enable 157  GPIO clock */
    
51.     RCC_AHB1PeriphClockCmd(FLASH_SPI_157_GPIO_CLK, ENABLE);
    
52.    
    
53. 
    
54.     GPIO_PinAFConfig(FLASH_SPI_SCK_GPIO_PORT, FLASH_SPI_SCK_SOURCE, FLASH_SPI_SCK_AF);
    
55.     GPIO_PinAFConfig(FLASH_SPI_MISO_GPIO_PORT, FLASH_SPI_MISO_SOURCE, FLASH_SPI_MISO_AF);
    
56.     GPIO_PinAFConfig(FLASH_SPI_MOSI_GPIO_PORT, FLASH_SPI_MOSI_SOURCE, FLASH_SPI_MOSI_AF);
    
57. 
    
58.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
59.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
60.     GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;
    
61.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
62. 
    
63.     /* SPI SCK pin configuration */
    
64.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
    
65.     GPIO_Init(FLASH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
    
66. 
    
67.     /* SPI  MOSI pin configuration */
    
68.     GPIO_InitStructure.GPIO_Pin =  FLASH_SPI_MOSI_PIN;
    
69.     GPIO_Init(FLASH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
    
70. 
    
71.     /* SPI MISO pin configuration */
    
72.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN;
    
73.     GPIO_Init(FLASH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
    
74. 
    
75. 
    
76.     /* Configure GPIO PIN for Lis Chip select */
    
77.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_CS_PIN;
    
78.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    
79.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
80.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
81.     GPIO_Init(FLASH_SPI_CS_GPIO_PORT, &GPIO_InitStructure);
    
82.    
    
83.     SPI_FLASH_CS_HIGH();
    
84. 
    
85.   /* Configure GPIO PIN for 157 */
    
86.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_157_PIN;
    
87.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    
88.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
89.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
90.     GPIO_Init(FLASH_SPI_157_GPIO_PORT, &GPIO_InitStructure);
    
91. 
    
92.     /* SPI1 configuration */
    
93.     SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    
94.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    
95.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    
96.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    
97.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    
98.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    
99.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
    
100.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     
101.     SPI_InitStructure.SPI_CRCPolynomial = 7;
     
102.     SPI_Init(FLASH_SPI, &SPI_InitStructure);
     
103. 
     
104.     /* Enable SPI1  */
     
105.     SPI_Cmd(FLASH_SPI, ENABLE);
     
106.     SPI_FLASH_157_DIS();
     
107.    
     
108.     //SPI_DMAInit();
     
109.     /* I2S DMA IRQ Channel configuration */
     
110.    /* NVIC_InitStructure.NVIC_IRQChannel = SPI1_DMA_RX_IRQn;
     
111.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
     
112.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
     
113.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
114.     NVIC_Init(&NVIC_InitStructure);
     
115.    
     
116.     NVIC_InitStructure.NVIC_IRQChannel = SPI1_DMA_TX_IRQn;
     
117.     NVIC_Init(&NVIC_InitStructure);
     
118.     Delay_Init(168);*/
     
119. 
     
120. }
     
121. 
     
122. /*******************************************************************************
     
123. * Function Name  : SPI_FLASH_SectorErase
     
124. * Description    : Erases the specified FLASH sector.
     
125. * Input          : SectorAddr: address of the sector to erase.
     
126. * Output         : None
     
127. * Return         : None
     
128. *******************************************************************************/
     
129. //void SPI_FLASH_SectorErase(u32 SectorAddr)
     
130. //{
     
131. //  /* Send write enable instruction */
     
132. //  SPI_FLASH_WriteEnable();
     
133. //
     
134. //  /* Sector Erase */
     
135. //  /* Select the FLASH: Chip Select low */
     
136. //  SPI_FLASH_CS_LOW();
     
137. //  /* Send Sector Erase instruction */
     
138. //  SPI_FLASH_SendByte(SE);
     
139. //  /* Send SectorAddr high nibble address byte */
     
140. //  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
     
141. //  /* Send SectorAddr medium nibble address byte */
     
142. //  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
     
143. //  /* Send SectorAddr low nibble address byte */
     
144. //  SPI_FLASH_SendByte(SectorAddr & 0xFF);
     
145. //  /* Deselect the FLASH: Chip Select high */
     
146. //  SPI_FLASH_CS_HIGH();
     
147. //
     
148. //  /* Wait the end of Flash writing */
     
149. //  SPI_FLASH_WaitForWriteEnd();
     
150. //}
     
151. 
     
152. /*******************************************************************************
     
153. * Function Name  : SPI_FLASH_BulkErase
     
154. * Description    : Erases the entire FLASH.
     
155. * Input          : None
     
156. * Output         : None
     
157. * Return         : None
     
158. *******************************************************************************/
     
159. //void SPI_FLASH_BulkErase(void)
     
160. //{
     
161. //  /* Send write enable instruction */
     
162. //  SPI_FLASH_WriteEnable();
     
163. //
     
164. //  /* Bulk Erase */
     
165. //  /* Select the FLASH: Chip Select low */
     
166. //  SPI_FLASH_CS_LOW();
     
167. //  /* Send Bulk Erase instruction  */
     
168. //  SPI_FLASH_SendByte(0xc7);
     
169. //  /* Deselect the FLASH: Chip Select high */
     
170. //  SPI_FLASH_CS_HIGH();
     
171. //
     
172. //  /* Wait the end of Flash writing */
     
173. //  //SPI_FLASH_WaitForWriteEnd();
     
174. //  SPI_FLASH_Wait(TIME_BULK_ERASE);
     
175. //}
     
176. 
     
177. //void SPI_FLASH_4KByteErase(u32 SectorAddr)
     
178. //{
     
179. //  /* Send write enable instruction */
     
180. //  SPI_FLASH_WriteEnable();
     
181. //
     
182. //  /* Bulk Erase */
     
183. //  /* Select the FLASH: Chip Select low */
     
184. //  SPI_FLASH_CS_LOW();
     
185. //  /* Send Bulk Erase instruction  */
     
186. //  SPI_FLASH_SendByte(0x20);
     
187. //  /* Send SectorAddr high nibble address byte */
     
188. //  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
     
189. //  /* Send SectorAddr medium nibble address byte */
     
190. //  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
     
191. //  /* Send SectorAddr low nibble address byte */
     
192. //  SPI_FLASH_SendByte(SectorAddr & 0xFF);
     
193. //  /* Deselect the FLASH: Chip Select high */
     
194. //
     
195. //  SPI_FLASH_CS_HIGH();
     
196. //
     
197. //  /* Wait the end of Flash writing */
     
198. //  //SPI_FLASH_WaitForWriteEnd();
     
199. //  SPI_FLASH_Wait(30);
     
200. //}
     
201. 
     
202. void SPI_FLASH_WriteSR(unsigned char data)
     
203. {
     
204.     SPI_FLASH_CS_LOW();
     
205.     SPI_FLASH_SendByte(EWSR);
     
206.     SPI_FLASH_CS_HIGH();
     
207.    
     
208.     SPI_FLASH_CS_LOW();
     
209.     SPI_FLASH_SendByte(WRSR);
     
210.     SPI_FLASH_SendByte(data);
     
211.     SPI_FLASH_CS_HIGH();
     
212. }
     
213. 
     
214. void SPI_FLASH_ChipErase()
     
215. {
     
216.     SPI_FLASH_WriteSR(0x00);  //写状态寄存器为整片都非保护模式
     
217.         SPI_FLASH_WriteEnable();
     
218. 
     
219.         SPI_FLASH_CS_LOW();
     
220.     SPI_FLASH_SendByte(CE);
     
221.     SPI_FLASH_CS_HIGH();
     
222. 
     
223.         SPI_FLASH_WriteDisable();
     
224.         //Delay_ms(40);   
     
225.         TIM_Delay_10ms(40);
     
226.         while(time_is_up == 0);
     
227.         time_is_up = 0;
     
228. 
     
229.         //SPI_FLASH_Wait(50);/* 延时至少35ms */
     
230. }
     
231. 
     
232. 
     
233. //void SPI_FLASH_ByteWrite(u32 WriteAddr)
     
234. //{
     
235. //  /* Enable the write access to the FLASH */
     
236. //  SPI_FLASH_WriteEnable();
     
237. //
     
238. //  /* Select the FLASH: Chip Select low */
     
239. //  SPI_FLASH_CS_LOW();
     
240. //  /* Send "Write to Memory " instruction */
     
241. //  SPI_FLASH_SendByte(WRITE);
     
242. //  /* Send WriteAddr high nibble address byte to write to */
     
243. //  SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
     
244. //  /* Send WriteAddr medium nibble address byte to write to */
     
245. //  SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
     
246. //  /* Send WriteAddr low nibble address byte to write to */
     
247. //  SPI_FLASH_SendByte(WriteAddr & 0xFF);
     
248. //
     
249. //    /* Send the current byte */
     
250. //    SPI_FLASH_SendByte(0x22);
     
251. //
     
252. //  /* Deselect the FLASH: Chip Select high */
     
253. //  SPI_FLASH_CS_HIGH();
     
254. //
     
255. //  /* Wait the end of Flash writing */
     
256. ////  SPI_FLASH_WaitForWriteEnd();
     
257. ////SPI_FLASH_Wait(TIME_PAGE_PROGRAME);
     
258. //  SPI_FLASH_Wait(100);
     
259. //}
     
260. extern DMA_InitTypeDef    SPIDMA_InitStructure;
     
261. void SPI_DMAInit1(unsigned char *buf, unsigned short size, unsigned char type)
     
262. {
     
263.   unsigned char temp[256]={2,2,2,2,2,2,2,2,2,2,2,2};
     
264.       /* Enable the DMA clock */
     
265.   RCC_AHB1PeriphClockCmd(SPI1_DMA_CLK, ENABLE);
     
266.   
     
267.   /* Clear any pending flag on Rx Stream  */
     
268.   DMA_ClearFlag(SPI1_DMA_STREAM_TX, SPI1_TX_DMA_FLAG_FEIF | SPI1_TX_DMA_FLAG_DMEIF | SPI1_TX_DMA_FLAG_TEIF | \
     
269.                                        SPI1_TX_DMA_FLAG_HTIF | SPI1_TX_DMA_FLAG_TCIF);
     
270.   /* Disable the EE I2C Tx DMA stream */
     
271.   DMA_Cmd(SPI1_DMA_STREAM_TX, DISABLE);
     
272.   /* Configure the DMA stream for the EE I2C peripheral TX direction */
     
273.   DMA_DeInit(SPI1_DMA_STREAM_TX);
     
274.   SPIDMA_InitStructure.DMA_Channel = SPI1_DMA_CHANNEL;
     
275.   SPIDMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI1_DR_Address;
     
276.   if(type == 1) //RX
     
277.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)temp;    /* This parameter will be configured durig communication */
     
278.   else if(type == 2) //TX
     
279.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buf;    /* This parameter will be configured durig communication */
     
280.   SPIDMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; /* This parameter will be configured durig communication */
     
281.   SPIDMA_InitStructure.DMA_BufferSize = size;              /* This parameter will be configured durig communication */
     
282.   SPIDMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
     
283.   SPIDMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
     
284.   SPIDMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
     
285.   SPIDMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
     
286.   SPIDMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
     
287.   SPIDMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
     
288.   SPIDMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
     
289.   SPIDMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
     
290.   SPIDMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
     
291.   SPIDMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
     
292.   DMA_Init(SPI1_DMA_STREAM_TX, &SPIDMA_InitStructure);
     
293.   
     
294.   /* Clear any pending flag on Rx Stream */
     
295.   DMA_ClearFlag(SPI1_DMA_STREAM_RX, SPI1_RX_DMA_FLAG_FEIF | SPI1_RX_DMA_FLAG_DMEIF | SPI1_RX_DMA_FLAG_TEIF | \
     
296.                                        SPI1_RX_DMA_FLAG_HTIF | SPI1_RX_DMA_FLAG_TCIF);
     
297.   /* Disable the EE I2C DMA Rx stream */
     
298.   DMA_Cmd(SPI1_DMA_STREAM_RX, DISABLE);
     
299.   /* Configure the DMA stream for the EE I2C peripheral RX direction */
     
300.   DMA_DeInit(SPI1_DMA_STREAM_RX);
     
301.   if(type == 1) //RX
     
302.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buf;    /* This parameter will be configured durig communication */
     
303.   else if(type == 2) //TX
     
304.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)temp;    /* This parameter will be configured durig communication */
     
305.   SPIDMA_InitStructure.DMA_BufferSize = size;
     
306.   SPIDMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
     
307.   DMA_Init(SPI1_DMA_STREAM_RX, &SPIDMA_InitStructure);
     
308. 
     
309.   /* Enable the DMA Channels Interrupts */
     
310.   DMA_ITConfig(SPI1_DMA_STREAM_RX, DMA_IT_TC, ENABLE);  
     
311.   DMA_ITConfig(SPI1_DMA_STREAM_TX, DMA_IT_TC, ENABLE);  
     
312. }
     
313. /*------------------------------------------------------------------------------
     
314. 函数名称 : SPI_FLASH_WaitForWriteEnd
     
315. 函数功能 : 等待FLASH操作完成
     
316. 入口参数 :  无
     
317. 出口参数 :  无
     
318. ------------------------------------------------------------------------------*/
     
319. 
     
320. void SPI_FLASH_PageWrite(unsigned int Addr, unsigned char *buf, unsigned int num)
     
321. {
     
322.     unsigned short i = 0, j = 0;
     
323.     SPI_FLASH_WriteEnable();
     
324. 
     
325.         /* 传输前两个字节数据 */
     
326.     SPI_FLASH_CS_LOW();
     
327. 
     
328.     SPI_FLASH_SendByte(0xAD);
     
329.     SPI_FLASH_SendByte(Addr>>16);
     
330.     SPI_FLASH_SendByte(Addr>>8);
     
331.     SPI_FLASH_SendByte(Addr);
     
332.     SPI_FLASH_SendByte(*buf++);
     
333.     SPI_FLASH_SendByte(*buf++);
     
334. 
     
335.     SPI_FLASH_CS_HIGH();
     
336.    
     
337.     delay_nus(20);                          /* 延时 */
     
338.         
     
339.    for(i=0; i<((num-2)/2); i++) //总共大小为256个字
     
340.     {
     
341.         SPI_FLASH_CS_LOW();
     
342. 
     
343.         SPI_FLASH_SendByte(0xAD);
     
344.         
     
345. #ifdef SPI1DMA_TX         
     
346.         SPI_DMAInit1(buf, 2, 2);
     
347.         
     
348.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
     
349.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);
     
350.         DMA_Cmd(SPI1_DMA_STREAM_TX, ENABLE);
     
351.         DMA_Cmd(SPI1_DMA_STREAM_RX, ENABLE);
     
352.        // for(j=0; j<0xfff8; j++);
     
353. 
     
354.         while (!DMA_GetFlagStatus(SPI1_DMA_STREAM_TX, SPI1_RX_DMA_FLAG_TCIF))
     
355.         {
     
356.           if((j++) > 0xfff0)    break;
     
357.         }
     
358. 
     
359.         DMA_Cmd(SPI1_DMA_STREAM_TX, DISABLE);
     
360.         DMA_Cmd(SPI1_DMA_STREAM_RX, DISABLE);
     
361.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, DISABLE);
     
362.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, DISABLE);
     
363. 
     
364.         
     
365.         buf+=2;
     
366. #else
     
367.         SPI_FLASH_SendByte(*buf++);
     
368.    SPI_FLASH_SendByte(*buf++);
     
369. #endif
     
370.         SPI_FLASH_CS_HIGH();
     
371. 
     
372.         delay_nus(15);/* 延时 */
     
373.     }
     
374.     SPI_FLASH_WriteDisable();
     
375.     delay_nus(20);
     
376. }
     
377. 
     
378. /*------------------------------------------------------------------------------
     
379. 函数名称 : SPI_FLASH_WaitForWriteEnd
     
380. 函数功能 : 等待FLASH操作完成
     
381. 入口参数 :  无
     
382. 出口参数 :  无
     
383. ------------------------------------------------------------------------------*/
     
384. void SPI_FLASH_WaitForWriteEnd2(void)
     
385. {
     
386.   u8 FLASH_Status = 0;
     
387. 
     
388.   /* Select the FLASH: Chip Select low */
     
389. 
     
390.    SPI_FLASH_CS_LOW();
     
391. 
     
392.   /* Send "Read Status Register" instruction */
     
393.   SPI_FLASH_SendByte(RDSR);
     
394. 
     
395.   /* Loop as long as the memory is busy with a write cycle */
     
396.   do
     
397.   {
     
398.     /* Send a dummy byte to generate the clock needed by the FLASH
     
399.     and put the value of the status register in FLASH_Status variable */
     
400.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
     
401. 
     
402.   }
     
403.   while ((FLASH_Status & WIP_Flag) == RESET); /* Write in progress */
     
404. 
     
405.   /* Deselect the FLASH: Chip Select high */
     
406.   SPI_FLASH_CS_HIGH();
     
407. }
     
408. 
     
409. /*------------------------------------------------------------------------------
     
410. 函数名称 : SPI_FLASH_Writebyte
     
411. 函数功能 : 写一个字节数据
     
412. 入口参数 :  address:地址  buffer:数据
     
413. 出口参数 :  无
     
414. ------------------------------------------------------------------------------*/
     
415. 
     
416. void SPI_FLASH_Writebyte(unsigned int Addr, unsigned char *buf)
     
417. {
     
418.     unsigned short i = 0, j = 0;
     
419. 
     
420.     SPI_FLASH_WriteEnable();
     
421. 
     
422.     SPI_FLASH_CS_LOW();
     
423.         SPI_FLASH_SendByte(0x02);
     
424.         SPI_FLASH_SendByte((Addr)>>16);
     
425.     SPI_FLASH_SendByte((Addr)>>8);
     
426.         SPI_FLASH_SendByte((Addr));
     
427.         SPI_FLASH_SendByte(*buf);
     
428.     SPI_FLASH_CS_HIGH();
     
429.            SPI_FLASH_WaitForWriteEnd();
     
430.     SPI_FLASH_WriteDisable();
     
431.     delay_nus(20);
     
432. }
     
433. /*------------------------------------------------------------------------------
     
434. 函数名称 : SPI_FLASH_Writenbyte
     
435. 函数功能 : 写一个字节数据
     
436. 入口参数 :  address:地址  buffer:数据 num :数量
     
437. 出口参数 :  无
     
438. 
     
439. ------------------------------------------------------------------------------*/
     
440. 
     
441. 
     
442. void SPI_FLASH_Writenbyte(unsigned int Addr, unsigned char *buf,u16 num)
     
443. {
     
444. u8 i;
     
445. for(i=0;i<num;i++)
     
446. {
     
447.    SPI_FLASH_Writebyte(Addr++,&buf[i]);
     
448. }
     
449. 
     
450. }
     
451. /*------------------------------------------------------------------------------
     
452. 函数名称 : SPI_FLASH_Readnbyte
     
453. 函数功能 : 写一个字节数据
     
454. 入口参数 :  address:地址  buffer:数据 num :数量
     
455. 出口参数 :  无
     
456. 
     
457. ------------------------------------------------------------------------------*/
     
458. 
     
459. void SPI_FLASH_Readnbyte(unsigned int Addr,unsigned char *buf,u16 num)
     
460. {
     
461.     unsigned short i = 0;
     
462. 
     
463.     SPI_FLASH_CS_LOW();
     
464. 
     
465.     SPI_FLASH_SendByte(0x0b);
     
466.         SPI_FLASH_SendByte(Addr>>16);
     
467.         SPI_FLASH_SendByte(Addr>>8);
     
468.         SPI_FLASH_SendByte(Addr);
     
469.         //dummy
     
470.         SPI_FLASH_SendByte(Dummy_Byte);
     
471.     for(i=0;i<num;i++)
     
472.     {
     
473.                 buf[i]= SPI_FLASH_SendByte(Dummy_Byte);
     
474. 
     
475.         }
     
476. 
     
477.        
     
478.     SPI_FLASH_CS_HIGH();
     
479. }
     
480. 
     
481. void SPI_FLASH_PageWriteEnd(unsigned int Addr, unsigned char *buf, unsigned int num)
     
482. {
     
483.     unsigned short i = 0;
     
484.     SPI_FLASH_WriteEnable();
     
485. 
     
486.         /* 传输前两个字节数据 */
     
487.     SPI_FLASH_CS_LOW();
     
488. 
     
489.     SPI_FLASH_SendByte(0xAD);
     
490.         SPI_FLASH_SendByte(Addr>>16);
     
491.         SPI_FLASH_SendByte(Addr>>8);
     
492.         SPI_FLASH_SendByte(Addr);
     
493.         SPI_FLASH_SendByte(*buf++);
     
494.         SPI_FLASH_SendByte(*buf++);
     
495. 
     
496.     SPI_FLASH_CS_HIGH();
     
497. 
     
498.     delay_nus(20);                          /* 延时 */
     
499. 
     
500.         for(i=0; i<((num-2)/2); i++) //总共大小为256个字节
     
501.     {
     
502.         SPI_FLASH_CS_LOW();
     
503. 
     
504.                 SPI_FLASH_SendByte(0xAD);
     
505.                 SPI_FLASH_SendByte(*buf++);
     
506.             SPI_FLASH_SendByte(*buf++);
     
507. 
     
508.         SPI_FLASH_CS_HIGH();
     
509. 
     
510.                 delay_nus(15);/* 延时 */
     
511.         }
     
512. 
     
513.     if(num%2)
     
514.     {
     
515.         SPI_FLASH_CS_LOW();
     
516. 
     
517.                 SPI_FLASH_SendByte(0xAD);
     
518.                 SPI_FLASH_SendByte(*buf++);
     
519.             SPI_FLASH_SendByte(0xFF);
     
520. 
     
521.         SPI_FLASH_CS_HIGH();
     
522. 
     
523.                 delay_nus(15);
     
524.     }
     
525. 
     
526.         SPI_FLASH_WriteDisable();
     
527.         delay_nus(20);
     
528. }
     
529. 
     
530. 
     
531. void SPI_FLASH_PageRead(unsigned int Addr,unsigned char *buf)
     
532. {
     
533.     unsigned short i = 0;
     
534. 
     
535.     SPI_FLASH_CS_LOW();
     
536. 
     
537.     SPI_FLASH_SendByte(0x0B);
     
538.         SPI_FLASH_SendByte(Addr>>16);
     
539.         SPI_FLASH_SendByte(Addr>>8);
     
540.         SPI_FLASH_SendByte(Addr);
     
541.         SPI_FLASH_SendByte(0xFF);  //dummy
     
542. #ifdef SPI1DMA_RX     
     
543.         SPI_DMAInit1(buf, 256, 1);
     
544.         
     
545.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);
     
546.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
     
547.         DMA_Cmd(SPI1_DMA_STREAM_RX, ENABLE);
     
548.         DMA_Cmd(SPI1_DMA_STREAM_TX, ENABLE);
     
549.         //for(i=0; i<0xfff8; i++);
     
550.         while (!DMA_GetFlagStatus(SPI1_DMA_STREAM_RX, SPI1_RX_DMA_FLAG_TCIF))
     
551.         {
     
552.           if((i++) > 0xfff0)    break;
     
553.         }  
     
554.         
     
555. 
     
556.         DMA_Cmd(SPI1_DMA_STREAM_RX, DISABLE);
     
557.         DMA_Cmd(SPI1_DMA_STREAM_TX, DISABLE);
     
558.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, DISABLE);
     
559.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, DISABLE);
     
560.         
     
561. #else
     
562.         for(i=0; i<256; i++) //总共大小为256个字节
     
563.         {
     
564.                 *buf++ = SPI_FLASH_SendByte(Dummy_Byte);
     
565.         }
     
566. #endif
     
567. 
     
568.     SPI_FLASH_CS_HIGH();
     
569. }
     
570. 
     
571. /*******************************************************************************
     
572. * Function Name  : SPI_FLASH_BufferWrite
     
573. * Description    : Writes block of data to the FLASH. In this function, the
     
574. *                  number of WRITE cycles are reduced, using Page WRITE sequence.
     
575. * Input          : - pBuffer : pointer to the buffer  containing the data to be
     
576. *                    written to the FLASH.
     
577. *                  - WriteAddr : FLASH's internal address to write to.
     
578. *                  - NumByteToWrite : number of bytes to write to the FLASH.
     
579. * Output         : None
     
580. * Return         : None
     
581. *******************************************************************************/
     
582. //void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
     
583. //{
     
584. //  u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
     
585. //
     
586. //  Addr = WriteAddr % SPI_FLASH_PageSize;
     
587. //  count = SPI_FLASH_PageSize - Addr;
     
588. //  NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
     
589. //  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
     
590. //
     
591. //  if (Addr == 0) /* WriteAddr is SPI_FLASH_PageSize aligned  */
     
592. //  {
     
593. //    if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
     
594. //    {
     
595. //      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     
596. //    }
     
597. //    else /* NumByteToWrite > SPI_FLASH_PageSize */
     
598. //    {
     
599. //      while (NumOfPage--)
     
600. //      {
     
601. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     
602. //        WriteAddr +=  SPI_FLASH_PageSize;
     
603. //        pBuffer += SPI_FLASH_PageSize;
     
604. //      }
     
605. //
     
606. //      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
607. //    }
     
608. //  }
     
609. //  else /* WriteAddr is not SPI_FLASH_PageSize aligned  */
     
610. //  {
     
611. //    if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
     
612. //    {
     
613. //      if (NumOfSingle > count) /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */
     
614. //      {
     
615. //        temp = NumOfSingle - count;
     
616. //
     
617. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     
618. //        WriteAddr +=  count;
     
619. //        pBuffer += count;
     
620. //
     
621. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
     
622. //      }
     
623. //      else
     
624. //      {
     
625. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     
626. //      }
     
627. //    }
     
628. //    else /* NumByteToWrite > SPI_FLASH_PageSize */
     
629. //    {
     
630. //      NumByteToWrite -= count;
     
631. //      NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
     
632. //      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
     
633. //
     
634. //      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     
635. //      WriteAddr +=  count;
     
636. //      pBuffer += count;
     
637. //
     
638. //      while (NumOfPage--)
     
639. //      {
     
640. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     
641. //        WriteAddr +=  SPI_FLASH_PageSize;
     
642. //        pBuffer += SPI_FLASH_PageSize;
     
643. //      }
     
644. //
     
645. //      if (NumOfSingle != 0)
     
646. //      {
     
647. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
648. //      }
     
649. //    }
     
650. //  }
     
651. //}
     
652. //
     
653. /*******************************************************************************
     
654. * Function Name  : SPI_FLASH_BufferRead
     
655. * Description    : Reads a block of data from the FLASH.
     
656. * Input          : - pBuffer : pointer to the buffer that receives the data read
     
657. *                    from the FLASH.
     
658. *                  - ReadAddr : FLASH's internal address to read from.
     
659. *                  - NumByteToRead : number of bytes to read from the FLASH.
     
660. * Output         : None
     
661. * Return         : None
     
662. *******************************************************************************/
     
663. //void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
     
664. //{
     
665. //  /* Select the FLASH: Chip Select low */
     
666. //  SPI_FLASH_CS_LOW();
     
667. //
     
668. //  /* Send "Read from Memory " instruction */
     
669. //  SPI_FLASH_SendByte(READ);
     
670. //
     
671. //  /* Send ReadAddr high nibble address byte to read from */
     
672. //  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
673. //  /* Send ReadAddr medium nibble address byte to read from */
     
674. //  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     
675. //  /* Send ReadAddr low nibble address byte to read from */
     
676. //  SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
677. //
     
678. //  while (NumByteToRead--) /* while there is data to be read */
     
679. //  {
     
680. //    /* Read a byte from the FLASH */
     
681. //    *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
     
682. //    /* Point to the next location where the byte read will be saved */
     
683. //    pBuffer++;
     
684. //  }
     
685. //
     
686. //  /* Deselect the FLASH: Chip Select high */
     
687. //  SPI_FLASH_CS_HIGH();
     
688. //}
     
689. 
     
690. //u8 SPI_FLASH_ByteRead(u32 ReadAddr)
     
691. //{
     
692. //    u8 temp = 0;
     
693. //
     
694. //  /* Select the FLASH: Chip Select low */
     
695. //  SPI_FLASH_CS_LOW();
     
696. //
     
697. //  /* Send "Read from Memory " instruction */
     
698. //  SPI_FLASH_SendByte(0x03);
     
699. //
     
700. //  /* Send ReadAddr high nibble address byte to read from */
     
701. //  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
702. //  /* Send ReadAddr medium nibble address byte to read from */
     
703. //  SPI_FLASH_SendByte((ReadAddr & 0xFF00) >> 8);
     
704. //  /* Send ReadAddr low nibble address byte to read from */
     
705. //  SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
706. //
     
707. //    /* Read a byte from the FLASH */
     
708. //    temp = SPI_FLASH_SendByte(Dummy_Byte);
     
709. //
     
710. //  /* Deselect the FLASH: Chip Select high */
     
711. //  SPI_FLASH_CS_HIGH();
     
712. //
     
713. //    return temp;
     
714. //}
     
715. 
     
716. 
     
717. 
     
718. /*******************************************************************************
     
719. * Function Name  : SPI_FLASH_ReadID
     
720. * Description    : Reads FLASH identification.
     
721. * Input          : None
     
722. * Output         : None
     
723. * Return         : FLASH identification
     
724. *******************************************************************************/
     
725. u32 SPI_FLASH_ReadID()
     
726. {
     
727.   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
     
728. 
     
729.   /* Select the FLASH: Chip Select low */
     
730.   SPI_FLASH_CS_LOW();
     
731. 
     
732.   /* Send "RDID " instruction */
     
733.   SPI_FLASH_SendByte(0x9F);
     
734. 
     
735.   /* Read a byte from the FLASH */
     
736.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
     
737. 
     
738.   /* Read a byte from the FLASH */
     
739.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
     
740. 
     
741.   /* Read a byte from the FLASH */
     
742.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
     
743. 
     
744.   /* Deselect the FLASH: Chip Select high */
     
745.   SPI_FLASH_CS_HIGH();
     
746. 
     
747.   Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
     
748. 
     
749.   return Temp;
     
750. }
     
751. 
     
752. 
     
753. /*******************************************************************************
     
754. * Function Name  : SPI_FLASH_StartReadSequence
     
755. * Description    : Initiates a read data byte (READ) sequence from the Flash.
     
756. *                  This is done by driving the /CS line low to select the device,
     
757. *                  then the READ instruction is transmitted followed by 3 bytes
     
758. *                  address. This function exit and keep the /CS line low, so the
     
759. *                  Flash still being selected. With this technique the whole
     
760. *                  content of the Flash is read with a single READ instruction.
     
761. * Input          : - ReadAddr : FLASH's internal address to read from.
     
762. * Output         : None
     
763. * Return         : None
     
764. *******************************************************************************/
     
765. //void SPI_FLASH_StartReadSequence(u32 ReadAddr)
     
766. //{
     
767. //  /* Select the FLASH: Chip Select low */
     
768. //  SPI_FLASH_CS_LOW();
     
769. //
     
770. //  /* Send "Read from Memory " instruction */
     
771. //  SPI_FLASH_SendByte(READ);
     
772. //
     
773. //  /* Send the 24-bit address of the address to read from -----------------------*/
     
774. //  /* Send ReadAddr high nibble address byte */
     
775. //  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
776. //  /* Send ReadAddr medium nibble address byte */
     
777. //  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     
778. //  /* Send ReadAddr low nibble address byte */
     
779. //  SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
780. //}
     
781. 
     
782. /*******************************************************************************
     
783. * Function Name  : SPI_FLASH_ReadByte
     
784. * Description    : Reads a byte from the SPI Flash.
     
785. *                  This function must be used only if the Start_Read_Sequence
     
786. *                  function has been previously called.
     
787. * Input          : None
     
788. * Output         : None
     
789. * Return         : Byte Read from the SPI Flash.
     
790. *******************************************************************************/
     
791. u8 SPI_FLASH_ReadByte(void)
     
792. {
     
793.   return (SPI_FLASH_SendByte(Dummy_Byte));
     
794. }
     
795. 
     
796. /*******************************************************************************
     
797. * Function Name  : SPI_FLASH_SendByte
     
798. * Description    : Sends a byte through the SPI interface and return the byte
     
799. *                  received from the SPI bus.
     
800. * Input          : byte : byte to send.
     
801. * Output         : None
     
802. * Return         : The value of the received byte.
     
803. *******************************************************************************/
     
804. u8 SPI_FLASH_SendByte(u8 byte)
     
805. {
     
806.   /* Loop while DR register in not emplty */
     
807. //          while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
808. 
     
809.   /* Send byte through the SPI1 peripheral */
     
810.         SPI_I2S_SendData(SPI1, byte);
     
811.         //while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
812.   /* Wait to receive a byte */
     
813.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
     
814. 
     
815.   /* Return the byte read from the SPI bus */
     
816.           return SPI_I2S_ReceiveData(SPI1);
     
817. //          return 0;
     
818. }
     
819. 
     
820. /*******************************************************************************
     
821. * Function Name  : SPI_FLASH_SendHalfWord
     
822. * Description    : Sends a Half Word through the SPI interface and return the
     
823. *                  Half Word received from the SPI bus.
     
824. * Input          : Half Word : Half Word to send.
     
825. * Output         : None
     
826. * Return         : The value of the received Half Word.
     
827. *******************************************************************************/
     
828. u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
     
829. {
     
830.   /* Loop while DR register in not emplty */
     
831.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
832. 
     
833.   /* Send Half Word through the SPI1 peripheral */
     
834.   SPI_I2S_SendData(SPI1, HalfWord);
     
835. 
     
836.   /* Wait to receive a Half Word */
     
837.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
     
838. 
     
839.   /* Return the Half Word read from the SPI bus */
     
840.   return SPI_I2S_ReceiveData(SPI1);
     
841. }
     
842. 
     
843. /*******************************************************************************
     
844. * Function Name  : SPI_FLASH_WriteEnable
     
845. * Description    : Enables the write access to the FLASH.
     
846. * Input          : None
     
847. * Output         : None
     
848. * Return         : None
     
849. *******************************************************************************/
     
850. void SPI_FLASH_WriteEnable()
     
851. {
     
852.   /* Select the FLASH: Chip Select low */
     
853.     SPI_FLASH_CS_LOW();
     
854. 
     
855.   /* Send "Write Enable" instruction */
     
856.   SPI_FLASH_SendByte(WREN);
     
857. 
     
858.   /* Deselect the FLASH: Chip Select high */
     
859.     SPI_FLASH_CS_HIGH();
     
860. }
     
861. 
     
862. void SPI_FLASH_WriteDisable()
     
863. {
     
864.   /* Select the FLASH: Chip Select low */
     
865.     SPI_FLASH_CS_LOW();
     
866. 
     
867.   /* Send "Write Enable" instruction */
     
868.   SPI_FLASH_SendByte(WRDI);
     
869. 
     
870.   /* Deselect the FLASH: Chip Select high */
     
871.     SPI_FLASH_CS_HIGH();
     
872. }
     
873. 
     
874. /*******************************************************************************
     
875. * Function Name  : SPI_FLASH_WaitForWriteEnd
     
876. * Description    : Polls the status of the Write In Progress (WIP) flag in the
     
877. *                  FLASH's status  register  and  loop  until write  opertaion
     
878. *                  has completed.
     
879. * Input          : None
     
880. * Output         : None
     
881. * Return         : None
     
882. *******************************************************************************/
     
883. void SPI_FLASH_WaitForWriteEnd()
     
884. {
     
885.   u8 FLASH_Status = 0;
     
886. 
     
887.   /* Select the FLASH: Chip Select low */
     
888.     SPI_FLASH_CS_LOW();
     
889. 
     
890.   /* Send "Read Status Register" instruction */
     
891.   SPI_FLASH_SendByte(RDSR);
     
892. 
     
893.   /* Loop as long as the memory is busy with a write cycle */
     
894.   do
     
895.   {
     
896.     /* Send a dummy byte to generate the clock needed by the FLASH
     
897.     and put the value of the status register in FLASH_Status variable */
     
898.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
     
899. 
     
900.   }
     
901.   while ((FLASH_Status & WIP_Flag) == SET); /* Write in progress */
     
902. 
     
903.   /* Deselect the FLASH: Chip Select high */
     
904.     SPI_FLASH_CS_HIGH();
     
905. }
     
906. 
     
907. void SPI_FLASH_Wait(uint64_t time)
     
908. {
     
909.         flash_wait = time;
     
910.         while(flash_wait);
     
911. }
     
912. 
     
913. 
     
914. //void FlashRWTest(void)
     
915. //{
     
916. //                /* Get SPI Flash ID */
     
917. //        FLASH_ID = SPI_FLASH_ReadID();
     
918. //        /* Check the SPI Flash ID */
     
919. //        if (FLASH_ID == M25P64_FLASH_ID)
     
920. //        {
     
921. //                /* OK: Set GPIO_LED */
     
922. //                GPIOB->BSRR = 0x1000E000;
     
923. //        }
     
924. //        else
     
925. //        {
     
926. //                /* Error: Set GPIO_LED*/
     
927. //                GPIOB->BSRR = 0x2000D000;
     
928. //        }
     
929. //
     
930. //        SPI_FLASH_SectorErase(FLASH_SectorToErase);
     
931. //
     
932. //        /* Write Tx_Buffer data to SPI FLASH memory */
     
933. //        //SPI_FLASH_BufferWrite(TxBuffer, FLASH_WriteAddress, BufferSize);
     
934. //
     
935. //        /* Read data from SPI FLASH memory */
     
936. //        //SPI_FLASH_BufferRead(RxBuffer, FLASH_ReadAddress, BufferSize);
     
937. //}
     
938. 
     
939. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
     

复制代码

【必读】版权免责声明

1、本主题所有言论和内容纯属会员个人意见，与本论坛立场无关。2、本站对所发内容真实性、客观性、可用性不做任何保证也不负任何责任，网友之间仅出于学习目的进行交流。3、对提供的数字内容不拥有任何权利，其版权归原著者拥有。请勿将该数字内容进行商业交易、转载等行为，该内容只为学习所提供，使用后发生的一切问题与本站无关。 4、本网站不保证本站提供的下载资源的准确性、安全性和完整性;同时本网站也不承担用户因使用这些下载资源对自己和他人造成任何形式的损失或伤害。 5、本网站所有软件和资料均为网友推荐收集整理而来，仅供学习用途使用，请务必下载后两小时内删除，禁止商用。6、如有侵犯你版权的，请及时联系我们（电子邮箱1370723259@qq.com）指出，本站将立即改正。