一、QSPI
        SPI 是 Queued SPI 的简写，是 Motorola公司推出的 SPI 接口的扩展，比 SPI 应用更加广泛。在 SPI 协议的基础上，Motorola 公司对其功能进行了增强，增加了队列传输机制，推出了队列串行外围接口协议（即 QSPI 协议），使用该接口，用户可以一次性传输包含多达16个8位或16位数据的传输队列。一旦传输启动，直到传输结束，都不需要CPU干预，极大的提高了传输效率。该协议在ColdFire系列MCU得到广泛应用。与SPI相比，QSPI的最大结构特点是以80字节的RAM代替了SPI的发送和接收寄存器。QSPI 是一种专用的通信接口，连接单、双或四（条数据线） SPI Flash 存储介质。
* B- Z0 q7 i- d. y
该接口可以在以下三种模式下工作：
. ?# O8 U+ j+ @& L① 间接模式：使用 QSPI 寄存器执行全部操作
9 H1 l* m# }. c. w② 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）
( _9 t) _7 g) m9 M- ?  [4 i- W9 l③ 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器。
/ k) I1 x# @; O! |" E! @
QSPI通过6根线与SPI芯片通信，下图是内部框图：

0 _7 d0 W% ^( }6 G+ `3 m. O

+ M* E# O9 B; u9 }: A- n
; a' h% L6 y) ~: n4 sQSPI每条命令，必须包含一个或多个阶段：指令、地址、交替字节、空指令和数据。
! W0 p3 c% b5 t- M7 }# D; T1 j
& _5 m- S) ~3 M. V% H+ U: VQSPI发送命令：等待QSPI空闲；设置命令参数。
- ]7 S$ E9 \4 i/ S- o
' A; J+ T) I% Q: C$ N" Z) rQSPI读数据：设置数据传输长度；设置QSPI工作模式并设置地址；读取数据。

QSPI写数据：设置数据传输长度；设置QSPI工作模式并设置地址；写数据。
9 j9 e! u9 \2 B

# H* S+ A3 ]6 ]) s( O' ^二、几个重要的函数

1. HAL_StatusTypeDef     HAL_QSPI_Init     (QSPI_HandleTypeDef *hqspi); // 初始化
   
2. 
   3 J: h- N7 l' w
3. HAL_StatusTypeDef HAL_QSPI_Command(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t Timeout); // 发送命令
   
4. 
   
5. HAL_StatusTypeDef     HAL_QSPI_Transmit     (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 发送数据
   6 Z( \8 F& X; a- J& V$ j9 t+ G
6. 
   $ o: _% }) Q0 ?
7. HAL_StatusTypeDef     HAL_QSPI_Receive      (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 接收数据

复制代码

0 }! V' _7 I$ H$ W7 I* c: g% m三、几个重要的结构

1. // QSPI操作句柄
   ) G5 M5 G! v+ H5 m2 b6 i. t
2. typedef struct
     X9 j9 y* v8 n& C
3. {
   
4.   QUADSPI_TypeDef            *Instance;        /* QSPI registers base address        */
   - `# f! k; a) n* ~1 @9 C9 O# P
5.   QSPI_InitTypeDef           Init;             /* QSPI communication parameters      */
   
6.   uint8_t                    *pTxBuffPtr;      /* Pointer to QSPI Tx transfer Buffer */
   , a* X3 t* r6 r& t: l
7.   __IO uint16_t              TxXferSize;       /* QSPI Tx Transfer size              */
   
8.   __IO uint16_t              TxXferCount;      /* QSPI Tx Transfer Counter           */
   
9.   uint8_t                    *pRxBuffPtr;      /* Pointer to QSPI Rx transfer Buffer */
     ^1 B  E3 w+ M7 D4 |
10.   __IO uint16_t              RxXferSize;       /* QSPI Rx Transfer size              */
    0 s; x0 @8 W" j. g
11.   __IO uint16_t              RxXferCount;      /* QSPI Rx Transfer Counter           */
    ' ~  x& o5 i: m8 {/ h% \9 h
12.   DMA_HandleTypeDef          *hdma;            /* QSPI Rx/Tx DMA Handle parameters   */
    " }3 I) J9 }: F
13.   __IO HAL_LockTypeDef       Lock;             /* Locking object                     */
    
14.   __IO HAL_QSPI_StateTypeDef State;            /* QSPI communication state           */
    
15.   __IO uint32_t              ErrorCode;        /* QSPI Error code                    */
    
16.   uint32_t                   Timeout;          /* Timeout for the QSPI memory access */
    2 X7 j+ }% N' N
17. }QSPI_HandleTypeDef;
    
