一、QSPI
% Z8 Q! r; e0 c  g' O        SPI 是 Queued SPI 的简写，是 Motorola公司推出的 SPI 接口的扩展，比 SPI 应用更加广泛。在 SPI 协议的基础上，Motorola 公司对其功能进行了增强，增加了队列传输机制，推出了队列串行外围接口协议（即 QSPI 协议），使用该接口，用户可以一次性传输包含多达16个8位或16位数据的传输队列。一旦传输启动，直到传输结束，都不需要CPU干预，极大的提高了传输效率。该协议在ColdFire系列MCU得到广泛应用。与SPI相比，QSPI的最大结构特点是以80字节的RAM代替了SPI的发送和接收寄存器。QSPI 是一种专用的通信接口，连接单、双或四（条数据线） SPI Flash 存储介质。
6 t7 {9 A" S. m5 ?0 W1 V" n
该接口可以在以下三种模式下工作：
; _) {8 s+ q" f8 _7 M4 @8 ^4 B1 H- n① 间接模式：使用 QSPI 寄存器执行全部操作
② 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）
% X/ c( D8 L8 R; k: k③ 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器。

QSPI通过6根线与SPI芯片通信，下图是内部框图：
  j- z0 T4 @6 g: M
5 L% c3 g3 U; D" K+ m- W

: E# N6 e9 O2 ?0 `! E4 y
QSPI每条命令，必须包含一个或多个阶段：指令、地址、交替字节、空指令和数据。

" |' s0 [% n7 [- F" h- kQSPI发送命令：等待QSPI空闲；设置命令参数。
; F1 b9 W3 a- p6 d6 f6 `
* I1 i; P* }9 L% p5 L  i  tQSPI读数据：设置数据传输长度；设置QSPI工作模式并设置地址；读取数据。
# P# k) b( q& M! l# o; S
QSPI写数据：设置数据传输长度；设置QSPI工作模式并设置地址；写数据。

: u) v" f5 X! U  r5 I0 Q3 B  b6 b( K
二、几个重要的函数
" t+ m$ I6 x! H2 N9 {- f- R

1. HAL_StatusTypeDef     HAL_QSPI_Init     (QSPI_HandleTypeDef *hqspi); // 初始化
   3 X7 ?' X9 o' l
2. 
   
3. HAL_StatusTypeDef HAL_QSPI_Command(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t Timeout); // 发送命令
   , y% R1 [8 u. P3 f
4. 
   2 y6 _; {4 u/ ]
5. HAL_StatusTypeDef     HAL_QSPI_Transmit     (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 发送数据
   * S+ M1 O6 t0 k' x( N4 q
6. 
   
7. HAL_StatusTypeDef     HAL_QSPI_Receive      (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 接收数据

复制代码

, Q* Y, R4 v9 `  [9 X8 L三、几个重要的结构

1. // QSPI操作句柄
   
2. typedef struct
   ) t( P. v) D" N/ a9 Y, E
3. {
   6 T2 N9 r4 j5 {# s5 i) u
4.   QUADSPI_TypeDef            *Instance;        /* QSPI registers base address        */
   : C# H+ G2 l( I+ q
5.   QSPI_InitTypeDef           Init;             /* QSPI communication parameters      */
   
6.   uint8_t                    *pTxBuffPtr;      /* Pointer to QSPI Tx transfer Buffer */
   
7.   __IO uint16_t              TxXferSize;       /* QSPI Tx Transfer size              */
   ' i9 c# z) ]8 L& w  t- L
8.   __IO uint16_t              TxXferCount;      /* QSPI Tx Transfer Counter           */
   . @6 `) j2 q( z/ H
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           */
    
12.   DMA_HandleTypeDef          *hdma;            /* QSPI Rx/Tx DMA Handle parameters   */
    " W/ S/ P. ]) q  I3 ]) Q) V8 |
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 */
    
17. }QSPI_HandleTypeDef;
    % d8 g" q4 I) Z# P" L" u
18. 
    
19. // Instance：QSPI基地址  ---  QUADSPI
    
20. // Init：设置QSPI参数
    
21. // pTxBuffPtr,TxXferSize,TxXferCount：发送缓存指针 发送数据量 剩余数据量
    
22. // pRxBuffPtr,RxXferSize,RxXferCount：接收缓存指针 发送数据量 剩余数据量
    
23. // hdma与DMA相关， 其他为过程变量不需要关心

复制代码

1. // 参数配置 时钟分频系数  FIFO阈值  采样移位  FLASH大小  片选高电平时间  时钟模式  闪存ID  双闪存模式设置
   . w' {9 S: |+ E0 q6 U" [8 g
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 */
   9 `: P( l  c2 J
6. 
   
7.   uint32_t FifoThreshold;      /* Specifies the threshold number of bytes in the FIFO (used only in indirect mode)
   4 e" S2 ~9 P& I# h- a; _! E) w5 j
8.                                   This parameter can be a value between 1 and 32 */
   
9. 
   - P+ _! d- u& R* E( C9 i
10.   uint32_t SampleShifting;     /* Specifies the Sample Shift. The data is sampled 1/2 clock cycle delay later to
    ! {. s$ ]  a, v, C3 b: Y' i7 t
11.                                   take in account external signal delays. (It should be QSPI_SAMPLE_SHIFTING_NONE in DDR mode)
    % S& M( ]2 ~7 d& h: q8 d/ k! [9 N4 N+ K0 p
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
    2 H+ ?. m) v2 i. g
16.                                   (addressed using 32 bits) in indirect mode, but the addressable space in
    6 {0 \% s/ D. ?3 @
17.                                   memory-mapped mode is limited to 256MB
    
18.                                   This parameter can be a number between 0 and 31 */
    
19. 
    
20.   uint32_t ChipSelectHighTime; /* Specifies the Chip Select High Time. ChipSelectHighTime+1 defines the minimum number
    ) \- q# g2 ]  l- f' _
21.                                   of clock cycles which the chip select must remain high between commands.
    
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.
    
25.                                   This parameter can be a value of @ref QSPI_ClockMode */
    
26. 
    & W& C$ H9 Q" N5 }$ X1 ^4 ]% ^
27.   uint32_t FlashID;            /* Specifies the Flash which will be used,
    $ [8 }% |1 i. c  K5 }% `* h4 h
28.                                   This parameter can be a value of @ref QSPI_Flash_Select */
    
29. 
    
30.   uint32_t DualFlash;          /* Specifies the Dual Flash Mode State
    $ V8 q9 o, [% U( m& u8 Z
31.                                   This parameter can be a value of @ref QSPI_DualFlash_Mode */                                               
    
32. }QSPI_InitTypeDef;

复制代码

1. // 采样移位
   , ^9 N- U0 z' \0 t3 \: H! J0 g
2. #define QSPI_SAMPLE_SHIFTING_NONE           ((uint32_t)0x00000000U)        /*!<No clock cycle shift to sample data*/
   - b8 L, [6 M" B' ~% b
3. #define QSPI_SAMPLE_SHIFTING_HALFCYCLE      ((uint32_t)QUADSPI_CR_SSHIFT) /*!<1/2 clock cycle shift to sample data*/

复制代码

四、QSPI接口设计（仅供参考）
0 n# @& M2 [+ q4 _

1. #define QSPI_CLK_ENABLE()         __HAL_RCC_QSPI_CLK_ENABLE();
   
2. 
   ; Y2 S" |" r" t- _0 J8 m6 y7 @& X
3. #define QSPI_BK1_NCS_PORT         GPIOB
   
4. #define QSPI_BK1_NCS_PIN          GPIO_PIN_6
   
5. #define QSPI_BK1_NCS_AF           GPIO_AF10_QUADSPI
   / b( q$ M+ R0 D$ [
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)
   . n$ A8 M# l3 @# X2 J( X: V* k
7. 
   
8. #define QSPI_BK1_CLK_PORT         GPIOB
   
9. #define QSPI_BK1_CLK_PIN          GPIO_PIN_2
   9 u  ^/ j/ |8 J; \- X
10. #define QSPI_BK1_CLK_AF           GPIO_AF9_QUADSPI
    3 D' }4 S: j, G* F( v* @6 C
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)
    ! ~* f  L6 I+ g) c6 N
12. 
    9 v+ S; U& W( g" F
13. #define QSPI_BK1_IO0_PORT         GPIOF
    
14. #define QSPI_BK1_IO0_PIN          GPIO_PIN_8
    / b% j+ s: ^1 c
15. #define QSPI_BK1_IO0_AF           GPIO_AF10_QUADSPI
    . k7 E+ n2 W, W; v: I
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)
    1 J: |& t) {8 Z+ O- t1 C: k1 U+ t
17. 
    * f( C& y" D/ x
18. #define QSPI_BK1_IO1_PORT         GPIOF
    . k* u9 A  O$ n  t/ k
19. #define QSPI_BK1_IO1_PIN          GPIO_PIN_9
    ' ^4 V- u# z% p/ |
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)
    3 s* D; O- i/ L! i! V
22. 
    
23. #define QSPI_BK1_IO2_PORT         GPIOF
    
24. #define QSPI_BK1_IO2_PIN          GPIO_PIN_7
    ) Q; P0 X; ]/ x2 |4 b; C
25. #define QSPI_BK1_IO2_AF           GPIO_AF9_QUADSPI
    ; I2 S3 l' w- B9 v( ^: t
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)
    
27. 
    
28. #define QSPI_BK1_IO3_PORT         GPIOF
    
29. #define QSPI_BK1_IO3_PIN          GPIO_PIN_6
    # b5 ~" o$ R7 t3 O! p( n* V* Z; n
30. #define QSPI_BK1_IO3_AF           GPIO_AF9_QUADSPI
    2 ^( G1 }: ?  S2 Q, N
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. // 封装几个必要的接口
   3 c) t: n% _+ n! I' j
2. static QSPI_HandleTypeDef qspi_handle;
   - ^9 Q* P' k+ Z( D
3. 
   * F0 s! x8 ?- ^. g. p4 D; D
4. static void qspi_gpio_init(void)
   
5. {
   
6.   QSPI_CLK_ENABLE();
   
7. 
   & w6 o4 R* U2 k' a9 q0 I
8.   QSPI_BK1_NCS_CONFIG();
     c; l1 C% R  [$ l& S8 G5 x
9.   QSPI_BK1_CLK_CONFIG();
   
10.   QSPI_BK1_IO0_CONFIG();
    & [7 Q5 h  x, V0 T+ W0 f
11.   QSPI_BK1_IO1_CONFIG();
    $ ?7 i2 Y# ]! O
12.   QSPI_BK1_IO2_CONFIG();
    
13.   QSPI_BK1_IO3_CONFIG();
    
14. }
    * K8 ^- S; w5 |; C% r
15. 
      H6 ]  t* W. @6 y$ [
16. static void qspi_mode_init(void)
    
17. {
    - ?2 O8 r8 z. \) @' W3 I
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个字节
    
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
    . d2 W! u2 P! f& _
25.   qspi_handle.Init.FlashID = QSPI_FLASH_ID_1;            // 第一片flash
    % p; L8 M) a! c. [3 h
26.   qspi_handle.Init.DualFlash = QSPI_DUALFLASH_DISABLE;   // 禁止双闪存模式
    
27.   HAL_QSPI_Init(&qspi_handle);      //QSPI初始化
    : y! w) Z  w7 Q: D* X0 W
28. }
    
29. 
    
30. void QSPIInit(void)
    
31. {
    8 d% c2 q8 q8 d0 Y$ U: _
32.   qspi_gpio_init();
    & H0 o  s" M" V0 O, I
33.   qspi_mode_init();
    
34. }
    $ @  H1 S8 Y: }: y- T: Y( t8 C8 ^+ p
35. 
    6 R4 ^- I  R) f; h. n9 r; p
