FLASH 存储学习-串行SPI nor

分类： 嵌入式

1.1 SST25VF080B简介1.1.1 主要特性

关键点：容量、速度（时钟速度、读写速度）、功耗。

l 容量：8MBit；

l 最高SPI时钟频率：50MHz；

l 低功耗模式下电流消耗：5uA，正常读模式电流：15mA；低功耗！采用不同的制造技术功耗要低很多。

l 整片擦除：35ms；扇区/块擦除：18ms；字节编程：7us；整片擦除的速度要快很多！

1.2 系统框图与电路1.2.1 系统框图

    关于内部存储矩阵的访问和存储结构同并行NorFlash的一致，只不过多了个串行接口，用于实现对串行数据的解码。

1.2.2 存储组织

扇区大小4KB，块大小：32/64KB；页大小为字节或字。

1.2.3 引脚及封装

引脚说明：

l SCK、SI、SO、CE – SPI接口控制线

l WP# -- 用于使能状态寄存器中的BPL位，有效时只允许锁定BPL，而不允许解锁BPL。不是说明使能保护！BPL位用于锁定控制扇区保护的相应位。

l HOLD# -- 用于暂停与SPI的通信，而不需要复位器件；

1.2.4 典型电路

使用STM32F103驱动该器件时，典型的电路如图所示。

注意，WP为低，判定寄存器的锁定功能将启用。但不会太影响片内块的保护。

1.3 保护机制

  l 软件写保护：状态寄存器中的BP3—BP0、BPL提供片内块、状态寄存器的写保护。

  l 硬件保护：WP#引脚—低电平，用于锁定状态寄存位7—BPL。由表2，WP#为高时，可以执行状态寄存器写命令，可随时更改状态寄存器。为低时，只能将BPL置为1，而不能从1置为0，即置1后，状态寄存器将锁定不变。

WP# àBPL、BP3—BP0

BPLàBP3、BP0

1.4 编程接口1.4.1 状态寄存器

状态寄存器用于用于获取FLASH的当前工作状态。

l BUSY位：指示是否正在编程或擦除操作；

l WEL位：指示器件是否处理可写的状态。RESET状态(0)指示不可写，默认在上电、完成写操作后，器件自行返回到不可写状态，以保护器件不受意外的擦写。因而每次写FLASH前，都必须先清除(写1)，以使能器件的写。软件可控写。

l AAI位：指示器件是否处理地址自动增加模式或者是字节编程模式。

l BPL位：用于控制BPX是否可写。

l BPX位：用于控制保护块的范围，属于软件保护，扇区保护如下。

                                          

这里的扇区保护比较简单，更为复杂的扇区保护机制可针对每个扇区进行保护。

1.4.2 命令接口

通信过程中，仅仅只有读ID、读数据、读状态寄存器需要在可保护CS不变而继续写数据。其它的则需要写完后接CS线。

1.5 通信时序1． 单字SPI通信时序

无论SPI总线空闲时SCK为高或为低，保证在上升沿采样数据，下降沿输出数据。先传送高位，每次传送8位。

2． 读命令

3． 快速读模式

有可能内部使用了缓冲模式，可在更高的时钟速度（50MHz）下读数据。

4． 写使能

该命令可设置状态寄存器中的WEL位，使得可执行擦除和编程命令。

5． 写禁能

6． 字节编程

7． AAI编程

即自动地址增量的字编程，每个周期写1个字。

在最后，通过WRDI返回来正常模式。在每写完两个字后，需查询害怕状态。

在写字的过程中，有三种方式检测是否完成字编程。其中硬件检测：读SO的状态。可在写AAI命令之前，通过命令配置SO口为RD/BY#状态。或者也可通过读取状态寄存器来检测是否完成写操作。

8． 4KB的扇区擦除

9． 32K块擦除

10． 64K块擦除

11． 整片擦除

12． 读状态寄存器

13． 使能写状态寄存器和写状态寄存器

两条命令必须连续写，不允许被打断?以避免意外写状态寄存器。

l 当WP#为低电平时，BPL只能写1，不可写0.；此时若BPL位为高时，写状态寄存器命令将被忽略。即此时，状态寄存器只能被锁定(写1)，而不能再解锁(写0)！锁定后将不能再任意改高保护方式，相当于将当前的保护方式给固定下来！

l 而若WP#为高电平，BPL位失效，状态寄存器不再被锁定，此时BPL、BPX可被更改。BPL位可设置为１，也可设置为０。可任意更改保护方式。

