一、QSPI
0 w8 H8 A3 i$ C* a        SPI 是 Queued SPI 的简写，是 Motorola公司推出的 SPI 接口的扩展，比 SPI 应用更加广泛。在 SPI 协议的基础上，Motorola 公司对其功能进行了增强，增加了队列传输机制，推出了队列串行外围接口协议（即 QSPI 协议），使用该接口，用户可以一次性传输包含多达16个8位或16位数据的传输队列。一旦传输启动，直到传输结束，都不需要CPU干预，极大的提高了传输效率。该协议在ColdFire系列MCU得到广泛应用。与SPI相比，QSPI的最大结构特点是以80字节的RAM代替了SPI的发送和接收寄存器。QSPI 是一种专用的通信接口，连接单、双或四（条数据线） SPI Flash 存储介质。

该接口可以在以下三种模式下工作：
) O# [1 J! c$ J0 R) z① 间接模式：使用 QSPI 寄存器执行全部操作
② 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）
; D& h, k7 N/ f; c/ N/ @  I③ 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器。
% L: K7 V+ `% C6 L) a" ?
% u$ n* ]" B" ^QSPI通过6根线与SPI芯片通信，下图是内部框图：

& I9 q( I/ U8 ~2 }+ h
QSPI每条命令，必须包含一个或多个阶段：指令、地址、交替字节、空指令和数据。
, d; y2 L6 f  z. {& n
% ^( g' A6 k# E! [9 NQSPI发送命令：等待QSPI空闲；设置命令参数。

/ c2 O' h5 c' ?+ [9 V* e- oQSPI读数据：设置数据传输长度；设置QSPI工作模式并设置地址；读取数据。
( ~( G% Y0 H: _; g+ C* d+ g. c
& W* u9 l& |. a1 V% ?  w! d, E$ a6 X. [QSPI写数据：设置数据传输长度；设置QSPI工作模式并设置地址；写数据。

, D/ `' P! \* j& h
二、几个重要的函数
% r+ P' r, l, T- \6 e

1. HAL_StatusTypeDef     HAL_QSPI_Init     (QSPI_HandleTypeDef *hqspi); // 初始化
   6 o- P* t. H) q, L. A7 P
2. 
   
3. HAL_StatusTypeDef HAL_QSPI_Command(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t Timeout); // 发送命令
   , u8 K6 t! C' N
4. 
   
