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

该接口可以在以下三种模式下工作：
1 w( V9 t9 Z. f# o, b① 间接模式：使用 QSPI 寄存器执行全部操作
② 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）
1 l* C. |1 z, K# S- k/ W  T, `  q1 C③ 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器。
4 [' I) k6 Z2 o5 n7 }  q
QSPI通过6根线与SPI芯片通信，下图是内部框图：

1 n9 I! X" S9 p" M- `

/ B. J* _, K% \8 z; T2 f+ ^$ t% f
QSPI每条命令，必须包含一个或多个阶段：指令、地址、交替字节、空指令和数据。
; l+ d0 K. \( t7 O7 Z9 t
1 Z) R0 j9 r( h8 Z- V# V# AQSPI发送命令：等待QSPI空闲；设置命令参数。

. a. G( L1 [) j9 [) B/ n1 OQSPI读数据：设置数据传输长度；设置QSPI工作模式并设置地址；读取数据。

! c- o5 Y; W- z) ^: K6 JQSPI写数据：设置数据传输长度；设置QSPI工作模式并设置地址；写数据。


1 p" k$ T$ u5 O& ~4 |5 z/ l" ?二、几个重要的函数

1. HAL_StatusTypeDef     HAL_QSPI_Init     (QSPI_HandleTypeDef *hqspi); // 初始化
   
2. 
   
3. HAL_StatusTypeDef HAL_QSPI_Command(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t Timeout); // 发送命令
   ! ^/ l2 x- F2 s8 m, y; s. b
4. 
   / p# e! ?) N' ?! F- [
5. HAL_StatusTypeDef     HAL_QSPI_Transmit     (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 发送数据
   + n8 `  d$ c% u" d  q
6. 
   
7. HAL_StatusTypeDef     HAL_QSPI_Receive      (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 接收数据

复制代码

& }  N7 _6 Q8 c" \  K三、几个重要的结构
& m5 X3 l& M0 o$ I% U

1. // QSPI操作句柄
   
2. typedef struct
   
3. {
   # b1 [) o8 Z% p* X
4.   QUADSPI_TypeDef            *Instance;        /* QSPI registers base address        */
   , F& p; B" x/ D  a/ g
5.   QSPI_InitTypeDef           Init;             /* QSPI communication parameters      */
   & k3 \; j  Q% V4 ~5 l* i# ^
6.   uint8_t                    *pTxBuffPtr;      /* Pointer to QSPI Tx transfer Buffer */
   
7.   __IO uint16_t              TxXferSize;       /* QSPI Tx Transfer size              */
   $ I5 O8 ]9 X9 v9 v" O$ |+ |
8.   __IO uint16_t              TxXferCount;      /* QSPI Tx Transfer Counter           */
   
9.   uint8_t                    *pRxBuffPtr;      /* Pointer to QSPI Rx transfer Buffer */
   * S# a- ?  {: Q3 z6 e
10.   __IO uint16_t              RxXferSize;       /* QSPI Rx Transfer size              */
    # c  d9 A. F3 K4 f3 \
11.   __IO uint16_t              RxXferCount;      /* QSPI Rx Transfer Counter           */
    
12.   DMA_HandleTypeDef          *hdma;            /* QSPI Rx/Tx DMA Handle parameters   */
    1 ?: Z5 y0 Y2 F4 [
13.   __IO HAL_LockTypeDef       Lock;             /* Locking object                     */
    ( [: ?0 t9 ^0 h% k9 V" [
14.   __IO HAL_QSPI_StateTypeDef State;            /* QSPI communication state           */
    + B; i" _* a+ {( U7 o* n
15.   __IO uint32_t              ErrorCode;        /* QSPI Error code                    */
    # X% ~: v4 X8 @, b1 ?& B/ {5 y5 p
16.   uint32_t                   Timeout;          /* Timeout for the QSPI memory access */
    8 l2 `+ j8 x$ f" Q/ z4 Y
17. }QSPI_HandleTypeDef;
    
18. 
    
19. // Instance：QSPI基地址  ---  QUADSPI
    ' P- b  a  X2 y& Q' l+ G
20. // Init：设置QSPI参数
    ! F7 f* R2 p9 b( F
21. // pTxBuffPtr,TxXferSize,TxXferCount：发送缓存指针 发送数据量 剩余数据量
    
22. // pRxBuffPtr,RxXferSize,RxXferCount：接收缓存指针 发送数据量 剩余数据量
    ) \# w9 v/ W) q, Q
23. // hdma与DMA相关， 其他为过程变量不需要关心

复制代码

1. // 参数配置 时钟分频系数  FIFO阈值  采样移位  FLASH大小  片选高电平时间  时钟模式  闪存ID  双闪存模式设置
   + R4 U# A7 H/ a" X5 P, ^
2. typedef struct
   - _6 l' g$ Z9 P
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 */
   ; m9 S0 L, W: N. D1 y: a
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$ \$ H" P+ U+ j" q
9. 
   " O; n5 X8 d& V4 i6 P
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
    4 b0 ]; S* U% P
15.                                   required to address the flash memory. The flash capacity can be up to 4GB
    
16.                                   (addressed using 32 bits) in indirect mode, but the addressable space in
    , `4 c0 Q( t; H( [7 }# D) j- C8 C
17.                                   memory-mapped mode is limited to 256MB
    
18.                                   This parameter can be a number between 0 and 31 */
    * p* R( @  n6 H7 ]4 z" M
19. 
    
20.   uint32_t ChipSelectHighTime; /* Specifies the Chip Select High Time. ChipSelectHighTime+1 defines the minimum number
    8 N5 x& v6 Q7 {/ z# K$ X( _
21.                                   of clock cycles which the chip select must remain high between commands.
    
22.                                   This parameter can be a value of @ref QSPI_ChipSelectHighTime */
    ' [( m5 o, x) m$ s
23. 
    
24.   uint32_t ClockMode;          /* Specifies the Clock Mode. It indicates the level that clock takes between commands.
    6 E  f8 k2 V* d. U7 `" K
25.                                   This parameter can be a value of @ref QSPI_ClockMode */
    
26. 
    
27.   uint32_t FlashID;            /* Specifies the Flash which will be used,
    : |9 c! `; [9 S4 Z: J
28.                                   This parameter can be a value of @ref QSPI_Flash_Select */
    * a1 O5 `  }/ \
29. 
    " o4 ?0 U7 N7 D5 R  y8 H) h" [
30.   uint32_t DualFlash;          /* Specifies the Dual Flash Mode State
    
31.                                   This parameter can be a value of @ref QSPI_DualFlash_Mode */                                               
    
32. }QSPI_InitTypeDef;

复制代码

1. // 采样移位
   
2. #define QSPI_SAMPLE_SHIFTING_NONE           ((uint32_t)0x00000000U)        /*!<No clock cycle shift to sample data*/
   $ Q! G) Q) ]. K
3. #define QSPI_SAMPLE_SHIFTING_HALFCYCLE      ((uint32_t)QUADSPI_CR_SSHIFT) /*!<1/2 clock cycle shift to sample data*/

复制代码

  n( u. x+ a* l) V  d' l四、QSPI接口设计（仅供参考）

1. #define QSPI_CLK_ENABLE()         __HAL_RCC_QSPI_CLK_ENABLE();
   ( W2 l% ~5 s2 i( H% D
2. 
   
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
   : a2 {3 k- y; D! ]* r9 R! n
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)
   
7. 
   
8. #define QSPI_BK1_CLK_PORT         GPIOB
   
9. #define QSPI_BK1_CLK_PIN          GPIO_PIN_2
   * a' D3 Q2 j$ ~0 G6 y' G* r; }
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. 
    9 d6 @; Z( @# F0 x# r/ L/ x
13. #define QSPI_BK1_IO0_PORT         GPIOF
    
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)
    ) A9 I. U" [+ n
17. 
    & G4 l; M" o( ?% M5 I' C8 ]
18. #define QSPI_BK1_IO1_PORT         GPIOF
    . ^0 V; U3 u. p( j6 `
19. #define QSPI_BK1_IO1_PIN          GPIO_PIN_9
    
20. #define QSPI_BK1_IO1_AF           GPIO_AF10_QUADSPI
    / h! ?9 C2 @; P2 r! N" ^5 V# X
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)
    $ Y" h( B' h: f( T9 P( Y" o! |7 f
22. 
    % m- {: k- j. n
23. #define QSPI_BK1_IO2_PORT         GPIOF
    4 X9 R- S3 r6 B' Q8 c8 k; {2 X* H
24. #define QSPI_BK1_IO2_PIN          GPIO_PIN_7
    & u' `: i( W2 l5 i8 I+ h) |8 A
25. #define QSPI_BK1_IO2_AF           GPIO_AF9_QUADSPI
    
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
    
30. #define QSPI_BK1_IO3_AF           GPIO_AF9_QUADSPI
    : R& Y8 j3 W" @0 X/ k: W* 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. // 封装几个必要的接口
   
2. static QSPI_HandleTypeDef qspi_handle;
   
3. 
   
4. static void qspi_gpio_init(void)
   
5. {
   
6.   QSPI_CLK_ENABLE();
   
7. 
   
8.   QSPI_BK1_NCS_CONFIG();
   2 A4 d- g" g" o% C/ ~, k
9.   QSPI_BK1_CLK_CONFIG();
   
10.   QSPI_BK1_IO0_CONFIG();
    
11.   QSPI_BK1_IO1_CONFIG();
    9 [% V6 P% \3 a% K( J. p' r* Y7 J
12.   QSPI_BK1_IO2_CONFIG();
    
13.   QSPI_BK1_IO3_CONFIG();
    $ t% q: z4 I( x* z# I/ Z5 ~4 z
14. }
    , t/ B( y( L7 h9 d
15. 
    
16. static void qspi_mode_init(void)
    
17. {
    * l7 s0 ?4 t& l) u6 m8 B
18.   qspi_handle.Instance = QUADSPI;                        // QSPI
    5 [0 `! L) J4 h+ ~% V  m3 |
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)
    9 w0 t8 {% g; k6 r2 D
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参数
    # r; D$ w& {2 d9 Q5 ^/ `- p
24.   qspi_handle.Init.ClockMode = QSPI_CLOCK_MODE_0;        // 模式0
    
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初始化
    , w4 D) ?( `% z" h  C4 O- D
28. }
    3 T+ r" b! @, O( y
29. 
    : G& W& {; J' b& j' S# |& g% I
30. void QSPIInit(void)
    
31. {
    / J* k! I. p* i' w
32.   qspi_gpio_init();
    & }% E6 F$ D9 S8 u# B+ `% w5 {
33.   qspi_mode_init();
    4 E' [- _; Y0 a9 q: o
34. }
    
35. 
    $ ]" J8 g: d$ R6 J2 b
36. // QSPI发送命令
    
37. // instruction:要发送的指令
    
38. // address:发送到的目的地址
    
39. // dummyCycles:空指令周期数
    
40. // instructionMode:指令模式;QSPI_INSTRUCTION_NONE,QSPI_INSTRUCTION_1_LINE,QSPI_INSTRUCTION_2_LINE,QSPI_INSTRUCTION_4_LINE
    + n2 [( M, C: g0 A! ]8 t/ a
41. // addressMode:地址模式; QSPI_ADDRESS_NONE,QSPI_ADDRESS_1_LINE,QSPI_ADDRESS_2_LINE,QSPI_ADDRESS_4_LINE
    ) E7 ]9 N& F1 }4 h+ V
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
    : p1 [6 h, g4 J% P1 B7 S6 b$ j
44. void QSPISendCMD(uint32_t instruction, uint32_t address, uint32_t dummyCycles, uint32_t instructionMode, uint32_t addressMode, uint32_t addressSize, uint32_t dataMode)
    . R$ L  {% g" S: ]" v- K+ [  x- K$ z: f
45. {
    & c! w  S- a, K" k# h, E$ J
46.   QSPI_CommandTypeDef Cmdhandler;
    6 D& L' N; v  ^7 t
47. 
    " [7 L1 {0 y6 p" ?3 Z- m
48.   Cmdhandler.Instruction = instruction;           // 指令
    3 @& h0 K4 w' v  s3 w& C) Y
49.   Cmdhandler.Address = address;                   // 地址
    9 U! R0 M7 i3 N
50.   Cmdhandler.DummyCycles = dummyCycles;           // 设置空指令周期数
    " H5 w9 g% }1 z+ y
51.   Cmdhandler.InstructionMode = instructionMode;   // 指令模式
    ! A6 Y" o7 t7 C4 C4 l9 M
52.   Cmdhandler.AddressMode = addressMode;           // 地址模式
    
53.   Cmdhandler.AddressSize = addressSize;           // 地址长度
    : Z- c7 b! d$ ^5 a% G+ ^
54.   Cmdhandler.DataMode = dataMode;                 // 数据模式
    ( k- U+ Q1 B8 g/ w
55.   Cmdhandler.SIOOMode = QSPI_SIOO_INST_EVERY_CMD; // 每次都发送指令
    
56.   Cmdhandler.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; // 无交替字节
    
57.   Cmdhandler.DdrMode = QSPI_DDR_MODE_DISABLE;           // 关闭DDR模式
    
58.   Cmdhandler.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
    5 E; T( @0 s6 `( x+ l' D9 v9 }8 P  H
59. 
    . ?  ~& M# l% t6 Y2 Z
60.   HAL_QSPI_Command(&qspi_handle, &Cmdhandler, 5000);
    $ }$ Y" d4 W9 x: ~& z
61. }
    8 g' L3 U( X; k7 Q2 x( R
62. 
    
63. // 接收指定长度数据
    : v+ c  h+ f7 _7 q6 B6 O% U" t
64. uint8_t QSPIReceive(uint8_t *buffer, uint32_t length)
    
65. {
    
66.   qspi_handle.Instance->DLR = length - 1;
    
67.         
    
68.   if(HAL_QSPI_Receive(&qspi_handle, buffer, 5000) == HAL_OK)
    ; A. O3 E: ^0 z" S$ f1 V5 V
69.   {
    
70.     return 0;  //接收数据
    ' ?* ^: Q! ~, H- v% f
71.   }
    7 B8 U8 v' d! L8 j7 X0 P, @
72.   else
    ( w3 F" {  V9 k3 h
73.   {
    
74.     return 1;
    
75.   }
    
76. }
    
77. 
    
78. // 发送指定长度数据
    
79. uint8_t QSPITransmit(uint8_t *buffer, uint32_t length)
    
80. {
    
81.   qspi_handle.Instance->DLR = length - 1;
    " r6 A& V% [) z! ^8 ^
82.   if(HAL_QSPI_Transmit(&qspi_handle, buffer, 5000) == HAL_OK)
    5 o, j" x2 Y. Q( l# c; J$ N# t
83.   {
    , |$ y& L3 v/ K4 B8 B  S" ]+ A/ l# k
84.     return 0;  //发送数据
    2 L3 g& a6 e) ~; u
85.   }
    ( N1 G  Z( ]' {) t
86.   else
    1 w' z9 b5 p7 {4 y% f1 E* m
87.   {
    , C6 \% L8 P/ t  m- Q2 P4 O
88.     return 1;
    
89.   }
    
90. }

复制代码

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

1. #define W25QXX_WRITE_ENABLE      0x06
   
2. #define W25QXX_WRITE_DISABLE     0x04
   " }8 ^" M' w6 m. w# C6 j
3. #define W25QXX_READ_STATUS_REG1  0x05
   
4. #define W25QXX_READ_STATUS_REG2  0x35
   
5. #define W25QXX_READ_STATUS_REG3  0x15
   ; L4 J- _/ g6 M; r9 u
6. #define W25QXX_WRITE_STATUS_REG1 0x01
   
7. #define W25QXX_WRITE_STATUS_REG2 0x31
   * F+ P  D0 {( U! ~2 U: R* X
8. #define W25QXX_WRITE_STATUS_REG3 0x11
   $ o* I% F& {0 f4 U1 c1 U0 d- e$ A
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
    
13. #define W25QXX_BLOCK_ERASE       0xD8
    + T, p4 v' n" g' k% n& P- ^- a! u
14. #define W25QXX_SECTOR_ERASE      0x20
    ; o- H* K2 g+ t4 k% g
15. #define W25QXX_CHIP_ERASE        0xC7
    4 T* b7 j2 H. B: C- V- `
16. #define W25QXX_DEVICEID          0xAB
      o) M- e( T/ |/ j" S* c% S& y
17. #define W25QXX_MANUFACT_DEVICEID 0x90
    3 e) w, ~- L! u% G, C) V
18. #define W25QXX_JEDEC_DEVICEID    0x9F
    ' L5 f4 ^5 p, Q$ C0 F
19. #define W25QXX_EABLE_4BYTE_ADDR  0xB7
    
20. #define W25QXX_EXIT_4BYTE_ADDR   0xE9
    6 T) E, `3 \6 U; l8 f3 h+ e. p
21. #define W25QXX_SET_READ_PARAM    0xC0
    
22. #define W25QXX_ENTER_QPIMODE     0x38
    ! S/ x) b2 h8 p6 `% ~2 }1 Y
23. #define W25QXX_EXIT_QPIMODE      0xFF
    
24. 
    
25. uint8_t w25qxx_qpi_mode = 0; // QSPI模式标志:0,SPI模式;1,QPI模式.
    
26. 
    4 ]8 q7 _) M, r& z
27. // 读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
    
28. // 状态寄存器1：
    
29. // BIT7  6   5   4   3   2   1   0
    
30. // SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
31. // SPR:默认0,状态寄存器保护位,配合WP使用
    $ A: j! @: v1 S- L( u
32. // TB,BP2,BP1,BP0:FLASH区域写保护设置
    
33. // WEL:写使能锁定
    
34. // BUSY:忙标记位(1,忙;0,空闲)
    
35. // 默认:0x00
    
36. // 状态寄存器2：
    
37. // BIT7  6   5   4   3   2   1   0
    
38. // SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
    6 _* e: p2 A8 h$ i1 I  e
39. // 状态寄存器3：
    0 a- q! }; K/ p# T: X( k9 ^
40. // BIT7      6    5    4   3   2   1   0
    . b) i9 c. a" h; F0 Y' P/ C5 A  N
41. // HOLD/RST  DRV1 DRV0 (R) (R) WPS ADP ADS
    
42. // reg:状态寄存器号，范:1~3
    & p: ?1 A$ _  h3 Z
43. // 返回值:状态寄存器值
    ; h1 b' m. b" _
44. static uint8_t w25qxx_read_status(uint8_t reg)
    3 u9 I  e% W2 d+ r6 s* D* D+ x
45. {
      I* R7 F) t( J% U1 {7 U1 Y
46.   uint8_t value = 0, command = 0;
    . n# a, S% s( ]/ F
47. 
    
48.   switch(reg)
    
49.   {
    3 r# J$ @- m6 S/ |. g4 p, s
50.   case 1:
    
51.     command = W25QXX_READ_STATUS_REG1;  // 读状态寄存器1指令
    & }' x) {0 K0 Y& a9 N4 g" R
52.     break;
    
53. 
    
54.   case 2:
    
55.     command = W25QXX_READ_STATUS_REG2;  // 读状态寄存器2指令
    
56.     break;
    
57. 
    9 j% {& v4 w+ k; D
58.   case 3:
    . H# l9 A1 S: ]
59.     command = W25QXX_READ_STATUS_REG3;  // 读状态寄存器3指令
    , E$ \6 W& |* T& V
60.     break;
    7 r0 z" [: S4 L0 A# M. {* l
61. 
    
62.   default:
    
63.     command = W25QXX_READ_STATUS_REG1;
    
64.     break;
    
65.   }
    
66. 
    
67.   if(w25qxx_qpi_mode)
    
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个字节数据
    
70.   }
    
71.   else
    1 D1 p: {0 O- W! c
72.   {
    ; l! @+ y0 v* K% u) |& o
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.   }
    " [! P3 L3 c! S! f5 p( R8 U0 G1 q0 P* z* T
75. 
    . C5 N6 x# h$ n  j
76.   QSPIReceive(&value, 1);
    3 Y1 S/ `9 k" k2 n+ i2 i* X5 s% f
77. 
    4 h0 |4 P8 s' B9 w
78.   return value;
    / y0 Y8 x  Q4 I$ w! @
79. }
    
80. 
    
81. // 写状态寄存器
    4 \& b' Z, R' _/ s! L
82. static void w25qxx_write_status(uint8_t reg, uint8_t status)
    
83. {
    , c5 Z4 G1 Z5 }5 j9 \" G3 C
84.   uint8_t command = 0;
    
85. 
    
86.   switch(reg)
    5 x5 d! h3 m6 P
87.   {
    ! m+ A  P! p" c: J0 i! @
88.   case 1:
    " g' T& a( w. Y+ f0 o( I
89.     command = W25QXX_WRITE_STATUS_REG1;  //写状态寄存器1指令
    
90.     break;
    
91.   case 2:
    ' f7 ?9 k! ~$ c* D" b: P" D
92.     command = W25QXX_WRITE_STATUS_REG2;  //写状态寄存器2指令
    " l1 G6 R' {+ I5 i% ~( h" o
93.     break;
    3 ?4 F: E7 T- h! }+ n, G- t
94.   case 3:
    
95.     command = W25QXX_WRITE_STATUS_REG3;  //写状态寄存器3指令
      Q1 b1 h2 f( |/ B# X$ X
96.     break;
    2 Y  U- P7 v" F+ K
97.   default:
    
98.     command = W25QXX_WRITE_STATUS_REG1;
    / H$ P9 L6 [8 |
99.     break;
    
100.   }
     ! B, C2 X1 v; M4 \1 v, f
101.   if(w25qxx_qpi_mode)
     
102.   {
     1 k) Y  |  l/ }. \$ |4 h8 h
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个字节数据
     4 S& E/ C, n5 v1 U5 A
104.   }
     
105.   else
     
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个字节数据
     8 e3 g9 K" W  U) P+ {  U
108.   }
     ' X) ]8 A$ {7 n- }8 ?
109.   QSPITransmit(&status, sizeof(status));
     
110. }
     
111. 
     
112. // 写使能  将S1寄存器的WEL置位
     
113. static void w25qxx_write_enable(void)
     
114. {
     
115.   if(w25qxx_qpi_mode)
     7 R) m4 r) G) @; @
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个字节数据
     6 ]" c6 s  k" D; M4 p( x$ l4 b
118.   }
     
119.   else
     ) h1 p! b- O" i! `6 ~
120.   {
       \3 T6 ~$ Y+ e
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.   }
     % n/ D4 p2 j! Q. ~* O; @
123. }
     
124. 
     0 j0 I" L: F6 [# ]
125. // 写失能  将WEL清零
     
126. void W25QXX_Write_Disable(void)
     
127. {
     * E% e5 B" d4 L
128.   if(w25qxx_qpi_mode)
     
129.   {
     ( S) l; o" ^/ u- m& M, x
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个字节数据
     . }' n# S. w  m  X/ C
131.   }
     
132.   else
     ; _$ }5 x# a7 x
133.   {
       X7 `4 K6 L. F) a; Q, W* ]
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.   }
     / |* l- _, j0 N! p
136. }
     
137. 
     
138. // 等待空闲
     ( r/ o: K, K0 A! t) x
139. void w25qxx_wait_busy(void)
     7 r  P/ A: l, ]% z( h
140. {
     
141.   while((w25qxx_read_status(1) & 0x01) == 0x01); // 等待BUSY位清空
     
142. }
     
143. 
     
144. // W25QXX进入QSPI模式
     
145. static void w25qxx_qspi_init(void)
     , e5 l. w3 s9 V, \
146. {
     
147.   uint8_t reg2;
     
148.   reg2 = w25qxx_read_status(2); // 先读出状态寄存器2的原始值
     ' D1 @3 J% ^9 p# i) N6 }3 X
149.   if((reg2 & 0X02) == 0)  // QE位未使能
     
150.   {
     7 Q1 Z0 c( r8 W1 e; k7 w+ s6 p
151.     w25qxx_write_enable(); // 写使能
     : g" ^( }% ^2 p9 o4 o
152.     reg2 |= 1 << 1; // 使能QE位
     2 k# W# Z: `+ y7 ~: |
153.     w25qxx_write_status(2, reg2); // 写状态寄存器2
     7 J* d4 m; F+ D8 U. J0 D0 u
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个字节数据
     & n9 k8 `' M9 L9 \2 J
157. 
     ; Z9 n  N: M& z1 z' i
158.   w25qxx_qpi_mode = 1; // 标记QSPI模式
     
159. }
       U' {3 e" j# N
160. 
     , T7 s: v6 r. f/ C6 Y7 R; E  [
161. // 0XEF13,表示芯片型号为W25Q80
     
162. // 0XEF14,表示芯片型号为W25Q16
     
163. // 0XEF15,表示芯片型号为W25Q32
     
164. // 0XEF16,表示芯片型号为W25Q64
     
165. // 0XEF17,表示芯片型号为W25Q128
     - ]- n' |5 b% u3 b
166. // 0XEF18,表示芯片型号为W25Q256
     
167. static void w25qxx_id_get(void)
     3 A6 }* @$ v. Y9 N; J6 e
168. {
     9 `% a- [4 `# A+ c
169.   uint8_t temp[2];
     5 n7 l0 J' m" `3 S- P
170.   uint16_t device_id;
       z  ?& U, @* P: T6 k
171. 
     / i$ T7 }6 z: ^1 i
172.   if(w25qxx_qpi_mode)
     
173.   {
     9 K& ~; a$ B$ G* m
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个字节数据
     
175.   }
     
176.   else
     5 j: B" O* s) A4 Q8 f
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.   }
     - c; e7 R5 Y# ^9 E% ?
180. 
     
181.   QSPIReceive(temp, 2);
     
182. 
     
183.   device_id = (temp[0] << 8) | temp[1];
     
184. 
     
185.   printf("QSPI Flash Device ID: %X\r\n", device_id);
     / b" Q3 U6 s: A; m* v  p3 c" f" w
186. }
     
187. 
     
188. void W25QXXInit(void)
     
189. {
     ) Y3 r- g* j. @1 a* K
190.   uint8_t temp;
     
191. 
     
192.   QSPIInit();
     / x  c% x' t% i  t
193.   w25qxx_qspi_init(); // 使能QSPI模式
     4 w7 d7 y; u* c& O+ S
194.   w25qxx_id_get();    // 读取FLASH ID.
     2 ^* N3 i- Q# J, J  T# K
195. 
     
196.   temp = w25qxx_read_status(3); // 读取状态寄存器3，判断地址模式
     % m9 x9 L6 V' N7 B( y
197.   if((temp & 0X01) == 0) // 如果不是4字节地址模式,则进入4字节地址模式
     
198.   {
     2 h0 V- a" N4 s; M
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个字节数据
     0 Z) L& X6 Q! J9 K1 M2 H! `/ _% S7 t
204.   temp = 3 << 4;      // 设置P4&P5=11,8个dummy clocks,104M
     . W* N1 D& l: B6 x0 Q
205.   QSPITransmit(&temp, 1);
     % a$ M  i( {# }1 J( \" w
206. }
     # J: q1 m4 m" u% S- Q2 d
207. 
     
208. // 擦除一块4096字节 最少需要150ms
     
209. void W25QXXSectorErase(uint32_t addr)
     : O+ `) b' U# p- T# A4 W
210. {
     3 x! h1 O; t2 l/ q
211.   //addr /= 4096;
     
212.   addr *= 4096;
     % d! s$ o0 x' M7 g' E- E( @
213. 
     
214.   w25qxx_write_enable();
       D% n0 u: }, a# u: k8 N& I
215.   w25qxx_wait_busy();
     0 Y' r/ ~) z5 [
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. }
     
219. 
     
220. 
     
221. // 擦除整个芯片
     + H% F  W) {! H
222. void W25QXXChipErase(void)
     & x$ u6 y. t% I4 E. z# K* i4 n
223. {
     
224.   w25qxx_write_enable();          //SET WEL
     : @2 v5 d& d5 X
225.   w25qxx_wait_busy();
     . a3 g) a) Q" P/ _0 b# _  Q! t9 @6 x
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();           //等待芯片擦除结束
     7 q3 Z+ }6 {# H
228. }
     
229. 
     
230. // 写最多256字节
     
231. void W25QXXWritePage(uint32_t addr, uint8_t *buffer, uint16_t length)
     
232. {
     ( U0 k( }. Q) z; w1 c
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个数据
     & [: h  X9 S8 o  T* ?' f. K$ f
235.   QSPITransmit(buffer, length);
     + [+ S, d7 p8 S' O" B6 A* j) Q+ a" _
236.   w25qxx_wait_busy();            //等待写入结束
     
237. }
     / [! X" e2 E2 q0 D
238. 
     
239. // 写最多65536字节 无擦除动作
     
240. void W25QXXWriteExt(uint32_t addr, uint8_t *buffer, uint16_t length)
     ) p, a6 G4 {# g  o) U7 h4 L. ^. k' u+ x
241. {
     
242.   uint16_t pageremain = 256 - addr % 256; // 单页剩余的字节数
     
243. 
     8 @" y$ z0 z& n4 D9 n" v: V( O
244.   if(addr + length - 1 > (32 * 1024 * 1024))
     
245.   {
     ' ]0 Z* N" n5 u6 r6 I) r& ?( q
246.     return;
     . k8 o, m4 }  [7 o" R
247.   }
     
248. 
     7 P% ?' w! l& F6 n1 i
249.   if(length <= pageremain)
     
250.   {
     * n. \: ]7 W- K$ V' E
251.     pageremain = length;  // 不大于256个字节
     
252.   }
     " w) N* V& T8 ~* p+ V. s
253.   while(1)
     
254.   {
     0 b* {! M# N/ t; @3 f
255.     // 分页写入
     
256.     W25QXXWritePage(addr, buffer, pageremain);
     ) d# g9 i. v  @! G
257. 
     
258.     if(length == pageremain)
     1 o/ W6 \: @- M0 D3 e) a3 e! t
259.     {
     
260.       break;  //写入结束了
     8 `. Z$ H* i' R
261.     }
     
262.     else
     
263.     {
     $ k. \; k/ C% _& ]- C: D7 A7 \7 |
264.       buffer += pageremain;
     
265.       addr += pageremain;
     
266. 
     
267.       length -= pageremain; // 减去已经写入了的字节数
     3 Y, a* X* c% `4 r
268.       if(length > 256)
     & `" P* U$ F& B- z+ @
269.       {
     
270.         pageremain = 256;  // 一次可以写入256个字节
     
271.       }
     
272.       else
     6 T8 h" g% v0 O- C2 [
273.       {
     
274.         pageremain = length;  // 不够256个字节了
     / \' l0 z- v/ q% j" I
275.       }
     
276.     }
     * R$ x, Y* k6 X; Q
277.   }
     
278. }
     
279. 
     
280. // 写最多65536字节 带擦除动作
     
281. static uint8_t W25QXX_BUFFER[4096];
       J" X8 l, p- A
282. void W25QXXWrite(uint32_t addr, uint8_t* buffer, uint16_t length)
     3 k- K! `1 J, s
283. {
     
284.   uint32_t secpos;
     
285.   uint16_t secoff, secremain, i;
     
286.   uint8_t * w25q_buf;
     6 H8 ]# k7 e" @
287. 
     
288.   w25q_buf = W25QXX_BUFFER;
     
289. 
     
290.   secpos = addr / 4096; // 扇区地址
     9 b4 A6 L6 E6 W9 v) r1 i& s1 Y3 E; l
291.   secoff = addr % 4096; // 在扇区内的偏移
     
292.   secremain = 4096 - secoff; // 扇区剩余空间大小
     6 y/ Q: V5 }: w1 I, R
293. 
     , }6 ]1 j; X* a" x( @. R. v
294.   if(length <= secremain)
     
295.   {
     
296.     secremain = length;  // 不大于4096个字节
     + _( p: ~1 H* R" x9 x" W
297.   }
     4 {/ k5 X- H6 W6 F
298.   while(1)
     
299.   {
     
300.           WatchdogFeed();
     
301.     W25QXXRead(secpos * 4096, w25q_buf, 4096); // 读出整个扇区的内容
     * E) s8 W  Y; ~  {* \3 [  ~
302.     for(i = 0; i < secremain; ++i)
     
303.     {
     . T6 B& u& v# ?0 e' K3 }. c
304.       if(w25q_buf[secoff + i] != 0XFF)
     6 p9 M6 k0 [" T+ @
305.       {
     
306.         break;  // 需要擦除
     ; V9 V& U% O# U) @4 a
307.       }
     % u4 ?1 |& j& V
308.     }
     $ c4 |, [% [: a7 @, b" B
309.     if(i < secremain) // 需要擦除
     
310.     {
     
311.       W25QXXSectorErase(secpos); // 擦除这个扇区
     4 g6 X' J+ {4 t" q. l& m4 F
312.       for(i = 0; i < secremain; ++i)
     
313.       {
     
314.         w25q_buf[i + secoff] = buffer<i>;</i>
     5 t# Y: _( t+ B6 b8 k& F
315.       }
     ) q- Y6 Y0 i, n) x3 M4 o
316.       W25QXXWriteExt(secpos * 4096, w25q_buf, 4096); // 写入整个扇区
     - M/ |  u& U6 R6 w! I+ ~: ?2 B. ^1 S
317. 
     
318.     }
     
319.     else
     
320.     {
     ( `+ [  K* P4 F) G3 Y" p) |- }
321.       W25QXXWriteExt(addr, buffer, secremain);  // 写已经擦除了的,直接写入扇区剩余区间.
     # T! z  S; q- _( K& s
322.     }
     
323.     if(length == secremain)
     9 R. y& B; Z/ r' O2 r
324.     {
     
325.       break;
     6 e8 `* V. P; [/ @- S+ T
326.     }
     & V. x) Y$ U/ ~$ J
327.     else
     * L8 `, z( |4 ]  {
328.     {
     7 L& |# K# S0 q. ?
329.       secpos++;
     ! V; G' X% r. ~. s, `
330.       secoff = 0;
     7 a7 g* N" |# y
331. 
     & T" ^- e) o) u- X! e
332.       buffer += secremain;
     # H5 ~7 G3 X6 r# C) e. K9 ]- @' t# H
333.       addr += secremain;
     
334.       length -= secremain;
     
335.       if(length > 4096)
     
336.       {
     
337.         secremain = 4096;
     8 @6 C/ t+ E4 |+ {  }! d' o5 l
338.       }
     
339.       else
     
340.       {
     
341.         secremain = length;
     
342.       }
     ( v* M1 `; C, s" T
343.     }
     ! M+ E. U( U0 {
344.   };
     ( N( Z+ ]& m# U  x; t7 m
345. }
     
346. 
     , B  @" U$ V; D: B# n
347. 
     . l1 T5 T" h" ?) D5 e' N! j
348. // 读取SPI FLASH,仅支持QPI模式  在指定地址开始读取指定长度的数据 65536
     6 M: f3 q4 c# x
349. void W25QXXRead(uint32_t addr, uint8_t *buffer, uint16_t length)
     
350. {
     0 Q+ u4 r+ O% `$ O% y1 @6 h
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);
     : q+ O/ h0 B; N: y/ x2 o
353. }

复制代码

* ~9 T) h/ k  e* o也可以使用SPI操作W25QXX。
/ q" E4 X' `( t' J% W


: v5 c: p0 A# K