18. 
    ; L2 |$ m- T5 _5 `7 ~1 W
19. // Instance：QSPI基地址  ---  QUADSPI
    
20. // Init：设置QSPI参数
    
21. // pTxBuffPtr,TxXferSize,TxXferCount：发送缓存指针 发送数据量 剩余数据量
    0 C" j1 P) ~% i' Q0 t
22. // pRxBuffPtr,RxXferSize,RxXferCount：接收缓存指针 发送数据量 剩余数据量
    * A0 A, d' K8 ]1 y' \8 w
23. // hdma与DMA相关， 其他为过程变量不需要关心

复制代码

1. // 参数配置 时钟分频系数  FIFO阈值  采样移位  FLASH大小  片选高电平时间  时钟模式  闪存ID  双闪存模式设置
   
2. typedef struct
   9 W; a1 w4 }$ O  Q2 k  N
3. {
   
4.   uint32_t ClockPrescaler;     /* Specifies the prescaler factor for generating clock based on the AHB clock.
   & O. ~# l4 C$ X/ F
5.                                   This parameter can be a number between 0 and 255 */
   6 F% U4 `7 `% [6 t0 I% G2 Q/ L% S, k
6. 
   
7.   uint32_t FifoThreshold;      /* Specifies the threshold number of bytes in the FIFO (used only in indirect mode)
   5 e- [6 d# o1 o' ~. k
8.                                   This parameter can be a value between 1 and 32 */
   
9. 
     H8 T0 n8 W* Z6 W5 `
10.   uint32_t SampleShifting;     /* Specifies the Sample Shift. The data is sampled 1/2 clock cycle delay later to
    ' u! H/ d0 \7 u4 Q& Q
11.                                   take in account external signal delays. (It should be QSPI_SAMPLE_SHIFTING_NONE in DDR mode)
    . {! n4 q3 o- v/ `3 \  q5 }, H0 D" x
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
    
15.                                   required to address the flash memory. The flash capacity can be up to 4GB
    ) f' D; ^5 Z: x1 A- V4 F
16.                                   (addressed using 32 bits) in indirect mode, but the addressable space in
    
17.                                   memory-mapped mode is limited to 256MB
    ! C. u7 H. k2 {1 S
18.                                   This parameter can be a number between 0 and 31 */
    
19. 
    + r* u# v% U) l4 I7 o
20.   uint32_t ChipSelectHighTime; /* Specifies the Chip Select High Time. ChipSelectHighTime+1 defines the minimum number
    
21.                                   of clock cycles which the chip select must remain high between commands.
    + e: _/ v6 f7 P: R( j2 o
22.                                   This parameter can be a value of @ref QSPI_ChipSelectHighTime */
    
23. 
    
24.   uint32_t ClockMode;          /* Specifies the Clock Mode. It indicates the level that clock takes between commands.
    ' p! m# a! `& y: m2 q
25.                                   This parameter can be a value of @ref QSPI_ClockMode */
    
26. 
    ' F, b% y2 y* ~4 k( g
27.   uint32_t FlashID;            /* Specifies the Flash which will be used,
    
28.                                   This parameter can be a value of @ref QSPI_Flash_Select */
    4 H8 Y4 V; K7 }5 u! h8 L6 u
29. 
    3 S: s  a( ], m* \9 n3 w8 g- s2 m
30.   uint32_t DualFlash;          /* Specifies the Dual Flash Mode State
    . k% z. I3 c5 A$ I  i1 I
31.                                   This parameter can be a value of @ref QSPI_DualFlash_Mode */                                               
    - R# b( o: j' \
32. }QSPI_InitTypeDef;

复制代码

1. // 采样移位
   : p; g; d' e) r" A9 G# U
2. #define QSPI_SAMPLE_SHIFTING_NONE           ((uint32_t)0x00000000U)        /*!<No clock cycle shift to sample data*/
   3 c8 |$ m' v! I5 w
3. #define QSPI_SAMPLE_SHIFTING_HALFCYCLE      ((uint32_t)QUADSPI_CR_SSHIFT) /*!<1/2 clock cycle shift to sample data*/

复制代码

四、QSPI接口设计（仅供参考）
+ S% l1 a' v& W$ |  R8 U3 F

1. #define QSPI_CLK_ENABLE()         __HAL_RCC_QSPI_CLK_ENABLE();
   , v6 A/ _; V+ z
2. 
   
3. #define QSPI_BK1_NCS_PORT         GPIOB
   6 N/ K/ k6 X# E# c( p$ ^