5. HAL_StatusTypeDef     HAL_QSPI_Transmit     (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 发送数据
   
6. 
   
7. HAL_StatusTypeDef     HAL_QSPI_Receive      (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 接收数据

复制代码

三、几个重要的结构
! [/ V) b! U5 R7 r

1. // QSPI操作句柄
   
2. typedef struct
   
3. {
   + R0 [+ H1 l4 t2 ~. L# H# ^1 V
4.   QUADSPI_TypeDef            *Instance;        /* QSPI registers base address        */
   
5.   QSPI_InitTypeDef           Init;             /* QSPI communication parameters      */
   " T* T' t# R: F$ [% `! p
6.   uint8_t                    *pTxBuffPtr;      /* Pointer to QSPI Tx transfer Buffer */
   
7.   __IO uint16_t              TxXferSize;       /* QSPI Tx Transfer size              */
   / ]. t* U' _/ y/ _0 F( d+ s& M
8.   __IO uint16_t              TxXferCount;      /* QSPI Tx Transfer Counter           */
   
9.   uint8_t                    *pRxBuffPtr;      /* Pointer to QSPI Rx transfer Buffer */
   
10.   __IO uint16_t              RxXferSize;       /* QSPI Rx Transfer size              */
    
11.   __IO uint16_t              RxXferCount;      /* QSPI Rx Transfer Counter           */
    , k! z: L! {# L" w7 _# A
12.   DMA_HandleTypeDef          *hdma;            /* QSPI Rx/Tx DMA Handle parameters   */
    , N7 r" z) x: T! Z+ j/ p
13.   __IO HAL_LockTypeDef       Lock;             /* Locking object                     */
    
14.   __IO HAL_QSPI_StateTypeDef State;            /* QSPI communication state           */
    
15.   __IO uint32_t              ErrorCode;        /* QSPI Error code                    */
    6 |8 f6 a9 n% Q
16.   uint32_t                   Timeout;          /* Timeout for the QSPI memory access */
    % U& y- M/ g% ^/ A+ Z* Z6 v  r( s
17. }QSPI_HandleTypeDef;
      Z* U. h' n% n  G+ G
18. 
    % S3 P( ?3 z& T& P$ `1 l( U+ V9 a
19. // Instance：QSPI基地址  ---  QUADSPI
    3 d! {+ H- K4 V$ H
20. // Init：设置QSPI参数
    * o; b/ c% D, v! x5 f7 u
21. // pTxBuffPtr,TxXferSize,TxXferCount：发送缓存指针 发送数据量 剩余数据量
    
22. // pRxBuffPtr,RxXferSize,RxXferCount：接收缓存指针 发送数据量 剩余数据量
    
23. // hdma与DMA相关， 其他为过程变量不需要关心

复制代码

1. // 参数配置 时钟分频系数  FIFO阈值  采样移位  FLASH大小  片选高电平时间  时钟模式  闪存ID  双闪存模式设置
   
2. typedef struct
   
3. {
   
4.   uint32_t ClockPrescaler;     /* Specifies the prescaler factor for generating clock based on the AHB clock.
   
5.                                   This parameter can be a number between 0 and 255 */
   ) x" |' i' S; g/ R! y
6. 
   
7.   uint32_t FifoThreshold;      /* Specifies the threshold number of bytes in the FIFO (used only in indirect mode)
   
8.                                   This parameter can be a value between 1 and 32 */
   ! k: v) A+ X, K( `7 I
9. 
   
10.   uint32_t SampleShifting;     /* Specifies the Sample Shift. The data is sampled 1/2 clock cycle delay later to
    
11.                                   take in account external signal delays. (It should be QSPI_SAMPLE_SHIFTING_NONE in DDR mode)
    
12.                                   This parameter can be a value of @ref QSPI_SampleShifting */
    
13. 
    
14.   uint32_t FlashSize;          /* Specifies the Flash Size. FlashSize+1 is effectively the number of address bits
    " j% W+ _4 [! i7 J$ s8 Z$ d3 Q
15.                                   required to address the flash memory. The flash capacity can be up to 4GB
    ' ]3 k2 Q4 ?. n* E6 ]; o; m) B
16.                                   (addressed using 32 bits) in indirect mode, but the addressable space in
    
17.                                   memory-mapped mode is limited to 256MB
    , M) e- e. w+ p/ J$ R
18.                                   This parameter can be a number between 0 and 31 */
    % c1 D) ^/ T5 d2 b$ f! R6 b7 i
19. 
    
20.   uint32_t ChipSelectHighTime; /* Specifies the Chip Select High Time. ChipSelectHighTime+1 defines the minimum number
    0 N3 s- N  t* r  i* {; k: p
21.                                   of clock cycles which the chip select must remain high between commands.
    0 A5 V2 [' P0 E- P
22.                                   This parameter can be a value of @ref QSPI_ChipSelectHighTime */
    " \; a  w/ H( C
23. 
    + w1 H4 u! k% B1 Q$ A& ]
24.   uint32_t ClockMode;          /* Specifies the Clock Mode. It indicates the level that clock takes between commands.
    3 o) S  T3 L* s4 d
25.                                   This parameter can be a value of @ref QSPI_ClockMode */
    
26. 
    ) f0 I2 M9 d. j( F9 Y) S$ g
27.   uint32_t FlashID;            /* Specifies the Flash which will be used,
    ! i! K4 D. s& t3 [
28.                                   This parameter can be a value of @ref QSPI_Flash_Select */
    & }5 Y' w! y& V1 t8 n: e1 u8 A$ h6 A
29. 
    
30.   uint32_t DualFlash;          /* Specifies the Dual Flash Mode State
    
31.                                   This parameter can be a value of @ref QSPI_DualFlash_Mode */                                               
    2 T8 {7 J/ W4 {
32. }QSPI_InitTypeDef;

复制代码

1. // 采样移位
   
2. #define QSPI_SAMPLE_SHIFTING_NONE           ((uint32_t)0x00000000U)        /*!<No clock cycle shift to sample data*/
   , d5 ^* `2 r% a# |+ n
3. #define QSPI_SAMPLE_SHIFTING_HALFCYCLE      ((uint32_t)QUADSPI_CR_SSHIFT) /*!<1/2 clock cycle shift to sample data*/

复制代码

四、QSPI接口设计（仅供参考）

1. #define QSPI_CLK_ENABLE()         __HAL_RCC_QSPI_CLK_ENABLE();
   8 }+ r4 A5 O2 Z* L; R1 U  h
2. 
   4 D$ z9 b( w: s1 Q
3. #define QSPI_BK1_NCS_PORT         GPIOB
   + o5 h4 `7 T; n: {; F" [4 _$ P$ n
4. #define QSPI_BK1_NCS_PIN          GPIO_PIN_6
   7 B6 T7 R, b- w+ `
5. #define QSPI_BK1_NCS_AF           GPIO_AF10_QUADSPI
   + J# ]0 ]2 }7 g7 G. n% H+ r
6. #define QSPI_BK1_NCS_CONFIG()     GPIOConfigExt(QSPI_BK1_NCS_PORT, QSPI_BK1_NCS_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, QSPI_BK1_NCS_AF)
   9 S! V, b5 Q# C( Z0 W
7. 
   
8. #define QSPI_BK1_CLK_PORT         GPIOB
   ! m5 B* m6 B# K) Q$ Q  l* g
9. #define QSPI_BK1_CLK_PIN          GPIO_PIN_2
   
10. #define QSPI_BK1_CLK_AF           GPIO_AF9_QUADSPI
      L: l! P" D5 ?1 T4 @
11. #define QSPI_BK1_CLK_CONFIG()     GPIOConfigExt(QSPI_BK1_CLK_PORT, QSPI_BK1_CLK_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, QSPI_BK1_CLK_AF)
    
12. 
    
13. #define QSPI_BK1_IO0_PORT         GPIOF
    - F. N" q6 Z  h# e$ o
14. #define QSPI_BK1_IO0_PIN          GPIO_PIN_8
    
15. #define QSPI_BK1_IO0_AF           GPIO_AF10_QUADSPI
    
16. #define QSPI_BK1_IO0_CONFIG()     GPIOConfigExt(QSPI_BK1_IO0_PORT, QSPI_BK1_IO0_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, QSPI_BK1_IO0_AF)
    
17. 
    
18. #define QSPI_BK1_IO1_PORT         GPIOF
    
19. #define QSPI_BK1_IO1_PIN          GPIO_PIN_9
    
20. #define QSPI_BK1_IO1_AF           GPIO_AF10_QUADSPI
    ' I  _8 I0 f. E: Z
21. #define QSPI_BK1_IO1_CONFIG()     GPIOConfigExt(QSPI_BK1_IO1_PORT, QSPI_BK1_IO1_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, QSPI_BK1_IO1_AF)
    ! L. C9 I8 C; c/ S" a
22. 
    2 `4 ^2 A/ S2 I5 c
23. #define QSPI_BK1_IO2_PORT         GPIOF
    0 I' `; Y2 \. O& I, V% d. ]
24. #define QSPI_BK1_IO2_PIN          GPIO_PIN_7
    9 A5 h) k: d4 m. q# R- ]: E- p( m
25. #define QSPI_BK1_IO2_AF           GPIO_AF9_QUADSPI
    * }; c. W) @+ i; b4 V: h% ~9 E