36. // QSPI发送命令
    % O/ t  T  v! s% d
37. // instruction:要发送的指令
    
38. // address:发送到的目的地址
    3 i$ [' a, Q3 S
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
    ! ]! A9 t$ I) f  h6 }- U2 o
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
    + E: g" w/ [% m% ]+ K
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. {
    ! T  N8 \- w+ X" K' B) ^
46.   QSPI_CommandTypeDef Cmdhandler;
    # z! Y2 A& M4 t. H5 q/ k
47. 
    
48.   Cmdhandler.Instruction = instruction;           // 指令
    1 n- k/ ?# p8 ~2 Y9 G1 d+ R9 j5 Z
49.   Cmdhandler.Address = address;                   // 地址
    
50.   Cmdhandler.DummyCycles = dummyCycles;           // 设置空指令周期数
    , z6 Z0 @# b8 k% d
51.   Cmdhandler.InstructionMode = instructionMode;   // 指令模式
    * B/ ^' |* C( H& Q: y% B
52.   Cmdhandler.AddressMode = addressMode;           // 地址模式
    
53.   Cmdhandler.AddressSize = addressSize;           // 地址长度
    
54.   Cmdhandler.DataMode = dataMode;                 // 数据模式
    . p; N- c# t' j- L, r" p
55.   Cmdhandler.SIOOMode = QSPI_SIOO_INST_EVERY_CMD; // 每次都发送指令
    
56.   Cmdhandler.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; // 无交替字节
    
57.   Cmdhandler.DdrMode = QSPI_DDR_MODE_DISABLE;           // 关闭DDR模式
    ) G2 I  [( r! s
58.   Cmdhandler.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
    
59. 
    6 Q/ J$ N5 |4 g7 V. B2 r
60.   HAL_QSPI_Command(&qspi_handle, &Cmdhandler, 5000);
    
61. }
    
62. 
    ( D, k7 f/ x8 E* j1 N. x
63. // 接收指定长度数据
    + i- |+ e2 e5 i7 o4 U
64. uint8_t QSPIReceive(uint8_t *buffer, uint32_t length)
    . U1 |9 d4 N& a" c; {' C
65. {
    $ ?* b3 g& h) A! c2 Y( g
66.   qspi_handle.Instance->DLR = length - 1;
    + v9 p& y7 j. S5 V: Z& M
67.         
    
68.   if(HAL_QSPI_Receive(&qspi_handle, buffer, 5000) == HAL_OK)
    3 S/ j+ k$ @; B; R+ q0 Y! |
69.   {
    ( y, J- D/ H6 P/ K
70.     return 0;  //接收数据
    3 j, ?9 y+ {. Z% n
71.   }
    # g; j; u+ i1 @, q4 l
72.   else
    0 a" m% [; f' `6 p+ w+ h
73.   {
    
74.     return 1;
    
75.   }
    
76. }
    
77. 
    
78. // 发送指定长度数据
    
79. uint8_t QSPITransmit(uint8_t *buffer, uint32_t length)
    
80. {
    ( }, `! R* o* O" F: e
81.   qspi_handle.Instance->DLR = length - 1;
    , @0 T, Z% V8 r# J4 w
82.   if(HAL_QSPI_Transmit(&qspi_handle, buffer, 5000) == HAL_OK)
    
83.   {
    9 i% G1 V, s5 {7 I
84.     return 0;  //发送数据
    
85.   }
    7 t: z8 `3 ^$ X- h1 C" F% v
86.   else
    
87.   {
    
88.     return 1;
    , p9 p1 p! g+ @* s" ^! }
89.   }
    
90. }

复制代码

+ c; H1 K. A# ]+ d2 \# x五、QSPI驱动W25Q256
: b( e9 [$ x( G& O' j* L9 I' o6 ?W25Q256:32M  512块，每块16个扇区，每个扇区4K。具体指令看手册。封装了如下接口（初始化读写擦除等接口是以后移植文件系统的基础）：

1. #define W25QXX_WRITE_ENABLE      0x06
   : }: {7 F8 k; L  `
2. #define W25QXX_WRITE_DISABLE     0x04
   , b+ j2 Q4 }) \7 ?( Z
3. #define W25QXX_READ_STATUS_REG1  0x05
   
4. #define W25QXX_READ_STATUS_REG2  0x35
   
5. #define W25QXX_READ_STATUS_REG3  0x15
   : X+ R% s; D( R; B
6. #define W25QXX_WRITE_STATUS_REG1 0x01
   ) x: {" @4 A$ j8 V* _% ^
7. #define W25QXX_WRITE_STATUS_REG2 0x31
   
8. #define W25QXX_WRITE_STATUS_REG3 0x11
   
9. #define W25QXX_READ_DATA         0x03
   
10. #define W25QXX_FAST_READ_DATA    0x0B
    
11. #define W25QXX_FAST_READ_DUAL    0x3B
    
12. #define W25QXX_PAGE_PROGRAM      0x02
    0 M. |0 r5 g3 @: p1 l1 Q# r
13. #define W25QXX_BLOCK_ERASE       0xD8
    1 w5 w$ h( x. z! T! U6 K# t
14. #define W25QXX_SECTOR_ERASE      0x20
    ( e: A, k+ r: s
15. #define W25QXX_CHIP_ERASE        0xC7
    3 c9 v& T* l5 Q8 ~3 @4 B
16. #define W25QXX_DEVICEID          0xAB
    
17. #define W25QXX_MANUFACT_DEVICEID 0x90
    
18. #define W25QXX_JEDEC_DEVICEID    0x9F
    1 g# m1 [9 c  K$ ^! |0 P7 g$ q4 N
19. #define W25QXX_EABLE_4BYTE_ADDR  0xB7
    6 i" u2 W! g( |2 L" t8 r8 Q
20. #define W25QXX_EXIT_4BYTE_ADDR   0xE9
    
21. #define W25QXX_SET_READ_PARAM    0xC0
    + C# J6 F& Y, K9 I2 t+ V( K; b
22. #define W25QXX_ENTER_QPIMODE     0x38
    
23. #define W25QXX_EXIT_QPIMODE      0xFF
    ; _4 K2 D; @/ g, P0 R
24. 
    
25. uint8_t w25qxx_qpi_mode = 0; // QSPI模式标志:0,SPI模式;1,QPI模式.
    0 B: h. G5 X5 ^) f; y6 I
26. 
    
27. // 读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
    
28. // 状态寄存器1：
    
29. // BIT7  6   5   4   3   2   1   0
    
30. // SPR   RV  TB BP2 BP1 BP0 WEL BUSY
      x6 S+ y+ U+ w# v1 {" O
31. // SPR:默认0,状态寄存器保护位,配合WP使用
      N# _/ x! A  r- ~/ c+ V- V( M
32. // TB,BP2,BP1,BP0:FLASH区域写保护设置
    * Y- W: e$ I( ]3 c( f3 t- a! ^8 s
33. // WEL:写使能锁定
    ! N, i: A4 \+ o* M( ~
34. // BUSY:忙标记位(1,忙;0,空闲)
    2 i) l  j1 ?+ ?3 y
35. // 默认:0x00
    
36. // 状态寄存器2：
    
37. // BIT7  6   5   4   3   2   1   0
    9 x8 M7 m* n0 q9 |+ d7 D
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
    " @3 n  f/ k& z5 Y
42. // reg:状态寄存器号，范:1~3
    & u) S; X6 p, L5 t% w' N
43. // 返回值:状态寄存器值
    + O, K7 w$ F! ]* z6 U
44. static uint8_t w25qxx_read_status(uint8_t reg)
    
45. {
    
46.   uint8_t value = 0, command = 0;
    
47. 
    ( u! V6 F; _, L  N5 X# [5 W
48.   switch(reg)
    + {) h! O1 b" j# B% v
49.   {
    % `) s2 |( p, u) \- _$ g
50.   case 1:
    : }# b4 E/ h, t% l
51.     command = W25QXX_READ_STATUS_REG1;  // 读状态寄存器1指令
    ( O0 I% o: D$ k  C2 g: l- ^: K
52.     break;
    
53. 
    0 P* K* M  e0 o/ z! c5 y$ H
54.   case 2:
    
55.     command = W25QXX_READ_STATUS_REG2;  // 读状态寄存器2指令
    
56.     break;
    - O5 u+ Y- i+ C7 Y0 g) H& J
57. 
    ( B7 t# K6 ^) |+ }
58.   case 3:
    % c% w* j& ?' N5 S0 z
59.     command = W25QXX_READ_STATUS_REG3;  // 读状态寄存器3指令
    4 z6 Q/ d2 P3 d% ^5 l& {; r
60.     break;
    - J0 X# B2 r$ E) q
61. 
    
62.   default:
    
63.     command = W25QXX_READ_STATUS_REG1;
    
64.     break;
    
65.   }
    
66. 
    
67.   if(w25qxx_qpi_mode)
    
68.   {
    0 G+ w' q9 T  j2 K9 N
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.   }
    * n) r1 q3 t& \1 G
71.   else
    1 N/ O8 v: N- V. V8 Z* A; |5 s
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.   }
    8 T6 A$ ~. J; |3 Q* p
75. 
    : ~0 D( m& ?( M8 A, B
76.   QSPIReceive(&value, 1);
    
77. 
    
78.   return value;
    ' }$ O4 ^! I( u# ?
79. }
    : O2 h& O( R4 B3 X
80. 
    4 o, G. T7 e0 m+ E# D% n
81. // 写状态寄存器
    
82. static void w25qxx_write_status(uint8_t reg, uint8_t status)
    
83. {
    
84.   uint8_t command = 0;
    
85. 
    * S7 C+ y' o' R$ n) p
86.   switch(reg)
    
87.   {
    ) v  f, L8 X. l- w/ y9 v1 M+ q8 |
88.   case 1:
    
89.     command = W25QXX_WRITE_STATUS_REG1;  //写状态寄存器1指令
    
90.     break;
    + W: c6 ]# w$ A; T
91.   case 2:
    # C  o2 R+ a% f
92.     command = W25QXX_WRITE_STATUS_REG2;  //写状态寄存器2指令
    
93.     break;
    6 R! B5 q4 s1 M/ T! k- v* p
94.   case 3:
    
95.     command = W25QXX_WRITE_STATUS_REG3;  //写状态寄存器3指令
    - v+ u& Z7 C! h7 }  b- i" K
96.     break;
    
97.   default:
    
98.     command = W25QXX_WRITE_STATUS_REG1;
    : a3 r$ Z9 E. T
99.     break;
    # a+ @& z5 t# }* P- M( d! `
100.   }
     8 z  l+ m2 @1 K$ S
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个字节数据
     & }. ?; K" Z8 ?4 r7 d! D
104.   }
     
105.   else
     , ^  g2 S2 J1 b+ T* V* Z, v- }