WP#的作用，锁定BPL为1。一旦BPL锁定为1，则BPX将不可再更改，即软件保护将被锁定。当WP#无效时，BPL可随时、任意更改，同时更改软件保护。

14． JEDEC Read-ID

获取SST制造商的ID和SST FLASH器件的ID。

1.6 驱动设计

驱动框架如下图：

算法编写原则：

(1) 可以为每一种SPI Flash针对性的写一份驱动源码，但是当更换Flash时，需要修改的地方很多；当系统中有多个设备时，显示这不够用，因而最好的方法是实现面向对像的封装，将与Flash设备相关的信息封装在一个结构体内，具体的算法根据结构体中相关的数据来决定如何访问硬件，做到过程可以不依赖于实际的硬件；

(2) 尽量按标准的初始化、读写、关闭、控制接口设计API，这样可统一抽像出相应的结构，也易于使用和理解。留给最终用户调用的API应该尽量的少和易于理解；

(3) SPI Flash接口为SPI，操作方法与并行接口一致，但其扇区组织类似，从最大到最小区域分为芯片-块-扇区-页。编程算法则也是通过写命令序列的方式，如发送命令字-发送字节-发送数据-查询状态寄存器。保护方式是通过存储器中的一些非易失性的位置0或置1选择性地以扇区或块为保护单位。

1.7 驱动代码

点击(此处)折叠或打开

1. // SST25VF080B驱动接口
   
2. // By:lstzixing At ZLG
   
3. // Date: 2011-1
   
4. #include "STM32Lib\\stm32f10x.h"
   
5. #include "hal.h"
   
6. 
   
7. typedef unsigned long uint32;
   
8. typedef unsigned short uint16;
   
9. typedef unsigned char uint8;
   
10. 
    
11. #define SPI_FLASH_SIZE (1024*1024*2) // SPI Flash容量
    
12. #define SPI_FLASH_OK 0 
    
13. #define SPI_FLASH_ERR_PARA 3 // SPI Flash参数错误
    
14. 
    
15. // SPI Flash擦除操作码
    
16. #define SPI_FLASH_ERASE_CHIP 0 // 整片擦除
    
17. #define SPI_FLASH_ERASE_SECTOR 1 // 扇区擦除
    
18. #define SPI_FLASH_ERASE_BLOCK 2 // 块擦除
    
19. 
    
20. // SPI状态寄存器和位
    
21. #define SPI_FLASH_REG_BIT_BUSY (1 << 0)
    
22. #define SPI_FLASH_REG_BIT_WEL (1 << 1)
    
23. #define SPI_FLASH_REG_BIT_BPX (0xF << 2)
    
24. #define SPI_FLASH_REG_BIT_AAI (1 << 6)
    
25. #define SPI_FLASH_REG_BIT_BPL (1 << 7)
    
26. 
    
27. #define SPIFlashSelect()         GPIO_ResetBits(GPIOC, GPIO_Pin_13) /* SST CS = L */ 
    
28. #define SPIFlashDeSelect()         GPIO_SetBits(GPIOC, GPIO_Pin_13) /* SST CS = H */
    
29. 
    
30. /*********************************************************************************************************
    
31. ** Function name: SPIFlashInit
    
32. ** Descriptions: 初始化SPI硬件，设置相关的GPIO口、SPI控制器
    
33. ** Input parameters: none
    
34. ** Output parameters: None
    
35. ** Returned value: none
    
36. *********************************************************************************************************/
    
37. void SPIFlashInit(void)
    