26. #define QSPI_BK1_IO2_CONFIG()     GPIOConfigExt(QSPI_BK1_IO2_PORT, QSPI_BK1_IO2_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, QSPI_BK1_IO2_AF)
    ; R' |" U2 F' Q
27. 
    
28. #define QSPI_BK1_IO3_PORT         GPIOF
    ! F2 I% ]( o1 Q+ c* s+ k8 J: J9 U" h
29. #define QSPI_BK1_IO3_PIN          GPIO_PIN_6
    7 q2 ~2 p0 T) U$ x7 R* \7 Z8 D& O
30. #define QSPI_BK1_IO3_AF           GPIO_AF9_QUADSPI
    / i) H! P) H7 i, ~1 h  m
31. #define QSPI_BK1_IO3_CONFIG()     GPIOConfigExt(QSPI_BK1_IO3_PORT, QSPI_BK1_IO3_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, QSPI_BK1_IO3_AF)

复制代码

1. // 封装几个必要的接口
   
2. static QSPI_HandleTypeDef qspi_handle;
   
3. 
   
4. static void qspi_gpio_init(void)
   
5. {
   5 _* J0 M6 e! A# c
6.   QSPI_CLK_ENABLE();
   * s- j7 n* T" d/ m
7. 
   2 ^* Q9 s) ]; t! z3 _. n/ K* Z1 ~
8.   QSPI_BK1_NCS_CONFIG();
   
9.   QSPI_BK1_CLK_CONFIG();
   
