设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 制作出给stm32wb55烧外部nor flash(w25q32jv)的stldr档
返回列表 发新帖
查看: 928|回复: 0
收起左侧

制作出给stm32wb55烧外部nor flash(w25q32jv)的stldr档

[复制链接]
ID:1160110 发表于 2025-9-9 22:02 | 显示全部楼层 |阅读模式
使用 P-NUCLEO-WB55
主要 的qspi驱动代码如下，因是使用ok焊接，所以在读和mapping的时候4线不成功，改成用1线式
pin脚使用如下:
    /**QUADSPI GPIO Configuration
    PB8     ------> QUADSPI_BK1_IO1
    PB9     ------> QUADSPI_BK1_IO0
    PA6     ------> QUADSPI_BK1_IO3
    PA7     ------> QUADSPI_BK1_IO2
    PB10     ------> QUADSPI_CLK
    PB11     ------> QUADSPI_BK1_NCS

整包source code跑ide
附件是使用QSPI_MemoryMapped 的sample code改写 builde出 elf档后，改附档名为stldr，放入stm32Cube programmer的ExternalLoader ，就可以识别后做烧录
qspi_borad.jpg qspi_programmer_write.jpg qspi_programmer_read.jpg stldr.png

  1. #include "main.h"
  2. #include "stm32wbxx_hal.h"
  3. #include "stm32wbxx_hal_qspi.h"
  4. /* USER CODE BEGIN 0 */
  5. static uint8_t QSPI_WriteEnable(void);
  6. static uint8_t QSPI_AutoPollingMemReady(uint32_t Timeout);
  7. static uint8_t QSPI_Configuration(void);
  8. static uint8_t QSPI_ResetChip(void);
  9. static HAL_StatusTypeDef QSPI_EnableQuadIfNeeded(void);
  10. #define HAL_QPSI_TIMEOUT_DEFAULT_VALUE HAL_QSPI_TIMEOUT_DEFAULT_VALUE
  11. #define HAL_QSPI_TIMEOUT_DEFAULT_VALUE 5000U
  12. #if defined(__ICCARM__)
  13. /* New definition from EWARM V9, compatible with EWARM8 */
  14. int iar_fputc(int ch);
  15. #define PUTCHAR_PROTOTYPE int iar_fputc(int ch)
  16. #elif defined (__CC_ARM) || defined(__ARMCC_VERSION)
  17. /* ARM Compiler 5/6 */
  18. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
  19. #elif defined(__GNUC__)
  20. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
  21. #endif /* __ICCARM__ */
  22. /* USER CODE END 0 */
  23. QSPI_HandleTypeDef hqspi;
  24. UART_HandleTypeDef huart1;

  26. /* USER CODE BEGIN 1 */
  27. void MX_QUADSPI_Init(void)
  28. {

  30.   /* USER CODE BEGIN QUADSPI_Init 0 */

  32.   /* USER CODE END QUADSPI_Init 0 */

  34.   /* USER CODE BEGIN QUADSPI_Init 1 */

  36.   /* USER CODE END QUADSPI_Init 1 */
  37.   /* QUADSPI parameter configuration*/
  38.   hqspi.Instance = QUADSPI;
  39.   hqspi.Init.ClockPrescaler = 2;
  40.   //hqspi.Init.ClockPrescaler = 2;
  41.   //hqspi.Init.FifoThreshold = 4;
  42.   hqspi.Init.FifoThreshold = 4;
  43.   hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
  44.   hqspi.Init.FlashSize = 21;
  45.   //hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_4_CYCLE;
  46.   hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_1_CYCLE;
  47.   hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
  48.   if (HAL_QSPI_Init(&hqspi) != HAL_OK)
  49.   {
  50.     Error_Handler();
  51.   }
  52.   /* USER CODE BEGIN QUADSPI_Init 2 */

  54.   /* USER CODE END QUADSPI_Init 2 */

  56. }
  57. static void W25Qx_QSPI_Delay(uint32_t ms)
  58. {
  59.         HAL_Delay(ms);
  60. }
  61. /* QUADSPI init function */
  62. uint8_t CSP_QUADSPI_Init(void) {
  63.         //prepare QSPI peripheral for ST-Link Utility operations
  64.         if (HAL_QSPI_DeInit(&hqspi) != HAL_OK) {
  65.                 return HAL_ERROR;
  66.         }

  68.         MX_QUADSPI_Init();

  70.         if (QSPI_ResetChip() != HAL_OK) {
  71.                 return HAL_ERROR;
  72.         }

  74.         HAL_Delay(1);

  76.         if (QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) {
  77.                 return HAL_ERROR;
  78.         }

  80.         if (QSPI_WriteEnable() != HAL_OK) {

  82.                 return HAL_ERROR;
  83.         }
  84. #if 0
  85.         QSPI_CommandTypeDef s_command;
  86.         uint8_t value = W25Q256JV_FSR_QE;

  88.         s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  89.         s_command.Instruction = WRITE_STATUS_REG2_CMD;
  90.         s_command.AddressMode = QSPI_ADDRESS_NONE;
  91.         s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  92.         s_command.DataMode = QSPI_DATA_1_LINE;
  93.         s_command.DummyCycles = 0;
  94.         s_command.NbData = 1;
  95.         s_command.DdrMode = QSPI_DDR_MODE_DISABLE;
  96.         //s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  97.         s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;


  100.         if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  101.         {
  102.                 return HAL_ERROR;
  103.         }
  104.                         /* 传输数据 */
  105.         if (HAL_QSPI_Transmit(&hqspi, &value, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  106.         {
  107.                 return HAL_ERROR;
  108.         }
  109. #endif

  111. #if 0
  112.           s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;                // 指令QSPI单线传输
  113.           s_command.Instruction       = ENTER_QPI_MODE_CMD;                                        // 指令，0x38使能QPI模式
  114.           s_command.AddressMode       = QSPI_ADDRESS_NONE;                                // 地址跳过
  115.           s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;                // 交替字节模式跳过
  116.           s_command.DummyCycles       = 0;                                                                // 空指令周期数
  117.           s_command.DataMode          = QSPI_DATA_NONE;                                        // 数据模式跳过
  118.           s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;                        // 禁止DDR模式
  119.           //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;                // 禁止DDR模式数据延时
  120.           s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;                  // 在每个事务中发送指令

  122.           /* Send the command */
  123.           if (HAL_QSPI_Command(&hqspi, &s_command, 1000) != HAL_OK)
  124.                 {
  125.                         return HAL_ERROR;
  126.                 }

  128. #endif
  129. #if 0
  130.         if (QSPI_AutoPollingMemReady(W25Q128JV_SUBSECTOR_ERASE_MAX_TIME) != QSPI_OK)
  131.         {
  132.                                 return HAL_ERROR;
  133.         }
  134. #endif
  135.         printf("CSP_QUADSPI_Init Done1\n");
  136. #if 1
  137.         if (QSPI_Configuration() != HAL_OK) {
  138.                 return HAL_ERROR;
  139.         }
  140. #endif
  141.         QSPI_EnableQuadIfNeeded();
  142.         HAL_Delay(100);
  143.         printf("CSP_QUADSPI_Init Done2\n");
  144.         return HAL_OK;
  145. }


  148. uint8_t CSP_QSPI_Erase_Chip(void) {
  149.         QSPI_CommandTypeDef sCommand;

  151.         if (QSPI_WriteEnable() != HAL_OK) {
  152.                 return HAL_ERROR;
  153.         }

  155.         /* Erasing Sequence --------------------------------- */
  156.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  157.         sCommand.Instruction = CHIP_ERASE_CMD;
  158.         sCommand.AddressMode = QSPI_ADDRESS_NONE;
  159.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  160.         sCommand.DataMode = QSPI_DATA_NONE;
  161.         sCommand.DummyCycles = 0;
  162.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  163.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  164.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;

  166.         if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_MAX_DELAY) != HAL_OK) {
  167.                 return HAL_ERROR;
  168.         }

  170.         if (QSPI_AutoPollingMemReady(HAL_MAX_DELAY) != HAL_OK) {
  171.                 return HAL_ERROR;
  172.         }

  174.         return HAL_OK;
  175. }

  177. uint8_t QSPI_AutoPollingMemReady(uint32_t Timeout) {

  179.         QSPI_CommandTypeDef     s_command;
  180.         QSPI_AutoPollingTypeDef s_config;
  181.         /* 配置自动轮询模式等待存储器准备就绪 */
  182.         s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
  183.         s_command.Instruction       = READ_STATUS_REG1_CMD;
  184.         s_command.AddressMode       = QSPI_ADDRESS_NONE;
  185.         s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  186.         s_command.DataMode          = QSPI_DATA_1_LINE;
  187.         s_command.DummyCycles       = 0;
  188.         s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
  189.         //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
  190.         s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;

  192.         s_config.Match           = 0x00;
  193.         s_config.Mask            = W25Q256JV_FSR_BUSY;
  194.         s_config.MatchMode       = QSPI_MATCH_MODE_AND;
  195.         s_config.StatusBytesSize = 1;
  196.         s_config.Interval        = 0x10;
  197.         s_config.AutomaticStop   = QSPI_AUTOMATIC_STOP_ENABLE;

  199.         if (HAL_QSPI_AutoPolling(&hqspi, &s_command, &s_config, HAL_MAX_DELAY) != HAL_OK)
  200.         {
  201.                 return HAL_ERROR;
  202.         }

  204.         return HAL_OK;
  205. }

  207. static uint8_t QSPI_WriteEnable(void) {
  208.         QSPI_CommandTypeDef     s_command;
  209.         QSPI_AutoPollingTypeDef s_config;
  210.         /* 启用写操作 */
  211.         s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
  212.         s_command.Instruction       = WRITE_ENABLE_CMD;
  213.         s_command.AddressMode       = QSPI_ADDRESS_NONE;
  214.         s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  215.         s_command.DataMode          = QSPI_DATA_NONE;
  216.         s_command.DummyCycles       = 0;
  217.         s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
  218.         //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
  219.         s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
  220.         if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  221.         {
  222.                 return HAL_ERROR;
  223.         }

  225.         /* 配置自动轮询模式等待写启用 */
  226.         s_config.Match           = W25Q256JV_FSR_WREN;
  227.         s_config.Mask            = W25Q256JV_FSR_WREN;
  228.         s_config.MatchMode       = QSPI_MATCH_MODE_AND;
  229.         s_config.StatusBytesSize = 1;
  230.         s_config.Interval        = 0x10;
  231.         s_config.AutomaticStop   = QSPI_AUTOMATIC_STOP_ENABLE;

  233.         s_command.Instruction    = READ_STATUS_REG1_CMD;
  234.         s_command.DataMode       = QSPI_DATA_1_LINE;
  235.         s_command.NbData         = 1;

  237.         if (HAL_QSPI_AutoPolling(&hqspi, &s_command, &s_config, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  238.         {
  239.                 return HAL_ERROR;
  240.         }

  242.         return HAL_OK;
  243. }
  244. /*Enable quad mode and set dummy cycles count*/
  245. static HAL_StatusTypeDef QSPI_EnableQuadIfNeeded(void)
  246. {
  247.     HAL_StatusTypeDef ret;
  248.     QSPI_CommandTypeDef sCommand = {0};
  249.     uint8_t sr1 = 0, sr2 = 0;

  251.     /* 1) 讀 SR1 */
  252.     sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  253.     sCommand.Instruction     = READ_STATUS_REG_CMD;
  254.     sCommand.AddressMode     = QSPI_ADDRESS_NONE;
  255.     sCommand.DataMode        = QSPI_DATA_1_LINE;
  256.     sCommand.NbData          = 1;
  257.     sCommand.SIOOMode        = QSPI_SIOO_INST_EVERY_CMD;
  258.     if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;
  259.     if (HAL_QSPI_Receive(&hqspi, &sr1, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;

  261.     /* 2) 讀 SR2 */
  262.     sCommand.Instruction = READ_STATUS_REG2_CMD;
  263.     if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;
  264.     if (HAL_QSPI_Receive(&hqspi, &sr2, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;

  266.     /* 若 QE 已經為 1，直接回傳 OK */
  267.     if (sr2 & QE_BIT) return HAL_OK;

  269.     /* 3) WREN */
  270.     ret = QSPI_WriteEnable();
  271.     if (ret != HAL_OK) return ret;

  273.     /* 4) 寫 SR1 + SR2 (把 QE bit 設為 1) */
  274.     uint8_t sr_buf[2];
  275.     sr_buf[0] = sr1;
  276.     sr_buf[1] = sr2 | QE_BIT;

  278.     sCommand.Instruction = WRITE_STATUS_REG1_CMD; /* 0x01: write SR1 + SR2 */
  279.     sCommand.DataMode    = QSPI_DATA_1_LINE;
  280.     sCommand.NbData      = 2;
  281.     sCommand.AddressMode = QSPI_ADDRESS_NONE;
  282.     if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;
  283.     if (HAL_QSPI_Transmit(&hqspi, sr_buf, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;

  285.     /* 5) poll WIP until finished */
  286.     if (QSPI_AutoPollingMemReady(HAL_MAX_DELAY) != HAL_OK) return HAL_ERROR;

  288.     /* 6) read back SR2 to ensure QE is set */
  289.     sCommand.Instruction = READ_STATUS_REG2_CMD;
  290.     sCommand.DataMode    = QSPI_DATA_1_LINE;
  291.     sCommand.NbData      = 1;
  292.     if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;
  293.     if (HAL_QSPI_Receive(&hqspi, &sr2, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) return HAL_ERROR;

  295.     if (sr2 & QE_BIT) return HAL_OK;
  296.     return HAL_ERROR;
  297. }

  299. uint8_t QSPI_Configuration(void) {
  300.         QSPI_CommandTypeDef sCommand = { 0 };
  301.         uint8_t reg;
  302.         HAL_StatusTypeDef ret;

  304.         /* Read Volatile Configuration register 2 --------------------------- */
  305.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  306.         sCommand.Instruction = READ_STATUS_REG2_CMD;
  307.         sCommand.AddressMode = QSPI_ADDRESS_NONE;
  308.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  309.         sCommand.DataMode = QSPI_DATA_1_LINE;
  310.         sCommand.DummyCycles = 0;
  311.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  312.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  313.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  314.         sCommand.NbData = 1;

  316.         if ((ret = HAL_QSPI_Command(&hqspi, &sCommand,
  317.                         HAL_QPSI_TIMEOUT_DEFAULT_VALUE)) != HAL_OK) {
  318.                 return ret;
  319.         }

  321.         if ((ret = HAL_QSPI_Receive(&hqspi, ®, HAL_QPSI_TIMEOUT_DEFAULT_VALUE))
  322.                         != HAL_OK) {
  323.                 return ret;
  324.         }

  326.         /* Enable Volatile Write operations ---------------------------------------- */
  327.         sCommand.DataMode = QSPI_DATA_NONE;
  328.         sCommand.Instruction = VOLATILE_SR_WRITE_ENABLE;

  330.         if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  331.                         != HAL_OK) {
  332.                 return ret;
  333.         }

  335.         /* Write Volatile Configuration register 2 (QE = 1) -- */
  336.         sCommand.DataMode = QSPI_DATA_1_LINE;
  337.         sCommand.Instruction = WRITE_STATUS_REG2_CMD;
  338.         reg |= 2; // QE bit

  340.         if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  341.                         != HAL_OK) {
  342.                 return ret;
  343.         }

  345.         if (HAL_QSPI_Transmit(&hqspi, ®, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  346.                         != HAL_OK) {
  347.                 return ret;
  348.         }

  350.         /* Read Volatile Configuration register 3 --------------------------- */
  351.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  352.         sCommand.Instruction = READ_STATUS_REG3_CMD;
  353.         sCommand.AddressMode = QSPI_ADDRESS_NONE;
  354.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  355.         sCommand.DataMode = QSPI_DATA_1_LINE;
  356.         sCommand.DummyCycles = 0;
  357.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  358.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  359.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  360.         sCommand.NbData = 1;

  362.         if ((ret = HAL_QSPI_Command(&hqspi, &sCommand,
  363.                         HAL_QPSI_TIMEOUT_DEFAULT_VALUE)) != HAL_OK) {
  364.                 return ret;
  365.         }

  367.         if ((ret = HAL_QSPI_Receive(&hqspi, ®, HAL_QPSI_TIMEOUT_DEFAULT_VALUE))
  368.                         != HAL_OK) {
  369.                 return ret;
  370.         }

  372.         /* Write Volatile Configuration register 2 (DRV1:2 = 00) -- */
  373.         sCommand.Instruction = WRITE_STATUS_REG3_CMD;
  374.         reg &= 0x9f; // DRV1:2 bit

  376.         if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  377.                         != HAL_OK) {
  378.                 return ret;
  379.         }

  381.         if (HAL_QSPI_Transmit(&hqspi, ®, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  382.                         != HAL_OK) {
  383.                 return ret;
  384.         }

  386.         return HAL_OK;
  387. #if 0
  388.         QSPI_CommandTypeDef sCommand;
  389.           uint8_t reg;


  392.         /*enter 4 byte address*/
  393.                 sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  394.                 sCommand.Instruction = ENTER_4_BYTE_ADD_CMD;
  395.                 sCommand.AddressMode = QSPI_ADDRESS_NONE;
  396.                 sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  397.                 sCommand.DataMode = QSPI_DATA_NONE;
  398.                 sCommand.DummyCycles = 0;
  399.                 sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  400.                 //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  401.                 sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  402.                 sCommand.NbData = 0;

  404.                 if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  405.                                 != HAL_OK) {
  406.                         return HAL_ERROR;
  407.                 }




  412.         /*read configuration register*/
  413.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  414.         sCommand.Instruction = READ_CONFIGURATION_REG_CMD;
  415.         sCommand.AddressMode = QSPI_ADDRESS_NONE;
  416.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  417.         sCommand.DataMode = QSPI_DATA_1_LINE;
  418.         sCommand.DummyCycles = 0;
  419.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  420.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  421.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  422.         sCommand.NbData = 1;

  424.         if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  425.                         != HAL_OK) {
  426.                 return HAL_ERROR;
  427.         }


  430.         if (HAL_QSPI_Receive(&hqspi, ®,
  431.         HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) {
  432.                 return HAL_ERROR;
  433.         }



  437.         if (QSPI_WriteEnable() != HAL_OK) {

  439.                         return HAL_ERROR;
  440.                 }


  443.         /*set dummy cycles*/
  444.         MODIFY_REG(reg, 0xF0, (DUMMY_CLOCK_CYCLES_READ_QUAD << POSITION_VAL(0xF0)));

  446.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  447.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  448.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  449.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  450.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  451.         sCommand.Instruction = WRITE_VOL_CFG_REG_CMD;
  452.         sCommand.AddressMode = QSPI_ADDRESS_NONE;
  453.         sCommand.DataMode = QSPI_DATA_1_LINE;
  454.         sCommand.DummyCycles = 0;
  455.         sCommand.NbData = 1;

  457.         if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  458.                         != HAL_OK) {
  459.                 return HAL_ERROR;
  460.         }

  462.         if (HAL_QSPI_Transmit(&hqspi, ®,
  463.         HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) {
  464.                 Error_Handler();
  465.                 return HAL_ERROR;
  466.         }
  467.         return HAL_OK;
  468. #endif
  469. }


  472. uint8_t CSP_QSPI_EraseSector(uint32_t EraseStartAddress, uint32_t EraseEndAddress) {

  474.         QSPI_CommandTypeDef sCommand;

  476.         EraseStartAddress = EraseStartAddress
  477.                         - EraseStartAddress % MEMORY_SECTOR_SIZE;

  479.         /* Erasing Sequence -------------------------------------------------- */
  480.         sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
  481.         sCommand.Instruction       = 0xD8;
  482.         sCommand.AddressMode       = QSPI_ADDRESS_1_LINE;
  483.         sCommand.AddressSize       = QSPI_ADDRESS_24_BITS;
  484.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  485.         sCommand.DataMode          = QSPI_DATA_NONE;
  486.         sCommand.DummyCycles       = 0;
  487.         sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;
  488.     //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
  489.         sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;

  491.         while (EraseEndAddress >= EraseStartAddress) {
  492.                 sCommand.Address = (EraseStartAddress & 0x0FFFFFFF);

  494.                 if (QSPI_WriteEnable() != HAL_OK) {
  495.                         return HAL_ERROR;
  496.                 }

  498.                 if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  499.                                 != HAL_OK) {
  500.                         return HAL_ERROR;
  501.                 }
  502.                 EraseStartAddress += MEMORY_SECTOR_SIZE;

  504.                 if (QSPI_AutoPollingMemReady(W25Q128JV_SECTOR_ERASE_MAX_TIME) != HAL_OK) {
  505.                         return HAL_ERROR;
  506.                 }
  507.         }

  509.         return HAL_OK;
  510. }

  512. uint8_t CSP_QSPI_WriteMemory(uint8_t* buffer, uint32_t address,uint32_t buffer_size) {

  514.         QSPI_CommandTypeDef sCommand;
  515.         uint32_t end_addr, current_size, current_addr;

  517.         /* Calculation of the size between the write address and the end of the page */
  518.         current_addr = 0;

  520.         //
  521.         while (current_addr <= address) {
  522.                 current_addr += MEMORY_PAGE_SIZE;
  523.         }
  524.         current_size = current_addr - address;

  526.         /* Check if the size of the data is less than the remaining place in the page */
  527.         if (current_size > buffer_size) {
  528.                 current_size = buffer_size;
  529.         }

  531.         /* Initialize the adress variables */
  532.         current_addr = address;
  533.         end_addr = address + buffer_size;

  535. #if 1
  536. #if 1
  537.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  538.         sCommand.Instruction = QUAD_IN_FAST_PROG_CMD;
  539.         sCommand.AddressMode = QSPI_ADDRESS_1_LINE;
  540.         sCommand.AddressSize = QSPI_ADDRESS_24_BITS;
  541.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  542.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  543.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  544.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  545.         sCommand.DataMode = QSPI_DATA_4_LINES;
  546.         sCommand.NbData = buffer_size;
  547.         sCommand.Address = address;
  548.         sCommand.DummyCycles = 0;
  549. #else
  550.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  551.         sCommand.Instruction = QUAD_IN_FAST_PROG_CMD;
  552.         sCommand.AddressMode = QSPI_ADDRESS_4_LINES;
  553.         sCommand.AddressSize = QSPI_ADDRESS_24_BITS;
  554.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  555.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  556.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  557.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  558.         sCommand.DataMode = QSPI_DATA_4_LINES;
  559.         sCommand.NbData = buffer_size;
  560.         sCommand.Address = address;
  561.         sCommand.DummyCycles = 0;
  562. #endif
  563. #else
  564.         /* 初始化程序命令 */
  565.         sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
  566.         sCommand.Instruction       = PAGE_PROG;
  567.         sCommand.AddressMode       = QSPI_ADDRESS_1_LINE;
  568.         sCommand.AddressSize       = QSPI_ADDRESS_24_BITS;
  569.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  570.         sCommand.DataMode          = QSPI_DATA_1_LINE;
  571.         sCommand.DummyCycles       = 0;
  572.         sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;
  573.         //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
  574.         sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
  575. #endif
  576.         /* Perform the write page by page */
  577.         do {
  578.                 sCommand.Address = current_addr;
  579.                 sCommand.NbData = current_size;

  581.                 if (current_size == 0) {
  582.                         return HAL_OK;
  583.                 }

  585.                 /* Enable write operations */
  586.                 if (QSPI_WriteEnable() != HAL_OK) {
  587.                         return HAL_ERROR;
  588.                 }

  590.                 /* Configure the command */
  591.                 if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  592.                                 != HAL_OK) {

  594.                         return HAL_ERROR;
  595.                 }

  597.                 /* Transmission of the data */
  598.                 if (HAL_QSPI_Transmit(&hqspi, buffer, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  599.                                 != HAL_OK) {

  601.                         return HAL_ERROR;
  602.                 }

  604.                 /* Configure automatic polling mode to wait for end of program */
  605.                 if (QSPI_AutoPollingMemReady(HAL_MAX_DELAY) != HAL_OK) {
  606.                         return HAL_ERROR;
  607.                 }

  609.                 /* Update the address and size variables for next page programming */
  610.                 current_addr += current_size;
  611.                 buffer += current_size;
  612.                 current_size =
  613.                                 ((current_addr + MEMORY_PAGE_SIZE) > end_addr) ?
  614.                                                 (end_addr - current_addr) : MEMORY_PAGE_SIZE;
  615.         } while (current_addr <= end_addr);

  617.         return HAL_OK;

  619. }


  622. uint8_t CSP_QSPI_EnableMemoryMappedMode(void) {

  624.         QSPI_CommandTypeDef sCommand;
  625.         QSPI_MemoryMappedTypeDef sMemMappedCfg;

  627.         /* Enable Memory-Mapped mode-------------------------------------------------- */
  628.         sCommand.InstructionMode    = QSPI_INSTRUCTION_1_LINE;
  629.         sCommand.Instruction        = 0x0B;                      // Fast Read
  630.         sCommand.AddressMode        = QSPI_ADDRESS_1_LINE;
  631.         sCommand.AddressSize        = QSPI_ADDRESS_24_BITS;
  632.         sCommand.AlternateByteMode  = QSPI_ALTERNATE_BYTES_NONE; // 單線不需要 Mode/Alt byte
  633.         sCommand.DataMode           = QSPI_DATA_1_LINE;
  634.         sCommand.DummyCycles        = 8;                         // 0x0B 規格書要求 8 dummy
  635.         sCommand.DdrMode            = QSPI_DDR_MODE_DISABLE;
  636.         sCommand.SIOOMode           = QSPI_SIOO_INST_EVERY_CMD;
  637.         sCommand.Address            = 0;
  638.         sCommand.NbData             = 0;                         // memory-mapped 忽略

  640.         sMemMappedCfg.TimeOutActivation = QSPI_TIMEOUT_COUNTER_DISABLE;
  641.         sMemMappedCfg.TimeOutPeriod     = 0;
  642. #if 0
  643. #if 1
  644.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  645.         sCommand.AddressSize = QSPI_ADDRESS_24_BITS;
  646.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_4_LINES;
  647.         //sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  648.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  649.         sCommand.AlternateBytes = 0xFF;
  650.         sCommand.AlternateBytesSize = 1;
  651.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  652.         sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  653.         sCommand.AddressMode = QSPI_ADDRESS_4_LINES;
  654.         sCommand.DataMode = QSPI_DATA_4_LINES;
  655.         sCommand.NbData = 0;
  656.         sCommand.Address = 0;
  657.         sCommand.Instruction = QUAD_IN_OUT_FAST_READ_CMD;
  658.         sCommand.DummyCycles = 4;
  659.         sMemMappedCfg.TimeOutPeriod  = 0;
  660.         sMemMappedCfg.TimeOutActivation = QSPI_TIMEOUT_COUNTER_DISABLE;
  661. #else
  662.         sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  663.         sCommand.AddressSize = QSPI_ADDRESS_24_BITS;
  664.         sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_4_LINES;
  665.         sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
  666.         sCommand.AlternateBytes = 0xFF;
  667.         sCommand.AlternateBytesSize = 1;
  668.         //sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  669.         sCommand.SIOOMode = QSPI_SIOO_INST_ONLY_FIRST_CMD;
  670.         sCommand.AddressMode = QSPI_ADDRESS_4_LINES;
  671.         sCommand.DataMode = QSPI_DATA_4_LINES;
  672.         sCommand.NbData = 0;
  673.         sCommand.Address = 0;
  674.         sCommand.Instruction = QUAD_IN_OUT_FAST_READ_CMD;
  675.         sCommand.DummyCycles = 4;
  676.         sMemMappedCfg.TimeOutPeriod  = 0;
  677.         sMemMappedCfg.TimeOutActivation = QSPI_TIMEOUT_COUNTER_DISABLE;
  678. #endif
  679. #endif
  680.         if (HAL_QSPI_MemoryMapped(&hqspi, &sCommand, &sMemMappedCfg) != HAL_OK) {
  681.                 return HAL_ERROR;
  682.         }
  683.         HAL_Delay(100);
  684.         return HAL_OK;
  685. }

  687. uint8_t QSPI_ResetChip() {
  688.         QSPI_CommandTypeDef s_command;
  689.         uint32_t temp = 0;
  690.         /* 初始化复位使能命令 */
  691.         s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
  692.         s_command.Instruction       = RESET_ENABLE_CMD;
  693.         s_command.AddressMode       = QSPI_ADDRESS_NONE;
  694.         s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  695.         s_command.DataMode          = QSPI_DATA_NONE;
  696.         s_command.DummyCycles       = 0;
  697.         s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
  698.         //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
  699.         s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;

  701.         /* 发送命令 */
  702.         if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  703.         {
  704.                 return HAL_ERROR;
  705.         }

  707.         /* 发送复位存储器命令 */
  708.         s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  709.         s_command.Instruction = RESET_MEMORY_CMD;
  710.         s_command.AddressMode = QSPI_ADDRESS_NONE;
  711.         s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  712.         s_command.DataMode = QSPI_DATA_NONE;
  713.         s_command.DummyCycles = 0;
  714.         s_command.DdrMode = QSPI_DDR_MODE_DISABLE;
  715.         //s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  716.         s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
  717.         if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  718.         {
  719.                 return HAL_ERROR;
  720.         }

  722.         for (temp = 0; temp < 500000; temp++) {
  723.                 __NOP();
  724.         }
  725. #if 0
  726.         s_command.InstructionMode = QSPI_INSTRUCTION_4_LINES;
  727.         s_command.Instruction = RESET_ENABLE_CMD;

  729.         /* 发送命令 */
  730.         if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  731.         {
  732.                 return HAL_ERROR;
  733.         }
  734.         W25Qx_QSPI_Delay(1);
  735.         /* 配置自动轮询模式等待存储器就绪 */
  736.         if (QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != QSPI_OK)
  737.         {
  738.                 return HAL_ERROR;
  739.         }
  740. #endif
  741.         return HAL_OK;
  742. }
  743. uint8_t CSP_QSPI_Read(uint8_t *pData, uint32_t ReadAddr, uint32_t Size) {
  744.         QSPI_CommandTypeDef s_command;
  745.           if(Size == 0)
  746.           {
  747.             printf("BSP_QSPI_Read Size = 0");
  748.             return HAL_ERROR;
  749.           }
  750. #if 1
  751.                 /* 初始化读命令 */
  752.                 s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
  753.                 s_command.Instruction       = 0x03;
  754.                 s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
  755.                 s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
  756.                 s_command.Address           = ReadAddr;
  757.                 s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  758.                 s_command.DataMode          = QSPI_DATA_1_LINE;
  759.                 s_command.DummyCycles       = 0;
  760.                 s_command.NbData            = Size;
  761.                 s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
  762.                 //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
  763.                 s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;

  765.                 /* 配置命令 */
  766.                 if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  767.                 {
  768.                         return HAL_ERROR;
  769.                 }

  771.                 /* 接收数据 */
  772.                 if (HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  773.                 {
  774.                         return HAL_ERROR;
  775.                 }
  776. #else
  777.         /* Initialize the read command */
  778.         s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;
  779.         s_command.Instruction = QUAD_IN_OUT_FAST_READ_CMD;
  780.         s_command.AddressMode = QSPI_ADDRESS_4_LINES;
  781.         s_command.AddressSize = QSPI_ADDRESS_24_BITS;
  782.         s_command.Address = ReadAddr;
  783.         s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  784.         s_command.DataMode = QSPI_DATA_4_LINES;
  785.         s_command.DummyCycles = 6U;
  786.         s_command.NbData = Size;
  787.         s_command.DdrMode = QSPI_DDR_MODE_DISABLE;
  788.         //s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
  789.         s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;

  791.         /* Configure the command */
  792.         if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  793.                         != HAL_OK) {
  794.                 return HAL_ERROR;
  795.         }

  797.         /* Set S# timing for Read command */
  798.         MODIFY_REG(hqspi.Instance->DCR, QUADSPI_DCR_CSHT,
  799.                         QSPI_CS_HIGH_TIME_5_CYCLE);

  801.         /* Reception of the data */
  802.         if (HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)
  803.                         != HAL_OK) {
  804.                 return HAL_ERROR;
  805.         }

  807.         /* Restore S# timing for nonRead commands */
  808.         MODIFY_REG(hqspi.Instance->DCR, QUADSPI_DCR_CSHT,
  809.                         QSPI_CS_HIGH_TIME_6_CYCLE);
  810. #endif
  811.         return HAL_OK;
  812. }
  813. uint32_t QSPI_FLASH_ReadDeviceID(void)
  814. {
  815.         QSPI_CommandTypeDef s_command;
  816.         uint32_t Temp = 0;
  817.         uint8_t pData[3];
  818.         /*##-2-读取设备ID测试    ###########################################*/
  819.         /* 读取制造/设备 ID */
  820.         s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
  821.         s_command.Instruction       = 0x90;
  822.         s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
  823.         s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
  824.         s_command.Address           = 0x000000;
  825.         s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
  826.         s_command.DataMode          = QSPI_DATA_1_LINE;
  827.         s_command.DummyCycles       = 0;
  828.         s_command.NbData            = 2;
  829.         s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
  830.         //s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
  831.         s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;

  833.         if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  834.         {
  835.                 printf("something wrong ....\r\n");
  836.     return 0;
  837.         }
  838.         if (HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
  839.         {
  840.                 printf("something wrong ....\r\n");
  841.     return 0;
  842.         }

  844.         Temp = pData[1] |( pData[0]<<8 ) ;
  845.         return Temp;
  846. }
  847. PUTCHAR_PROTOTYPE
  848. {
  849.   /* Place your implementation of fputc here */
  850.   /* e.g. write a character to the USART1 and Loop until the end of transmission */
  851.   HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);

  853.   return ch;
  854. }
  855. /* USER CODE END 1 */
复制代码
参考 github/WellinZHANG/External_Loader

QSPI_MemoryMapped.7z

983.25 KB, 下载次数: 0, 下载积分: 黑币 -5

source code

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的奖励！

查看全部评分

回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表