38. {
    
39.     // 打开SPI1和GPIO时钟 
    
40.     RCC->APB2ENR |= RCC_APB2ENR_SPI1EN |
    
41.                     RCC_APB2ENR_IOPAEN |
    
42.                     RCC_APB2ENR_IOPBEN |
    
43.                     RCC_APB2ENR_IOPCEN |
    
44.                     RCC_APB2ENR_IOPDEN |
    
45.                     RCC_APB2ENR_IOPEEN |
    
46.                     RCC_APB2ENR_IOPFEN;
    
47. 
    
48.     // PA5/6/7为复用模式， 50MHZ
    
49.     GPIOA->CRL &= ~(GPIO_CRL_CNF5 | GPIO_CRL_CNF6 | GPIO_CRL_CNF7 |
    
50.                     GPIO_CRL_MODE5 | GPIO_CRL_MODE6 | GPIO_CRL_MODE7);
    
51.     GPIOA->CRL |= GPIO_CRL_MODE5 | GPIO_CRL_MODE6 | GPIO_CRL_MODE7 |
    
52.                   GPIO_CRL_CNF5_1 | GPIO_CRL_CNF6_1 | GPIO_CRL_CNF7_1;
    
53. 
    
54.     // 配置PC.13为输出片选线
    
55.     GPIOC->CRH &= ~(GPIO_CRH_CNF13 | GPIO_CRH_MODE13);
    
56.     GPIOC->CRH |= GPIO_CRH_MODE13;
    
57. 
    
58.     // 配置SPI1,第一个时钟沿采样、主机、分频最大、使能、软件从机管理 
    
59.     SPI1->CR1 = //SPI_CR1_CPHA | 
    
60.                 SPI_CR1_MSTR |
    
61.                 //SPI_CR1_BR |
    
62.                 SPI_CR1_SSI | 
    
63.                 SPI_CR1_SPE |
    
64.                 SPI_CR1_SSM; 
    
65. 
    
66.     SPI1->CR2 = 0;
    
67. 
    
68.     SPIFlashDeSelect();
    
69. }
    
70. 
    
71. /*********************************************************************************************************
    
72. ** Function name: SPIWriteReadByte
    
73. ** Descriptions: 向SPI发送并读取一数据
    
74. ** Input parameters: data 要发送的数据
    
75. ** Output parameters: None
    
76. ** Returned value: uint16 读取的数据
    
77. *********************************************************************************************************/
    
78. static uint16 SPIWriteReadByte(uint16 data)
    
79. {
    
80.     // 发送一字节
    
81.     while((SPI1->SR & SPI_I2S_FLAG_TXE) == RESET);
    
82.     SPI1->DR = data;
    
83. 
    
84.     // 接收一字节
    
85.     while((SPI1->SR & SPI_I2S_FLAG_RXNE) == RESET);
    
86.     return(SPI1->DR);
    
87. }
    
88. 
    
89. /*********************************************************************************************************
    
90. ** Function name: SPIFlashReadstatusReg
    
91. ** Descriptions: 读状态寄存器
    
92. ** Input parameters: none
    
93. ** Output parameters: 当前状态寄存器的值
    
94. ** BIT0 -- BUSY位，写忙标志 
    
95. ** BIT1 -- WEL位，FLASH处于写保护状态
    
96. ** BIT6[5..2]--BP [3..0],扇区保护位
    
97. ** BIT6 -- 指示正在自动自境编程中
    
98. ** BIT7 -- BPL，BPX的保护位
    
99. ** Returned value: none
    
100. *********************************************************************************************************/
     
101. static uint8 SPIFlashReadstatusReg (void)
     
102. {
     
103.     uint8 uByte;
     
104. 
     
105.     // 发送读状态寄存器命令
     
106.     SPIFlashSelect();
     
107.     {
     
108.         SPIWriteReadByte(0x5);
     
109.         uByte = SPIWriteReadByte(0xFF);
     
110.     }
     
111.     SPIFlashDeSelect();
     
112. 
     
113.     return uByte; 
     
114. }
     
115. 
     
116. /*********************************************************************************************************
     
117. ** Function name: SPIFlashWritestatusReg
     
118. ** Descriptions: 写状态寄存器
     
119. ** Input parameters: status 要写入的值
     
120. ** Output parameters: none
     
121. ** Returned value: none
     
122. *********************************************************************************************************/
     
123. static void SPIFlashWritestatusReg (uint8 status)
     
124. {
     
125.     // 发送使能状态寄存器写命令
     
126.     SPIFlashSelect();
     
127.     {
     
128.         SPIWriteReadByte(0x50);
     
129.     }
     
130.     SPIFlashDeSelect();
     
131.     
     
132.     // 写命令和状态值
     
133.     SPIFlashSelect();
     
134.     {
     
135.         SPIWriteReadByte(0x1);
     
136.         SPIWriteReadByte(status);
     
137.     }
     
138.     SPIFlashDeSelect();
     
139. }
     
140. 
     
141. /*********************************************************************************************************
     
142. ** Function name: SPIFlashReadID
     
143. ** Descriptions: 读SPI FLASH的JEDEC ID
     
144. ** Input parameters: none
     
145. ** Output parameters: 读的ID，从最高字节到最低字节：制造商ID(1B)-存储类型(1B)-存储容量(1B)
     
146. ** Returned value: none
     
147. *********************************************************************************************************/
     