4. #define QSPI_BK1_NCS_PIN          GPIO_PIN_6
   : }1 c$ O) s- ~. V; ~$ `
5. #define QSPI_BK1_NCS_AF           GPIO_AF10_QUADSPI
   . }1 W2 c8 g1 Q8 V7 h4 v1 X% i1 I
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)
   * l- E, ]4 N9 O% J! w% j7 o
7. 
   0 Y2 I7 k) P6 z
8. #define QSPI_BK1_CLK_PORT         GPIOB
   9 u  B* k5 G, W  y: T  v! g
9. #define QSPI_BK1_CLK_PIN          GPIO_PIN_2
   - k. E- D9 K. _" {
10. #define QSPI_BK1_CLK_AF           GPIO_AF9_QUADSPI
    
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
    
14. #define QSPI_BK1_IO0_PIN          GPIO_PIN_8
    + ~& k$ ]7 [$ ^# D8 K( \/ z
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)
    % x; L) m9 Y) w2 ~: W( O
17. 
    
18. #define QSPI_BK1_IO1_PORT         GPIOF
    
19. #define QSPI_BK1_IO1_PIN          GPIO_PIN_9
    / u# |/ _- ^. C: ?  ^+ _7 F# u7 t
20. #define QSPI_BK1_IO1_AF           GPIO_AF10_QUADSPI
    
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)
    2 ~1 w2 e( C( n
22. 
    
23. #define QSPI_BK1_IO2_PORT         GPIOF
    5 s6 `7 Q, T9 e5 [5 o- r1 E* s" Z
24. #define QSPI_BK1_IO2_PIN          GPIO_PIN_7
    
25. #define QSPI_BK1_IO2_AF           GPIO_AF9_QUADSPI
    : k/ o. {( S: V' G
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)
    0 J$ z8 d. o. T4 W! r, b/ C
27. 
      c* x: x% B. X: a9 L, Y; U4 H4 F
28. #define QSPI_BK1_IO3_PORT         GPIOF
    ; M& ?: R5 A9 \( Q( l6 D
29. #define QSPI_BK1_IO3_PIN          GPIO_PIN_6
    7 W& i. `& E1 e5 W+ B0 `$ ?9 U0 |
30. #define QSPI_BK1_IO3_AF           GPIO_AF9_QUADSPI
    9 L5 m: z7 Y0 S. o
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. // 封装几个必要的接口
   # e% p5 K( @4 J. {2 l- X- E
2. static QSPI_HandleTypeDef qspi_handle;
     d; o# M' Z/ @( n6 m
3. 
   
4. static void qspi_gpio_init(void)
     p7 v: ^$ B; ~/ @. q  ]2 e
5. {
   1 _/ z' J- o! i
6.   QSPI_CLK_ENABLE();
   
7. 
   
8.   QSPI_BK1_NCS_CONFIG();
   ; x" Q$ l9 b: o# N
9.   QSPI_BK1_CLK_CONFIG();
   9 Z( e# t. j- A- e" i# Y' M5 e
10.   QSPI_BK1_IO0_CONFIG();
    ; D: F! d: E+ v) S+ D: z5 j
11.   QSPI_BK1_IO1_CONFIG();
    
12.   QSPI_BK1_IO2_CONFIG();
    
13.   QSPI_BK1_IO3_CONFIG();
    5 y0 g* Q' b8 L8 J% a
14. }
    
15. 
    $ ?1 F6 v5 |3 A
16. static void qspi_mode_init(void)
    0 r" I" R. }9 n4 d* {
17. {
    ; }$ N# k# c3 K2 L* V0 Z
18.   qspi_handle.Instance = QUADSPI;                        // QSPI
    
19.   qspi_handle.Init.ClockPrescaler = 2;                   // QPSI分频比，W25Q256最大频率为104M 所以此处应该为2，QSPI频率就为216/(2+1)=72MHZ
    8 T1 D! `: O+ ^5 e! [4 s$ q
20.   qspi_handle.Init.FifoThreshold = 4;                    // FIFO阈值为4个字节
    
21.   qspi_handle.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE; // 采样移位半个周期(DDR模式下,必须设置为0)
    2 y) X! b4 J. W# f4 M) ~
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
    ' E, T7 X( w! a# B
25.   qspi_handle.Init.FlashID = QSPI_FLASH_ID_1;            // 第一片flash
    + H3 P9 r7 \4 I% @
26.   qspi_handle.Init.DualFlash = QSPI_DUALFLASH_DISABLE;   // 禁止双闪存模式
    5 o# r4 \. v* M1 f) d9 n4 M/ j
27.   HAL_QSPI_Init(&qspi_handle);      //QSPI初始化
    * Y8 a9 T5 E- J0 M  V- F
28. }
    
29. 
    5 c4 W$ {( t( F5 p. _
30. void QSPIInit(void)
    
31. {
    
32.   qspi_gpio_init();
    7 w/ \' R4 l6 I. f
33.   qspi_mode_init();
    / n! P9 _) b- c3 Z
34. }
    ( G0 N+ U, y* P- Q, k& E3 |
35. 
    + ~  a" _7 w+ a' w$ |5 F* z
36. // QSPI发送命令
    
37. // instruction:要发送的指令
    
38. // address:发送到的目的地址
    2 u, V3 N8 C# `( ~9 y' q$ T
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
    3 L( M  ?) W/ |
44. void QSPISendCMD(uint32_t instruction, uint32_t address, uint32_t dummyCycles, uint32_t instructionMode, uint32_t addressMode, uint32_t addressSize, uint32_t dataMode)
    
45. {
    
46.   QSPI_CommandTypeDef Cmdhandler;
    / Z1 ~) R7 v4 l  o/ ~
47. 
    2 R! S; C2 P0 c2 c# O' [2 {
48.   Cmdhandler.Instruction = instruction;           // 指令
    $ y/ G$ \* @( T$ S# T" Q& d
49.   Cmdhandler.Address = address;                   // 地址
    
50.   Cmdhandler.DummyCycles = dummyCycles;           // 设置空指令周期数
    
51.   Cmdhandler.InstructionMode = instructionMode;   // 指令模式
    6 `4 y# L7 Z( m: n+ ?7 ?
52.   Cmdhandler.AddressMode = addressMode;           // 地址模式
    
53.   Cmdhandler.AddressSize = addressSize;           // 地址长度
    . J% J6 U: ]! p- Q) c: @& V0 V& n
54.   Cmdhandler.DataMode = dataMode;                 // 数据模式
    
55.   Cmdhandler.SIOOMode = QSPI_SIOO_INST_EVERY_CMD; // 每次都发送指令
    9 ?' ]8 Z( b6 {
56.   Cmdhandler.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; // 无交替字节
    
57.   Cmdhandler.DdrMode = QSPI_DDR_MODE_DISABLE;           // 关闭DDR模式
    
58.   Cmdhandler.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
    
59. 
    ) K2 s$ M% ~  M, N. ~
60.   HAL_QSPI_Command(&qspi_handle, &Cmdhandler, 5000);
    $ n/ g' X, _4 A$ N" U% b
61. }
    
62. 
    7 R! u/ o! L; g9 N
63. // 接收指定长度数据
    
64. uint8_t QSPIReceive(uint8_t *buffer, uint32_t length)
    ( s) M3 m' O3 _9 ~* y7 i
65. {
    
66.   qspi_handle.Instance->DLR = length - 1;
    3 R/ o- K  L, s; }1 }5 W1 [- T
67.         
    % G5 ?4 b& `. `7 k$ i
68.   if(HAL_QSPI_Receive(&qspi_handle, buffer, 5000) == HAL_OK)
    
69.   {
    
70.     return 0;  //接收数据
    6 O' q+ o, V3 U1 d
71.   }
    5 e: I- ?! `: Z2 u8 [
72.   else
    
73.   {
    
74.     return 1;
    ! x: u' O: `0 i( S$ L, b1 F
75.   }
    
76. }
    3 t3 n* N: l- ?* ]5 p
77. 
    ( _; X" ~2 n* J, W1 @( F3 a: W' }
78. // 发送指定长度数据
    - N1 _6 v6 `8 }8 @6 Z. |0 T
79. uint8_t QSPITransmit(uint8_t *buffer, uint32_t length)
    3 J/ D8 z3 s& P
80. {
    
81.   qspi_handle.Instance->DLR = length - 1;
    
82.   if(HAL_QSPI_Transmit(&qspi_handle, buffer, 5000) == HAL_OK)
    
83.   {
    
84.     return 0;  //发送数据
    
85.   }
    
86.   else
    " {6 {7 ~& P' J( _( e/ I9 X, s
87.   {
    
88.     return 1;
    * a6 l. m! @# x6 e+ t9 Z
89.   }
    ! q* m% ]) B+ U& b8 D& g( J9 O
90. }

复制代码

五、QSPI驱动W25Q256
9 A( e9 ~7 }9 \$ e8 QW25Q256:32M  512块，每块16个扇区，每个扇区4K。具体指令看手册。封装了如下接口（初始化读写擦除等接口是以后移植文件系统的基础）：

1. #define W25QXX_WRITE_ENABLE      0x06
   " |/ z$ I3 |; R- c* H
2. #define W25QXX_WRITE_DISABLE     0x04
   " F& Y4 G6 D& ?' C
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
   + _5 e$ B' N3 j
7. #define W25QXX_WRITE_STATUS_REG2 0x31
   
8. #define W25QXX_WRITE_STATUS_REG3 0x11
   / K) I/ b' U3 T$ t' N
9. #define W25QXX_READ_DATA         0x03
   ' [; ^2 H; f. M% _7 f0 ^, F+ l% X
10. #define W25QXX_FAST_READ_DATA    0x0B
    2 V. D0 C0 R7 o9 t5 u; z; V
11. #define W25QXX_FAST_READ_DUAL    0x3B
    # C' x" g  a" Z# h) p7 r$ ?4 b
12. #define W25QXX_PAGE_PROGRAM      0x02
    8 G# l4 y( E  ?2 U7 l* Q
13. #define W25QXX_BLOCK_ERASE       0xD8
    & G4 o& @1 s9 P3 c3 P
14. #define W25QXX_SECTOR_ERASE      0x20
    " P  K( ^( U8 B0 c5 S
15. #define W25QXX_CHIP_ERASE        0xC7
    % o* f* y5 h" U9 w6 A' n
16. #define W25QXX_DEVICEID          0xAB
    2 Y* |0 ?1 ?3 D& Y/ s6 W; `
17. #define W25QXX_MANUFACT_DEVICEID 0x90
    
18. #define W25QXX_JEDEC_DEVICEID    0x9F
    
19. #define W25QXX_EABLE_4BYTE_ADDR  0xB7
    8 ?9 J# @- L9 n/ }
20. #define W25QXX_EXIT_4BYTE_ADDR   0xE9
    
21. #define W25QXX_SET_READ_PARAM    0xC0
    ; {8 n/ y2 K" x+ M; e/ ?% n3 {
22. #define W25QXX_ENTER_QPIMODE     0x38
    : D3 {+ S0 k) e/ \) ~. D& {8 r
23. #define W25QXX_EXIT_QPIMODE      0xFF
    
24. 
    
25. uint8_t w25qxx_qpi_mode = 0; // QSPI模式标志:0,SPI模式;1,QPI模式.
    
26. 
    
27. // 读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
    ( g4 a6 l& N* l& k
28. // 状态寄存器1：
    
29. // BIT7  6   5   4   3   2   1   0
    
30. // SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    ; J7 `+ \# G8 M+ U6 |. I! b# E& O
31. // SPR:默认0,状态寄存器保护位,配合WP使用
    
32. // TB,BP2,BP1,BP0:FLASH区域写保护设置
    : t# }' r4 e6 Q  D; n: J
33. // WEL:写使能锁定
    
34. // BUSY:忙标记位(1,忙;0,空闲)
    
35. // 默认:0x00
    - E5 j% T& e: j: N3 }1 z
36. // 状态寄存器2：
    
37. // BIT7  6   5   4   3   2   1   0
    $ q* _, R1 {2 P: ^  M$ F9 A: E& l
38. // SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
    
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
    
43. // 返回值:状态寄存器值
    
44. static uint8_t w25qxx_read_status(uint8_t reg)
    0 p; ^/ e3 y/ j  y
45. {
    
46.   uint8_t value = 0, command = 0;
    8 V! u3 y7 b+ m3 j
47. 
    2 j/ F) C7 E& ^. C/ ]
48.   switch(reg)
    
49.   {
    ( v0 j: o8 G1 T3 D
50.   case 1:
    1 s5 _, J* Z  {2 O
51.     command = W25QXX_READ_STATUS_REG1;  // 读状态寄存器1指令
    
52.     break;
    
53. 
    
54.   case 2:
    
55.     command = W25QXX_READ_STATUS_REG2;  // 读状态寄存器2指令
    
56.     break;
    " E! P$ ?% k0 i- H
57. 
    2 C. R* c! c/ I  I0 v, n/ h
58.   case 3:
    7 y( j+ }/ u  g9 g; d8 A3 I: S3 x; L8 l( z
59.     command = W25QXX_READ_STATUS_REG3;  // 读状态寄存器3指令
    # n% X! T3 u% d: \/ Q; B0 e' i* p  B
60.     break;
    
61. 
    
62.   default:
    + n1 j5 G$ U+ h! c
63.     command = W25QXX_READ_STATUS_REG1;
    
64.     break;
    ( B8 L* W! ]+ z
65.   }
    
66. 
    7 i! m) w# _( Q$ U9 b6 i0 l
67.   if(w25qxx_qpi_mode)
    0 g+ M' R$ Z6 z1 |
68.   {
    
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个字节数据
    & C+ S- T1 G+ n% {% J& @5 Z' C7 Q
70.   }
    8 s# S, a  c' n* o4 N; U- t) V5 W
71.   else
    0 Y6 Z1 K. W+ C6 m( z
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个字节数据
    $ I$ g( U$ V8 X5 c, _
74.   }
    - w$ h* r# V+ x8 i: ?& e
75. 
    
76.   QSPIReceive(&value, 1);
    & |. v8 T7 M) R; J4 E2 P
77. 
    
78.   return value;
    4 a# l- P; @" |0 j, \; p3 e
79. }
    ) ~+ c  I0 @6 A, x2 M( }
80. 
    $ e5 ~. C3 |% Q- d8 N% u/ ^2 f0 {5 U
81. // 写状态寄存器
    
82. static void w25qxx_write_status(uint8_t reg, uint8_t status)
    ) R& H2 v- K5 t. Y- m* S# }
83. {
    ' p4 R4 x+ ]$ Z7 n  [. I3 y
84.   uint8_t command = 0;
    , S+ T- C' w, M
85. 
    1 N5 E  O0 H5 g
86.   switch(reg)
    ' n' n; y0 S* q9 w+ o# o$ E/ r
87.   {
    0 q7 `9 \, B$ ^
88.   case 1:
    
89.     command = W25QXX_WRITE_STATUS_REG1;  //写状态寄存器1指令
    " {5 ]+ M, j' a# M' Y7 V
90.     break;
    
91.   case 2:
    
92.     command = W25QXX_WRITE_STATUS_REG2;  //写状态寄存器2指令
    
93.     break;
    
94.   case 3:
    $ M1 B6 R' ]" d* i! M) S
95.     command = W25QXX_WRITE_STATUS_REG3;  //写状态寄存器3指令
    
96.     break;
    & V) ^5 Y- ?+ a% J  [2 J1 n  D/ R
97.   default:
    
98.     command = W25QXX_WRITE_STATUS_REG1;
    - w! R( [3 k4 p+ B2 \+ j
99.     break;
    
100.   }
     
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个字节数据
     
104.   }
     
105.   else
     3 |3 {0 b& Y( q4 U  a7 B
106.   {
     1 D+ C# `+ g1 F+ Q
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个字节数据
     2 ?4 K: m+ q2 G
108.   }
     2 V% S, R$ L3 g  w- U. d, @/ P* B
109.   QSPITransmit(&status, sizeof(status));
     : ?2 p1 d6 W! V
110. }
     
111. 
     
112. // 写使能  将S1寄存器的WEL置位
     
113. static void w25qxx_write_enable(void)
     3 W3 x: `- b  Y' E
114. {
     / F8 }  k8 C  P2 z3 M8 }" {: P
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.   }
       I# Q2 n  A. H6 s3 L1 b, k8 S. \
119.   else
       A2 i) A8 b+ ^8 A
120.   {
     
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个字节数据
     ; U& M# m# k$ b! |% q/ I/ i
122.   }
     , l. F& I4 `: p, M, x
123. }
     
124. 
     
125. // 写失能  将WEL清零
     : A' o' q8 {6 h, P2 ~
126. void W25QXX_Write_Disable(void)
     * x( C3 ?: F' p
127. {
     
128.   if(w25qxx_qpi_mode)
     $ C- ?: T& b- W+ n
129.   {
     # c, o0 h5 o  n2 F5 f2 ]* n
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.   }
     
132.   else
     
133.   {
     + t7 E5 q. @1 e; X- m# u) x
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.   }
     
136. }
     
137. 
     
138. // 等待空闲
     & \, `0 M* {9 P7 X( m1 d
139. void w25qxx_wait_busy(void)
     
140. {
     
141.   while((w25qxx_read_status(1) & 0x01) == 0x01); // 等待BUSY位清空
     
142. }
     
143. 
     
144. // W25QXX进入QSPI模式
     
145. static void w25qxx_qspi_init(void)
     
146. {
     6 E# C5 y) f) h  q: {: M
147.   uint8_t reg2;
     
148.   reg2 = w25qxx_read_status(2); // 先读出状态寄存器2的原始值
     1 c0 d' Q5 V( E
149.   if((reg2 & 0X02) == 0)  // QE位未使能
     0 c7 s8 }' [, T6 D# Y# N& r
150.   {
     % P, _  N: N. Q) I* p$ e1 p  [
151.     w25qxx_write_enable(); // 写使能
     7 V. O5 b% I! h! O$ l) v
152.     reg2 |= 1 << 1; // 使能QE位
     
153.     w25qxx_write_status(2, reg2); // 写状态寄存器2
     + w4 D; L5 f4 h$ w# }
154.   }
     
155. 
     4 T6 j) |! [7 T! U$ D( Z3 b6 L7 \0 }( Y
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个字节数据
     * q8 E: K+ w8 _0 [! H, e
157. 
     
158.   w25qxx_qpi_mode = 1; // 标记QSPI模式
     
159. }
     ' }4 R5 t) Y3 R) p
160. 
     9 X& O4 }8 t1 Q+ A
161. // 0XEF13,表示芯片型号为W25Q80
     ( Q& H2 M+ E: r+ b% W
162. // 0XEF14,表示芯片型号为W25Q16
     
163. // 0XEF15,表示芯片型号为W25Q32
     1 @9 N/ G( ?" k5 p0 ^" ~
164. // 0XEF16,表示芯片型号为W25Q64
     
165. // 0XEF17,表示芯片型号为W25Q128
     
166. // 0XEF18,表示芯片型号为W25Q256
     
167. static void w25qxx_id_get(void)
     9 ]4 w' j8 y: F
168. {
     % b' o8 {, z4 p3 r
169.   uint8_t temp[2];
     
170.   uint16_t device_id;
     * @+ C' v: }( X1 ?0 s  i
171. 
     $ K+ G6 B$ X2 L) q$ z8 i# `
172.   if(w25qxx_qpi_mode)
     ! m$ W) s+ e8 K8 r7 i+ R/ S
173.   {
     $ ]7 B1 y: \+ S7 |9 t
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 x; X/ a0 I6 E& ~
175.   }
     
176.   else
     1 F% j  R0 R) I8 S6 m# f
177.   {
     ' n% y0 y) n2 |
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个字节数据
     ; r3 h. o% s- u! [& I
179.   }
     
180. 
     
181.   QSPIReceive(temp, 2);
     / b' @* |$ |( O# C3 d# s" l6 R
182. 
     : x, q7 r9 G8 ?$ _8 H
183.   device_id = (temp[0] << 8) | temp[1];
     
184. 
     
185.   printf("QSPI Flash Device ID: %X\r\n", device_id);
     
186. }
     
187. 
     
188. void W25QXXInit(void)
     + {6 F0 H# Q6 X3 g/ U1 s4 A
189. {
     
190.   uint8_t temp;
     
191. 
     . j2 F) ^# z+ L' X3 M3 x. v1 e
192.   QSPIInit();
     ) ^- C# k; A' n9 X0 z2 a$ s
193.   w25qxx_qspi_init(); // 使能QSPI模式
     
194.   w25qxx_id_get();    // 读取FLASH ID.
     
195. 
     ! x( d/ x9 a/ k6 l
196.   temp = w25qxx_read_status(3); // 读取状态寄存器3，判断地址模式
     
197.   if((temp & 0X01) == 0) // 如果不是4字节地址模式,则进入4字节地址模式
     
198.   {
     
199.     w25qxx_write_enable(); // 写使能
     
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个字节数据
     
201.   }
     
202.   w25qxx_write_enable(); // 写使能
     
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个字节数据
     - p: {! P- Y9 L; r6 R7 |
204.   temp = 3 << 4;      // 设置P4&P5=11,8个dummy clocks,104M
     
205.   QSPITransmit(&temp, 1);
     % A! t) h% z/ F3 Z0 m. J
206. }
     
207. 
     
208. // 擦除一块4096字节 最少需要150ms
     
209. void W25QXXSectorErase(uint32_t addr)
     
210. {
     
211.   //addr /= 4096;
     
212.   addr *= 4096;
     " q5 A1 M- U$ w* ^
213. 
     1 Q1 C( ^$ m+ ?- c
214.   w25qxx_write_enable();
     
215.   w25qxx_wait_busy();
     ; ]- f( w: ?* ~: q$ g
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();
     & [; i0 G! v2 ~" ?4 ?& m
218. }
     ! f8 S/ O! m/ y5 ~  I# w2 ^8 e6 h
219. 
     
220. 
     6 |6 |+ c+ q. ~* x+ ^% Q
221. // 擦除整个芯片
     
222. void W25QXXChipErase(void)
     & `: S' z* h& q
223. {
     ' I+ `7 l+ R" S: z
224.   w25qxx_write_enable();          //SET WEL
     
225.   w25qxx_wait_busy();
     
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个字节数据
     ' j9 _2 g( E# [7 D( S$ O( t: Q
227.   w25qxx_wait_busy();           //等待芯片擦除结束
     
228. }
     
229. 
     
230. // 写最多256字节
     
231. void W25QXXWritePage(uint32_t addr, uint8_t *buffer, uint16_t length)
     1 [' P7 V2 z) K
232. {
     4 }" f7 {  c  ]1 ^7 X/ q
233.   w25qxx_write_enable();          //写使能
     
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个数据
     . ]3 Y% B; y4 L1 j" F2 g6 V
235.   QSPITransmit(buffer, length);
     3 J# q# i& o6 q- i
236.   w25qxx_wait_busy();            //等待写入结束
     ! E! L: F; V* M& H2 I) J# L( \& c. N
237. }
     6 b" r  ^, F5 c$ }# @
238. 
     
239. // 写最多65536字节 无擦除动作
     % r: r5 z8 @2 W9 {; Y0 c6 Z
240. void W25QXXWriteExt(uint32_t addr, uint8_t *buffer, uint16_t length)
     9 `  O; v4 B. q! Q
241. {
     
242.   uint16_t pageremain = 256 - addr % 256; // 单页剩余的字节数
     - K6 k# x$ e* J' V$ K
243. 
     . G5 N# O+ g/ b
244.   if(addr + length - 1 > (32 * 1024 * 1024))
     ! ^5 t9 u8 Y. ~1 u- }
245.   {
     
246.     return;
     
247.   }
     
248. 
     
249.   if(length <= pageremain)
     
250.   {
     9 A7 C$ J8 [3 q" q; Y9 X
251.     pageremain = length;  // 不大于256个字节
     
252.   }
     8 K: |+ L6 S4 Z
253.   while(1)
     * Y' l$ T, N* Y. F& |
254.   {
     $ e* P0 ^: f, a8 O
255.     // 分页写入
     
256.     W25QXXWritePage(addr, buffer, pageremain);
     
257. 
     1 ~$ _/ b# J. G% j& ]
258.     if(length == pageremain)
     
259.     {
     / X" D, U* `) p2 B9 `- O
260.       break;  //写入结束了
     
261.     }
     5 U( z0 H, ?5 R" W  U
262.     else
     / }! b" _9 V# K) J& L& c
263.     {
     
264.       buffer += pageremain;
     
265.       addr += pageremain;
     
266. 
     0 h, m9 p! Z6 u
267.       length -= pageremain; // 减去已经写入了的字节数
     
268.       if(length > 256)
     
269.       {
     
270.         pageremain = 256;  // 一次可以写入256个字节
     
271.       }
     
272.       else
       q* T7 S$ Y4 V  n0 K4 ]# {. I
273.       {
     
274.         pageremain = length;  // 不够256个字节了
     
275.       }
     
276.     }
     
277.   }
     9 Z' X6 K* [- t$ b) |& ]
278. }
     
279. 
     
280. // 写最多65536字节 带擦除动作
     , H+ Y5 a* O3 t: M' j
281. static uint8_t W25QXX_BUFFER[4096];
     
282. void W25QXXWrite(uint32_t addr, uint8_t* buffer, uint16_t length)
     & e' h& @+ G3 u& L
283. {
     
284.   uint32_t secpos;
     
285.   uint16_t secoff, secremain, i;
     8 r3 b4 E- _/ T
286.   uint8_t * w25q_buf;
     + U8 a. H8 r! B& X
287. 
     4 J, u& u9 B5 m6 {- K9 g
288.   w25q_buf = W25QXX_BUFFER;
     9 h! M! Z2 Y* B1 b0 v
289. 
     # ~/ m% D) C9 A& e! E
290.   secpos = addr / 4096; // 扇区地址
     
291.   secoff = addr % 4096; // 在扇区内的偏移
     
292.   secremain = 4096 - secoff; // 扇区剩余空间大小
     
293. 
     8 O7 c; h  U- Q, k6 o" y+ b0 J
294.   if(length <= secremain)
     ' U) `5 D8 R- F
295.   {
     
296.     secremain = length;  // 不大于4096个字节
     
297.   }
     , z& S9 p* T0 b7 Y! M
298.   while(1)
     
299.   {
     1 S2 g. t& o: G# z! I5 j/ I* t
300.           WatchdogFeed();
     
301.     W25QXXRead(secpos * 4096, w25q_buf, 4096); // 读出整个扇区的内容
     
302.     for(i = 0; i < secremain; ++i)
     
303.     {
     
304.       if(w25q_buf[secoff + i] != 0XFF)
     ' Z2 w# |2 A6 r  |
305.       {
     
306.         break;  // 需要擦除
     
307.       }
     / T  s& R6 n+ \7 r9 u4 [
308.     }
     
309.     if(i < secremain) // 需要擦除
     2 g) P; n9 a- t5 V% f! o" c1 t. t
310.     {
     
311.       W25QXXSectorErase(secpos); // 擦除这个扇区
     4 ^. }5 j  ~* N) @- a
312.       for(i = 0; i < secremain; ++i)
     0 ^& N+ F& o- [( F6 {
313.       {
     " [) ^0 G9 ^+ Y
314.         w25q_buf[i + secoff] = buffer<i>;</i>
     ) b" M; g+ y8 W. M
315.       }
     % s! U! H- N; m: z2 k
316.       W25QXXWriteExt(secpos * 4096, w25q_buf, 4096); // 写入整个扇区
     : D' a% F, A) r  Y! F) C6 Z1 S3 _  o
317. 
     
318.     }
     
319.     else
     % ]- s: {' X! c# b5 E1 V
320.     {
     * S+ c5 ?! ?# S: I
321.       W25QXXWriteExt(addr, buffer, secremain);  // 写已经擦除了的,直接写入扇区剩余区间.
     
322.     }
     - C6 t9 _# T$ _) ^4 a7 S" `
323.     if(length == secremain)
     / X' f) ]0 D: o9 u
324.     {
     
325.       break;
     
326.     }
     
327.     else
     
328.     {
     ' z$ _9 r; ^6 i. n2 x9 d) P, U
329.       secpos++;
     
330.       secoff = 0;
     
331. 
     
332.       buffer += secremain;
     . I- f& V& D/ o! J1 F" r1 |! a9 i
333.       addr += secremain;
       @. T; j- q3 H( V
334.       length -= secremain;
     7 f" \9 D* h4 N7 I, G
335.       if(length > 4096)
     
336.       {
     7 D+ L* x, J8 b( W9 n
337.         secremain = 4096;
     ' P  r0 A& o9 d
338.       }
     9 U8 P' G& ?2 Q% y/ h# U$ g5 E) \" p
339.       else
     
340.       {
     
341.         secremain = length;
     & T2 ~2 {" o2 o3 h6 O* `0 p
342.       }
     
343.     }
     
344.   };
     
345. }
     ! Y4 R- e4 X1 C& W+ z& }
346. 
     - W0 J9 X) f+ {" Y5 m7 H0 R6 I
347. 
     8 G* u$ e6 `. ?
348. // 读取SPI FLASH,仅支持QPI模式  在指定地址开始读取指定长度的数据 65536
     
349. void W25QXXRead(uint32_t addr, uint8_t *buffer, uint16_t length)
       A- H- f+ o7 Y9 r0 p
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个数据
     / Q; @( j( Q; b; U2 S
352.   QSPIReceive(buffer, length);
     
353. }

复制代码

也可以使用SPI操作W25QXX。
) C# m& r6 o$ {
! o: x8 v6 `' s6 G! j$ ?

5 X, Z. {, @0 e% H" Q% f