10.   QSPI_BK1_IO0_CONFIG();
    ; f$ R2 h4 `2 P
11.   QSPI_BK1_IO1_CONFIG();
    7 X2 n1 _4 j; C8 D1 [1 b2 E
12.   QSPI_BK1_IO2_CONFIG();
    # r4 a" p' q, ^' J
13.   QSPI_BK1_IO3_CONFIG();
    $ \% B) R+ W% u( K7 w
14. }
    
15. 
    
16. static void qspi_mode_init(void)
    - s1 c/ g4 @# i/ b& |
17. {
    # u  j" q  ^" s$ M, R2 K3 a+ }5 X
18.   qspi_handle.Instance = QUADSPI;                        // QSPI
    
19.   qspi_handle.Init.ClockPrescaler = 2;                   // QPSI分频比，W25Q256最大频率为104M 所以此处应该为2，QSPI频率就为216/(2+1)=72MHZ
    
20.   qspi_handle.Init.FifoThreshold = 4;                    // FIFO阈值为4个字节
    : r- G# }- O. U
21.   qspi_handle.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE; // 采样移位半个周期(DDR模式下,必须设置为0)
    
22.   qspi_handle.Init.FlashSize = POSITION_VAL(0X2000000) - 1; // SPI FLASH大小，W25Q256大小为32M字节
    
23.   qspi_handle.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_4_CYCLE; // 片选高电平时间为4个时钟(13.8*4=55.2ns),即手册里面的tSHSL参数
    
24.   qspi_handle.Init.ClockMode = QSPI_CLOCK_MODE_0;        // 模式0
    7 U# w5 t2 h& Q
25.   qspi_handle.Init.FlashID = QSPI_FLASH_ID_1;            // 第一片flash
    
26.   qspi_handle.Init.DualFlash = QSPI_DUALFLASH_DISABLE;   // 禁止双闪存模式
    
27.   HAL_QSPI_Init(&qspi_handle);      //QSPI初始化
    5 Z. u$ e+ x9 o
28. }
    3 L4 `; W5 L. {% ?4 F
29. 
    # u  C" |# B) m7 f, A) V; x" a
30. void QSPIInit(void)
    $ j0 V) g8 q- L9 o0 I9 j  [
31. {
    * I5 A- F; Q9 \8 V
32.   qspi_gpio_init();
    5 a( s+ F# X" g9 h5 S" }
33.   qspi_mode_init();
    
34. }
    
35. 
    " l. c( o3 O" ~; f' f
36. // QSPI发送命令
    1 N% @& {% s9 `
37. // instruction:要发送的指令
    
38. // address:发送到的目的地址
    % t/ I& o" R: z1 M) Q/ L  [
39. // dummyCycles:空指令周期数
    
40. // instructionMode:指令模式;QSPI_INSTRUCTION_NONE,QSPI_INSTRUCTION_1_LINE,QSPI_INSTRUCTION_2_LINE,QSPI_INSTRUCTION_4_LINE
    
41. // addressMode:地址模式; QSPI_ADDRESS_NONE,QSPI_ADDRESS_1_LINE,QSPI_ADDRESS_2_LINE,QSPI_ADDRESS_4_LINE
    
42. // addressSize:地址长度;QSPI_ADDRESS_8_BITS,QSPI_ADDRESS_16_BITS,QSPI_ADDRESS_24_BITS,QSPI_ADDRESS_32_BITS
    
43. // dataMode:数据模式; QSPI_DATA_NONE,QSPI_DATA_1_LINE,QSPI_DATA_2_LINE,QSPI_DATA_4_LINE
    9 Q! n: q  I7 S- M+ A  ?" {" B
44. void QSPISendCMD(uint32_t instruction, uint32_t address, uint32_t dummyCycles, uint32_t instructionMode, uint32_t addressMode, uint32_t addressSize, uint32_t dataMode)
    " T: U8 M4 l- t: E3 M
45. {
    
46.   QSPI_CommandTypeDef Cmdhandler;
    
47. 
    6 Y; |% `- G9 p0 e. S$ z' E
48.   Cmdhandler.Instruction = instruction;           // 指令
    
49.   Cmdhandler.Address = address;                   // 地址
    , h8 a3 _. v( O% r' i( |
50.   Cmdhandler.DummyCycles = dummyCycles;           // 设置空指令周期数
    , [1 ?7 v" m1 B7 g5 ?4 T  Q" F& m
51.   Cmdhandler.InstructionMode = instructionMode;   // 指令模式
    ! @4 ^& K- D: t: {
52.   Cmdhandler.AddressMode = addressMode;           // 地址模式
    
53.   Cmdhandler.AddressSize = addressSize;           // 地址长度
    
54.   Cmdhandler.DataMode = dataMode;                 // 数据模式
    
55.   Cmdhandler.SIOOMode = QSPI_SIOO_INST_EVERY_CMD; // 每次都发送指令
    , _& Y+ |2 p2 t$ j, u$ `
56.   Cmdhandler.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; // 无交替字节
    ' L, w* |+ T5 q6 C( g$ T1 @
57.   Cmdhandler.DdrMode = QSPI_DDR_MODE_DISABLE;           // 关闭DDR模式
    / f4 Z6 ~, Y8 h  `
58.   Cmdhandler.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
    # c6 Z- f/ T& \3 S+ M
59. 
    
60.   HAL_QSPI_Command(&qspi_handle, &Cmdhandler, 5000);
    # L* D- t. ], \( u2 n0 W) \
61. }
    
62. 
    3 W" ?0 }: m7 x7 X: D, f9 a' R
63. // 接收指定长度数据
    . i' v' [/ x6 G- S$ l
64. uint8_t QSPIReceive(uint8_t *buffer, uint32_t length)
    & x. ^: r' u. k4 z- f  `8 _! A
65. {
    2 r" ^- d! v* o5 {* `+ }) u  K
66.   qspi_handle.Instance->DLR = length - 1;
    
67.         
    
68.   if(HAL_QSPI_Receive(&qspi_handle, buffer, 5000) == HAL_OK)
    
69.   {
    
70.     return 0;  //接收数据
    . h' I) w( p+ H  z
71.   }
    
72.   else
    
73.   {
    
74.     return 1;
    
75.   }
    : P- X* H) H& o/ u( j6 p8 C2 V
76. }
    
77. 
    
78. // 发送指定长度数据
    ' B% j8 j0 K' \) K* \: x2 ?7 t4 p
79. uint8_t QSPITransmit(uint8_t *buffer, uint32_t length)
    " @: D2 Y" P1 `) ]  Q
80. {
    * [5 W: l7 D' |7 S
81.   qspi_handle.Instance->DLR = length - 1;
    7 G& C' R* o2 P- {/ d, r
82.   if(HAL_QSPI_Transmit(&qspi_handle, buffer, 5000) == HAL_OK)
    
83.   {
    # S( U2 U$ S7 G5 {
84.     return 0;  //发送数据
    & x. _! l' E5 F  o) x1 T1 J
85.   }
    
86.   else
    
87.   {
    
88.     return 1;
    7 ~& ^/ ^$ X  P* _, v
89.   }
    
90. }

复制代码

五、QSPI驱动W25Q256
- u2 |# A+ q3 S; d  S& `W25Q256:32M  512块，每块16个扇区，每个扇区4K。具体指令看手册。封装了如下接口（初始化读写擦除等接口是以后移植文件系统的基础）：

: M" Y. i: W3 Z$ B: F  o

1. #define W25QXX_WRITE_ENABLE      0x06
   5 _, h0 a* J% x' `% ^+ ]
2. #define W25QXX_WRITE_DISABLE     0x04
     }0 z: |0 G- H/ S. F( ?- q* O
3. #define W25QXX_READ_STATUS_REG1  0x05
   
4. #define W25QXX_READ_STATUS_REG2  0x35
   
5. #define W25QXX_READ_STATUS_REG3  0x15
   
6. #define W25QXX_WRITE_STATUS_REG1 0x01
   ; y6 e# u8 ^: x) {7 C1 p  q
7. #define W25QXX_WRITE_STATUS_REG2 0x31
   
8. #define W25QXX_WRITE_STATUS_REG3 0x11
   $ o% |. z$ x' W( a
9. #define W25QXX_READ_DATA         0x03
   + k' l; L" `; t  U0 |. ?! N
10. #define W25QXX_FAST_READ_DATA    0x0B
    
11. #define W25QXX_FAST_READ_DUAL    0x3B
    
12. #define W25QXX_PAGE_PROGRAM      0x02
    
13. #define W25QXX_BLOCK_ERASE       0xD8
    
14. #define W25QXX_SECTOR_ERASE      0x20
    7 z+ L5 c! l. A* B/ s+ E
15. #define W25QXX_CHIP_ERASE        0xC7
    % D5 H5 ^6 \" q5 o7 \3 I$ V; p
16. #define W25QXX_DEVICEID          0xAB
    $ w/ K5 v' e, \6 R* L
17. #define W25QXX_MANUFACT_DEVICEID 0x90
    
18. #define W25QXX_JEDEC_DEVICEID    0x9F
    * N# Q7 M# i  r) d3 D) [
19. #define W25QXX_EABLE_4BYTE_ADDR  0xB7
    8 w. t4 M9 ]* U" l" f
20. #define W25QXX_EXIT_4BYTE_ADDR   0xE9
    9 K- D* J; ]1 M% Y5 }* B
21. #define W25QXX_SET_READ_PARAM    0xC0
    ; L* n4 g# T3 M1 F
22. #define W25QXX_ENTER_QPIMODE     0x38
    + B8 x, j! t) Z# l* M  z
23. #define W25QXX_EXIT_QPIMODE      0xFF
    ) e" Y. }5 Z5 j" d. |: U, I
24. 
    6 n+ [/ r% _9 C8 k
25. uint8_t w25qxx_qpi_mode = 0; // QSPI模式标志:0,SPI模式;1,QPI模式.
    ) Y: A2 o: X' Z0 s2 d1 q
26. 
    
27. // 读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
    
28. // 状态寄存器1：
    ! _. D; w9 ^. \. r: j3 L8 D