148. uint32 SPIFlashReadID (void)
     
149. {
     
150.     uint32 spiID;
     
151. 
     
152.     // 发送低速读命令0x9F，3字节地址,写入的字节
     
153.     SPIFlashSelect();
     
154.     {
     
155.         SPIWriteReadByte(0x9F);
     
156.         spiID = SPIWriteReadByte(0xff) << 16;
     
157.         spiID |= SPIWriteReadByte(0xff) << 8;
     
158.         spiID |= SPIWriteReadByte(0xff);
     
159.     }
     
160.     SPIFlashDeSelect();
     
161. 
     
162.     return spiID;
     
163. }
     
164. 
     
165. 
     
166. /*********************************************************************************************************
     
167. ** Function name: SPIFlashRead
     
168. ** Descriptions: 以低速方式(<=25MHZ)从SPI FLASH读数据
     
169. ** Input parameters: readBuf 读数据存储的缓冲区首址
     
170. ** readCnt 要读取的数据量
     
171. ** Output parameters: uint32 实际读得的数据量。当读地址超出芯片容量时，将只读在芯片地址范围内
     
172. ** 的数据
     
173. ** Returned value: none
     
174. *********************************************************************************************************/
     
175. uint32 SPIFlashRead (uint32 readAddr, uint8 * readBuf, uint32 readCnt)
     
176. {
     
177.     uint32 i;
     
178.     uint8 addr[3];
     
179. 
     
180.     // 检查参数
     
181.     if (readAddr >= SPI_FLASH_SIZE || 
     
182.         readBuf == 0 ||
     
183.         readCnt == 0) {
     
184.         return SPI_FLASH_ERR_PARA;
     
185.     }
     
186. 
     
187.     // 校正要读的数据总量
     
188.     if (readAddr + readCnt >= SPI_FLASH_SIZE) {
     
189.         readCnt = SPI_FLASH_SIZE - readAddr;
     
190.     }
     
191. 
     
192.     // 将地址转换为字节数组
     
193.     addr[0] = (uint8)(readAddr >> 16);
     
194.     addr[1] = (uint8)(readAddr >> 8);
     
195.     addr[2] = (uint8)(readAddr & 0xff);
     
196. 
     
197.     // 等待SPI Flash完成写操作
     
198.     while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
199. 
     
200.     SPIFlashSelect();
     
201.     {
     
202.         // 发送低速读命令0x3，3字节地址
     
203.         SPIWriteReadByte(0x3);
     
204.         SPIWriteReadByte(addr[0]);
     
205.         SPIWriteReadByte(addr[1]);
     
206.         SPIWriteReadByte(addr[2]);
     
207.     
     
208.         // 依次读readCnt个数据
     
209.         for (i = 0; i < readCnt; i++) {
     
210.             readBuf[i] = SPIWriteReadByte(0xff);
     
211.         }
     
212.     }
     
213.     SPIFlashDeSelect();
     
214. 
     
215.     return i;
     
216. }
     
217. 
     
218. /*********************************************************************************************************
     
219. ** Function name: SPIFlashFastRead
     
220. ** Descriptions: 以高速方式(<=50MHZ)从SPI FLASH读数据
     
221. ** Input parameters: readBuf 读数据存储的缓冲区首址
     
222. ** readCnt 要读取的数据量
     
223. ** Output parameters: uint32 实际读得的数据量。当读地址超出芯片容量时，将只读在芯片地址范围内
     
224. ** 的数据
     
225. ** Returned value: none
     
226. *********************************************************************************************************/
     
227. uint32 SPIFlashFastRead (uint32 readAddr, uint8 * readBuf, uint32 readCnt)
     
