你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【经验分享】STM32F7xx —— QSPI

[复制链接]
STMCU小助手 发布时间:2021-12-11 12:00
一、QSPI+ A+ a! C6 \' G; H( s
        SPI 是 Queued SPI 的简写,是 Motorola公司推出的 SPI 接口的扩展,比 SPI 应用更加广泛。在 SPI 协议的基础上,Motorola 公司对其功能进行了增强,增加了队列传输机制,推出了队列串行外围接口协议(即 QSPI 协议),使用该接口,用户可以一次性传输包含多达16个8位或16位数据的传输队列。一旦传输启动,直到传输结束,都不需要CPU干预,极大的提高了传输效率。该协议在ColdFire系列MCU得到广泛应用。与SPI相比,QSPI的最大结构特点是以80字节的RAM代替了SPI的发送和接收寄存器。QSPI 是一种专用的通信接口,连接单、双或四(条数据线) SPI Flash 存储介质。# u  @4 S  _. X# E4 C* F" z
7 I1 i! T( j4 o5 v( P# V. J6 y
该接口可以在以下三种模式下工作:
) c( R" D2 C8 S* T① 间接模式:使用 QSPI 寄存器执行全部操作' D8 w& q$ L' e* r7 [
② 状态轮询模式:周期性读取外部 Flash 状态寄存器,而且标志位置 1 时会产生中断(如擦除或烧写完成,会产生中断)$ d" b+ v" m8 B/ T& _) [
③ 内存映射模式:外部 Flash 映射到微控制器地址空间,从而系统将其视作内部存储器。
& h5 G" t* [' X2 S  B+ `2 C; k4 r3 L; ^* f
QSPI通过6根线与SPI芯片通信,下图是内部框图:% {  O9 h: _1 M- K

* a: m* H7 y; I( }: W+ `
20190123173205949.png

) n7 p$ e' E, }3 i3 p/ d0 \8 i, L4 w2 F2 w; c: N6 M3 }9 M# M
QSPI每条命令,必须包含一个或多个阶段:指令、地址、交替字节、空指令和数据。. l5 |! g0 F1 Q, |

; B6 y4 u9 t5 ]: a  |QSPI发送命令:等待QSPI空闲;设置命令参数。
* n  ]( B  w  s; `% F  W" W) N! H/ O! j
QSPI读数据:设置数据传输长度;设置QSPI工作模式并设置地址;读取数据。- w( |9 o+ O& C8 }) ?3 d2 I

2 [# n% u& s$ W# ?- P" |QSPI写数据:设置数据传输长度;设置QSPI工作模式并设置地址;写数据。1 b" H1 X: D2 |1 X* R
* v6 q' e8 R& P  O. B

& C, B% x" Q( H1 F, O二、几个重要的函数" ]* o0 g: ]: W# J  g
  1. HAL_StatusTypeDef     HAL_QSPI_Init     (QSPI_HandleTypeDef *hqspi); // 初始化' J% j, _2 ]/ C4 {- @4 y
  2. ! j7 B, ^' d' q' X
  3. HAL_StatusTypeDef HAL_QSPI_Command(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t Timeout); // 发送命令
    2 u4 z6 w2 l$ Z4 Z6 {6 j; Q
  4. , W: V% w% S- t7 x; m
  5. HAL_StatusTypeDef     HAL_QSPI_Transmit     (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 发送数据
    ; i/ n) S7 q& Y7 `% @6 P. S) B1 C

  6. ! F" S3 O; A# w' Q* B: a' N
  7. HAL_StatusTypeDef     HAL_QSPI_Receive      (QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout); // 接收数据
复制代码

. O1 c& q& j1 ~! x, }: H三、几个重要的结构3 d* A$ W! O- y  f: Y9 v/ r
  1. // QSPI操作句柄
    $ J- I) c8 P8 h" Q' S7 X
  2. typedef struct% s; W: R2 O8 ]
  3. {/ j. h0 P( n0 V6 e6 N
  4.   QUADSPI_TypeDef            *Instance;        /* QSPI registers base address        */; t. z, U$ [: T" R7 Y
  5.   QSPI_InitTypeDef           Init;             /* QSPI communication parameters      */
    3 K7 @- j9 D- D% f4 Q& a$ |
  6.   uint8_t                    *pTxBuffPtr;      /* Pointer to QSPI Tx transfer Buffer */
    " `4 j2 Z( v! r, v. b
  7.   __IO uint16_t              TxXferSize;       /* QSPI Tx Transfer size              */
    9 Q# P+ ^$ ~0 z5 ]
  8.   __IO uint16_t              TxXferCount;      /* QSPI Tx Transfer Counter           */+ n7 Q+ t7 f! v2 j: e
  9.   uint8_t                    *pRxBuffPtr;      /* Pointer to QSPI Rx transfer Buffer */
    ' V8 r) t' `7 H& s  R
  10.   __IO uint16_t              RxXferSize;       /* QSPI Rx Transfer size              */1 ~9 k: h4 o  a7 |3 e1 g
  11.   __IO uint16_t              RxXferCount;      /* QSPI Rx Transfer Counter           */
      |+ H: p, h+ A7 d; x& p1 N! B
  12.   DMA_HandleTypeDef          *hdma;            /* QSPI Rx/Tx DMA Handle parameters   */" v2 O- g- Y! t
  13.   __IO HAL_LockTypeDef       Lock;             /* Locking object                     */- c- Z& Q( c) o6 l2 B% J0 x( u5 d( F
  14.   __IO HAL_QSPI_StateTypeDef State;            /* QSPI communication state           */
    + K/ [* z  r: c3 R
  15.   __IO uint32_t              ErrorCode;        /* QSPI Error code                    */
    , X+ D! C0 y. ]& S. g1 ]
  16.   uint32_t                   Timeout;          /* Timeout for the QSPI memory access */ 6 K, b# V  l4 _
  17. }QSPI_HandleTypeDef;
    & |- S0 ?+ ~7 Q* S. D

  18. 7 A  P% C, \8 p" K# X- F
  19. // Instance:QSPI基地址  ---  QUADSPI
    6 k, {- R8 c0 ^# o& l$ Y% l
  20. // Init:设置QSPI参数
    8 e5 r5 q" i3 u* r5 z. u
  21. // pTxBuffPtr,TxXferSize,TxXferCount:发送缓存指针 发送数据量 剩余数据量
    / l$ {9 N# `# c' X1 E4 C
  22. // pRxBuffPtr,RxXferSize,RxXferCount:接收缓存指针 发送数据量 剩余数据量
    & ~: O0 B2 z9 t0 s4 c2 g# }
  23. // hdma与DMA相关, 其他为过程变量不需要关心
复制代码
  1. // 参数配置 时钟分频系数  FIFO阈值  采样移位  FLASH大小  片选高电平时间  时钟模式  闪存ID  双闪存模式设置
    3 Q" i* ^+ B5 g9 H5 `5 `/ X
  2. typedef struct
    ' i$ @7 S' O- s, }/ V) F+ Z6 z
  3. {
    " r5 P9 ]! ?" A7 V# a  \! ], C
  4.   uint32_t ClockPrescaler;     /* Specifies the prescaler factor for generating clock based on the AHB clock.
    ! r2 n9 m# C% s$ U) T3 D
  5.                                   This parameter can be a number between 0 and 255 */ 8 y: O! B0 N3 D) g2 T- k8 l8 q6 m

  6. 6 q6 [* m/ _' ]- d/ d
  7.   uint32_t FifoThreshold;      /* Specifies the threshold number of bytes in the FIFO (used only in indirect mode)
    # Y% O: V4 }3 B& D
  8.                                   This parameter can be a value between 1 and 32 */
    1 u5 O& f; u+ G: d, I

  9. & N4 F7 _! O* M
  10.   uint32_t SampleShifting;     /* Specifies the Sample Shift. The data is sampled 1/2 clock cycle delay later to * \5 m$ I; N6 ?; l, q
  11.                                   take in account external signal delays. (It should be QSPI_SAMPLE_SHIFTING_NONE in DDR mode)# ]1 K) F  d7 B) Z+ L0 A- E
  12.                                   This parameter can be a value of @ref QSPI_SampleShifting */8 c9 j$ r! r1 c0 U; ^8 H

  13. 8 k7 Y& n2 t: m* Z/ }8 {
  14.   uint32_t FlashSize;          /* Specifies the Flash Size. FlashSize+1 is effectively the number of address bits ( W+ i& N; {$ U' h/ l4 X+ e
  15.                                   required to address the flash memory. The flash capacity can be up to 4GB 7 D1 Z) n+ [6 p6 X$ \: r+ e) I) @
  16.                                   (addressed using 32 bits) in indirect mode, but the addressable space in , U: M: E8 }8 y
  17.                                   memory-mapped mode is limited to 256MB+ a' f6 o. z; G2 N: E3 K% N# l
  18.                                   This parameter can be a number between 0 and 31 */7 d& D4 A9 T! g" s) ^

  19. ) ]9 |1 A" G- t: Y$ x3 y: W
  20.   uint32_t ChipSelectHighTime; /* Specifies the Chip Select High Time. ChipSelectHighTime+1 defines the minimum number
    $ U! r# w0 ?5 P1 E4 c
  21.                                   of clock cycles which the chip select must remain high between commands.$ I4 k9 u9 t- F- h7 }2 L
  22.                                   This parameter can be a value of @ref QSPI_ChipSelectHighTime */
    . z3 W, M2 A) m1 V

  23. + \/ b# z3 Z' Y; F- h3 Z
  24.   uint32_t ClockMode;          /* Specifies the Clock Mode. It indicates the level that clock takes between commands.- y5 x  ]9 t( A( P/ ~, l! r
  25.                                   This parameter can be a value of @ref QSPI_ClockMode */
    # Z/ ^8 d( k; a- ?1 B  _" g

  26. 8 k3 |+ D* v2 Q  n  m+ y; n
  27.   uint32_t FlashID;            /* Specifies the Flash which will be used,
    5 `% z& `( |, S
  28.                                   This parameter can be a value of @ref QSPI_Flash_Select */
    7 D7 Z( S. F7 t9 N# i8 ]! ]: D
  29. $ B6 n8 ?9 H4 ^) }6 e/ J3 [9 Z0 s- j
  30.   uint32_t DualFlash;          /* Specifies the Dual Flash Mode State0 F, n* a! [3 }/ H( [- L
  31.                                   This parameter can be a value of @ref QSPI_DualFlash_Mode */                                               
    3 Z( _* b" S9 l8 `
  32. }QSPI_InitTypeDef;
复制代码
  1. // 采样移位
    / L0 U1 _0 R4 Y8 q0 Q, p4 k" ?
  2. #define QSPI_SAMPLE_SHIFTING_NONE           ((uint32_t)0x00000000U)        /*!<No clock cycle shift to sample data*/" g8 Q$ e% H& K  N6 v0 Y+ W
  3. #define QSPI_SAMPLE_SHIFTING_HALFCYCLE      ((uint32_t)QUADSPI_CR_SSHIFT) /*!<1/2 clock cycle shift to sample data*/
复制代码

5 h9 e; k; |, [; L0 a5 D' v四、QSPI接口设计(仅供参考)

. ?7 z8 b4 s* h' W7 l4 I
  1. #define QSPI_CLK_ENABLE()         __HAL_RCC_QSPI_CLK_ENABLE();% p+ M! m* u) r: N

  2.   \% o& s# l/ D
  3. #define QSPI_BK1_NCS_PORT         GPIOB
    ) i, }4 f& G2 n9 p$ n
  4. #define QSPI_BK1_NCS_PIN          GPIO_PIN_6
    3 d8 @, P) h8 H; |$ m9 d( _& M
  5. #define QSPI_BK1_NCS_AF           GPIO_AF10_QUADSPI
    + k! H+ Y/ b; m% 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). ^0 R; E0 U) _* ?1 R

  7. 8 Z% ]. U+ _5 D4 X, {& Y% A$ `9 X( u
  8. #define QSPI_BK1_CLK_PORT         GPIOB
    : z4 `$ w0 u5 B# ~, T. b( I% X
  9. #define QSPI_BK1_CLK_PIN          GPIO_PIN_28 c4 f/ E. q: A2 E# s
  10. #define QSPI_BK1_CLK_AF           GPIO_AF9_QUADSPI
    $ E: k% d# q2 l- R
  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)3 M/ D, R; [- O" n, O

  12. " a- n8 J. y) Q5 R% K9 `9 r- S
  13. #define QSPI_BK1_IO0_PORT         GPIOF
    4 L5 y- ?' i0 ]% d8 ]( |
  14. #define QSPI_BK1_IO0_PIN          GPIO_PIN_8  i, l3 ]% `# S& m
  15. #define QSPI_BK1_IO0_AF           GPIO_AF10_QUADSPI1 H2 b2 [& H; C9 `$ |0 l
  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)
    : }3 \0 c6 ]4 E) l: P3 o

  17. $ C. V3 z  C3 m% H4 b
  18. #define QSPI_BK1_IO1_PORT         GPIOF
    # s; }, X9 N: f2 A7 h8 Y% e
  19. #define QSPI_BK1_IO1_PIN          GPIO_PIN_9
    1 c! ]! K; I4 m5 D
  20. #define QSPI_BK1_IO1_AF           GPIO_AF10_QUADSPI$ j2 P2 c0 n( V% [) c
  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)
    . ~" M7 @3 k' z' o7 z# v

  22. : y8 K! w! I  s% [! n: l" O
  23. #define QSPI_BK1_IO2_PORT         GPIOF" Q! k- K& _+ V+ V: a, o3 _$ e
  24. #define QSPI_BK1_IO2_PIN          GPIO_PIN_73 i2 V" ~% }9 Q0 Y) K7 o$ V/ i# w
  25. #define QSPI_BK1_IO2_AF           GPIO_AF9_QUADSPI
    - D/ ~: L" e9 b5 w# I
  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)- @8 f; ^- U( H2 R' v( ]  {% h

  27. 9 P' @. P1 l% X7 v) T
  28. #define QSPI_BK1_IO3_PORT         GPIOF! \- H4 J) S. i  K( Y1 @! L
  29. #define QSPI_BK1_IO3_PIN          GPIO_PIN_6+ l1 L: v6 X: C) @2 ~
  30. #define QSPI_BK1_IO3_AF           GPIO_AF9_QUADSPI
      x& }; g6 S8 p2 _. y4 u
  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. // 封装几个必要的接口
    ; Q) k+ B- `: o. K
  2. static QSPI_HandleTypeDef qspi_handle;# T  D8 G: [/ y& |1 T; S

  3. 1 Q+ T+ Q+ \( W' a
  4. static void qspi_gpio_init(void)2 T/ Q5 \% [- z7 r- ]
  5. {
      N4 t  T  A0 M; A4 \
  6.   QSPI_CLK_ENABLE();3 w( l7 `4 h4 D# ?# @
  7. 2 J; v; E# X7 Z
  8.   QSPI_BK1_NCS_CONFIG();  z3 X) \3 A9 n. l! r# M
  9.   QSPI_BK1_CLK_CONFIG();5 s3 U% J; a8 t
  10.   QSPI_BK1_IO0_CONFIG();$ s, b- I. M8 j6 i/ J( m: B
  11.   QSPI_BK1_IO1_CONFIG();! ]6 I2 g$ p' C& z7 r; Q0 D' h
  12.   QSPI_BK1_IO2_CONFIG();
    " p4 M' k4 P& C8 ]3 B
  13.   QSPI_BK1_IO3_CONFIG();
    & }$ ~; F- C+ b' O0 R* W5 N* \
  14. }! R6 \* j# \! b8 r; Z4 D/ p0 F
  15. # t; T# Q9 e6 O) j. n
  16. static void qspi_mode_init(void)
    6 b+ d: ?7 w& J0 H' o# M
  17. {# H: K: m7 P- t9 c- T
  18.   qspi_handle.Instance = QUADSPI;                        // QSPI7 |% U3 F% D- X, z, p0 U4 N5 q
  19.   qspi_handle.Init.ClockPrescaler = 2;                   // QPSI分频比,W25Q256最大频率为104M 所以此处应该为2,QSPI频率就为216/(2+1)=72MHZ
    : a5 _! q5 W; q9 H
  20.   qspi_handle.Init.FifoThreshold = 4;                    // FIFO阈值为4个字节
    " E. f4 q5 d7 j% \9 h& v5 w9 J6 ~' U0 t
  21.   qspi_handle.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE; // 采样移位半个周期(DDR模式下,必须设置为0)4 Q1 Z* ^+ u6 O6 q: F3 E* g
  22.   qspi_handle.Init.FlashSize = POSITION_VAL(0X2000000) - 1; // SPI FLASH大小,W25Q256大小为32M字节8 o8 ~3 y) S& u  m
  23.   qspi_handle.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_4_CYCLE; // 片选高电平时间为4个时钟(13.8*4=55.2ns),即手册里面的tSHSL参数
    - {* b9 p8 z' b" t$ \1 T2 I
  24.   qspi_handle.Init.ClockMode = QSPI_CLOCK_MODE_0;        // 模式0/ v9 y" j5 X8 Q8 R* V! s
  25.   qspi_handle.Init.FlashID = QSPI_FLASH_ID_1;            // 第一片flash
    . ~5 o3 w5 p9 [) X/ _
  26.   qspi_handle.Init.DualFlash = QSPI_DUALFLASH_DISABLE;   // 禁止双闪存模式- s# Y. z% i7 q# ^: F; Z1 I# p
  27.   HAL_QSPI_Init(&qspi_handle);      //QSPI初始化9 T' ]1 t" H- C/ h
  28. }8 Z# q, g5 T4 t" F, s2 [; F

  29. * e$ P" r8 D" g9 a! R
  30. void QSPIInit(void)
    - f, G' `! |5 m0 @8 g  ]. ?2 |
  31. {( g3 \5 N- _+ `2 u
  32.   qspi_gpio_init();
    ; i# w* h; j. A* M
  33.   qspi_mode_init();8 e- [- C! i7 v" _6 U( F
  34. }$ p( [: ^  G* [& K
  35. 0 R, p2 q- l8 \
  36. // QSPI发送命令7 E# h9 _* I+ n6 X
  37. // instruction:要发送的指令5 s: d; F) k6 ?  {
  38. // address:发送到的目的地址
    $ n) s; \0 O5 O0 n; x6 u: I
  39. // dummyCycles:空指令周期数" a& Z+ c9 c* F
  40. // instructionMode:指令模式;QSPI_INSTRUCTION_NONE,QSPI_INSTRUCTION_1_LINE,QSPI_INSTRUCTION_2_LINE,QSPI_INSTRUCTION_4_LINE! e2 Y, o1 Z$ T- s8 S$ E. @' M
  41. // addressMode:地址模式; QSPI_ADDRESS_NONE,QSPI_ADDRESS_1_LINE,QSPI_ADDRESS_2_LINE,QSPI_ADDRESS_4_LINE
    5 l  U6 b8 }8 A% E7 f# n  T! X6 |
  42. // addressSize:地址长度;QSPI_ADDRESS_8_BITS,QSPI_ADDRESS_16_BITS,QSPI_ADDRESS_24_BITS,QSPI_ADDRESS_32_BITS
    5 K- Q! p! J" l5 L1 j
  43. // dataMode:数据模式; QSPI_DATA_NONE,QSPI_DATA_1_LINE,QSPI_DATA_2_LINE,QSPI_DATA_4_LINE" C; g: q: B+ X: |2 v8 I' V
  44. void QSPISendCMD(uint32_t instruction, uint32_t address, uint32_t dummyCycles, uint32_t instructionMode, uint32_t addressMode, uint32_t addressSize, uint32_t dataMode)
    ; m; f8 H1 k5 u# R
  45. {
    4 Z* q8 A; \* B$ r
  46.   QSPI_CommandTypeDef Cmdhandler;
    : \7 W4 N, w3 k( U" Z' `
  47. % m* w( ?) l# m) m8 w8 }  o' K
  48.   Cmdhandler.Instruction = instruction;           // 指令
    3 J% c0 W& x2 W* z. |/ Z9 ^' f1 D
  49.   Cmdhandler.Address = address;                   // 地址
    . S2 k9 b0 s% ?8 j
  50.   Cmdhandler.DummyCycles = dummyCycles;           // 设置空指令周期数
    , B  {8 H7 ?# j( j1 A
  51.   Cmdhandler.InstructionMode = instructionMode;   // 指令模式9 e9 F9 S9 F- W! T. P
  52.   Cmdhandler.AddressMode = addressMode;           // 地址模式9 U; ~( I) ^' I
  53.   Cmdhandler.AddressSize = addressSize;           // 地址长度
    4 o) ]# L! j' y+ k( R1 Y4 _6 B
  54.   Cmdhandler.DataMode = dataMode;                 // 数据模式
    9 Y9 U$ d/ W8 ]# V! e* D- ~
  55.   Cmdhandler.SIOOMode = QSPI_SIOO_INST_EVERY_CMD; // 每次都发送指令- I) l+ g8 s- |' m2 E: \
  56.   Cmdhandler.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; // 无交替字节
    $ m* |, J+ |! ^- t
  57.   Cmdhandler.DdrMode = QSPI_DDR_MODE_DISABLE;           // 关闭DDR模式
    & @, w" i% _. Y( v4 Q) r& s: _
  58.   Cmdhandler.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;; M# Z3 Y8 k. E9 B4 {& T

  59. - H& j$ Y( v7 T& P" i7 `$ b
  60.   HAL_QSPI_Command(&qspi_handle, &Cmdhandler, 5000);7 k6 u: [4 w7 T9 f
  61. }1 ]: X2 t8 \. |: G$ Q  p
  62. 8 z4 k* I8 E! P8 H8 a- E
  63. // 接收指定长度数据
    ! U9 {- \$ B9 U' t* {
  64. uint8_t QSPIReceive(uint8_t *buffer, uint32_t length)4 G: }( K9 T! D8 }
  65. {3 H2 |9 b: M" P
  66.   qspi_handle.Instance->DLR = length - 1;$ w1 ?8 F) e# {2 z
  67.         
    8 Z4 J4 U) {8 g: d1 ~& F* X
  68.   if(HAL_QSPI_Receive(&qspi_handle, buffer, 5000) == HAL_OK)/ \, v# u3 v5 Q8 P( t% ~7 b" F3 {
  69.   {2 s# \& }' H$ G+ g* Q5 q  m+ k9 B- x
  70.     return 0;  //接收数据' C0 T- p2 D. E5 U
  71.   }" N: k5 C# T# ]  ~% R1 ^3 S
  72.   else
    9 U5 c: H$ a" z" v+ h7 c6 m
  73.   {
    : y7 \' o! D+ }! Q
  74.     return 1;9 n7 U* I/ s5 }( r1 ?- z
  75.   }' i. s$ c6 @+ m2 @. D2 h3 i
  76. }/ Z/ `# [: K" W6 r  _2 m
  77. / C! w! L* @+ C2 d# K& |
  78. // 发送指定长度数据0 ]# v9 i2 c8 s  ^
  79. uint8_t QSPITransmit(uint8_t *buffer, uint32_t length)
    + O9 s1 Z: S4 R3 t4 y* ?, G, `
  80. {6 P9 O4 B0 J) R8 u
  81.   qspi_handle.Instance->DLR = length - 1;
    ; z- \- d  t" b5 O- x
  82.   if(HAL_QSPI_Transmit(&qspi_handle, buffer, 5000) == HAL_OK)2 c9 A, H, u- t, P7 p* J
  83.   {
    : x9 k3 H( R/ ~+ J9 `$ ]9 C+ V  E  T% @) Y
  84.     return 0;  //发送数据( m: |& `) \) h6 x6 j) R
  85.   }
    ! _7 n7 i( [& g. i5 {: t# a( U
  86.   else) ]" `1 P. F$ _2 u+ }
  87.   {9 X# g8 j4 {4 }) U- E! }
  88.     return 1;
    - ^3 \: ]1 `2 l
  89.   }
    + J' S& X4 Z4 }$ l! L7 J1 l
  90. }
复制代码

1 C) o: y$ C) u五、QSPI驱动W25Q256
0 M/ M- |& B9 t; F! [- l! J) A% YW25Q256:32M  512块,每块16个扇区,每个扇区4K。具体指令看手册。封装了如下接口(初始化读写擦除等接口是以后移植文件系统的基础):
9 s! @( @6 w. F  v* c2 H7 V' r
7 V4 l4 o( M- R
  1. #define W25QXX_WRITE_ENABLE      0x06
    / P4 L7 I6 V. m6 ~8 p) ^* X
  2. #define W25QXX_WRITE_DISABLE     0x04
    9 T% W# N; c( }- x. I
  3. #define W25QXX_READ_STATUS_REG1  0x05
    7 }* `2 J6 T" S, T, V+ A. d4 o- `
  4. #define W25QXX_READ_STATUS_REG2  0x353 y6 H8 X# g2 j
  5. #define W25QXX_READ_STATUS_REG3  0x153 ^" U4 z* }+ j+ t
  6. #define W25QXX_WRITE_STATUS_REG1 0x01
    , l' |3 K8 @1 m; \* ~
  7. #define W25QXX_WRITE_STATUS_REG2 0x31
      H! X' Q0 j8 x# `" F
  8. #define W25QXX_WRITE_STATUS_REG3 0x11
    5 ~! L: V% z, k
  9. #define W25QXX_READ_DATA         0x03! @: m# `6 t# G0 F% n, r
  10. #define W25QXX_FAST_READ_DATA    0x0B7 s0 \7 `6 v% V) a( A9 Q7 k
  11. #define W25QXX_FAST_READ_DUAL    0x3B
    ! e+ G- h& r) \  }# g. T
  12. #define W25QXX_PAGE_PROGRAM      0x02
    9 m4 ^, }8 W6 S: d
  13. #define W25QXX_BLOCK_ERASE       0xD8" q4 |7 p5 A2 ~, J# B+ A) r; i# y7 X
  14. #define W25QXX_SECTOR_ERASE      0x20
    ) o2 S# ^4 p) A; ^0 \4 ~
  15. #define W25QXX_CHIP_ERASE        0xC7
    % g& `. M$ m2 B$ t& T3 L' m8 W
  16. #define W25QXX_DEVICEID          0xAB
    * H7 W, n+ c( o; b
  17. #define W25QXX_MANUFACT_DEVICEID 0x90
    & u6 _8 P. G5 w3 \4 `" L: h# U$ c
  18. #define W25QXX_JEDEC_DEVICEID    0x9F0 @) c' a' r& Q
  19. #define W25QXX_EABLE_4BYTE_ADDR  0xB7* }* z" p, d, E% l; ]+ Z
  20. #define W25QXX_EXIT_4BYTE_ADDR   0xE9
    6 ?8 d) Z$ x% W, P1 @+ V) U, {1 p
  21. #define W25QXX_SET_READ_PARAM    0xC08 o! F- X( q1 ~
  22. #define W25QXX_ENTER_QPIMODE     0x380 K5 n, q% c* p6 T
  23. #define W25QXX_EXIT_QPIMODE      0xFF. ~" v' j$ q# x7 L3 ^

  24. % A) g" y  b6 V  b; u
  25. uint8_t w25qxx_qpi_mode = 0; // QSPI模式标志:0,SPI模式;1,QPI模式.0 C6 H) J: S: {6 D4 Y' V

  26. 9 ~" O! e9 ~! z
  27. // 读取W25QXX的状态寄存器,W25QXX一共有3个状态寄存器7 D5 R+ B* O: N' x* g. y4 s3 M
  28. // 状态寄存器1:! y$ ]3 h1 h$ x1 a
  29. // BIT7  6   5   4   3   2   1   0/ o8 O5 Z  `& F
  30. // SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    ' O! v) r; j4 v8 m! P9 k0 m
  31. // SPR:默认0,状态寄存器保护位,配合WP使用! h4 Q  H+ j2 s1 V, ^, X: `8 v2 Q
  32. // TB,BP2,BP1,BP0:FLASH区域写保护设置' \# r4 h' r: c( L
  33. // WEL:写使能锁定0 h) Y- r, D, e9 i
  34. // BUSY:忙标记位(1,忙;0,空闲)
      H8 x. q1 i' [) y8 J# |
  35. // 默认:0x00
    ( R" p; h6 Y( L# m, Q9 z
  36. // 状态寄存器2:* U9 [' n+ i- K7 x
  37. // BIT7  6   5   4   3   2   1   0
    / ^+ u  V( \% E5 d
  38. // SUS   CMP LB3 LB2 LB1 (R) QE  SRP15 H1 S/ c& V  J0 A1 B1 y% R  G
  39. // 状态寄存器3:
    * `( t  c2 u5 ^8 Y  R" B
  40. // BIT7      6    5    4   3   2   1   0" Y2 u. k0 B, q) |9 b$ ^
  41. // HOLD/RST  DRV1 DRV0 (R) (R) WPS ADP ADS7 M: f' _; h5 \2 J7 ^9 u
  42. // reg:状态寄存器号,范:1~3/ B6 I8 n6 e$ Z0 G9 ~0 _+ @
  43. // 返回值:状态寄存器值
    8 M* n$ `9 P' X5 M1 ?
  44. static uint8_t w25qxx_read_status(uint8_t reg)
    . \/ }; r$ K) n; Q7 \1 |
  45. {
    ; ?) q9 F, c2 W
  46.   uint8_t value = 0, command = 0;
    ' N7 o4 D( f! y7 h7 T: p

  47. 0 L9 V. L& T( d
  48.   switch(reg)+ ~# z3 q2 h5 c8 D9 M0 P% G
  49.   {
    & c; c) P) D$ b" f! l8 }; N
  50.   case 1:
    ( M, g6 I1 Q2 N
  51.     command = W25QXX_READ_STATUS_REG1;  // 读状态寄存器1指令3 I  S3 E2 }. O8 X: H
  52.     break;8 P5 Z' G2 W8 X
  53. & u' s/ q7 ~2 i# U' b6 r
  54.   case 2:# ^& d: U2 U  l. w' ]+ B
  55.     command = W25QXX_READ_STATUS_REG2;  // 读状态寄存器2指令
    ) e' w9 `/ k* P
  56.     break;$ J  I. A8 q! v( H# f3 m  A) n

  57. 6 H5 G$ {3 g+ N, J' N1 l
  58.   case 3:) [3 e& S) B5 Z" [
  59.     command = W25QXX_READ_STATUS_REG3;  // 读状态寄存器3指令
    : e$ W% m- G! L
  60.     break;
    ; R- |' I  x5 U, d9 u  Y
  61. - s! M) J6 l) Y2 p; Q+ w0 ~1 V" g
  62.   default:2 |1 L9 Z8 y( s( l  e, ]
  63.     command = W25QXX_READ_STATUS_REG1;* L0 u) K. O# m
  64.     break;
    / W6 ~! o% y$ h: k1 D6 x* c
  65.   }
    - _& h- j9 t0 x* C  n* a
  66. 6 [# F( |; z' c& T$ z; G
  67.   if(w25qxx_qpi_mode)5 z/ u. Y& F) M: ~
  68.   {
    6 t- W6 ~; W8 o, f
  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个字节数据
    4 h. s5 _/ L8 h& s0 Y
  70.   }
    $ d9 M" I4 q+ i4 ?4 Z1 {, \
  71.   else
    4 b. X- @0 W  Y8 ^
  72.   {) m1 q! a( ]" T$ S
  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个字节数据
    1 n+ q+ L6 w7 S9 `/ {
  74.   }( n9 p, ~3 h' h9 S  v
  75. # P  z* V% P* ?6 K: X# ^
  76.   QSPIReceive(&value, 1);
    - f3 O& p: A+ Q, h+ A+ [3 ^8 B4 A

  77. 4 x$ [* U8 d+ U- e; q) F% l
  78.   return value;% _5 o2 s) v5 y! q
  79. }
    ; R3 |. ]4 C* ~; }9 y" Y9 m

  80. 1 f1 W) y3 e; ]& F3 a0 ]
  81. // 写状态寄存器
    , E( n  e! \9 k& T: Z2 S
  82. static void w25qxx_write_status(uint8_t reg, uint8_t status)6 y: O0 \* Y! ]: t9 b
  83. {
    $ m) Z; [6 Z7 {; e. |4 V
  84.   uint8_t command = 0;7 W2 T; s' V4 G2 i- F3 ^6 L

  85. 0 D- [" [& E# e
  86.   switch(reg)
    8 B6 ]6 p! D2 e7 f9 G1 C
  87.   {$ n% B+ r2 ]* Z1 d
  88.   case 1:
    % J; G0 h: N2 ~0 F' x9 F" t
  89.     command = W25QXX_WRITE_STATUS_REG1;  //写状态寄存器1指令
    1 B5 d8 V- R  R9 v" q" y
  90.     break;
    0 }( H; A( d) X" N
  91.   case 2:
    $ F  J0 x  v+ R; N1 I$ |$ |6 v
  92.     command = W25QXX_WRITE_STATUS_REG2;  //写状态寄存器2指令
    . R* [& t5 f7 k- S; Y' \" H9 C7 ?
  93.     break;
    , ?: y& k. f) ?
  94.   case 3:; d  e5 X6 N( }/ n
  95.     command = W25QXX_WRITE_STATUS_REG3;  //写状态寄存器3指令# ~1 T) V# U- q" @0 o) x$ z% X
  96.     break;# Y6 b# P5 p4 P- p2 Z
  97.   default:
    ( A/ p$ c. K! y& H' T. t
  98.     command = W25QXX_WRITE_STATUS_REG1;
    9 F5 ^2 m# g! i2 C0 v
  99.     break;/ B9 ]& d* D, U& I4 H' S' i1 R
  100.   }
    # A- L% u; D- [/ Q# k9 q$ ]1 a
  101.   if(w25qxx_qpi_mode)4 j4 O8 W9 b4 T* ?4 ?, x
  102.   {
    8 P' U6 g3 t3 c( r  j( ~. i# R
  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个字节数据
    ) G8 k, W, l  I, k: A
  104.   }6 }" ^/ y9 M, ~- d: d6 _8 k  n
  105.   else
    4 t8 @) M! c# m2 |* i7 L' u
  106.   {& |" l* ~  |9 j5 K4 f
  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 D# _/ Y) |+ [. y" R6 S7 P* p5 n
  108.   }9 P' s4 N3 s5 l' A$ K
  109.   QSPITransmit(&status, sizeof(status));
    ' l7 a) J: m$ x4 Q
  110. }% ]; f% }( F1 e& E0 B5 F

  111. / R" Q' m  d7 u" o; J' `5 v  z
  112. // 写使能  将S1寄存器的WEL置位# c$ {" e. {; g/ {. L4 F
  113. static void w25qxx_write_enable(void)
    / r: U7 K# n9 z0 Z; Z  V/ X5 G
  114. {
    4 }2 V1 q6 T/ `' [3 @2 A8 m" n
  115.   if(w25qxx_qpi_mode)
    . |* ~: R/ _, A" u. b* K& @+ y
  116.   {- S2 q2 E  E* Q. S( d
  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个字节数据
    ! u9 Z5 P2 w/ z% k% V: u* G) |
  118.   }$ Y( L* M0 e# w: [# a7 P# d
  119.   else& O6 n" u& ?% I+ ]$ H
  120.   {- y  N" C2 V$ ?. O: g. j( L/ 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个字节数据) ]5 G5 |8 p; G$ L; i
  122.   }- w0 i9 I* L, ]4 D( P$ {; z2 `
  123. }% c2 @' R0 ^; v( `2 @4 L) M$ q

  124. 9 {2 X7 E9 M, U8 ]/ M
  125. // 写失能  将WEL清零( v) p) |# G& p3 `, C! [& x  j% C1 c9 a
  126. void W25QXX_Write_Disable(void)
    1 z# w- b* R" ]) O- X6 {
  127. {
    % J  e" e/ l0 c1 b
  128.   if(w25qxx_qpi_mode)
    9 I. D& P6 L6 ~% F
  129.   {
    / D1 q6 n$ R# F+ E5 f2 }' S! T/ d! W
  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个字节数据, `3 J2 o2 T2 C5 a8 c' k
  131.   }
    # v; ^1 j0 B: ?7 i: u' ~
  132.   else
    / T& n4 W) Z( N# }( h
  133.   {  v! y3 P$ ^, ~3 `6 G6 u
  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个字节数据/ K/ P5 u& Y! ?0 y3 y
  135.   }1 n: T) l3 p; u% s4 D
  136. }& r9 s4 [( O$ H4 v/ e0 @' B
  137. * a, i/ K' \7 G
  138. // 等待空闲
    0 f2 ~  |- K( z( `3 r4 e
  139. void w25qxx_wait_busy(void)
    8 n) l0 _9 }* C" \( r- E" r
  140. {
    ( ^5 R" ]. F# a! ?4 R
  141.   while((w25qxx_read_status(1) & 0x01) == 0x01); // 等待BUSY位清空
    : u6 W2 I7 M6 B8 X4 y& h; ^" D5 ~& w
  142. }1 R1 \3 w- X( ?! @1 B+ {
  143. 3 ~6 o) C% }- m8 C# P" N$ {
  144. // W25QXX进入QSPI模式
    - x6 Z9 m. c. o+ u" \
  145. static void w25qxx_qspi_init(void)2 }% P& a6 W% w) {4 a" r  i9 b0 z
  146. {: h1 I/ v' q; ]4 U0 w0 k
  147.   uint8_t reg2;4 j" `! I3 g) i3 ?" b) f4 W
  148.   reg2 = w25qxx_read_status(2); // 先读出状态寄存器2的原始值
    4 i6 \" I% {7 d. ]5 Z
  149.   if((reg2 & 0X02) == 0)  // QE位未使能6 e) k' z4 j/ k
  150.   {
    ! u1 N6 c  X# C
  151.     w25qxx_write_enable(); // 写使能3 {5 b0 w' O1 X  m7 a# v
  152.     reg2 |= 1 << 1; // 使能QE位& b$ o% J6 r8 U& l
  153.     w25qxx_write_status(2, reg2); // 写状态寄存器2! g, `; y) C/ P
  154.   }1 ^# o5 |/ {( c+ ?$ R% }

  155. + y, l( p. h& }8 p- l( u) J3 p1 M2 f* D8 N
  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个字节数据
    4 o5 Y6 O7 J7 E& e/ g+ o9 s+ z

  157. / b0 r3 b! V; p
  158.   w25qxx_qpi_mode = 1; // 标记QSPI模式
    3 M- M, n8 G. o3 s; E
  159. }! a- x: X2 d% ]! Z

  160. % ]2 W( u. }, E9 w( x7 K/ I  d
  161. // 0XEF13,表示芯片型号为W25Q80! G$ Y2 i% V, _$ B  Y- r+ k
  162. // 0XEF14,表示芯片型号为W25Q166 m8 K+ d+ @! A0 g
  163. // 0XEF15,表示芯片型号为W25Q32
      _9 b. X# ]9 q% ^1 }) a+ N
  164. // 0XEF16,表示芯片型号为W25Q64
    $ m9 `8 ?3 S2 i$ L" E! x
  165. // 0XEF17,表示芯片型号为W25Q128
    0 f" G; U+ d3 B: R5 ~( f
  166. // 0XEF18,表示芯片型号为W25Q256* N7 m1 p8 O" o9 q2 ~4 R1 p7 x
  167. static void w25qxx_id_get(void)! {/ ^1 X# d" Z& ^/ `. ^: ?
  168. {  Y! Q* y; T. v4 q; ]; G2 y; h) V
  169.   uint8_t temp[2];
    7 M9 p$ o, a/ d( C) K* _  S2 p
  170.   uint16_t device_id;
    7 m$ G9 d! U% t7 }! l

  171. & o" s: Z+ V' s2 V5 r9 Z
  172.   if(w25qxx_qpi_mode)
    / {! v6 }4 w/ @# v5 {6 @% X* e) V
  173.   {
    1 k+ A+ R9 b5 T& H- D% c
  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个字节数据  A# C9 [. G& x3 \# X5 A8 F$ {
  175.   }0 o/ E8 i0 k% i, Z. P
  176.   else8 C% {  [7 A" D: U# J3 z
  177.   {. X  u# z* S8 x/ U9 M" [+ Y$ @
  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个字节数据
    ! Q$ c5 `" ^( N
  179.   }
    % j, m  }5 @% q2 U

  180. 0 w& C0 Y5 ^7 U
  181.   QSPIReceive(temp, 2);- v- i  \- _3 L5 k1 T

  182. 5 a# x2 k4 M1 a* j, w+ B
  183.   device_id = (temp[0] << 8) | temp[1];6 L6 k: N1 V' p0 l8 n8 Y

  184. 4 I; U4 l8 q. X# y; t. V
  185.   printf("QSPI Flash Device ID: %X\r\n", device_id);
    ! f5 @/ I9 n* N6 S) g9 @
  186. }% K9 ?  r8 q- t: d& c" [
  187. ; l. P% X. A9 Y3 e0 b( z5 a2 \
  188. void W25QXXInit(void)
    2 N! A5 O: ^  `! d  N
  189. {
    : e7 S/ _. Y3 H9 P
  190.   uint8_t temp;+ |/ m4 s" M2 V0 s& v( n

  191. 2 u# V( N8 }" T3 e& u' j. f. _& K
  192.   QSPIInit();; K5 D& k2 X- F9 m+ Y9 j
  193.   w25qxx_qspi_init(); // 使能QSPI模式) X7 s  D6 R. k, B8 `% l
  194.   w25qxx_id_get();    // 读取FLASH ID.. @' z5 g/ K- T, \& C6 x* j

  195. * k, ~  j9 ]9 ~2 Z% w$ O0 Q, ?! ~1 i$ o
  196.   temp = w25qxx_read_status(3); // 读取状态寄存器3,判断地址模式0 Q" u5 a. h4 B2 m
  197.   if((temp & 0X01) == 0) // 如果不是4字节地址模式,则进入4字节地址模式
    6 O. r& C8 `- {& f. @6 \
  198.   {
    + H- D+ q1 @3 b4 Y- A
  199.     w25qxx_write_enable(); // 写使能8 H9 {) }6 N! M  ^# S( J( k
  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个字节数据8 c" ^1 V+ D+ b; h
  201.   }# G3 q: d/ V9 M" a# ]" R' S6 H
  202.   w25qxx_write_enable(); // 写使能( k* c8 u& |$ Q
  203.   QSPISendCMD(W25QXX_SET_READ_PARAM, 0, 0, QSPI_INSTRUCTION_4_LINES, QSPI_ADDRESS_NONE, QSPI_ADDRESS_8_BITS, QSPI_DATA_4_LINES); // QPI,设置读参数指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据% p+ f" C" H" \# g% J4 m
  204.   temp = 3 << 4;      // 设置P4&P5=11,8个dummy clocks,104M
      ~4 u& g  Y' k
  205.   QSPITransmit(&temp, 1);
    9 F9 Y" n' M: r$ J
  206. }. e0 ~' r# `; p# |3 |8 C
  207. # q4 n$ H! W) D  F3 {/ V
  208. // 擦除一块4096字节 最少需要150ms
    * p+ H3 J0 K& \: U0 ]
  209. void W25QXXSectorErase(uint32_t addr)4 e! P1 }+ p1 T- y
  210. {, w8 P/ _: Y: k8 X
  211.   //addr /= 4096;" p+ G! |# F$ n" r9 O
  212.   addr *= 4096;6 ^; `1 l: T7 @# c
  213. ' F/ p6 s$ z+ G% @9 T3 \
  214.   w25qxx_write_enable();4 Q2 G: V$ x/ S: m
  215.   w25qxx_wait_busy();0 Q# ]. {; u6 g* j% Q4 V& b4 M
  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个字节数据( w9 M8 h1 Z( u2 @" C) j
  217.   w25qxx_wait_busy();
    ; c3 r! t' P8 A% z) C9 {3 O
  218. }
    9 c6 X. T  t8 J
  219. ; Q5 R: f& ]8 {

  220. 7 y) O$ q3 b9 x% h
  221. // 擦除整个芯片! N# m6 t( u  y: }) T8 X8 y
  222. void W25QXXChipErase(void)
      J: X  s; o5 t1 Q1 [2 E* J. Y$ d2 Z, a
  223. {! g5 \5 e) L# ]7 o, h
  224.   w25qxx_write_enable();          //SET WEL$ e* H6 z% A7 c* n! v' T" L
  225.   w25qxx_wait_busy();
    - u( \2 @7 K7 b% J& Q/ J: A
  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个字节数据3 ?4 k, G- _( J% u" Z0 @
  227.   w25qxx_wait_busy();           //等待芯片擦除结束
    2 a4 R& z. u* ?
  228. }
    ) u& V- z& d- O" K% T1 X

  229. % t# m5 X+ Y1 J
  230. // 写最多256字节& Z! N4 \# n7 S% @) Z; J
  231. void W25QXXWritePage(uint32_t addr, uint8_t *buffer, uint16_t length)
    - M: K0 Q/ [% n9 z( D# E4 Y2 \/ J# v; l
  232. {
    ( R5 v# @; y, E3 }. [& @
  233.   w25qxx_write_enable();          //写使能7 E7 q# q3 e5 U3 v' U( 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个数据
    * e( }9 w# m# O
  235.   QSPITransmit(buffer, length);' ~( s0 p$ P; |8 e
  236.   w25qxx_wait_busy();            //等待写入结束
    ; g: F" J3 k7 l+ v
  237. }  v+ Q6 X1 q. J8 W5 l4 L+ ~- O
  238. $ d) b( p% P; K0 j& v, D
  239. // 写最多65536字节 无擦除动作
    / ?! j9 S/ ]& @. n! v3 T
  240. void W25QXXWriteExt(uint32_t addr, uint8_t *buffer, uint16_t length)
    2 S2 o: L- w2 T& _% d
  241. {
    % T7 V; Q3 ?. E, ?! q- d
  242.   uint16_t pageremain = 256 - addr % 256; // 单页剩余的字节数
    $ V) R" K( p$ l6 A7 s+ m5 b, _! |

  243. 3 u' k; S& V7 u4 A% M
  244.   if(addr + length - 1 > (32 * 1024 * 1024))
    & \( A3 Y! T$ m( H9 u3 o& x& t
  245.   {
    ; E! h" U! ?' E4 ?) T- o1 l5 V
  246.     return;& \# @  ?: \, Y4 }
  247.   }
    8 l2 D) X8 N4 t$ x
  248. 8 T  |% B0 u* `/ H2 _
  249.   if(length <= pageremain), i9 z: Q) F4 j+ v& C& H
  250.   {
    3 e: q& l. B+ [' h- u5 O2 u
  251.     pageremain = length;  // 不大于256个字节
    & \+ P5 ~# Z/ r0 \7 Z
  252.   }6 W# J. B! D# b$ M
  253.   while(1)# z; j) X  r( T$ n3 _5 G
  254.   {; c# n" W8 G. b# c
  255.     // 分页写入  P: a7 e  W5 [
  256.     W25QXXWritePage(addr, buffer, pageremain);) M5 A3 t* r  G9 T5 j+ g" A
  257. 1 S7 i2 A0 B: e% P4 J$ Q5 J
  258.     if(length == pageremain)' E1 x/ a0 Z7 q% \
  259.     {0 O7 S- q, R  x
  260.       break;  //写入结束了
    9 i4 C( a6 |1 V+ d" J
  261.     }
    3 A7 Y. _5 p/ g' r* U
  262.     else1 E  _0 |: ]+ @+ ~5 `1 T
  263.     {* v8 x" Y+ R' [* x' i$ i
  264.       buffer += pageremain;
    1 W" S" J  O* B
  265.       addr += pageremain;+ h$ @1 A; I  n- R

  266. 0 V$ S; X9 g* c6 q
  267.       length -= pageremain; // 减去已经写入了的字节数
    ( o" ^  W4 P$ o" D# `! Y# M4 u
  268.       if(length > 256)) ]' G8 f/ G. H# ?" [- _1 v
  269.       {
    & H, D' [5 y- Z
  270.         pageremain = 256;  // 一次可以写入256个字节
    ) [' Y  q$ m, L9 N4 {, G' R9 R% q) X/ J
  271.       }3 j9 W8 [8 D$ A+ A: L# k# I" n
  272.       else
    : Q$ q2 P# F: i# r+ w  I
  273.       {2 [2 z7 q; r1 ^! J3 W. [6 S7 Y
  274.         pageremain = length;  // 不够256个字节了
    0 \6 H# w7 N( v3 m9 L' f# }- v; M
  275.       }
    # ?8 G+ }( i9 k  N
  276.     }
    " H" b5 M2 X: f" O& o1 h2 k
  277.   }9 T- h. u6 P: _. ], v( p6 V5 m
  278. }
    9 {5 G+ F1 r& C5 I9 A* N) N

  279. , d' j( E5 o& M& o, S* W
  280. // 写最多65536字节 带擦除动作
    % M6 }. B" r* {
  281. static uint8_t W25QXX_BUFFER[4096];# B7 g- ^: Q* g) e
  282. void W25QXXWrite(uint32_t addr, uint8_t* buffer, uint16_t length)2 `5 c" B8 N) c9 g( i
  283. {2 L. u) {- ]( E& M6 X. U% ]
  284.   uint32_t secpos;2 R3 b. K" A% _) l2 `
  285.   uint16_t secoff, secremain, i;* a* E0 z6 D5 T5 U# h
  286.   uint8_t * w25q_buf;
    " z4 m) o7 c9 g, _+ W8 w# d
  287. + ?# ?7 ?. T  u2 G5 {. i) _7 A' D
  288.   w25q_buf = W25QXX_BUFFER;
    & H6 S7 N- _6 \

  289.   Z2 R) w$ L* {3 l6 o
  290.   secpos = addr / 4096; // 扇区地址
    ; d6 d: S* Y2 X9 p/ ~( }9 j
  291.   secoff = addr % 4096; // 在扇区内的偏移3 r" W! _) G0 r* e1 B
  292.   secremain = 4096 - secoff; // 扇区剩余空间大小
    # X7 p2 b7 U& G5 n& U! ?1 ]
  293. 9 D. ?) r) b! l! g! h8 @+ _- u# G) ]
  294.   if(length <= secremain)
    ' o/ d0 {) V& e
  295.   {% o: {& i! a9 H7 T* j
  296.     secremain = length;  // 不大于4096个字节5 Y0 W; U- h+ f& R0 q3 X* C; T# ~2 R
  297.   }
    $ L% r2 W' ^5 U  L6 l
  298.   while(1)
    " o2 y$ d5 V$ @
  299.   {& {, y6 C3 ?9 f; F
  300.           WatchdogFeed();+ B) ?. u0 i- x! T5 Y6 E
  301.     W25QXXRead(secpos * 4096, w25q_buf, 4096); // 读出整个扇区的内容; o7 r8 J+ d, p: k0 d
  302.     for(i = 0; i < secremain; ++i); F1 @; g8 m' q2 o
  303.     {$ @4 T5 u6 t& J2 Q& y
  304.       if(w25q_buf[secoff + i] != 0XFF)
    . s. l! o  X% A6 m% E- I/ C
  305.       {  w. }" H# `+ g4 t
  306.         break;  // 需要擦除6 T2 }9 ]% ]5 Z7 C6 K1 h
  307.       }( m0 ]8 b( ?. T. D# Q0 S8 b
  308.     }0 r1 v& p3 p4 H, D6 c2 Q
  309.     if(i < secremain) // 需要擦除" w/ w4 ^, ^' G, k8 E5 a- N* p+ x) p
  310.     {
    1 O; M/ p/ L. N
  311.       W25QXXSectorErase(secpos); // 擦除这个扇区4 P' t" l- k+ x  k+ s; g
  312.       for(i = 0; i < secremain; ++i)
    6 n3 Z/ R  @: C3 ~, A" k, Y
  313.       {' I" ^2 k. U3 G$ [
  314.         w25q_buf[i + secoff] = buffer<i>;</i>
    * v: O5 a+ p. |( Q9 o: p9 [6 j
  315.       }; S' T! A4 g6 Z7 m$ l& A% l2 C7 E' u' U
  316.       W25QXXWriteExt(secpos * 4096, w25q_buf, 4096); // 写入整个扇区5 K; ]) s, x, p" Y3 e! E6 H

  317. / u& m3 r3 J5 @8 k+ D+ r
  318.     }
    0 d" a. G4 I- W. @" n9 g5 E) ]  ]
  319.     else
    - y2 X$ L* b1 R& f0 B
  320.     {
    3 m% S" N( }/ G+ I/ D
  321.       W25QXXWriteExt(addr, buffer, secremain);  // 写已经擦除了的,直接写入扇区剩余区间.
    - Q& H  ~) U: {/ a+ C: f& x% E# Y. {
  322.     }2 C1 Z6 z4 F& M7 A/ t  `) R
  323.     if(length == secremain)
    8 ?0 R6 [+ D6 K
  324.     {  q. U7 s( c' Y
  325.       break;' d" j4 x" g5 e' k. A6 b5 f
  326.     }) G. \. B! J) o) E6 H
  327.     else( ]* F% `  Q9 c) F/ B
  328.     {
    8 O+ c; d# M' Q$ x7 j
  329.       secpos++;, O. W2 s' K) [- w: i( g! ]% Q
  330.       secoff = 0;9 h1 N5 g$ M; j- Y4 w$ u

  331. ! y( G5 q$ B, H2 V2 i' u, P
  332.       buffer += secremain;
    9 a1 J- D+ V; a# g
  333.       addr += secremain;7 T- S( p- i+ I5 o
  334.       length -= secremain;& Q* x/ x, O4 T4 ^" N, p, t
  335.       if(length > 4096)) u! C8 |$ f8 h# ?
  336.       {
    ! r* |& }9 S) s$ {: C/ R# ?
  337.         secremain = 4096;& b3 v, z1 ?: W* b' ?/ i
  338.       }/ n+ P1 \6 F8 y% r" U2 T
  339.       else
    0 D) r& O1 w  ?# g/ i; k
  340.       {
    8 M+ }) Z# b# g! }4 ~+ L; b
  341.         secremain = length;% a5 O, w: ]: W$ x3 T+ {
  342.       }8 s( p, e# k) q4 h
  343.     }
    ( E7 y8 ~4 N4 }8 y0 r: t" y2 v
  344.   };5 {$ r. v" b- ^6 Q4 L; T
  345. }
    " @, M- a6 K) x7 c0 r# c+ _" N$ K0 Z

  346. * g3 _, V% Q& y1 H: {. \" R" H

  347. " _% [9 H( G1 t; Y0 B
  348. // 读取SPI FLASH,仅支持QPI模式  在指定地址开始读取指定长度的数据 65536
    5 @, ~4 n9 S; u- h8 J, N* N
  349. void W25QXXRead(uint32_t addr, uint8_t *buffer, uint16_t length)4 M5 j& T# N! e% I. p  [  V; P
  350. {! T! ?5 }6 n" [8 p$ s  o
  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, }. G: s* E3 L4 E6 q( z9 |6 M" O
  352.   QSPIReceive(buffer, length);& e4 }, o' s8 z4 D
  353. }
复制代码
' m. ?5 S* S: y& X6 L
也可以使用SPI操作W25QXX。. X' O2 A. K* Y  v
( G/ v, w2 d6 g, X! ^: \
1 ]/ G# F0 K  Q9 c( I
+ \! X: j2 E: a0 k) y* A
赞 收藏 评论0 发布时间:2021-12-11 12:00

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版