29. // BIT7  6   5   4   3   2   1   0
    7 |% I4 g% n  p  a& F
30. // SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
31. // SPR:默认0,状态寄存器保护位,配合WP使用
    . B' V5 l1 _# v# \, r$ K+ }
32. // TB,BP2,BP1,BP0:FLASH区域写保护设置
    
33. // WEL:写使能锁定
    : f( p3 f7 s6 ]6 n# |
34. // BUSY:忙标记位(1,忙;0,空闲)
    7 W: H' F: r) k2 I8 w
35. // 默认:0x00
    # ~. _1 b! m% W# R8 u
36. // 状态寄存器2：
    
37. // BIT7  6   5   4   3   2   1   0
    % }# F5 P8 q4 f& Z
38. // SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
    / _) L& z3 r. i1 q! I1 @, m$ z
39. // 状态寄存器3：
    
40. // BIT7      6    5    4   3   2   1   0
    
41. // HOLD/RST  DRV1 DRV0 (R) (R) WPS ADP ADS
    
42. // reg:状态寄存器号，范:1~3
    ' N: T) T1 Y9 g& ^8 W
43. // 返回值:状态寄存器值
    7 z; K, F, t  x* D" D
44. static uint8_t w25qxx_read_status(uint8_t reg)
    5 j/ S' J8 b$ P% b8 F