228. {
     
229.     uint32 i;
     
230.     uint8 addr[3];
     
231. 
     
232.     // 检查参数
     
233.     if (readAddr >= SPI_FLASH_SIZE || 
     
234.         readBuf == 0 ||
     
235.         readCnt == 0) {
     
236.         return SPI_FLASH_ERR_PARA;
     
237.     }
     
238. 
     
239.     // 校正要读的数据总量
     
240.     if (readAddr + readCnt >= SPI_FLASH_SIZE) {
     
241.         readCnt = SPI_FLASH_SIZE - readAddr;
     
242.     }
     
243. 
     
244.     // 将地址转换为字节数组
     
245.     addr[0] = (uint8)(readAddr >> 16);
     
246.     addr[1] = (uint8)(readAddr >> 8);
     
247.     addr[2] = (uint8)(readAddr & 0xff);
     
248. 
     
249.     // 等待SPI Flash完成写操作
     
250.     while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
251. 
     
252.     SPIFlashSelect();
     
253.     {
     
254.         // 发送低速读命令0x3，3字节地址,dummy字节
     
255.         SPIWriteReadByte(0xB);
     
256.         SPIWriteReadByte(addr[0]);
     
257.         SPIWriteReadByte(addr[1]);
     
258.         SPIWriteReadByte(addr[2]);
     
259.         SPIWriteReadByte(0xff);
     
260.     
     
261.         // 依次读readCnt个数据
     
262.         for (i = 0; i < readCnt; i++) {
     
263.             readBuf[i] = SPIWriteReadByte(0xff);
     
264.         }
     
265.     }
     
266.     SPIFlashDeSelect();
     
267. 
     
268.     return i;
     
269. }
     
270. 
     
271. /*********************************************************************************************************
     
272. ** Function name: SPIFlashWriteByte
     
273. ** Descriptions: 向SPI Flash指定地址处写一字节数据
     
274. ** Input parameters: writeAddr 写入的地址
     
275. ** udata 写入的值
     
276. ** Output parameters: none
     
277. ** Returned value: none
     
278. ** Notes: 写之前必须注意到写保护的存储影响
     
279. *********************************************************************************************************/
     
280. uint32 SPIFlashWriteByte (uint32 writeAddr, uint8 uByte)
     
281. {
     
282.     uint8 addr[3];
     
283. 
     
284.     // 检查写地址是否越界
     
285.     if (writeAddr >= SPI_FLASH_SIZE) {
     
286.         return SPI_FLASH_ERR_PARA;
     
287.     }
     
288. 
     
289.     // 将地址转换为字节数组
     
290.     addr[0] = (uint8)(writeAddr >> 16);
     
291.     addr[1] = (uint8)(writeAddr >> 8);
     
292.     addr[2] = (uint8)(writeAddr & 0xff);
     
293. 
     
294.     // 等待SPI Flash完成写操作
     
295.     while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
296. 
     
297.     // 发送写使能命令
     
298.     SPIFlashSelect();
     
299.     {
     
300.         SPIWriteReadByte(0x06);
     
301.     }
     
302.     SPIFlashDeSelect();
     
303. 
     
304.     // 写入实际要写入的数据
     
305.     SPIFlashSelect();
     
306.     {
     
307.         // 发送低速读命令0x3，3字节地址,写入的字节
     
308.         SPIWriteReadByte(0x2);
     
309.         SPIWriteReadByte(addr[0]);
     
310.         SPIWriteReadByte(addr[1]);
     
311.         SPIWriteReadByte(addr[2]);
     
312.         SPIWriteReadByte(uByte);
     
313.     }
     
314.     SPIFlashDeSelect();
     
315. 
     
316.     return SPI_FLASH_OK;
     
317. }
     
318. 
     
319. /*********************************************************************************************************
     
320. ** Function name: SPIFlashFastWrite
     
321. ** Descriptions: 以地址自增方式向指定FLASH地址处连续写字数据
     
322. ** Input parameters: writeAddr 写入的起始地址
     
323. ** writeBuferr 写数据存储的缓冲区
     
324. ** uWord 写入的数据量，以字为单位
     
325. ** Output parameters: none
     
326. ** Returned value: none
     
327. ** Notes: 写之前必须注意到写保护的存储影响
     
328. *********************************************************************************************************/
     
329. uint32 SPIFlashFastWrite (uint32 writeAddr, uint16 * writeBuferr, uint16 uWord)
     
