F450读写GD25Q128

apleilx

记录数据免不了要用到大容量的FLASH了，手上正好有GD25Q128的板子，连上写个驱动程序，现在可以读写擦除了。
450的DMA添加了不少功能，不过狗血限制太多，还没全搞明白，现在都是纯软件操作，程序留了DMA的接口，回头添加DMA传输。

freertos-bbs-gd25q.rar (3.15 MB, 下载次数: 26)

2017-6-9 17:24 上传

点击文件名下载附件
f450R25Q

附件工程：
IDE ： IAR ARM8.11.1
操作系统 ： freeRTOS
创建测试任务 ： \SOFTWARE\APP\strctr.c

gd25q部分程序清单：
gd25q_hal.h

1. #ifndef _GD25Q_HAL_H_
   
2. #define        _GD25Q_HAL_H_
   
3. 
   
4. #include "stdint.h"
   
5. #include "gd32f4xx.h"
   
6. #include "pincfg.h"
   
7. 
   
8. #ifdef _GD25Q_HAL_MODEL_
   
9. #define GD_EXT
   
10. #else
    
11. #define GD_EXT extern
    
12. #endif
    
13. 
    
14. #define GDSPI                                     SPI3
    
15. 
    
16. //WP# going low to protected the BP0~BP4 bits and SRP0~1 bits.
    
17. #define GD25WpEn()                       
    
18. #define GD25WpDis()                       
    
19. //To re-start communication with chip, the HOLD# must be at high and then CS# must be at low
    
20. #define GD25Cs(x)                                 (x?(SPI_F_CS = 1 ):(SPI_F_CS = 0))
    
21. #define GD25Hold(x)                          
    
22. 
    
23. GD_EXT uint32_t gd25qDmaEndSt;
    
24. 
    
25. void gdSpiInit(void);
    
26. uint8_t dgSpiRw(uint8_t dataW);
    
27. void gdSpiDma(uint8_t NewState);
    
28. void gdSpiDmaRw(uint8_t ModeRW, uint32_t  Len, uint8_t *Data);
    
29. 
    
30. #undef GD_EXT
    
31. 
    
32. #endif        /* _GD25Q_HAL_H_ */
    

复制代码

gd25q_hal.c

1. /* ------------------------------------------------------------------------*
   
2. *
   
3. * ------------------------------------------------------------------------*/
   
4. #define _GD25Q_HAL_MODEL_
   
5. 
   
6. #include "gd25q_hal.h"
   
7. #include "gd25q_cmd.h"
   
8. 
   
9. /*****************************************************************************//*!
   
10. * @brief   Dma for spi rx handle.
    
11. *               
    
12. * @param   none
    
13. *
    
14. * @return  none
    
15. *
    
16. * @ Pass/ Fail criteria: none
    
17. *****************************************************************************/  
    
18. void DMA1_Channel3_IRQHandler(){
    
19.         dma_channel_disable(DMA1, DMA_CH3);        
    
20.         dma_channel_disable(DMA1, DMA_CH4);         
    
21.         
    
22.         SPI_CTL1(GDSPI) &= ~ (SPI_CTL1_DMAREN | SPI_CTL1_DMATEN);
    
23.         
    
24.         dma_flag_clear(DMA1, DMA_CH3, DMA_INTC_FEEIFC);
    
25.         dma_flag_clear(DMA1, DMA_CH4, DMA_INTC_FEEIFC);
    
26.         //add code to tell os that data rw finished ----------------------------------------------
    
27.         
    
28.         //----------------------------------------------------------------------------------------
    
29. }
    
30. 
    
31. /*****************************************************************************//*!
    
32. * @brief   Dma for spi tx handle.
    
33. *               
    
34. * @param   none
    
35. *
    
36. * @return  none
    
37. *
    
38. * @ Pass/ Fail criteria: none
    
39. *****************************************************************************/  
    
40. void DMA1_Channel4_IRQHandler(){
    
41. 
    
42. }
    
43. 
    
44. /*****************************************************************************//*!
    
45. * @brief   hal init.
    
46. *               
    
47. * @param   none
    
48. *
    
49. * @return  none
    
50. *
    
51. * @ Pass/ Fail criteria: none
    
52. *****************************************************************************/   
    
