21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 【CPKCOR-RA8D1B核心板】8、 QSPI读取外部Flash ...
返回列表 发新帖我要提问

【CPKCOR-RA8D1B核心板】8、 QSPI读取外部Flash

[复制链接]
4467|0
 楼主| qintian0303 发表于 2024-12-17 10:35 | 显示全部楼层 |阅读模式
flash, QSPI, 外部FLASH, 核心, or, spi
本帖最后由 qintian0303 于 2024-12-17 10:38 编辑

       QSPI是Queued SPI的简写，是Motorola公司推出的SPI接口的扩展，比SPI应用更加广泛。在SPI协议的基础上，Motorola公司对其功能进行了增强，增加了队列传输机制，推出了队列串行外围接口协议（即QSPI协议）。QSPI 是一种专用的通信接口，连接单、双或四（条数据线） SPI Flash 存储介质。QSPI是一个内存控制器，用于连接具有SPI兼容接口的串行ROM(非易失性存储器。
       我们看一下核心板上的外扩Flash：
   

       外扩的Flash的型号是AT25SF128B。
       QSPI 使用 6 个信号连接Flash，分别是四个数据线QIO0~QIO3，一个时钟输出CLK，一个片选输出（低电平有效）QSSL，它们的作用介绍如下：
              QSSL：片选输出（低电平有效），适用于 FLASH 1。如果 QSPI 始终在双闪存模式下工作，则其也可用于 FLASH 2从设备选择信号线。QSPI通讯以QSSL线置低电平为开始信号，以QSSL线被拉高作为结束信号。
              CLK：时钟输出，适用于两个存储器，用于通讯数据同步。它由通讯主机产生，决定了通讯的速率， 不同的设备支持的最高时钟频率不一样，两个设备之间通讯时，通讯速率受限于低速设备。
              QIO0QIO0~QIO3：四线模式中为双向 IO。
接下来进行软件配置：
       添加OSPI功能模块：
   

       接下来我们配置一下引脚：
   

       一共是6个引脚，接下来配置模块信息：
   

       下面是部分Flash的命令，我们可以初始化这些内容:
   

       接下来我们代码测试一下QSPI的功能，我们定义了一些基础功能测试：
复制
  1. uint8_t g_read_data [OSPI_B_APP_DATA_SIZE]  = {RESET_VALUE};
    

  2. uint8_t g_write_data [OSPI_B_APP_DATA_SIZE] = {
    

  3.     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
    

  4.     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
    

  5.     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
    

  6.     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
    

  7. };
    


  8. 

  9. spi_flash_direct_transfer_t g_ospi_b_direct_transfer [OSPI_B_TRANSFER_MAX] =
    

  10. {
    

  11.  /* Transfer structure for SPI mode */
    

  12.     [OSPI_B_TRANSFER_WRITE_ENABLE_SPI] =
    

  13.     {
    

  14.         .command        = OSPI_B_COMMAND_WRITE_ENABLE_SPI,
    

  15.         .address        = OSPI_B_ADDRESS_DUMMY,
    

  16.         .data           = OSPI_B_DATA_DUMMY,
    

  17.         .command_length = OSPI_B_COMMAND_LENGTH_SPI,
    

  18.         .address_length = OSPI_B_ADDRESS_LENGTH_ZERO,
    

  19.         .data_length    = OSPI_B_DATA_LENGTH_ZERO,
    

  20.         .dummy_cycles   = OSPI_B_DUMMY_CYCLE_WRITE_SPI
    

  21.     },
    

  22.     [OSPI_B_TRANSFER_READ_STATUS_SPI] =
    

  23.     {
    

  24.         .command        = OSPI_B_COMMAND_READ_STATUS_SPI,
    

  25.         .address        = OSPI_B_ADDRESS_DUMMY,
    

  26.         .data           = OSPI_B_DATA_DUMMY,
    

  27.         .command_length = OSPI_B_COMMAND_LENGTH_SPI,
    

  28.         .address_length = OSPI_B_ADDRESS_LENGTH_ZERO,
    

  29.         .data_length    = OSPI_B_DATA_LENGTH_ONE,
    

  30.         .dummy_cycles   = OSPI_B_DUMMY_CYCLE_READ_STATUS_SPI
    

  31.     },
    

  32.     [OSPI_B_TRANSFER_READ_DEVICE_ID_SPI] =
    

  33.     {
    

  34.         .command        = OSPI_B_COMMAND_READ_DEVICE_ID_SPI,     //0x9f
    

  35.         .address        = OSPI_B_ADDRESS_DUMMY,                  //0
    

  36.         .data           = OSPI_B_DATA_DUMMY,                     //0
    

  37.         .command_length = OSPI_B_COMMAND_LENGTH_SPI,             //1
    

  38.         .address_length = OSPI_B_ADDRESS_LENGTH_ZERO,            //0
    

  39.         .data_length    = OSPI_B_DATA_LENGTH_FOUR,               //4
    

  40.         .dummy_cycles   = OSPI_B_DUMMY_CYCLE_READ_STATUS_SPI     //0
    

  41.     }
    

  42. };
    


  43. 

  44. fsp_err_t ospi_b_read_device_id (uint32_t * const p_id)
    

  45. {
    

  46.     fsp_err_t                   err             = FSP_SUCCESS;
    

  47.     spi_flash_direct_transfer_t transfer        = {RESET_VALUE};
    


  48. 

  49.     /* Read and check flash device ID */
    

  50.     transfer = g_ospi_b_direct_transfer[OSPI_B_TRANSFER_READ_DEVICE_ID_SPI];
    

  51.     err = R_OSPI_B_DirectTransfer(&g_qspi0_flash_ctrl, &transfer, SPI_FLASH_DIRECT_TRANSFER_DIR_READ);
    


  52. 

  53.     if(err!=FSP_SUCCESS)
    

  54.         {
    

  55.                 printf("R_OSPI_B_DirectTransfer API FAILED \r\n");
    

  56.         }
    

  57.     /* Get flash device ID */
    

  58.     *p_id = transfer.data;
    


  59. 

  60.     return err;
    

  61. }
    


  62. 

  63. static fsp_err_t ospi_b_write_enable (void)
    

  64. {
    

  65.     fsp_err_t                   err             = FSP_SUCCESS;
    

  66.     spi_flash_direct_transfer_t transfer        = {RESET_VALUE};
    


  67. 

  68.     /* Transfer write enable command */
    

  69.     transfer = g_ospi_b_direct_transfer[OSPI_B_TRANSFER_WRITE_ENABLE_SPI];
    

  70.     err = R_OSPI_B_DirectTransfer(&g_qspi0_flash_ctrl, &transfer, SPI_FLASH_DIRECT_TRANSFER_DIR_WRITE);
    

  71.     assert(FSP_SUCCESS == err);
    


  72. 

  73.     /* Read Status Register */
    

  74.     transfer = g_ospi_b_direct_transfer[OSPI_B_TRANSFER_READ_STATUS_SPI];
    

  75.     err = R_OSPI_B_DirectTransfer(&g_qspi0_flash_ctrl, &transfer, SPI_FLASH_DIRECT_TRANSFER_DIR_READ);
    

  76.     assert(FSP_SUCCESS == err);
    


  77. 

  78.     /* Check Write Enable bit in Status Register */
    

  79.     if(OSPI_B_WEN_BIT_MASK != (transfer.data & OSPI_B_WEN_BIT_MASK))
    

  80.     {
    

  81.         printf("Write enable FAILED\r\n");
    

  82.     }
    

  83.     return err;
    

  84. }
    


  85. 

  86. static fsp_err_t ospi_b_wait_operation (uint32_t timeout)
    

  87. {
    

  88.     fsp_err_t          err    = FSP_SUCCESS;
    

  89.     spi_flash_status_t status = {RESET_VALUE};
    


  90. 

  91.     status.write_in_progress = true;
    

  92.     while (status.write_in_progress)
    

  93.     {
    

  94.         /* Get device status */
    

  95.         R_OSPI_B_StatusGet(&g_qspi0_flash_ctrl, &status);
    

  96.         if(RESET_VALUE == timeout)
    

  97.         {
    

  98.             printf("OSPI time out occurred\r\n");
    

  99.         }
    

  100.         R_BSP_SoftwareDelay(1, OSPI_B_TIME_UNIT);
    

  101.         timeout --;
    

  102.     }
    

  103.     return err;
    

  104. }
    


  105. 

  106. static fsp_err_t ospi_b_erase_operation (uint8_t * const p_address)
    

  107. {
    

  108.     fsp_err_t   err             = FSP_SUCCESS;
    

  109.     uint32_t    sector_size     = RESET_VALUE;
    

  110.     uint32_t    erase_timeout   = RESET_VALUE;
    


  111. 

  112.     /* Check sector size according to input address pointer,
    

  113.         described in S28HS512T data sheet
    

  114.     */
    

  115.     if(OSPI_B_SECTOR_4K_END_ADDRESS < (uint32_t)p_address)
    

  116.     {
    

  117.         sector_size = OSPI_B_SECTOR_SIZE_256K;
    

  118.         erase_timeout = OSPI_B_TIME_ERASE_256K;
    

  119.     }
    

  120.     else
    

  121.     {
    

  122.         sector_size = OSPI_B_SECTOR_SIZE_4K;
    

  123.         erase_timeout = OSPI_B_TIME_ERASE_4K;
    

  124.     }
    


  125. 

  126.     /* Performs erase sector */
    

  127.     err = R_OSPI_B_Erase(&g_qspi0_flash_ctrl, p_address, sector_size);
    


  128. 

  129.     /* Wait till operation completes */
    

  130.     err = ospi_b_wait_operation(erase_timeout);
    


  131. 

  132.     return err;
    

  133. }
    


  134. 

  135. static fsp_err_t ospi_b_write_operation (uint8_t * const p_address,
    

  136.                                         uint8_t *pdata, uint16_t len)
    

  137. {
    

  138.     fsp_err_t   err         = FSP_SUCCESS;
    


  139. 

  140.     /* Erase sector before write data to flash device */
    

  141.     err = ospi_b_erase_operation(p_address);
    


  142. 

  143.     /* Write data to flash device */
    

  144.     err = R_OSPI_B_Write(&g_qspi0_flash_ctrl, pdata, p_address, len);
    


  145. 

  146.     /* Wait until write operation completes */
    

  147.     err = ospi_b_wait_operation(OSPI_B_TIME_WRITE);
    


  148. 

  149.     return err;
    

  150. }
    


  151. 


  152. 

  153. static fsp_err_t ospi_b_read_operation (uint8_t * const p_address,uint8_t *pdata, uint16_t len)
    

  154. {
    

  155.     fsp_err_t err = FSP_SUCCESS;
    


  156. 

  157.     /* Clean read buffer */
    

  158.     memset(pdata, RESET_VALUE, len);
    


  159. 

  160.     /* Read data from flash device */
    

  161.     memcpy(pdata, p_address, len);
    


  162. 

  163.     return err;
    

  164. }
       在main中我们需要先初始化：
复制
  1. void qspi_FlashInit( void )
    

  2. {
    

  3.   /* Open the OSPI instance. */
    

  4.     fsp_err_t err = R_OSPI_B_Open(&g_qspi0_flash_ctrl, &g_qspi0_flash_cfg);
    

  5.     assert(FSP_SUCCESS == err);
    


  6. 

  7.     /* Switch OSPI module to 1S-1S-1S mode to configure flash device */
    

  8.     err = R_OSPI_B_SpiProtocolSet(&g_qspi0_flash_ctrl, SPI_FLASH_PROTOCOL_EXTENDED_SPI);
    

  9.     assert(FSP_SUCCESS == err);
    


  10. 

  11.     /* Reset flash device by driving OM_RESET pin */
    

  12.     R_XSPI->LIOCTL_b.RSTCS0 = 0;
    

  13.     R_BSP_SoftwareDelay(OSPI_B_TIME_RESET_PULSE, OSPI_B_TIME_UNIT);
    

  14.     R_XSPI->LIOCTL_b.RSTCS1 = 1;
    

  15.     R_BSP_SoftwareDelay(OSPI_B_TIME_RESET_SETUP, OSPI_B_TIME_UNIT);
    


  16. 

  17.     ospi_b_write_enable();
    


  18. 

  19. }
       然后直接初始化阶段测试QSPI，我们写入一页数据，但是之读取其中的16个，并通过串口打印：
复制
  1. fsp_err_t ospi_b_Testoperation (uint8_t * p_address)
    

  2. {
    

  3.     fsp_err_t       err                         = FSP_SUCCESS;
    

  4.     uint16_t i = 0;
    


  5. 

  6.     err = ospi_b_erase_operation(p_address);
    

  7.     err = ospi_b_write_operation (p_address,g_write_data,OSPI_B_APP_DATA_SIZE);
    


  8. 

  9.     if(err==FSP_SUCCESS)
    

  10.     {
    

  11.         /* Print execution time */
    

  12.         printf("Write %d bytes completed successfully\r\n", (int)(OSPI_B_APP_DATA_SIZE));
    

  13.     }
    

  14.     else
    

  15.     {
    

  16.         printf("Write operation failure\r\n");
    

  17.     }
    

  18.     printf("Write Data:\r\n");
    

  19.     for(i=0;i<=OSPI_B_APP_DATA_SIZE-1;i++)
    

  20.     {
    

  21.         printf("%d ",g_write_data[i]);
    

  22.     }
    


  23. 

  24.     err = ospi_b_read_operation (p_address,g_read_data,16);
    

  25.     if(err==FSP_SUCCESS)
    

  26.     {
    

  27.         /* Print execution time */
    

  28.         printf("\r\nRead %d bytes completed successfully\r\n", (int)(OSPI_B_APP_DATA_SIZE));
    

  29.     }
    

  30.     else
    

  31.     {
    

  32.         printf("\r\nRead operation failure\r\n");
    

  33.     }
    

  34.     printf("Read Data:\r\n");
    

  35.     for(i=0;i<=sizeof(g_read_data)-1;i++)
    

  36.     {
    

  37.         printf("%d ",g_read_data[i]);
    

  38.     }
    

  39.     /* Compare data read and date written */
    

  40.     if(RESET_VALUE == memcmp(&g_read_data, &g_write_data, (size_t)16))
    

  41.     {
    

  42.         printf("\r\nData read matched data written\r\n");
    

  43.         printf("flash读写数据成功\r\n");
    

  44.     }
    

  45.     else
    

  46.     {
    

  47.         printf("\r\nData read does not match data written\r\n");
    

  48.         printf("flash读写数据失败\r\n");
    

  49.     }
    


  50. 

  51.     /* Performs OSPI erase operation */
    

  52.     err = ospi_b_erase_operation(p_address);
    

  53.     if(err==FSP_SUCCESS)
    

  54.     {
    

  55.         /* Print execution time */
    

  56.         printf("Erase sector completed successfully\r\n");
    

  57.     }
    

  58.     else
    

  59.     {
    

  60.         printf("erase operation failure\r\n");
    

  61.     }
    

  62.     return err;
    

  63. }
       串口打印结果如下：
   



本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

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

本版积分规则

qintian0303 Image Image
认证：硬件工程师
简介：有着多年硬件开发经验的专业人员，专注于医疗电子领域，热衷于对新鲜事物的探索，喜欢DIY！

602

主题

2899

帖子

12

粉丝
快速回复 在线客服 返回列表 返回顶部