45. {
    
46.   uint8_t value = 0, command = 0;
    , Z! p& w" H/ L6 g9 D
47. 
    
48.   switch(reg)
    
49.   {
    7 T, z0 \# n* H  l1 V$ d# j
50.   case 1:
    9 M% b9 p; l2 U) T' c' X$ N! I
51.     command = W25QXX_READ_STATUS_REG1;  // 读状态寄存器1指令
    & d5 E$ y7 D( e
52.     break;
    
53. 
    
54.   case 2:
    
55.     command = W25QXX_READ_STATUS_REG2;  // 读状态寄存器2指令
    
56.     break;
    : u( Q2 y) T( j7 S5 Y9 {4 M
57. 
    7 R$ x8 H" p. U: M- B" n4 t
58.   case 3:
    ) }( S0 \0 U2 n
59.     command = W25QXX_READ_STATUS_REG3;  // 读状态寄存器3指令
    + x$ i' Y' W) b+ ~# Q" H
60.     break;
    
61. 
    
62.   default:
    
63.     command = W25QXX_READ_STATUS_REG1;
    9 {6 h8 R  ^6 e. w: T. U7 f
64.     break;
    9 X& `5 ^0 @8 u, r8 [! R& J
65.   }
    7 _: {% j2 s' ?9 f
66. 
    
67.   if(w25qxx_qpi_mode)
    4 P4 R  H4 P7 h" b
68.   {
    ! p3 o  i3 u8 t8 l2 @2 D8 g
69.     QSPISendCMD(command, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_4_LINES);  //QPI,写command指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据
    
70.   }
    
71.   else
    # w  q. \  o6 ?+ Z& _- A
72.   {
    
73.     QSPISendCMD(command, 0, 0, QSPI_INSTRUCTION_1_LINE, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_1_LINE);  //SPI,写command指令,地址为0,单线传数据_8位地址_无地址_单线传输指令,无空周期,1个字节数据
    
74.   }
    
75. 
    
76.   QSPIReceive(&value, 1);
    
77. 
    
78.   return value;
    . R6 t" B/ A# P3 |8 u% y4 d4 G
79. }
    
80. 
    
81. // 写状态寄存器
    0 K3 {! l4 ]; A( A
82. static void w25qxx_write_status(uint8_t reg, uint8_t status)
    
83. {
    
84.   uint8_t command = 0;
    
85. 
    / o; o- e0 A5 a% `  h/ t$ |
86.   switch(reg)
    
87.   {
    
88.   case 1:
    
89.     command = W25QXX_WRITE_STATUS_REG1;  //写状态寄存器1指令
    7 m5 H6 P$ \1 L2 @
90.     break;
    
91.   case 2:
    5 \. Z5 S% d, z  B4 ?! E
92.     command = W25QXX_WRITE_STATUS_REG2;  //写状态寄存器2指令
    
93.     break;
    
94.   case 3:
    
95.     command = W25QXX_WRITE_STATUS_REG3;  //写状态寄存器3指令
    , R$ w' o2 t* a6 n' l2 \* C
96.     break;
    8 n2 a0 @  N6 T& a
97.   default:
    
98.     command = W25QXX_WRITE_STATUS_REG1;
    
99.     break;
    
100.   }
     7 L5 Z3 S$ H# Y# b5 A
101.   if(w25qxx_qpi_mode)
     
102.   {
     
103.     QSPISendCMD(command, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_4_LINES); // QPI,写command指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据
     & |( p" ]* F8 e! w
104.   }
     
105.   else
     - g2 H- H6 b) H; m3 {, g( O! [
106.   {
     
107.     QSPISendCMD(command, 0, 0, QSPI_INSTRUCTION_1_LINE, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_1_LINE); // SPI,写command指令,地址为0,单线传数据_8位地址_无地址_单线传输指令,无空周期,1个字节数据
     
108.   }
     - G. s& o0 R8 S4 F. Y" F
109.   QSPITransmit(&status, sizeof(status));
     9 w3 r0 m5 f) ]4 x- a' F: w
110. }
     
111. 
     8 `) N8 H1 u- v* m9 L0 b; ~2 P
112. // 写使能  将S1寄存器的WEL置位
     
113. static void w25qxx_write_enable(void)
     
114. {
     ' h& A5 G+ x- j$ p. H. R2 n% w6 C
115.   if(w25qxx_qpi_mode)
     
116.   {
     
117.     QSPISendCMD(W25QXX_WRITE_ENABLE, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // QPI,写使能指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
     
118.   }
     ( z% J8 Z8 Q6 l! |+ |1 B5 R9 _
119.   else
     
120.   {
     9 n- t9 a6 u# W, |8 J
121.     QSPISendCMD(W25QXX_WRITE_ENABLE, 0, 0, QSPI_INSTRUCTION_1_LINE, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // SPI,写使能指令,地址为0,无数据_8位地址_无地址_单线传输指令,无空周期,0个字节数据
     
122.   }
     + v) j5 E; X% v+ H% t! K
123. }
     1 O  Y) i: M3 t8 m# j4 j
124. 
     + y  n! [5 V2 d
125. // 写失能  将WEL清零
     
126. void W25QXX_Write_Disable(void)
     
127. {
     
128.   if(w25qxx_qpi_mode)
     
129.   {
     
130.     QSPISendCMD(W25QXX_WRITE_DISABLE, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // QPI,写禁止指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
     
131.   }
     . A' U0 {8 ]) c  ~! K  ~; Z
132.   else
     & F# p! c6 g& Z% m) J/ ]  D
133.   {
     ; K. _7 |7 H6 `% @2 G& a3 @
134.     QSPISendCMD(W25QXX_WRITE_DISABLE, 0, 0, QSPI_INSTRUCTION_1_LINE, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // SPI,写禁止指令,地址为0,无数据_8位地址_无地址_单线传输指令,无空周期,0个字节数据
     
135.   }
     : [7 I; C3 q7 i1 l; h& o3 t
136. }
     
137. 
     
138. // 等待空闲
     
139. void w25qxx_wait_busy(void)
     " f8 N. q4 ?/ a# T% Q2 c
140. {
     7 g/ i2 f- ^* K6 G7 W( D1 `3 \" x! d
141.   while((w25qxx_read_status(1) & 0x01) == 0x01); // 等待BUSY位清空
     1 R: c) E, o9 F
142. }
     3 U+ Q  g) m7 n
143. 
     
144. // W25QXX进入QSPI模式
     % H" d6 `2 r1 j! E1 \# t5 S& _
145. static void w25qxx_qspi_init(void)
     ( B: f& k: Q+ ]# \' r
146. {
     9 A  r9 ^8 t5 H! {
147.   uint8_t reg2;
     
148.   reg2 = w25qxx_read_status(2); // 先读出状态寄存器2的原始值
     ) y4 r; d) w; |2 w) D
149.   if((reg2 & 0X02) == 0)  // QE位未使能
     
150.   {
     . K  {; N6 [. v
151.     w25qxx_write_enable(); // 写使能
     
152.     reg2 |= 1 << 1; // 使能QE位
     
153.     w25qxx_write_status(2, reg2); // 写状态寄存器2
     
154.   }
     
155. 
     6 R4 H& ], R3 I1 A
156.   QSPISendCMD(W25QXX_ENTER_QPIMODE, 0, 0, QSPI_INSTRUCTION_1_LINE, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // 写command指令,地址为0,无数据_8位地址_无地址_单线传输指令,无空周期,0个字节数据
     6 Y% r1 i6 |3 @  g! u
157. 
     ; y( X' p* Q8 \5 z8 I* }
158.   w25qxx_qpi_mode = 1; // 标记QSPI模式
     
159. }
     
160. 
     - O7 }3 [# D! v8 F* G; D
161. // 0XEF13,表示芯片型号为W25Q80
     
162. // 0XEF14,表示芯片型号为W25Q16
     
163. // 0XEF15,表示芯片型号为W25Q32
     
164. // 0XEF16,表示芯片型号为W25Q64
     
165. // 0XEF17,表示芯片型号为W25Q128
     
166. // 0XEF18,表示芯片型号为W25Q256
     
167. static void w25qxx_id_get(void)
     / ^; Q: c$ n! [
168. {
     % N1 m- g: K. g6 a1 `3 u
169.   uint8_t temp[2];
     
170.   uint16_t device_id;
     4 l$ Y2 H% S% z3 F' |
171. 
     9 u3 R/ B) v; }. [/ g% j
172.   if(w25qxx_qpi_mode)
     * V8 q: z4 @2 E& [8 O# d. F
173.   {
     
174.     QSPISendCMD(W25QXX_MANUFACT_DEVICEID, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_4_LINES, QSPI_ADDRESS_24_BITS, QSPI_DATA_4_LINES); // QPI,读id,地址为0,4线传输数据_24位地址_4线传输地址_4线传输指令,无空周期,2个字节数据
     6 L) }2 f; P* j; z
175.   }
     
176.   else
     , G. D# U0 C+ p0 O1 [  V5 w4 q
177.   {
     
178.     QSPISendCMD(W25QXX_MANUFACT_DEVICEID, 0, 0, QSPI_INSTRUCTION_1_LINE, QSPI_ADDRESS_1_LINE, QSPI_ADDRESS_24_BITS, QSPI_DATA_1_LINE); // SPI,读id,地址为0,单线传输数据_24位地址_单线传输地址_单线传输指令,无空周期,2个字节数据
     % L, J! W" v/ F  Y" J. |6 ]
179.   }
     3 y5 Z9 [3 o  U  z& s0 u
180. 
     
181.   QSPIReceive(temp, 2);
     
182. 
     + M  b8 l8 G( O2 `4 n# D  Y  E
183.   device_id = (temp[0] << 8) | temp[1];
     ( F1 G9 Y2 n" u  t/ l
184. 
     
185.   printf("QSPI Flash Device ID: %X\r\n", device_id);
     
186. }
     
187. 
     ! Q) l( O; `* ]( {( C% Y& _2 [7 G7 m
188. void W25QXXInit(void)
     
189. {
     
190.   uint8_t temp;
     
191. 
     ; N, z/ ]. ]- n& F$ z( U7 l2 d
192.   QSPIInit();
     + z. x# N0 b4 Z) ^
193.   w25qxx_qspi_init(); // 使能QSPI模式
     2 T4 N- e+ m; X
194.   w25qxx_id_get();    // 读取FLASH ID.
     # P( Y2 }; o3 p/ C' B( q5 T
195. 
     % P  X9 a4 A- p& k% e9 \, }% q
196.   temp = w25qxx_read_status(3); // 读取状态寄存器3，判断地址模式
       A- R" o6 e: m, H# ?2 ]: ~
197.   if((temp & 0X01) == 0) // 如果不是4字节地址模式,则进入4字节地址模式
     
198.   {
     
199.     w25qxx_write_enable(); // 写使能
     + A! U  ~. E  T( Z
200.     QSPISendCMD(W25QXX_EABLE_4BYTE_ADDR, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // QPI,使能4字节地址指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
     " v: Q8 \0 |: P; S/ H) Z
201.   }
     / v3 n7 c5 Q/ G+ @
202.   w25qxx_write_enable(); // 写使能
     ! t' a9 L. e9 R1 a/ y* q% ~: a
203.   QSPISendCMD(W25QXX_SET_READ_PARAM, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_4_LINES); // QPI,设置读参数指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据
     
204.   temp = 3 << 4;      // 设置P4&P5=11,8个dummy clocks,104M
     
205.   QSPITransmit(&temp, 1);
     + {/ h- B) j' N% p
206. }
     % o: w2 x" |; n/ L/ z- P% I' ?: ]
207. 
     0 F, b9 @+ u6 B& Z) q$ q. o
208. // 擦除一块4096字节 最少需要150ms
     / B* M! |8 f' p' }6 A8 R# j/ {
209. void W25QXXSectorErase(uint32_t addr)
     
210. {
     
211.   //addr /= 4096;
     * t$ J0 A% \% D7 x. E) w. }' H) l
212.   addr *= 4096;
     ( ]' o5 W) V# t6 x
213. 
     
214.   w25qxx_write_enable();
     4 P. F# O/ [: U: y$ q8 P
215.   w25qxx_wait_busy();
     
216.   QSPISendCMD(W25QXX_SECTOR_ERASE, addr, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_4_LINES, QSPI_ADDRESS_32_BITS, QSPI_DATA_NONE); // QPI,写扇区擦除指令,地址为0,无数据_32位地址_4线传输地址_4线传输指令,无空周期,0个字节数据
     
217.   w25qxx_wait_busy();
     
218. }
     ' M: x$ b9 f( `1 ?# p$ V
219. 
     
220. 
     + b( W3 ~% q. f# Z
221. // 擦除整个芯片
     
222. void W25QXXChipErase(void)
     9 ^* u- B8 v; |5 b5 B1 m" e
223. {
     ) U/ i) n8 K; L% m- D, K3 H$ w
224.   w25qxx_write_enable();          //SET WEL
     
225.   w25qxx_wait_busy();
     $ U2 H* C% U& O9 ^% l
226.   QSPISendCMD(W25QXX_CHIP_ERASE, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // QPI,写全片擦除指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
     
227.   w25qxx_wait_busy();           //等待芯片擦除结束
     ; }1 ?+ }) R$ Q1 m# E
228. }
     # O- M/ T& ]1 M" j4 f2 e1 V
229. 
     1 w& b3 T2 H) ^5 L6 T% Q/ n
230. // 写最多256字节
     3 o* l$ m" W: H/ y% Y- {+ L
231. void W25QXXWritePage(uint32_t addr, uint8_t *buffer, uint16_t length)
     
232. {
     , u. g! H! c* R. y: t' z
233.   w25qxx_write_enable();          //写使能
     : Z7 Y, @* ]+ C3 [7 H6 [
234.   QSPISendCMD(W25QXX_PAGE_PROGRAM, addr, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_4_LINES, QSPI_ADDRESS_32_BITS, QSPI_DATA_4_LINES); // QPI,页写指令,地址为WriteAddr,4线传输数据_32位地址_4线传输地址_4线传输指令,无空周期,NumByteToWrite个数据
     ) q) e4 i: x" m' R- p
235.   QSPITransmit(buffer, length);
     " e0 J& o2 h: j; A
236.   w25qxx_wait_busy();            //等待写入结束
     $ j1 s# h& h; _% r" c: x  R
237. }
     - |$ k% V7 m) v5 I1 ?9 M0 X6 M
238. 
     
239. // 写最多65536字节 无擦除动作
     2 i% b; A0 X: U' u" p  w/ G
240. void W25QXXWriteExt(uint32_t addr, uint8_t *buffer, uint16_t length)
     9 f$ |. V- J+ J; T7 n; |/ L3 B
241. {
     
242.   uint16_t pageremain = 256 - addr % 256; // 单页剩余的字节数
     2 E! I) S) Y- j- {6 s" ]+ Z
243. 
     . h. R/ L0 f; l  M0 ?3 w7 b" G/ `
244.   if(addr + length - 1 > (32 * 1024 * 1024))
     % f1 g% J/ a8 y
245.   {
     1 }( {+ b+ d9 S
246.     return;
     
247.   }
     
248. 
     - m0 E$ ]; _8 u( U
249.   if(length <= pageremain)
     
250.   {
     % m, O8 u6 K! c' A( e
251.     pageremain = length;  // 不大于256个字节
     ; ^; i! v2 p1 B- I# v- C7 M5 l
252.   }
     * m* v4 ], D) \) M