53. void gdSpiInit()
    
54. {
    
55.     spi_parameter_struct SpiPar;
    
56.     // Enable USART APB clock
    
57.     rcu_periph_clock_enable(RCU_SPI3);
    
58.     rcu_periph_reset_enable(RCU_SPI3RST);
    
59.     rcu_periph_reset_disable(RCU_SPI3RST);  
    
60. 
    
61.     // Configure USART Rx/Tx as alternate function push-pull
    
62.     gpio_af_set(GPIOE, GPIO_AF_5,GPIO_PIN_2 | GPIO_PIN_5 | GPIO_PIN_6);
    
63.     gpio_mode_set(GPIOE, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_2 | GPIO_PIN_5 | GPIO_PIN_6);
    
64.     gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_2 | GPIO_PIN_5 | GPIO_PIN_6);
    
65. 
    
66.     GD25Cs(1);
    
67.     //GD25Hold(1);
    
68.     //GD25WpDis();
    
69. 
    
70.     //config spi
    
71.     SpiPar.device_mode = SPI_MASTER;
    
72.     SpiPar.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
    
73.     SpiPar.frame_size = SPI_FRAMESIZE_8BIT;
    
74.     SpiPar.nss = SPI_NSS_SOFT;
    
75.     SpiPar.endian = SPI_ENDIAN_MSB;
    
76.     SpiPar.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;
    
77.     SpiPar.prescale =SPI_PSC_256;
    
78.    
    
79.     spi_init(GDSPI, &SpiPar);
    
80.     spi_enable(GDSPI);
    
81.    
    
82.     NVIC_SetPriority(SPI3_IRQn, 0xFF);
    
83.     NVIC_ClearPendingIRQ(SPI3_IRQn);
    
84.     NVIC_DisableIRQ(SPI3_IRQn);
    
85. }
    
86. 
    
87. /*****************************************************************************//*!
    
88. * @brief   DMA control.
    
89. *               
    
90. * @param   none
    
91. *
    
92. * @return  none
    
93. *
    
94. * @ Pass/ Fail criteria: none
    
95. *****************************************************************************/
    
96. void gdSpiDmaRw(uint8_t ModeRW, uint32_t  Len, uint8_t *Data)
    
97. {
    
98.   
    
99. }
    
100. 
     
101. /*****************************************************************************//*!
     
102. * @brief   spi data read and write.
     
103. *               
     
104. * @param   none
     
105. *
     
106. * @return  none
     
107. *
     
108. * @ Pass/ Fail criteria: none
     
109. *****************************************************************************/
     
110. uint8_t dgSpiRw(uint8_t dataW)
     
111. {
     
112.     uint8_t dataR;
     
113.    
     
114.     while(SPI_STAT(GDSPI) & SPI_STAT_TRANS){}             //wait tx idle
     
115.         
     
116.     if(SPI_STAT(GDSPI) & SPI_STAT_RBNE)
     
117.         dataR = SPI_DATA(GDSPI);
     
118.    
     
119.     SPI_DATA(GDSPI) = dataW;
     
120.     dataW = 0;
     
121.     while(!(SPI_STAT(GDSPI) & SPI_STAT_RBNE)){}            //wait tx idle
     
122.     dataR = SPI_DATA(GDSPI);
     
123.     return ( dataR );
     
124. }
     

复制代码

gd25q_cmd.h

1. #ifndef _GD25Q_CMD_H_
   
2. #define        _GD25Q_CMD_H_
   
3. 
   
4. #include "stdint.h"
   
5. #include "gd25q_hal.h"
   
6. 
   
7. // command list
   
8. #define GD25CMD_Write_Enable                              0x06
   
9. #define GD25CMD_Write_Disable                             0x04
   
10. #define GD25CMD_SRWrite Enable                            0x50
    
11. #define GD25CMD_Read_StReg1                               0x05
    
12. #define GD25CMD_Read_StReg2                               0x35
    
13. #define GD25CMD_Read_StReg3                               0x15
    
14. #define GD25CMD_Write_StReg1                              0x01
    
