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

. X: F1 W+ ]+ \% \ 该接口可以在以下三种模式下工作：
7 w" n' a; e8 r, n4 a' d5 h& W1 _+ S① 间接模式：使用 QSPI 寄存器执行全部操作
② 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）
③ 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器。
3 G/ U  ~2 W) {! X2 u& _
QSPI通过6根线与SPI芯片通信，下图是内部框图：
: R6 @' l: @. c
. X! t. \! `! `* V9 Q

/ m& f0 M. k" a' d5 ]) J
QSPI每条命令，必须包含一个或多个阶段：指令、地址、交替字节、空指令和数据。

QSPI发送命令：等待QSPI空闲；设置命令参数。

QSPI读数据：设置数据传输长度；设置QSPI工作模式并设置地址；读取数据。
" V. D, }' G" J+ w
4 C( g8 R; @6 I+ aQSPI写数据：设置数据传输长度；设置QSPI工作模式并设置地址；写数据。
: c( b8 e* C- [, G' ~- w; u9 B) M

二、几个重要的函数

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); // 发送命令
   
4. 
   
5. HAL_StatusTypeDef     HAL_QSPI_Transmit     (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 发送数据
   
6. 
   & }8 D7 t& B" n% g
7. HAL_StatusTypeDef     HAL_QSPI_Receive      (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 接收数据

复制代码

, ~1 I/ S: u; G三、几个重要的结构

1. // QSPI操作句柄
   2 b* H( _0 @. o/ f; `2 X
2. typedef struct
   
3. {
   
4.   QUADSPI_TypeDef            *Instance;        /* QSPI registers base address        */
   ( I* t" L; |, ~6 ~8 m4 u* Y
5.   QSPI_InitTypeDef           Init;             /* QSPI communication parameters      */
   % S0 w5 c  y6 J3 \
6.   uint8_t                    *pTxBuffPtr;      /* Pointer to QSPI Tx transfer Buffer */
   
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 */
   5 R7 a3 t2 _6 F6 D9 F; B
10.   __IO uint16_t              RxXferSize;       /* QSPI Rx Transfer size              */
    % \3 v8 c) s6 d
11.   __IO uint16_t              RxXferCount;      /* QSPI Rx Transfer Counter           */
    
12.   DMA_HandleTypeDef          *hdma;            /* QSPI Rx/Tx DMA Handle parameters   */
    
13.   __IO HAL_LockTypeDef       Lock;             /* Locking object                     */
    
14.   __IO HAL_QSPI_StateTypeDef State;            /* QSPI communication state           */
    
15.   __IO uint32_t              ErrorCode;        /* QSPI Error code                    */
      J0 c2 N- t1 G. R
16.   uint32_t                   Timeout;          /* Timeout for the QSPI memory access */
    ( u5 f. Y. O3 c( v% O
17. }QSPI_HandleTypeDef;
    1 X/ R- |! _( F' `; T3 m% k
18. 
    
19. // Instance：QSPI基地址  ---  QUADSPI
    
20. // Init：设置QSPI参数
    * h! ~2 r/ p$ X9 [; [
21. // pTxBuffPtr,TxXferSize,TxXferCount：发送缓存指针 发送数据量 剩余数据量
    
22. // pRxBuffPtr,RxXferSize,RxXferCount：接收缓存指针 发送数据量 剩余数据量
    : C; P5 i9 S- i$ l
23. // hdma与DMA相关， 其他为过程变量不需要关心

复制代码

1. // 参数配置 时钟分频系数  FIFO阈值  采样移位  FLASH大小  片选高电平时间  时钟模式  闪存ID  双闪存模式设置
   
2. typedef struct
   ) b$ O; }7 m, `1 B  Q6 X
3. {
   , R$ L7 u* s# Q# ^" A; q( [
4.   uint32_t ClockPrescaler;     /* Specifies the prescaler factor for generating clock based on the AHB clock.
   0 i  B& {0 V! j: q: A: }9 T
5.                                   This parameter can be a number between 0 and 255 */
   8 \. q, j9 m. E- I
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 */
   8 L2 F3 H6 v' o) B" u5 F8 }  Q$ M7 Y6 {
9. 
   1 H7 I9 c. Z5 p7 D5 Y5 s0 p5 C$ e
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. 
    3 J2 o+ ]8 N1 s5 w5 }- n$ i
14.   uint32_t FlashSize;          /* Specifies the Flash Size. FlashSize+1 is effectively the number of address bits
    ) {; }* v. E2 u5 g. y
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
    
17.                                   memory-mapped mode is limited to 256MB
    6 r* r0 a& n$ t& D! z2 F
18.                                   This parameter can be a number between 0 and 31 */
    $ I; x( x% v. h& Y  z6 O
19. 
    
20.   uint32_t ChipSelectHighTime; /* Specifies the Chip Select High Time. ChipSelectHighTime+1 defines the minimum number
    # u* g/ @) h& t& M; J
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. 
    , a7 _1 S; J6 `/ F9 p$ f! d% L/ o
24.   uint32_t ClockMode;          /* Specifies the Clock Mode. It indicates the level that clock takes between commands.
    / n$ L5 D( z, A& Z( q2 \
25.                                   This parameter can be a value of @ref QSPI_ClockMode */
    7 P7 u7 V. \! X5 m# e
26. 
    ' f: h* S( f& r9 [. {
27.   uint32_t FlashID;            /* Specifies the Flash which will be used,
    * C0 ~3 V' f" q/ K
28.                                   This parameter can be a value of @ref QSPI_Flash_Select */
    7 i7 i4 l. P( e6 ], f* `; z
29. 
    
30.   uint32_t DualFlash;          /* Specifies the Dual Flash Mode State
    % L) e- S+ I. b9 l
31.                                   This parameter can be a value of @ref QSPI_DualFlash_Mode */                                               
    
32. }QSPI_InitTypeDef;

复制代码

1. // 采样移位
   2 u; _/ A( D) }' x) ]) x' Q
2. #define QSPI_SAMPLE_SHIFTING_NONE           ((uint32_t)0x00000000U)        /*!<No clock cycle shift to sample data*/
   
3. #define QSPI_SAMPLE_SHIFTING_HALFCYCLE      ((uint32_t)QUADSPI_CR_SSHIFT) /*!<1/2 clock cycle shift to sample data*/

复制代码

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

1. #define QSPI_CLK_ENABLE()         __HAL_RCC_QSPI_CLK_ENABLE();
   
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
   
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. 
   - r, o+ G& d( J
8. #define QSPI_BK1_CLK_PORT         GPIOB
   6 B6 k& N$ v+ Y- D0 h5 D* q
9. #define QSPI_BK1_CLK_PIN          GPIO_PIN_2
   ( v$ }4 X7 u+ I- h. s
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)
    / R% ?1 f. [0 }3 O# z* ]
12. 
    4 c$ d1 E! h2 t$ A; _8 }
13. #define QSPI_BK1_IO0_PORT         GPIOF
    
14. #define QSPI_BK1_IO0_PIN          GPIO_PIN_8
    " m& `& `7 r  u: H$ F4 Y
15. #define QSPI_BK1_IO0_AF           GPIO_AF10_QUADSPI
    
16. #define QSPI_BK1_IO0_CONFIG()     GPIOConfigExt(QSPI_BK1_IO0_PORT, QSPI_BK1_IO0_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, QSPI_BK1_IO0_AF)
    
17. 
    
18. #define QSPI_BK1_IO1_PORT         GPIOF
    
19. #define QSPI_BK1_IO1_PIN          GPIO_PIN_9
    % c" @% f# M( q( n% B6 z. ]
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)
    6 [. _% ]! Y! s
22. 
    
23. #define QSPI_BK1_IO2_PORT         GPIOF
    3 y6 K8 H  x+ O% Z6 D; H" V; G0 t
24. #define QSPI_BK1_IO2_PIN          GPIO_PIN_7
    ) C, [( q  ~2 ]5 v$ n( j/ M3 w
25. #define QSPI_BK1_IO2_AF           GPIO_AF9_QUADSPI
    0 \4 T/ Z3 q2 p- d3 n& V! D+ ~) n. w
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)
    " u' z# D- f) x  {- c
27. 
      z9 m6 r# z5 Q" s4 V" ~0 n8 U
28. #define QSPI_BK1_IO3_PORT         GPIOF
    2 o" i% w* m' D
29. #define QSPI_BK1_IO3_PIN          GPIO_PIN_6
    ; K0 C9 ^. y& m6 c
30. #define QSPI_BK1_IO3_AF           GPIO_AF9_QUADSPI
    
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;
   & n  |8 P" G0 ]9 Z  i# [
3. 
   
4. static void qspi_gpio_init(void)
   4 U" c) D* x% _5 X- R9 W9 y( S
5. {
   0 Y% {! J, y) `8 g
6.   QSPI_CLK_ENABLE();
   
7. 
   , J( ?  Y/ @( A6 d+ D  p
8.   QSPI_BK1_NCS_CONFIG();
   
9.   QSPI_BK1_CLK_CONFIG();
   
10.   QSPI_BK1_IO0_CONFIG();
    
11.   QSPI_BK1_IO1_CONFIG();
    5 [" B" S7 h9 o+ t2 v
12.   QSPI_BK1_IO2_CONFIG();
    
13.   QSPI_BK1_IO3_CONFIG();
    8 H( a' ?/ k7 d( }$ b4 z
14. }
    
15. 
    
16. static void qspi_mode_init(void)
    ( F& d1 ?+ ]' }# b% y# r
17. {
    
18.   qspi_handle.Instance = QUADSPI;                        // QSPI
    
19.   qspi_handle.Init.ClockPrescaler = 2;                   // QPSI分频比，W25Q256最大频率为104M 所以此处应该为2，QSPI频率就为216/(2+1)=72MHZ
    % P* g: a  w9 d3 c: Q0 k" [7 l
20.   qspi_handle.Init.FifoThreshold = 4;                    // FIFO阈值为4个字节
    , t7 v0 X/ C$ I/ ~& |+ N& z
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参数
    $ L$ j) J' O9 F" G( m& u' V' S+ 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;   // 禁止双闪存模式
    6 c- {% y1 r' q( Z9 ?% s0 p
27.   HAL_QSPI_Init(&qspi_handle);      //QSPI初始化
    . e: }3 W, U/ y$ a- {2 v2 _! ?
28. }
    
29. 
    
30. void QSPIInit(void)
    
31. {
    , |) V& ~: |! a7 Z& O
32.   qspi_gpio_init();
    , Q  y# G2 o0 G
33.   qspi_mode_init();
    6 |% @# K6 |1 Y0 t' v
34. }
    : ^, p3 c# X6 L* A" n# `
35. 
    
36. // QSPI发送命令
    
37. // instruction:要发送的指令
    $ C# ?2 Q7 h9 m
38. // address:发送到的目的地址
    5 ~- L( C3 @8 `3 K
39. // dummyCycles:空指令周期数
    
40. // instructionMode:指令模式;QSPI_INSTRUCTION_NONE,QSPI_INSTRUCTION_1_LINE,QSPI_INSTRUCTION_2_LINE,QSPI_INSTRUCTION_4_LINE
    " ^7 }- E: A/ m& d- n9 t# A5 K
41. // addressMode:地址模式; QSPI_ADDRESS_NONE,QSPI_ADDRESS_1_LINE,QSPI_ADDRESS_2_LINE,QSPI_ADDRESS_4_LINE
    7 E$ _& _2 h. y
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
    % r0 |9 [; x# g: J0 I
44. void QSPISendCMD(uint32_t instruction, uint32_t address, uint32_t dummyCycles, uint32_t instructionMode, uint32_t addressMode, uint32_t addressSize, uint32_t dataMode)
    7 r0 R% u& @( O2 @; k  _0 U
45. {
    3 P3 n' {0 z/ S, k0 B
46.   QSPI_CommandTypeDef Cmdhandler;
    & c/ b1 a4 a9 s0 M& }5 A) T
47. 
    5 q$ ^, Q0 g! e4 d0 J
48.   Cmdhandler.Instruction = instruction;           // 指令
    
49.   Cmdhandler.Address = address;                   // 地址
    
50.   Cmdhandler.DummyCycles = dummyCycles;           // 设置空指令周期数
    8 p% r( B) s4 R* E5 i' G+ ]# w
51.   Cmdhandler.InstructionMode = instructionMode;   // 指令模式
    0 i; u8 A2 F6 z
52.   Cmdhandler.AddressMode = addressMode;           // 地址模式
    ! ?; O  D5 Y; w8 ]! J4 X4 S
53.   Cmdhandler.AddressSize = addressSize;           // 地址长度
    
54.   Cmdhandler.DataMode = dataMode;                 // 数据模式
    1 V" h1 C2 F; o( }2 F" X+ h
55.   Cmdhandler.SIOOMode = QSPI_SIOO_INST_EVERY_CMD; // 每次都发送指令
    0 y2 Q& G) Y" ?0 @+ A  ?
56.   Cmdhandler.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; // 无交替字节
    
57.   Cmdhandler.DdrMode = QSPI_DDR_MODE_DISABLE;           // 关闭DDR模式
    
58.   Cmdhandler.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
    ' _4 U( X* ?) R2 B! M# l
59. 
    1 Q. B8 t" j& D+ Q# s' {
60.   HAL_QSPI_Command(&qspi_handle, &Cmdhandler, 5000);
    
61. }
    8 m2 V' L) q  G
62. 
    0 B9 K8 g* `# X% F! A3 i
63. // 接收指定长度数据
    / {) W; F+ s) i# d6 M/ m
64. uint8_t QSPIReceive(uint8_t *buffer, uint32_t length)
    
65. {
    5 \+ R0 D1 {5 x' \0 J
66.   qspi_handle.Instance->DLR = length - 1;
    ' @/ A2 m9 j1 I/ t. d
67.         
    
68.   if(HAL_QSPI_Receive(&qspi_handle, buffer, 5000) == HAL_OK)
    " @3 |; [  [+ t# N
69.   {
    3 W' J1 |( g/ d/ ~. p5 f/ v# B
70.     return 0;  //接收数据
    3 w. `, M% r  A9 K
71.   }
    
72.   else
    
73.   {
    
74.     return 1;
    
75.   }
    
76. }
    
77. 
    : q. M7 [+ [5 f) o1 D
78. // 发送指定长度数据
    8 z$ ?3 G- d- }* e% m
79. uint8_t QSPITransmit(uint8_t *buffer, uint32_t length)
    
80. {
    
81.   qspi_handle.Instance->DLR = length - 1;
    
82.   if(HAL_QSPI_Transmit(&qspi_handle, buffer, 5000) == HAL_OK)
    
83.   {
    
84.     return 0;  //发送数据
    ' ~: l, c  b" p5 Y  p0 T, O
85.   }
    6 L' y2 }( w2 p- a2 n3 j" E! ]$ H8 S# ?1 Z) y
86.   else
    
87.   {
    , q5 G  @' z5 y
88.     return 1;
    
89.   }
    
90. }

复制代码

五、QSPI驱动W25Q256
0 `4 c( ^# v1 c: ?* b1 EW25Q256:32M  512块，每块16个扇区，每个扇区4K。具体指令看手册。封装了如下接口（初始化读写擦除等接口是以后移植文件系统的基础）：
% N  D7 X( h8 X* `( S6 c

1. #define W25QXX_WRITE_ENABLE      0x06
   9 k% u  c0 a9 h& I1 @
2. #define W25QXX_WRITE_DISABLE     0x04
   
3. #define W25QXX_READ_STATUS_REG1  0x05
   ! R2 a, p4 B9 y2 a6 F, c" X
4. #define W25QXX_READ_STATUS_REG2  0x35
   
5. #define W25QXX_READ_STATUS_REG3  0x15
   # J1 f* x7 d1 e7 A
6. #define W25QXX_WRITE_STATUS_REG1 0x01
   ' |/ q+ c$ h) p  c/ ]9 L
7. #define W25QXX_WRITE_STATUS_REG2 0x31
   7 f& O0 \) S! s* Q, Q! m
8. #define W25QXX_WRITE_STATUS_REG3 0x11
   0 p8 `" n+ x0 g. `+ q  V! u
9. #define W25QXX_READ_DATA         0x03
   
10. #define W25QXX_FAST_READ_DATA    0x0B
    9 ?( q4 A# c( c" }' r( M! w
11. #define W25QXX_FAST_READ_DUAL    0x3B
    
12. #define W25QXX_PAGE_PROGRAM      0x02
    
13. #define W25QXX_BLOCK_ERASE       0xD8
    9 R. ~$ k0 Z, i: ^: M( ?
14. #define W25QXX_SECTOR_ERASE      0x20
    
15. #define W25QXX_CHIP_ERASE        0xC7
    $ U  Z- X0 k2 r* H- L% P. S
16. #define W25QXX_DEVICEID          0xAB
    
17. #define W25QXX_MANUFACT_DEVICEID 0x90
    
18. #define W25QXX_JEDEC_DEVICEID    0x9F
    8 ^7 m: _  w$ e: k7 l& Z, |3 _
19. #define W25QXX_EABLE_4BYTE_ADDR  0xB7
    
20. #define W25QXX_EXIT_4BYTE_ADDR   0xE9
    * [) n$ k" B% B+ ?. o& y
21. #define W25QXX_SET_READ_PARAM    0xC0
    
22. #define W25QXX_ENTER_QPIMODE     0x38
    + T" B  Y; L, M+ Z, a
23. #define W25QXX_EXIT_QPIMODE      0xFF
    
24. 
    
25. uint8_t w25qxx_qpi_mode = 0; // QSPI模式标志:0,SPI模式;1,QPI模式.
    / J1 w7 @+ d$ |  V6 O) S
26. 
    
27. // 读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
    ( c* `3 ^- ?, l2 ]& L9 ~1 g
28. // 状态寄存器1：
    : p4 I* j3 O) t8 w
29. // BIT7  6   5   4   3   2   1   0
    1 l, n! ~- Z1 [- U0 z
30. // SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    3 v7 t; X( I, x9 B1 g
31. // SPR:默认0,状态寄存器保护位,配合WP使用
    9 w. l% [  s8 }5 q8 Z& c
32. // TB,BP2,BP1,BP0:FLASH区域写保护设置
    3 ~: ~3 m! b, s+ S$ o! j: h6 C
33. // WEL:写使能锁定
    
34. // BUSY:忙标记位(1,忙;0,空闲)
    
35. // 默认:0x00
    
36. // 状态寄存器2：
    
37. // BIT7  6   5   4   3   2   1   0
    , c6 V$ S: x! J5 G
38. // SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
    9 a" i! [' J, I$ q! K0 A  R
39. // 状态寄存器3：
    
40. // BIT7      6    5    4   3   2   1   0
    ) ^! d( R  n8 i+ d$ t6 r) S
41. // HOLD/RST  DRV1 DRV0 (R) (R) WPS ADP ADS
    9 {0 W5 q3 A! t9 y
42. // reg:状态寄存器号，范:1~3
    
43. // 返回值:状态寄存器值
    ) d9 L5 `8 |' Q( J! K4 F1 P0 R
44. static uint8_t w25qxx_read_status(uint8_t reg)
    : u1 r3 e% u7 s- i) _8 T+ ?
45. {
    % X+ G$ w) {. M0 ?9 o
46.   uint8_t value = 0, command = 0;
    
47. 
    
48.   switch(reg)
    
49.   {
    
50.   case 1:
    4 i( a& T2 K4 x( t
51.     command = W25QXX_READ_STATUS_REG1;  // 读状态寄存器1指令
    , R  A- U5 b$ O4 Q% V; ]& v
52.     break;
    
53. 
    
54.   case 2:
    
55.     command = W25QXX_READ_STATUS_REG2;  // 读状态寄存器2指令
    
56.     break;
    ; m, |" ^% s. G, g7 j0 Z9 \6 B
57. 
    , H# C6 }/ {- y+ m! X
58.   case 3:
    
59.     command = W25QXX_READ_STATUS_REG3;  // 读状态寄存器3指令
    9 h" J0 x" y3 c* ^
60.     break;
    ' Q) ?, v4 V, g! T
61. 
    
62.   default:
    ( A% X0 }- X* y7 R4 E$ {
63.     command = W25QXX_READ_STATUS_REG1;
    
64.     break;
    6 \8 Y. f0 f7 m/ b/ y2 i# V
65.   }
    
66. 
    5 B- C) o/ O+ E8 w, J( b% x
67.   if(w25qxx_qpi_mode)
    
68.   {
    ) K4 F' a% _+ l6 B6 U9 ~/ o
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
    
72.   {
    5 I- j, N# V8 V( n
73.     QSPISendCMD(command, 0, 0, QSPI_INSTRUCTION_1_LINE, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_1_LINE);  //SPI,写command指令,地址为0,单线传数据_8位地址_无地址_单线传输指令,无空周期,1个字节数据
    
74.   }
    
75. 
    & i; X' v& f/ O0 P. D) G
76.   QSPIReceive(&value, 1);
    
77. 
    
78.   return value;
    ! b, [2 q2 g8 z4 s7 Z# |
79. }
    9 b1 H8 P; i1 ?# X' e# e# J
80. 
    8 Z7 D  D9 {7 `1 o3 ^
81. // 写状态寄存器
    $ U: t, h; v, i% ^3 O4 q
82. static void w25qxx_write_status(uint8_t reg, uint8_t status)
    : \' O9 v5 ?* t9 u8 U7 j3 [
83. {
    
84.   uint8_t command = 0;
    
85. 
    
86.   switch(reg)
    6 X( }4 J+ H* j8 r& _* z5 w7 x& P
87.   {
    
88.   case 1:
    & q; d5 K# j4 r  g, C/ ~
89.     command = W25QXX_WRITE_STATUS_REG1;  //写状态寄存器1指令
    
90.     break;
    3 \6 X( N$ Q+ N
91.   case 2:
    
92.     command = W25QXX_WRITE_STATUS_REG2;  //写状态寄存器2指令
    
93.     break;
    ) m& S( P- Z! N7 x
94.   case 3:
    2 e( U3 o0 i2 D; S  R
95.     command = W25QXX_WRITE_STATUS_REG3;  //写状态寄存器3指令
    7 P) p' V- c$ t7 a& t( z- [
96.     break;
    
97.   default:
    
98.     command = W25QXX_WRITE_STATUS_REG1;
    
99.     break;
    ' I& q  k, s, N" s8 `
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
     
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个字节数据
     7 C' W% T6 m; F4 a2 L/ D
108.   }
     & @6 s3 D- W7 O# r  s! t0 }8 @' }# g
109.   QSPITransmit(&status, sizeof(status));
     : f7 C1 ]! D4 o+ p* y$ Y
110. }
     ( Y! }& p9 x/ |8 ~
111. 
     
112. // 写使能  将S1寄存器的WEL置位
     
113. static void w25qxx_write_enable(void)
     
114. {
     
115.   if(w25qxx_qpi_mode)
     , R( z5 G. m) `; z3 o0 _
116.   {
     . X. n; V. B+ J7 v1 J
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.   }
     + E1 [5 }: @1 O% [
119.   else
     8 [, L! P  |; W8 R9 w. |6 o7 d
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个字节数据
     & ~6 C, _% W5 `" J* g6 U$ ]
122.   }
     
123. }
     2 p% [# m1 q/ ~, U3 x
124. 
     3 g) [' U- m/ s, v9 o) A8 B
125. // 写失能  将WEL清零
     
126. void W25QXX_Write_Disable(void)
     ) y5 t' I0 R+ F  X
127. {
     
128.   if(w25qxx_qpi_mode)
     
129.   {
     
130.     QSPISendCMD(W25QXX_WRITE_DISABLE, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_NONE); // QPI,写禁止指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
     
131.   }
     
132.   else
     8 P- }9 T% N, {+ R( I2 Y" ?: w
133.   {
     
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个字节数据
     4 T( o+ ~3 g$ K4 p, t
135.   }
     . C; M4 `1 P3 m" }2 l
136. }
     
137. 
     
138. // 等待空闲
     6 r! [! m* {, U# ^+ x* K" ~4 m  ~$ s7 Y
139. void w25qxx_wait_busy(void)
     ) J2 j$ H7 E0 N+ i2 D0 J
140. {
     
141.   while((w25qxx_read_status(1) & 0x01) == 0x01); // 等待BUSY位清空
     # ?' n0 L" B$ H2 a$ U
142. }
     
143. 
     
144. // W25QXX进入QSPI模式
     # x3 f6 W, X5 @# H% P0 Y4 @
145. static void w25qxx_qspi_init(void)
     
146. {
     & p& o7 t* Q$ w+ S0 A# R  p
147.   uint8_t reg2;
     ; q" Q, O- Q/ i' n8 Z# N
148.   reg2 = w25qxx_read_status(2); // 先读出状态寄存器2的原始值
     & n0 H; F; a9 {7 A  K) v  u! k
149.   if((reg2 & 0X02) == 0)  // QE位未使能
     ! ?" P+ ?& V+ k& i
150.   {
     4 ~9 C( B4 N2 F& l/ }; h; p' H0 G4 x
151.     w25qxx_write_enable(); // 写使能
     
152.     reg2 |= 1 << 1; // 使能QE位
     % D* H. }6 o; l- i& I; t
153.     w25qxx_write_status(2, reg2); // 写状态寄存器2
     * b9 E. R  Q3 y) J/ O
154.   }
     7 c2 m" l7 n# o+ M- T3 O
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个字节数据
     
157. 
     : q% C5 Z9 W  {) ]/ J* a
158.   w25qxx_qpi_mode = 1; // 标记QSPI模式
     % P7 `8 `- L. k9 L. d
159. }
     
160. 
     # W) y) l1 |. `: i
161. // 0XEF13,表示芯片型号为W25Q80
     ( W) ]7 b+ @- ]) F1 V" F" q3 K) I
162. // 0XEF14,表示芯片型号为W25Q16
     
163. // 0XEF15,表示芯片型号为W25Q32
     
164. // 0XEF16,表示芯片型号为W25Q64
     
165. // 0XEF17,表示芯片型号为W25Q128
     : s5 n$ Q0 t* o' N6 `" e  `
166. // 0XEF18,表示芯片型号为W25Q256
     
167. static void w25qxx_id_get(void)
     
168. {
     
169.   uint8_t temp[2];
     
170.   uint16_t device_id;
     
171. 
     
172.   if(w25qxx_qpi_mode)
     6 {* B- T1 l& F  h
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个字节数据
     # D1 X$ f, I, N, Z& }
175.   }
     / N8 ]3 s+ _3 Y' `8 p  v' r1 T3 V
176.   else
     
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个字节数据
     4 S# V; u) j' Z' Q
179.   }
     
180. 
     
181.   QSPIReceive(temp, 2);
     
182. 
     
183.   device_id = (temp[0] << 8) | temp[1];
     2 H- G2 T; ?6 F( [, a
184. 
     % u/ ~$ n% c4 i& V" }
185.   printf("QSPI Flash Device ID: %X\r\n", device_id);
     
186. }
     * u& C2 a' _# }4 l. G' D3 g0 g
187. 
     
188. void W25QXXInit(void)
     8 b+ k+ W7 s$ G0 ~$ l9 T
189. {
     
190.   uint8_t temp;
     8 F& V9 [' z) K1 Y2 q$ W8 {
191. 
     
192.   QSPIInit();
     
193.   w25qxx_qspi_init(); // 使能QSPI模式
     
194.   w25qxx_id_get();    // 读取FLASH ID.
     
195. 
     % d8 M% K8 l5 h4 ?, I
196.   temp = w25qxx_read_status(3); // 读取状态寄存器3，判断地址模式
     + g5 Q" ^( t8 T4 D, V
197.   if((temp & 0X01) == 0) // 如果不是4字节地址模式,则进入4字节地址模式
     6 D3 L/ C  ?: V( h. s
198.   {
     
199.     w25qxx_write_enable(); // 写使能
     ( T2 j) u! M6 K8 {7 j; c
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(); // 写使能
     0 A0 j' d7 C/ y9 m
203.   QSPISendCMD(W25QXX_SET_READ_PARAM, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_4_LINES); // QPI,设置读参数指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据
     
204.   temp = 3 << 4;      // 设置P4&P5=11,8个dummy clocks,104M
     
205.   QSPITransmit(&temp, 1);
     2 X( Q6 U8 A6 S+ w* j
206. }
     1 M: `2 W' ^& W7 h4 ^. E& z
207. 
     & a- L. q) N/ m8 A, G# L
208. // 擦除一块4096字节 最少需要150ms
     
209. void W25QXXSectorErase(uint32_t addr)
     + _' b  t# I0 v$ `# f
210. {
     
211.   //addr /= 4096;
     , J2 e# R* V/ H" o7 s
212.   addr *= 4096;
     
213. 
     * E. ^8 S- K) ^# [7 f
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();
     + }+ N/ _1 M; G' O
218. }
     
219. 
     7 ]8 @7 C: Q3 ^/ f: T
220. 
     # F7 R9 I2 Z4 \8 x$ s
221. // 擦除整个芯片
     
222. void W25QXXChipErase(void)
     
223. {
     
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个字节数据
     
227.   w25qxx_wait_busy();           //等待芯片擦除结束
     7 b4 I& K( m' H4 L% R1 R1 C
228. }
     
229. 
     
230. // 写最多256字节
     - |7 [* V7 }7 t/ p: X
231. void W25QXXWritePage(uint32_t addr, uint8_t *buffer, uint16_t length)
     9 x5 [5 \7 h, n6 a) m3 P
232. {
     * N$ H1 @, A$ Q1 p4 w! b/ ~+ }
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个数据
     6 {9 k, P# \) E; n  M
235.   QSPITransmit(buffer, length);
     
236.   w25qxx_wait_busy();            //等待写入结束
     # B( k' l6 t! V/ A$ y# z
237. }
     
238. 
     
239. // 写最多65536字节 无擦除动作
     
240. void W25QXXWriteExt(uint32_t addr, uint8_t *buffer, uint16_t length)
     6 W2 P& A! [/ m1 D' V+ P2 D% p: B) M$ C2 K
241. {
     
242.   uint16_t pageremain = 256 - addr % 256; // 单页剩余的字节数
     
243. 
     ( ?; N7 A; u/ X" t% j
244.   if(addr + length - 1 > (32 * 1024 * 1024))
     9 s0 |0 x# S0 Y' `5 a/ }- C5 c7 l* W
245.   {
     
246.     return;
     
247.   }
     ) _% @* w9 L* `# M) L
248. 
     & C, x) D* O" d' k* h0 ~
249.   if(length <= pageremain)
     
250.   {
     " C+ ^4 o* o9 ?) c/ r9 X
251.     pageremain = length;  // 不大于256个字节
     
252.   }
     
253.   while(1)
     7 C* O0 H5 x/ M
254.   {
     1 Z+ z/ a6 Q3 }5 M; a1 O, P8 a
255.     // 分页写入
     % ~+ V$ f9 o' u$ n
256.     W25QXXWritePage(addr, buffer, pageremain);
     , \' j5 _' j  d* J4 l
257. 
     
258.     if(length == pageremain)
     
259.     {
     1 j5 B" z5 E: M3 H& n! P  r8 [
260.       break;  //写入结束了
     & N4 s( l3 Z4 K/ R6 X2 M. S  H
261.     }
     
262.     else
     " l% \+ W; ~, g& ^2 t9 T4 H
263.     {
     
264.       buffer += pageremain;
     ( z/ j9 ~% d" ^7 ]& |
265.       addr += pageremain;
     
266. 
     / a/ e/ O, V. M# ]
267.       length -= pageremain; // 减去已经写入了的字节数
     
268.       if(length > 256)
     
269.       {
     
270.         pageremain = 256;  // 一次可以写入256个字节
     - o, B! i# p) ^7 G* [* _- F
271.       }
     
272.       else
     
273.       {
     
274.         pageremain = length;  // 不够256个字节了
     
275.       }
     " e: ?# ?' B4 b
276.     }
     
277.   }
     4 Z7 {1 ^# h  [, {0 s4 s
278. }
     
279. 
     
280. // 写最多65536字节 带擦除动作
     " b8 D2 q( ^: W, Q
281. static uint8_t W25QXX_BUFFER[4096];
       u) R9 i8 j% e" v- m- t
282. void W25QXXWrite(uint32_t addr, uint8_t* buffer, uint16_t length)
     
283. {
     
284.   uint32_t secpos;
     
285.   uint16_t secoff, secremain, i;
     - U7 h% P) ?, w" E
286.   uint8_t * w25q_buf;
     : |; q6 v6 m, N0 K) ]* E
287. 
     ; m7 a5 E# A. s7 v6 H3 Y
288.   w25q_buf = W25QXX_BUFFER;
     
289. 
     + a) T3 Z- v; L
290.   secpos = addr / 4096; // 扇区地址
     
291.   secoff = addr % 4096; // 在扇区内的偏移
     # {6 |+ S  O, a
292.   secremain = 4096 - secoff; // 扇区剩余空间大小
     
293. 
     
294.   if(length <= secremain)
     5 ]; N* n9 F7 h$ D+ u
295.   {
     
296.     secremain = length;  // 不大于4096个字节
     
297.   }
     * g+ a% o4 e# l- F
298.   while(1)
     $ _: z9 K: j2 W6 x+ @3 B
299.   {
     
300.           WatchdogFeed();
       ~5 W* J& E6 g9 |5 G# n
301.     W25QXXRead(secpos * 4096, w25q_buf, 4096); // 读出整个扇区的内容
     
302.     for(i = 0; i < secremain; ++i)
     8 N( m" O; `! q. _  B
303.     {
     8 s" P4 r% T  p/ [, @
304.       if(w25q_buf[secoff + i] != 0XFF)
       q; n4 R$ H: P; A; Z4 }
305.       {
     
306.         break;  // 需要擦除
     5 Q3 ]6 i3 `2 n) S* B
307.       }
     
308.     }
     
309.     if(i < secremain) // 需要擦除
     
310.     {
     
311.       W25QXXSectorErase(secpos); // 擦除这个扇区
     
312.       for(i = 0; i < secremain; ++i)
     ( j4 C* ?. _* O
313.       {
     
314.         w25q_buf[i + secoff] = buffer<i>;</i>
     ! o* |9 V0 h  u
315.       }
     4 ^6 K1 q5 \) |/ m8 U' q7 `* a
316.       W25QXXWriteExt(secpos * 4096, w25q_buf, 4096); // 写入整个扇区
     2 ?# f* T* A: Y
317. 
     
318.     }
     
319.     else
     
320.     {
     
321.       W25QXXWriteExt(addr, buffer, secremain);  // 写已经擦除了的,直接写入扇区剩余区间.
     
322.     }
     
323.     if(length == secremain)
     1 I7 }- }) j  K$ m  U% _% C1 P- e
324.     {
     
325.       break;
     ! H9 P- E: l( r9 ], n$ Q, g
326.     }
     $ B$ i) _% t& ]: T9 B% |' w/ U5 W1 n5 @
327.     else
     " a# i% F: v& N2 J; e( o# S
328.     {
     ! C$ ?2 q( X* _2 W" P" n) j& F
329.       secpos++;
     * z3 a0 o- _' k1 h9 }
330.       secoff = 0;
     0 O1 S$ x; J, o: Q2 B7 m% n7 S: {
331. 
     
332.       buffer += secremain;
     
333.       addr += secremain;
     4 c  y; y; }% v$ q; S2 C# x
334.       length -= secremain;
     # x5 z& I$ u0 ~% t
335.       if(length > 4096)
     
336.       {
     
337.         secremain = 4096;
     * c/ X2 v; W* r5 i
338.       }
     
339.       else
     
340.       {
     
341.         secremain = length;
     
342.       }
     
343.     }
     
344.   };
     1 a9 a9 W7 [  U
345. }
     ( G; f) g- y* D# ~8 k/ O: H. }' F
346. 
     
347. 
     & h- X. \: ?0 O- h
348. // 读取SPI FLASH,仅支持QPI模式  在指定地址开始读取指定长度的数据 65536
     
349. void W25QXXRead(uint32_t addr, uint8_t *buffer, uint16_t length)
     
350. {
     6 Q6 a# M! |' H5 K7 |9 x+ e
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个数据
     * H- Q2 K' ?5 m4 O( Q
352.   QSPIReceive(buffer, length);
     ; Q2 _  |' E: i& ?8 }
353. }

复制代码

也可以使用SPI操作W25QXX。
+ V* k1 \. B. ~; ]* F

- t' U: F. F, m) s8 K4 V