253.   while(1)
     3 O4 k4 Y% H( ]4 V3 V& W
254.   {
     4 H1 V! _" q5 p  A2 ^
255.     // 分页写入
     
256.     W25QXXWritePage(addr, buffer, pageremain);
     
257. 
     
258.     if(length == pageremain)
     ) m0 m$ a5 |8 B: O2 w; e% J
259.     {
     ' m0 K  _6 d: E( Q2 }
260.       break;  //写入结束了
     # R  `6 F# g" y  s
261.     }
     ; u, f4 Y7 s3 A& V$ i* D
262.     else
     * C5 w$ r$ d* p: q5 q9 Y8 Z, T
263.     {
     5 i& i# K/ Z. G/ \! ?  y
264.       buffer += pageremain;
     ! c: @1 U0 E3 F3 z7 u1 Q
265.       addr += pageremain;
     9 R* _9 `' J7 P; z, {- P) `
266. 
     * C4 ]* U& g8 ~* D
267.       length -= pageremain; // 减去已经写入了的字节数
     ' n" c: m# [3 X& H" W8 A$ z' O
268.       if(length > 256)
     . j5 A" ?3 t, C3 {' b- K3 ]% t' {" w
269.       {
     
270.         pageremain = 256;  // 一次可以写入256个字节
     
271.       }
     / M3 k8 V1 G; r. {/ Z* J
272.       else
     
273.       {
     
274.         pageremain = length;  // 不够256个字节了
     
275.       }
     
276.     }
     