15. #define GD25CMD_Write_StReg2                              0x31
    
16. #define GD25CMD_Write_StReg3                              0x11
    
17. #define GD25CMD_Read_Data                                 0x03
    
18. #define GD25CMD_Fast_Read                                 0x0B
    
19. #define GD25CMD_Dual_Output                               0x3B
    
20. #define GD25CMD_Dual_IO                                   0xBB
    
21. #define GD25CMD_Quad_Output                               0x6B
    
22. #define GD25CMD_Quad_IO                                   0xEB
    
23. #define GD25CMD_Quad_IO_Word                              0xE7
    
24. #define GD25CMD_Page_Program                              0x02
    
25. #define GD25CMD_Quad_Page_Program                         0x32
    
26. #define GD25CMD_Sector_Erase                              0x20
    
27. #define GD25CMD_Block_Erase_32K                           0x52
    
28. #define GD25CMD_Block_Erase_64K                           0xD8
    
29. #define GD25CMD_Chip_Erase                                0x60
    
30. #define GD25CMD_Enable_QPI                                0x38
    
31. #define GD25CMD_Enable_Reset                              0x66
    
32. #define GD25CMD_Reset                                     0x99
    
33. #define GD25CMD_Set_Burst_with_Wrap                       0x77
    
34. #define GD25CMD_Erase SecurityReg                         0x44
    
35. #define GD25CMD_Program SecurityReg                       0x42
    
36. #define GD25CMD_Read SecurityReg                          0x48
    
37. #define GD25CMD_Individual_Block_Lock                     0x36
    
38. #define GD25CMD_Individual_Block_Unlock                   0x39
    
39. #define GD25CMD_Read_Block_Lock                           0x3D
    
40. #define GD25CMD_Global_Block_Lock                         0x7E
    
41. #define GD25CMD_Global_Block_Unlock                       0x98
    
42. 
    
43. // flash information
    
44. #define GD25Q128_PAGE_SIZE                                0x100UL          //256bytes
    
45. #define GD25Q128_PAGE_MASK                                0xFFUL
    
46. #define GD25Q128_SECTOR_SIZE                              0x1000UL         //4kbytes
    
47. #define GD25Q128_SECTOR_MASK                              0xFFFUL
    
48. #define GD25Q128_BLOCK_SIZE                               0x8000UL         //32kbytes
    
49. #define GD25Q128_BLOCK_MASK                               0x7FFFUL
    
50. #define GD25Q128_CHIP_SIZE                                0x1000000UL      //16mbytes
    
51. #define GD25Q128_CHIP_MASK                                0xFFFFFFUL
    
52. 
    
53. // statue define
    
54. #define GD25Q_ST_BUSY_MASK                                0x01
    
55. #define GD25Q_ST_WRITE_EN                                 0x02
    
56. 
    
57. // mode
    
58. #define GD25Q_READ                                        0x00
    
59. #define GD25Q_WRITE                                       0x01
    
60. 
    
61. //function
    
62. uint32_t gd25qCmdStRead(void);
    
63. uint8_t  gd25qBusy(void);
    
64. 
    
65. 
    
66. void gd25qCmdWriteEn(void);
    
67. void gd25qCmdWriteDis(void);
    
68. void gd25qSectorErase(uint32_t addr);
    
69. void gd25qBlockErase(uint32_t addr);
    
70. void gd25qChipErase(void );
    
71. 
    
72. void gd25qRead(uint32_t addr,uint32_t Len,uint8_t *Des);
    
73. void gd25qWrite(uint32_t addr,uint32_t Len,uint8_t *Src);
    
74. void gd25qDmaRead(uint32_t addr,uint32_t Len,uint8_t *Des);
    
75. void gd25qDmaWrite(uint32_t addr,uint32_t Len,uint8_t *Src);
    
76. 
    
77. #endif        /* _GD25Q_CMD_H_ */
    

复制代码

gd25q_cmd.c

1. /* ------------------------------------------------------------------------*
   
2. *
   
3. * ------------------------------------------------------------------------*/
   
4. #include "gd25q_cmd.h"
   
5. #include "mytype.h"
   
6. 
   