330. {
     
331.     uint16 i;
     
332.     uint8 addr[3];
     
333. 
     
334.      // 检查参数
     
335.     if (writeAddr >= SPI_FLASH_SIZE || 
     
336.         writeBuferr == 0 ||
     
337.         uWord == 0) {
     
338.         return SPI_FLASH_ERR_PARA;
     
339.     }
     
340. 
     
341.     // 检查写地址是否越界
     
342.     if (writeAddr + (uWord << 1) >= SPI_FLASH_SIZE) {
     
343.         uWord = (SPI_FLASH_SIZE - writeAddr) >> 1; 
     
344.     }
     
345. 
     
346.     // 将地址转换为字节数组
     
347.     addr[0] = (uint8)(writeAddr >> 16);
     
348.     addr[1] = (uint8)(writeAddr >> 8);
     
349.     addr[2] = (uint8)(writeAddr & 0xff);
     
350. 
     
351.     // 等待SPI Flash完成写操作
     
352.     while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
353. 
     
354.     // 发送写使能命令
     
355.     SPIFlashSelect();
     
356.     {
     
357.         SPIWriteReadByte(0x06);
     
358.     }
     
359.     SPIFlashDeSelect();
     
360. 
     
361.     // 发送低速读命令0xAD，3字节地址,写入的字节
     
362.     SPIFlashSelect();
     
363.     {
     
364.         SPIWriteReadByte(0xAD);
     
365.         SPIWriteReadByte(addr[0]);
     
366.         SPIWriteReadByte(addr[1]);
     
367.         SPIWriteReadByte(addr[2]);
     
368.         SPIWriteReadByte(writeBuferr[0] >> 0x08);
     
369.         SPIWriteReadByte(writeBuferr[0] & 0xFF);
     
370.     }
     
371.     SPIFlashDeSelect();
     
372. 
     
373.     // 发送其它字节
     
374.     for (i = 1; i < uWord; i++) {
     
375.         // 等待SPI Flash完成写操作
     
376.         while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
377.     
     
378.         SPIFlashSelect();
     
379.         {
     
380.            // 发送引导命令和编程字数据
     
381.             SPIWriteReadByte(0xAD);
     
382.             SPIWriteReadByte(writeBuferr[i] >> 0x08);
     
383.             SPIWriteReadByte(writeBuferr[i] & 0xFF); 
     
384.         }
     
385.         SPIFlashDeSelect();
     
386.    } 
     
387. 
     
388.     // 等待SPI Flash完成写操作
     
389.     while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
390. 
     
391.     // 发送写禁能命令，退出该模式
     
392.     SPIFlashSelect();
     
393.     {
     
394.         SPIWriteReadByte(0x04);
     
395.     }
     
396.     SPIFlashDeSelect();
     
397. 
     
398.     return SPI_FLASH_OK;
     
399. }
     
400. 
     
401. 
     
402. /*********************************************************************************************************
     
403. ** Function name: SPIFlashChipErase
     
404. ** Descriptions: 擦除整块芯片
     
405. ** Input parameters: none
     
406. ** Output parameters: none
     
407. ** Returned value: none
     
408. ** Note: 如果sectorAaddr
     
409. *********************************************************************************************************/
     
410. void SPIFlashErase (uint8 eraseType, uint32 eraseAddr)
     
411. {
     
412.     uint8 addr[3];
     
413. 
     
414.     // 等待SPI Flash完成写操作
     
415.     while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
416. 
     
417.     // 发送写使能命令
     
418.     SPIFlashSelect();
     
419.     {
     
420.         SPIWriteReadByte(0x06);
     
421.     }
     
422.     SPIFlashDeSelect();
     
423. 
     
424.     // 根据类型选择擦除方式
     
425.     switch (eraseType) {
     
426.         // 选择整片擦除方式
     
427.         case SPI_FLASH_ERASE_CHIP:
     
428.             SPIFlashSelect();
     
429.             {
     
430.                 SPIWriteReadByte(0x60);
     
431.             }
     
432.             SPIFlashDeSelect();
     
433.             break;
     
434.         
     
435.         // 扇区擦除方式
     
436.         case SPI_FLASH_ERASE_SECTOR:
     
437.             if (eraseAddr < SPI_FLASH_SIZE) {
     
438.                 // 将地址转换为字节数组
     
439.                 addr[0] = (uint8)(eraseAddr >> 16);
     
440.                 addr[1] = (uint8)(eraseAddr >> 8);
     
441.                 addr[2] = (uint8)(eraseAddr & 0xff);
     
442.             
     
443.                 // 发送扇区擦除命令，擦除的扇区地址 
     
444.                 SPIFlashSelect();
     
445.                 {
     
446.                     SPIWriteReadByte(0x20);
     
447.                     SPIWriteReadByte(addr[0]);
     
448.                     SPIWriteReadByte(addr[1]);
     
449.                     SPIWriteReadByte(addr[2]);
     
450.                 }
     
451.                 SPIFlashDeSelect();
     
452.             }
     
453.             break;
     
454. 
     
455.         // 32K块擦除方式
     
456.         case SPI_FLASH_ERASE_BLOCK:
     
457.             if (eraseAddr < SPI_FLASH_SIZE) {
     
458.                 // 将地址转换为字节数组
     
459.                 addr[0] = (uint8)(eraseAddr >> 16);
     
460.                 addr[1] = (uint8)(eraseAddr >> 8);
     
461.                 addr[2] = (uint8)(eraseAddr & 0xff);
     
462.             
     
463.                 // 发送块擦除命令，擦除的块地址 
     
464.                 SPIFlashSelect();
     
465.                 {
     
466.                     SPIWriteReadByte(0x52);
     
467.                     SPIWriteReadByte(addr[0]);
     
468.                     SPIWriteReadByte(addr[1]);
     
469.                     SPIWriteReadByte(addr[2]);
     
470.                 }
     
471.                 SPIFlashDeSelect();
     
472.             }
     
473.             break;
     
474. 
     
475.         default:
     
476.             break;
     
477.     }
     
478. 
     
479. 
     
480. }
     