277.   }
     
278. }
     
279. 
     
280. // 写最多65536字节 带擦除动作
     
281. static uint8_t W25QXX_BUFFER[4096];
     8 `2 x1 o% |! _( Z# Z
282. void W25QXXWrite(uint32_t addr, uint8_t* buffer, uint16_t length)
     2 M: z/ J3 ~/ c6 X
283. {
     
284.   uint32_t secpos;
     
285.   uint16_t secoff, secremain, i;
     
286.   uint8_t * w25q_buf;
     . P/ L6 r% V+ M
287. 
     " u6 s% z7 O  r7 j
288.   w25q_buf = W25QXX_BUFFER;
     
289. 
     0 }9 ^8 r# C$ e! a
290.   secpos = addr / 4096; // 扇区地址
     
291.   secoff = addr % 4096; // 在扇区内的偏移
     
292.   secremain = 4096 - secoff; // 扇区剩余空间大小
     
293. 
     
294.   if(length <= secremain)
     
295.   {
     ( s4 @" W$ O) b& q. F
296.     secremain = length;  // 不大于4096个字节
     . n0 f4 p* |  o  j1 b- l  W6 X
297.   }
     
298.   while(1)
     
299.   {
     4 ^: [; Y9 R/ }, ?- o
300.           WatchdogFeed();
     
301.     W25QXXRead(secpos * 4096, w25q_buf, 4096); // 读出整个扇区的内容
     $ R: K; W+ d8 X, z4 m
302.     for(i = 0; i < secremain; ++i)
     % ]! w% c9 ~7 |0 n8 z6 E7 \$ f
303.     {
     * z; G  H3 P  B2 s% E7 D
304.       if(w25q_buf[secoff + i] != 0XFF)
     
305.       {
     ! P3 {- T% q4 O- U
306.         break;  // 需要擦除
     
307.       }
     
308.     }
     0 V$ Z8 H7 u. |. s
309.     if(i < secremain) // 需要擦除
     : T3 ?' {: g' }1 D! y
310.     {
     
311.       W25QXXSectorErase(secpos); // 擦除这个扇区
     + ?- w2 K$ O2 `0 h5 v$ I
312.       for(i = 0; i < secremain; ++i)
     1 N, K" z1 C' [( ~7 s
313.       {
     
314.         w25q_buf[i + secoff] = buffer<i>;</i>
     9 ?8 |0 H. G! k: b
315.       }
     2 @+ w& D( ?; V$ y% ?* K, a5 j
316.       W25QXXWriteExt(secpos * 4096, w25q_buf, 4096); // 写入整个扇区
     
317. 
     , K8 ^0 y  Y- D# G7 L( c! q
318.     }
     
319.     else
     
320.     {
     ! j; P. Y" [9 S5 g1 l& K7 z  k
321.       W25QXXWriteExt(addr, buffer, secremain);  // 写已经擦除了的,直接写入扇区剩余区间.
     ! P  y" P( k" x; u% ?  F
322.     }
     / J4 h' w6 e' i  X' b# T: B
323.     if(length == secremain)
     
324.     {
     
325.       break;
     
326.     }
     7 P% T- V: B  |6 `# X) t
327.     else
     
328.     {
     ; p8 v1 }" H3 i' X+ X. t( `
329.       secpos++;
     
330.       secoff = 0;
     * X" `6 T. P# Z" U6 b
331. 
     
332.       buffer += secremain;
     * s4 D0 A+ s' H' s
333.       addr += secremain;
     
334.       length -= secremain;
     
335.       if(length > 4096)
     ! ~6 |* J3 {. M) Q' j
336.       {
     7 B' S% K  o# y
337.         secremain = 4096;
     
338.       }
       q9 U9 l$ C7 ~& z
339.       else
     
340.       {
     
341.         secremain = length;
     
342.       }
     % \, }& p1 N. Q
343.     }
     , K3 {# [. y# H- o
344.   };
     * k4 ^' t( y% m# T" N' W
345. }
     
346. 
     8 m+ q+ A0 p( m
347. 
     
348. // 读取SPI FLASH,仅支持QPI模式  在指定地址开始读取指定长度的数据 65536
     
349. void W25QXXRead(uint32_t addr, uint8_t *buffer, uint16_t length)
     * c; M0 U' M5 O- c
350. {
     
351.   QSPISendCMD(W25QXX_FAST_READ_DATA, addr, 8, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_4_LINES, QSPI_ADDRESS_32_BITS, QSPI_DATA_4_LINES); // QPI,快速读数据,地址为ReadAddr,4线传输数据_32位地址_4线传输地址_4线传输指令,8空周期,length个数据
     
352.   QSPIReceive(buffer, length);
     0 Y( P) V2 `4 A2 I4 p
353. }

复制代码

0 I4 s& H% P7 |/ p也可以使用SPI操作W25QXX。


7 f3 p' \# ?- S0 H
: [7 o# W0 L) X