7. void gd25qWait(uint8_t Cnt)
   
8. {
   
9.     while(Cnt --){};
   
10. }
    
11. 
    
12. /*****************************************************************************//*!
    
13. * @brief   read status.
    
14. *               The Status Register may be read at any time,
    
15. *               even while a Program, Erase or Write Status Register cycle is in progress.
    
16. * @param   none
    
17. *
    
18. * @return  statues
    
19. *
    
20. * @ Pass/ Fail criteria: none
    
21. *****************************************************************************/
    
22. uint32_t gd25qCmdStRead(void)
    
23. {
    
24.     UINT32_VAL FlashSt;
    
25.    
    
26.     GD25Cs(0);
    
27.     FlashSt.byte.MB = 0;
    
28.     dgSpiRw( GD25CMD_Read_StReg1);
    
29.     FlashSt.byte.LB = dgSpiRw( 0xFF);
    
30.     GD25Cs(1);
    
31.     gd25qWait(2);
    
32.     GD25Cs(0);
    
33.     dgSpiRw( GD25CMD_Read_StReg2);
    
34.     FlashSt.byte.HB = dgSpiRw( 0xFF);
    
35.     GD25Cs(1);
    
36.     gd25qWait(2);
    
37.     GD25Cs(0);
    
38.     dgSpiRw( GD25CMD_Read_StReg3);
    
39.     FlashSt.byte.UB = dgSpiRw( 0xFF);
    
40.     GD25Cs(1);
    
41.    
    
42.     return FlashSt.Val;
    
43. }
    
44. 
    
45. /*****************************************************************************//*!
    
46. * @brief   read busy statues.
    
47. *               The Status Register may be read at any time,
    
48. *               even while a Program, Erase or Write Status Register cycle is in progress.
    
49. * @param   none
    
50. *
    
51. * @return  busy or not
    
52. *
    
53. * @ Pass/ Fail criteria: none
    
54. *****************************************************************************/
    
55. uint8_t  gd25qBusy(void)
    
56. {
    
57.     uint8_t FlashSt;
    
58.    
    
59.     GD25Cs(0);
    
60.     dgSpiRw( GD25CMD_Read_StReg1);
    
61.     FlashSt = dgSpiRw( 0xFF);
    
62.     GD25Cs(1);
    
63.    
    
64.     return ((uint8_t)(FlashSt & GD25Q_ST_BUSY_MASK));
    
65. }
    
66. 
    
67. /*****************************************************************************//*!
    
68. * @brief   write enable.
    
69. *               
    
70. * @param   none
    
71. *
    
72. * @return  none
    
73. *
    
74. * @ Pass/ Fail criteria: none
    
75. *****************************************************************************/
    
76. void gd25qCmdWriteEn(void)
    
77. {
    
78.     GD25Cs(0);
    
79. 
    
80.     dgSpiRw( GD25CMD_Write_Enable);
    
81.    
    
82.     GD25Cs(1);
    
83. }
    
84. 
    
85. /*****************************************************************************//*!
    
86. * @brief   write disable.
    
87. *               
    
88. * @param   none
    
89. *
    
90. * @return  none
    
91. *
    
92. * @ Pass/ Fail criteria: none
    
93. *****************************************************************************/
    
94. void gd25qCmdWriteDis(void)
    
95. {
    
96.     GD25Cs(0);
    
97. 
    
98.     dgSpiRw( GD25CMD_Write_Disable);
    
99.    
    
100.     GD25Cs(1);
     
101. }
     
102. 
     
103. /*****************************************************************************//*!
     
104. * @brief   Erase aector.       4k
     
105. *               
     
106. * @param   addr:      data address in chip
     
107. *
     
108. * @return  none
     
109. *
     
110. * @ Pass/ Fail criteria: none
     
111. *****************************************************************************/
     
112. void gd25qSectorErase(uint32_t addr)
     