106.   {
     5 O- X- a* s1 N1 K  D
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个字节数据
     7 ^7 J- [" T% m' o6 j3 u" W
108.   }
     
109.   QSPITransmit(&status, sizeof(status));
     
110. }
     
111. 
     
112. // 写使能  将S1寄存器的WEL置位
     
113. static void w25qxx_write_enable(void)
     % L; [  f" e9 d2 E" r
114. {
     * {. A2 P3 F8 X
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个字节数据
     & ?4 I: @0 Q  w. q4 J
118.   }
     3 [8 ^' k0 E2 ?3 {* P4 \
119.   else
     2 g. X) q6 J  ^# K' [' p# [4 ]2 F5 M
120.   {
     % p5 D+ u3 e& k9 m0 D8 I  d" B: K
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.   }
     6 Q" H+ Y4 }7 P6 V2 q) m
123. }
     
124. 
     ' l' g$ j+ s. z& S; X+ e
125. // 写失能  将WEL清零
     - ^: \" U6 m2 ^' l8 F& Q9 N1 w* h
126. void W25QXX_Write_Disable(void)
     
127. {
     % v0 ?, `" r' o- h
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个字节数据
     $ Z% ~' l0 J" {6 `+ A8 e6 f( P2 O6 t
131.   }
     
132.   else
     7 t% ]$ F  P6 |! L2 x
133.   {
     ! d8 R' E- I0 D
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个字节数据
     6 ^1 a5 R! F  b
135.   }
     
136. }
     " |" n* ?5 K9 D/ s