481. 
     
482. /*********************************************************************************************************
     
483. ** Function name: SPIFlashSetProtection
     
484. ** Descriptions: 设定SPI存储器的保护模式，加保护或解保护
     
485. ** Input parameters: isProtect 保护的模式，1--加保护， 0 -- 解保护
     
486. ** startAddr 保护区域的起始地址
     
487. ** stopAddr 保护区域的结束地址
     
488. ** Output parameters: 0 -- 操作成功， 1 -- 操作失败（当为解保护时，硬件保护阻止了解保护）
     
489. ** Returned value: none
     
490. *********************************************************************************************************/
     
491. uint32 SPIFlashSetProtection (uint8 isProtect, uint32 startAddr, uint32 stopAddr)
     
492. {
     
493.     uint8 BPXMask;
     
494.     uint8 status;
     
495. 
     
496.     // 等待SPI Flash完成写操作
     
497.     while (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BUSY );
     
498. 
     
499.     if (isProtect) {
     
500.         // 清除所有的保护位
     
501.         SPIFlashWritestatusReg(0);
     
502. 
     
503.         // 如果BPL只读，即不可更改BPX位
     
504.         if (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BPL) {
     
505. 
     
506.             // 当该区域已经加保护时，正确返回
     
507.             if ((status & SPI_FLASH_REG_BIT_BPX) > BPXMask) {
     
508.                 return 0;
     
509.             } else {
     
510.                 // 当未加保护时,返回错误，不可更改保护模式
     
511.                 return 1;
     
512.             }
     
513.             
     
514.         } else { 
     
515.             // 计算保护模式位
     
516.             if (startAddr > SPI_FLASH_SIZE) {
     
517.                 return 0;
     
518.             } else if (startAddr >= 0xF0000) {
     
519.                 BPXMask = 0x1 << 2; 
     
520.             } else if (startAddr >= 0xE0000) {
     
521.                 BPXMask = 0x2 << 2; 
     
522.             } else if (startAddr >= 0xC0000) {
     
523.                 BPXMask = 0x3 << 2; 
     
524.             } else if (startAddr >= 0x80000) {
     
525.                 BPXMask = 0x4 << 2; 
     
526.             } else {
     
527.                 BPXMask = 0x5 << 2; 
     
528.             }
     
529. 
     
530.             // BPL写读写，此时加上保护位即可，但不锁定BPL，以妨不可恢复 
     
531.             SPIFlashWritestatusReg(BPXMask);
     
532. 
     
533.             return 0;
     
534.         }
     
535.     } else {
     
536.         // 解除保护,写BPL位为0，解除保护
     
537.         SPIFlashWritestatusReg(0);
     
538. 
     
539.         // 读保护位，如果值不为全0，则可能硬件加保护，解保护失败
     
540.         if (SPIFlashReadstatusReg() & SPI_FLASH_REG_BIT_BPX) {
     
541.             return 1; 
     
542.         } else {
     
543.             return 0;
     
544.         }
     
545.     }
     
546. }
     
547. 
     
548. 
     
549. /* -------------------------------------------------- 测试代码 ---------------------------------------*/
     
550. uint32 id;
     
551. uint8 writeBuffer[1024];
     
552. uint8 readBuffer[1024];
     
553. uint8 status;
     
554. 
     
555. #define SPI_FLASH_SECTOR_SIZE (1024*4)
     
556. #define SPI_FLASH_BLOCK_SIZE (1024*32)
     
557. 
     
558. void SPIFlashTest (void)
     