113. {
     
114.     UINT32_VAL Par;
     
115.    
     
116.     //waiting for idle
     
117.     while(gd25qBusy()){}
     
118.         
     
119.     gd25qCmdWriteEn();
     
120.         
     
121.     GD25Cs(0);
     
122.     Par.Val = addr;   
     
123.     dgSpiRw( GD25CMD_Sector_Erase);
     
124.     dgSpiRw( Par.byte.UB);
     
125.     dgSpiRw( Par.byte.HB);
     
126.     dgSpiRw( Par.byte.LB);
     
127.     GD25Cs(1);
     
128. }
     
129. 
     
130. /*****************************************************************************//*!
     
131. * @brief   Erase block.      32k
     
132. *               
     
133. * @param   addr:      data address in chip
     
134. *
     
135. * @return  none
     
136. *
     
137. * @ Pass/ Fail criteria: none
     
138. *****************************************************************************/
     
139. void gd25qBlockErase(uint32_t addr)
     
140. {
     
141.     UINT32_VAL Par;
     
142.    
     
143.     //waiting for idle
     
144.     while(gd25qBusy()){}
     
145.         
     
146.     gd25qCmdWriteEn();
     
147.         
     
148.     GD25Cs(0);
     
149.     Par.Val = addr;   
     
150.     dgSpiRw( GD25CMD_Block_Erase_32K);
     
151.     dgSpiRw( Par.byte.UB);
     
152.     dgSpiRw( Par.byte.HB);
     
153.     dgSpiRw( Par.byte.LB);
     
154.     GD25Cs(1);
     
155. }
     
156. 
     
157. /*****************************************************************************//*!
     
158. * @brief   Erase chip.
     
159. *               
     
160. * @param   none
     
161. *
     
162. * @return  none
     
163. *
     
164. * @ Pass/ Fail criteria: none
     
165. *****************************************************************************/
     
166. void gd25qChipErase(void )
     
167. {
     
168.      while(gd25qBusy()){}
     
169.         
     
170.     gd25qCmdWriteEn();
     
171.         
     
172.     GD25Cs(0);  
     
173.     dgSpiRw( GD25CMD_Chip_Erase);
     
174.     GD25Cs(1);   
     
175. }
     
176. 
     
177. /*****************************************************************************//*!
     
178. * @brief   read data.
     
179. *               
     
180. * @param   addr          address in chip
     
181. *          len           length will be read
     
182. *          des           destination
     
183. *
     
184. * @return  none
     
185. *
     
186. * @ Pass/ Fail criteria: none
     
187. *****************************************************************************/
     
188. void gd25qRead(uint32_t addr,uint32_t Len,uint8_t *Des)
     
189. {
     
190.     UINT32_VAL Par;
     
191.    
     
192.     //waiting for idle
     
193.     while(gd25qBusy()){}
     
194.     //
     
195.     GD25Cs(0);
     
196.     Par.Val = addr;   
     
197.     dgSpiRw( GD25CMD_Read_Data);
     
198.     dgSpiRw( Par.byte.UB);
     
199.     dgSpiRw( Par.byte.HB);
     
200.     dgSpiRw( Par.byte.LB);
     
201.     while(Len--)
     
202.     {
     
203.         *Des++ = dgSpiRw( 0xFF );
     
204.     }
     
205.    
     
206.     GD25Cs(1);
     
207. }
     
208. 
     
209. /*****************************************************************************//*!
     
210. * @brief   write data ,must be in same page.
     
211. *               
     
212. * @param   addr          address in chip
     
213. *          len           length will be read
     
214. *          des           source
     
215. *
     
216. * @return  none
     
217. *
     
218. * @ Pass/ Fail criteria: none
     
219. *****************************************************************************/
     
220. void gd25qWrite(uint32_t addr,uint32_t Len,uint8_t *Src)
     
221. {
     
222.     UINT32_VAL Par;
     
223.    
     
224.     //waiting for idle
     
225.     while(gd25qBusy()){}
     
226.         
     
227.     gd25qCmdWriteEn();
     
228.         
     
229.     GD25Cs(0);
     
230.     Par.Val = addr;   
     
231.     dgSpiRw( GD25CMD_Page_Program);
     
232.     dgSpiRw( Par.byte.UB);
     
233.     dgSpiRw( Par.byte.HB);
     
234.     dgSpiRw( Par.byte.LB);
     
235.     while(Len--)
     
236.     {
     
237.         dgSpiRw( *Src++ );
     
238.     }  
     
239.     GD25Cs(1);
     
240. }
     