137. 
     
138. // 等待空闲
     0 f* p$ ?9 {) c  \* {: y1 r
139. void w25qxx_wait_busy(void)
     " z" N" ]! e0 j! F. Z
140. {
     
141.   while((w25qxx_read_status(1) & 0x01) == 0x01); // 等待BUSY位清空
     
142. }
     
143. 
     
144. // W25QXX进入QSPI模式
     
145. static void w25qxx_qspi_init(void)
       W* H+ _& V7 Y* U$ G7 {
146. {
     9 u, W2 k" x! D& X* G& d
147.   uint8_t reg2;
     9 j+ _% Q5 I$ V* \
148.   reg2 = w25qxx_read_status(2); // 先读出状态寄存器2的原始值
     
149.   if((reg2 & 0X02) == 0)  // QE位未使能
     " H3 C+ Z5 {4 X  r
150.   {
     6 w* N$ O# y6 w* m5 t3 n
151.     w25qxx_write_enable(); // 写使能
     + p) U. a' A& \
152.     reg2 |= 1 << 1; // 使能QE位
     3 c! ~: k: u* Q, M
153.     w25qxx_write_status(2, reg2); // 写状态寄存器2
     ' j5 U3 I8 R+ V9 J) e
154.   }
     
155. 
     
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个字节数据
     ; n+ X/ B! p0 q& n; K6 i$ [
157. 
     9 h, Z" n; Y$ M
158.   w25qxx_qpi_mode = 1; // 标记QSPI模式
     
159. }
     
160. 
     
161. // 0XEF13,表示芯片型号为W25Q80
     
162. // 0XEF14,表示芯片型号为W25Q16
     ( D6 Y# S, ?& r. u* ?  x8 w
163. // 0XEF15,表示芯片型号为W25Q32
     0 C. P7 E4 q* a9 G0 Q4 }
164. // 0XEF16,表示芯片型号为W25Q64
     * Z& W5 n7 i$ r' x' S" N
165. // 0XEF17,表示芯片型号为W25Q128
     4 C8 Q: b5 y, ]/ ?
166. // 0XEF18,表示芯片型号为W25Q256
     8 s$ X2 P5 R6 X' K
167. static void w25qxx_id_get(void)
     + L2 {7 [( V6 ?
168. {
     / m1 j4 t/ g5 H8 v
169.   uint8_t temp[2];
     
170.   uint16_t device_id;
     : J. E# E+ \; B0 o6 T
171. 
     ! c6 q( \% [5 n# N5 u
172.   if(w25qxx_qpi_mode)
     
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个字节数据
       [. r( q; |! G. b  ]5 L; @) i
175.   }
     
176.   else
     % |1 N- i( p$ D  S
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个字节数据
     
179.   }
     
180. 
     
181.   QSPIReceive(temp, 2);
     
182. 
     9 z9 N: @* G5 |+ G1 |
183.   device_id = (temp[0] << 8) | temp[1];
     % l( i7 U$ g. P$ U/ z+ U! b" N
184. 
     
185.   printf("QSPI Flash Device ID: %X\r\n", device_id);
     % e5 c9 |$ V! ^, M: }4 f- m' j% g+ j
186. }
     " F3 A5 P2 K. Q# J
187. 
     4 }) [+ N$ H$ n) E6 v% F6 j( i
188. void W25QXXInit(void)
     
189. {
     
190.   uint8_t temp;
     7 U* _0 k- j& y5 D' s9 Y, V
191. 
     
192.   QSPIInit();
     : e- M6 N; a# z; h0 m
193.   w25qxx_qspi_init(); // 使能QSPI模式
     
194.   w25qxx_id_get();    // 读取FLASH ID.
     
195. 
     9 \' @$ I4 z3 G: ?9 R
196.   temp = w25qxx_read_status(3); // 读取状态寄存器3，判断地址模式
     
197.   if((temp & 0X01) == 0) // 如果不是4字节地址模式,则进入4字节地址模式
     
198.   {
     
199.     w25qxx_write_enable(); // 写使能
     ( k  r- U5 @, S7 z* N
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.   }
     # E# b% [( U+ G' c' O" y) C& V
202.   w25qxx_write_enable(); // 写使能
     ' L2 N- P! V4 O" K
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个字节数据
     - u2 ^! d$ N! h, g7 c& [
204.   temp = 3 << 4;      // 设置P4&P5=11,8个dummy clocks,104M
     * n! S" A: ?- |& Z4 m
205.   QSPITransmit(&temp, 1);
     ( D( y8 g( N, N* J/ c1 i" r8 ~
206. }
     
207. 
     
208. // 擦除一块4096字节 最少需要150ms
     
209. void W25QXXSectorErase(uint32_t addr)
     4 f# Y. Z7 O! y
210. {
     9 s% l# E* }" l8 q3 x% O
211.   //addr /= 4096;
     
212.   addr *= 4096;
     ( A1 D3 }3 a) p2 d4 ~7 c$ B
213. 
     
214.   w25qxx_write_enable();
     
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();
     2 s! f) ~; d) q) Y  a
218. }
     
219. 
     - P1 W* N$ N" N* J0 v) V  v( l
220. 
     
221. // 擦除整个芯片
     
222. void W25QXXChipErase(void)
     - i; F$ Q+ Z$ a3 I9 c/ e
223. {
     
224.   w25qxx_write_enable();          //SET WEL
     ; E% _1 [7 o& O; e5 X; ~0 H2 U7 l  h
225.   w25qxx_wait_busy();
     ! r( P& |. y6 y) J( z. Q# |
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();           //等待芯片擦除结束
     - \0 N; {! V( s' e
228. }
     
229. 
     
230. // 写最多256字节
     
231. void W25QXXWritePage(uint32_t addr, uint8_t *buffer, uint16_t length)
     
232. {
     , ]  R- e4 |% y" x) O5 w
233.   w25qxx_write_enable();          //写使能
     . {1 Z. Q% F0 w3 c% R/ ]% s+ e8 h
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个数据
     , C  w) b( J+ G
235.   QSPITransmit(buffer, length);
     
236.   w25qxx_wait_busy();            //等待写入结束
     6 L! Z7 G$ X3 L! I, [/ l, J* D" V
237. }
     
238. 
     
239. // 写最多65536字节 无擦除动作
     
240. void W25QXXWriteExt(uint32_t addr, uint8_t *buffer, uint16_t length)
     - `; N' Y. B$ Q/ T
241. {
     6 v& }* O- N5 _, d6 Y/ Z
242.   uint16_t pageremain = 256 - addr % 256; // 单页剩余的字节数
     
243. 
     
244.   if(addr + length - 1 > (32 * 1024 * 1024))
     
245.   {
     6 a3 `% o0 j" P; h
246.     return;
     
247.   }
     ! F& c7 t# S: ?' w, n6 S
248. 
     : _* \" |/ B- |, G" j
249.   if(length <= pageremain)
     1 P5 a& f: U( `/ S0 k
250.   {
     & `* a( z% I, b" j
251.     pageremain = length;  // 不大于256个字节
     
252.   }
     
253.   while(1)
     
254.   {
     3 m. ~" q  q! r3 A2 s& h2 _( W# x
255.     // 分页写入
     # K6 {  R5 Y+ I
256.     W25QXXWritePage(addr, buffer, pageremain);
       w7 k8 f' G) Z: `- O; {3 W
257. 
     
258.     if(length == pageremain)
     
259.     {
     , w' h* D. c$ o
260.       break;  //写入结束了
     
261.     }
     5 [( n+ C# {  u& A% w* F8 ]
262.     else
     
263.     {
     7 A  L; ^: ~' H3 `" I) p
264.       buffer += pageremain;
     
265.       addr += pageremain;
     1 }- B# j" I9 ?2 `1 v
266. 
     
267.       length -= pageremain; // 减去已经写入了的字节数
     ; s9 t3 @  C4 \" [
268.       if(length > 256)
     + U$ r& L, ?% c9 \) W" |' i
269.       {
     8 J. o. h- D/ |! ~
270.         pageremain = 256;  // 一次可以写入256个字节
     0 U1 e" _9 b- g
271.       }
     . h9 u3 c& c2 e3 K
272.       else
     ; p9 Q2 ^9 f( e, e$ U8 t4 _
273.       {
     
274.         pageremain = length;  // 不够256个字节了
     - t5 W" {2 p! A, Y/ }2 T" i& a
275.       }
     , l: K1 b+ _% g1 h  y3 F. e4 \8 `$ B0 H
276.     }
     
277.   }
     
278. }
     
279. 
     ! z1 N0 R0 M+ ]/ r
280. // 写最多65536字节 带擦除动作
     : i! V6 n% D) s1 Z- R% R) Z
281. static uint8_t W25QXX_BUFFER[4096];
     9 j- d% e& s  q+ k' k
282. void W25QXXWrite(uint32_t addr, uint8_t* buffer, uint16_t length)
     
283. {
     ! o* f5 C, J0 j7 M. J
284.   uint32_t secpos;
     , v4 O. K0 e- U
285.   uint16_t secoff, secremain, i;
     + g! t+ j& v' k) O, ~
286.   uint8_t * w25q_buf;
     
287. 
     
288.   w25q_buf = W25QXX_BUFFER;
     7 K! i8 A; D1 l8 p# L
289. 
     
290.   secpos = addr / 4096; // 扇区地址
     / S# y0 y8 W) o8 n( t
291.   secoff = addr % 4096; // 在扇区内的偏移
     
292.   secremain = 4096 - secoff; // 扇区剩余空间大小
     
293. 
     
294.   if(length <= secremain)
     
295.   {
     * c# P( T+ ^1 p- ^2 A
296.     secremain = length;  // 不大于4096个字节
     
297.   }
     ! C0 S  v+ f3 ^% L: J0 \3 |
298.   while(1)
     
299.   {
     0 @& n& b( M6 Y. H$ c
300.           WatchdogFeed();
     $ ^  U) |  j3 x$ m: u& q0 G
301.     W25QXXRead(secpos * 4096, w25q_buf, 4096); // 读出整个扇区的内容
     
302.     for(i = 0; i < secremain; ++i)
     
303.     {
     2 F  ]9 a0 f! g
304.       if(w25q_buf[secoff + i] != 0XFF)
     
305.       {
     
306.         break;  // 需要擦除
     
307.       }
     + W5 }/ h4 y  M0 ^8 [  G
308.     }
     
309.     if(i < secremain) // 需要擦除
     # W; k# b8 V: n3 H4 {& G8 a
310.     {
     " [. }3 L1 x2 y2 {. _; x5 n
311.       W25QXXSectorErase(secpos); // 擦除这个扇区
     9 [% |+ u$ q7 L$ J
312.       for(i = 0; i < secremain; ++i)
     
313.       {
     ! v1 z% Z. R- I  t* y
314.         w25q_buf[i + secoff] = buffer<i>;</i>
     
315.       }
     
316.       W25QXXWriteExt(secpos * 4096, w25q_buf, 4096); // 写入整个扇区
     / a& ~/ I6 x+ i/ Y+ U: s
317. 
     
318.     }
     
319.     else
     
320.     {
     
321.       W25QXXWriteExt(addr, buffer, secremain);  // 写已经擦除了的,直接写入扇区剩余区间.
     . u  r- O1 o; O6 c
322.     }
     $ e) y9 e+ M3 v9 Q. o
323.     if(length == secremain)
     
324.     {
     $ _6 O6 l% n# Z4 r. c
325.       break;
     $ b+ v' U9 M2 z! J$ K
326.     }
     
327.     else
     9 I& i2 u9 O4 e7 j; H! B
328.     {
     
329.       secpos++;
     * o8 Z7 T; i6 I' ]. V
330.       secoff = 0;
     
331. 
     $ f: o( @. H% V5 v# a. m
332.       buffer += secremain;
     
333.       addr += secremain;
     
334.       length -= secremain;
     
335.       if(length > 4096)
     
336.       {
     ' s5 p4 n; ?" s+ h! {
337.         secremain = 4096;
     # u. I" u0 b9 Y$ ~1 R
338.       }
     * f. o, \( B$ _9 n8 ^
339.       else
     , A6 @& u- N. J8 Q5 O
340.       {
     
341.         secremain = length;
     # C1 E" b7 S2 {6 `$ k1 G7 G0 G) t9 e6 R
342.       }
     
343.     }
     . t, p7 S' }! R7 l
344.   };
     9 B) a/ w8 l$ y5 e
345. }
     4 Z2 S  O  O' T" C! c
346. 
     & R& N3 \/ B0 E
347. 
       l" @8 m/ _5 p
348. // 读取SPI FLASH,仅支持QPI模式  在指定地址开始读取指定长度的数据 65536
     7 C  P( k  @' a5 M; R, B" x
349. void W25QXXRead(uint32_t addr, uint8_t *buffer, uint16_t length)
     
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个数据
     ; b" h1 D4 C1 [6 @( u# X5 |
352.   QSPIReceive(buffer, length);
     
353. }

复制代码

* R" V9 m: z7 `& s0 K( t7 ]* X$ }! [+ v也可以使用SPI操作W25QXX。
7 R+ z3 A/ v7 G, W2 H0 ]% ^. B


6 [. O* e9 v: A2 b; T2 D& T