559. {
     
560.     uint32 i, j;
     
561.     
     
562.     // 初始化SPI控制器
     
563.     SPIFlashInit();
     
564. 
     
565.     // 读ID测试，值应为0x00BF258E
     
566.     id = SPIFlashReadID();
     
567.     if (id != 0x00BF258E) {
     
568.         return;
     
569.     }
     
570. 
     
571.     // 先解除保护才可写
     
572.     SPIFlashSetProtection(0, 0xF0000, 0xFFFFF);
     
573. 
     
574.     // 整片擦除测试
     
575.     SPIFlashErase(SPI_FLASH_ERASE_CHIP, 0);
     
576.     for (i = 0; i < SPI_FLASH_SIZE / sizeof(readBuffer); i++) {
     
577.         SPIFlashRead(i * sizeof(readBuffer), readBuffer, sizeof(readBuffer)); 
     
578.         for (j = 0; j < sizeof(readBuffer); j++) {
     
579.             if (readBuffer[j] != 0xff) {
     
580.                 return;
     
581.             }
     
582.         } 
     
583.     }
     
584.     
     
585.     // 字节写和读测试
     
586.     for (i = 0; i < SPI_FLASH_SIZE; i++) {
     
587.         SPIFlashWriteByte(i, i); 
     
588.         SPIFlashRead (i, readBuffer, 1); 
     
589.         if( readBuffer[0] != (i & 0xff)) {
     
590.             return;
     
591.         } 
     
592.     }
     
593.     
     
594.     // 扇区擦除测试
     
595.     for (i = 0; i < SPI_FLASH_SIZE / (4*1024); i++) {
     
596.         SPIFlashErase(SPI_FLASH_ERASE_SECTOR, i * (4*1024));
     
597.     }
     
598.     for (i = 0; i < SPI_FLASH_SIZE / sizeof(readBuffer); i++) {
     
599.         SPIFlashRead(i * sizeof(readBuffer), readBuffer, sizeof(readBuffer)); 
     
600.         for (j = 0; j < sizeof(readBuffer); j++) {
     
601.             if (readBuffer[j] != 0xff) {
     
602.                 return;
     
603.             }
     
604.         } 
     
605.     }
     
606. 
     
607.     // 快速写测试
     
608.     for (i = 0; i < SPI_FLASH_SIZE / sizeof(writeBuffer); i++) {
     
609.         for (j = 0; j < sizeof(writeBuffer); j++) {
     
610.             writeBuffer[j] = j;
     
611.         }
     
612.         SPIFlashFastWrite( i * sizeof(writeBuffer), (uint16 *)writeBuffer, sizeof(writeBuffer) >> 1);
     
613.         SPIFlashFastRead ( i * sizeof(writeBuffer), (uint8 *)readBuffer, sizeof(readBuffer));
     
614. 
     
615.         // 交换字节顺序再比较
     
616.         for (j = 0; j < sizeof(writeBuffer) >> 1; j++) {
     
617.             uint16 * ptr = (uint16 *)&readBuffer[j << 1];
     
618.             *ptr = ((*ptr & 0xff) << 8) | (*ptr >> 8); 
     
619.         }
     
620.         if( memcmp( writeBuffer, readBuffer, sizeof(readBuffer)) != 0) {
     
621.             return;
     
622.         }
     
623.     }
     
624. 
     
625.     // 扇区擦除测试
     
626.     for (i = 0; i < SPI_FLASH_SIZE / (32*1024); i++) {
     
627.         SPIFlashErase(SPI_FLASH_ERASE_BLOCK, i * (32*1024));
     
628.     }
     
629.     for (i = 0; i < SPI_FLASH_SIZE / sizeof(readBuffer); i++) {
     
630.         SPIFlashRead(i * sizeof(readBuffer), readBuffer, sizeof(readBuffer)); 
     
631.         for (j = 0; j < sizeof(readBuffer); j++) {
     
632.             if (readBuffer[j] != 0xff) {
     
633.                 return;
     
634.             }
     
635.         } 
     
636.     }
     
637.     
     
638.     // 保护测试
     
639.     SPIFlashSetProtection(1, 0xF0000, 0xFFFFF);
     
640.     SPIFlashSetProtection(1, 0x80000, 0xFFFFF);
     
641.     SPIFlashSetProtection(0, 0xF0000, 0xFFFFF);
     
642. }

阅读(1141) | 评论(0) | 转发(3) |