241. 
     
242. /*****************************************************************************//*!
     
243. * @brief   read data.
     
244. *               
     
245. * @param   addr          address in chip
     
246. *          len           length will be read
     
247. *          des           destination
     
248. *
     
249. * @return  none
     
250. *
     
251. * @ Pass/ Fail criteria: none
     
252. *****************************************************************************/
     
253. void gd25qDmaRead(uint32_t addr,uint32_t Len,uint8_t *Des)
     
254. {
     
255.     UINT32_VAL Par;
     
256.    
     
257.     //waiting for idle
     
258.     while(gd25qBusy()){}
     
259.     //
     
260.     GD25Cs(0);
     
261.     Par.Val = addr;   
     
262.     dgSpiRw( GD25CMD_Read_Data);
     
263.     dgSpiRw( Par.byte.UB);
     
264.     dgSpiRw( Par.byte.HB);
     
265.     dgSpiRw( Par.byte.LB);
     
266. 
     
267.     gdSpiDmaRw(GD25Q_READ,  Len, Des);
     
268.     GD25Cs(1);
     
269. }
     
270. 
     
271. /*****************************************************************************//*!
     
272. * @brief   write data ,must be in same page.
     
273. *               
     
274. * @param   addr          address in chip
     
275. *          len           length will be read
     
276. *          des           source
     
277. *
     
278. * @return  none
     
279. *
     
280. * @ Pass/ Fail criteria: none
     
281. *****************************************************************************/
     
282. void gd25qDmaWrite(uint32_t addr,uint32_t Len,uint8_t *Src)
     
283. {
     
284.     UINT32_VAL Par;
     
285.    
     
286.     //waiting for idle
     
287.     while(gd25qBusy()){}
     
288.         
     
289.     gd25qCmdWriteEn();
     
290.         
     
291.     GD25Cs(0);
     
292.     Par.Val = addr;   
     
293.     dgSpiRw( GD25CMD_Page_Program);
     
294.     dgSpiRw( Par.byte.UB);
     
295.     dgSpiRw( Par.byte.HB);
     
296.     dgSpiRw( Par.byte.LB);
     
297.         
     
298.     gdSpiDmaRw(GD25Q_WRITE,  Len, Src);
     
299.    
     
300.     GD25Cs(1);
     
301. }
     

复制代码

strctr.c

1. #define _STR_MODULE_
   
2. 
   
3. #include "osObjects.h"
   
4. #include "strctr.h"
   
5. #include "gd25q_cmd.h"
   
6. 
   
7. uint8_t Gd25DataBuff[1024];
   
8. 
   
9. /*****************************************************************************//*!
   
10. *
    
11. * @brief   led task.
    
12. *     
    
13. * @param   none
    
14. *
    
15. * @return  none
    
16. *
    
17. * @ Pass/ Fail criteria: none
    
18. *****************************************************************************/
    
19. 
    
20. void StrCtrTask(void *argument) {
    
21.     uint16_t Cnt;
    
22.   
    
23.     gdSpiInit();
    
24.     Cnt = 0;
    
25.    
    
26.     for (;;) {
    
27. 
    
28.         vTaskDelay(250);
    
29.         gd25qRead(Cnt, 1024, Gd25DataBuff);
    
30.         Cnt++;
    
31.         if(Gd25DataBuff[0]){
    
32.            // Cnt = 256;
    
33.             //while(Cnt--)
    
34.             //  Gd25DataBuff[Cnt] = Cnt;
    
35.             //gd25qWrite(0x00, 256, Gd25DataBuff);
    
36.             //gd25qWrite(0x100, 256, Gd25DataBuff);
    
37.             //gd25qWrite(0x200, 256, Gd25DataBuff);
    
38.             //gd25qWrite(0x300, 256, Gd25DataBuff);
    
39.             //gd25qWrite(0x400, 256, Gd25DataBuff);
    
40.             //gd25qWrite(0x500, 256, Gd25DataBuff);
    
41.         }
    
42.     }
    
43. }
    

复制代码