[15] STM32F7 - Discovery - QSPI, zewnętrzna pamięć Flash

W tym poście chciałbym poruszyć temat wykorzystania QSPI na płytce discovery do komunikacji z pamięcią Nor Flash. Kość umieszczona na płytce discovery to 128 Mbit pamięć N25Q128A13EF840E od Microna.

Układ został podłączony do mikrokontrolera w następujący sposób [STM32F7 Datasheet]:

Pamięć do STM32 jest podłączona w następujący sposób:

• Pin PB2 - QSPI_CLK (Pin 6 C)
• Pin PB6 - QSPI_CS (Pin 1 S#)
• Pin PD11 - QSPI_IO_0(Pin 5 DQ0)
• Pin PD12 - QSPI_IO_1(Pin 2 DQ1)
• Pin PE2 - QSPI_IO_2(Pin 3 DQ2)
• Pin PD13 - QSPI_IO_3(Pin 4 DQ3)

Cube Mx:

Poniżej zaprezentuję sposób przygotowania programu za pomocą środowiska CubeMx:

Włączenie QSPI:

Ustawienie QSPI:

Programowanie:

Przygotowanie funkcji jest oparte o biblioteki BSP udostępnione przez firmę ST.

Najpierw omówię plik .h. Na samej górze znajdują się w nim deklaracje pinów, które są nieużywane w przypadku gdy nie korzysta się z procedury inicjalizacyjnej z Cuba:

1. #define QSPI_CS_PIN                GPIO_PIN_6
2. #define QSPI_CS_GPIO_PORT          GPIOB
4. #define QSPI_CLK_PIN               GPIO_PIN_2
5. #define QSPI_CLK_GPIO_PORT         GPIOB
7. #define QSPI_D0_PIN                GPIO_PIN_11
8. #define QSPI_D0_GPIO_PORT          GPIOD
10. #define QSPI_D1_PIN                GPIO_PIN_12
11. #define QSPI_D1_GPIO_PORT          GPIOD
13. #define QSPI_D2_PIN                GPIO_PIN_2
14. #define QSPI_D2_GPIO_PORT          GPIOE
16. #define QSPI_D3_PIN                GPIO_PIN_13
17. #define QSPI_D3_GPIO_PORT          GPIOD

Następnie zdefiniowałem statusy dla przeprowadzonych operacji podczas korzystania z QSPI:

1. /* QSPI operation status */
2. #define QSPI_OK            ((uint8_t)0x00)
3. #define QSPI_ERROR         ((uint8_t)0x01)
4. #define QSPI_BUSY          ((uint8_t)0x02)
5. #define QSPI_NOT_SUPPORTED ((uint8_t)0x04)
6. #define QSPI_SUSPENDED     ((uint8_t)0x08)

Kolejnym elementem są zdefiniowane rozmiary pamięci oraz maksymalne czasy dla poszczególnych sektorów:

1. /* Defines declarations for external flash on board STM32F7-Disco */
2. #define N25Q128A_FLASH_SIZE                  0x1000000 /* 128 MBits => 16MBytes => 16,777,216 bytes */
3. #define N25Q128A_SECTOR_SIZE                 0x10000   /* 256 sectors of 64KBytes       */
4. #define N25Q128A_SUBSECTOR_SIZE              0x1000    /* 4096 subsectors of 4kBytes    */
5. #define N25Q128A_PAGE_SIZE                   0x100     /* 65536 pages of 256 bytes      */
6. #define N25Q128A_SUBSECTOR_CNT               4096      /* 4096 subsectors               */
8. #define N25Q128A_DUMMY_CYCLES_READ_QUAD      10
10. #define N25Q128A_BULK_ERASE_MAX_TIME         250000
11. #define N25Q128A_SECTOR_ERASE_MAX_TIME       3000
12. #define N25Q128A_SUBSECTOR_ERASE_MAX_TIME    800

Definicje operacji, rejestrów i komend:

1. /* Flag Status Register */
2. #define N25Q128A_FSR_PRERR                   ((uint8_t)0x02)    /*!< Protection error */
3. #define N25Q128A_FSR_PGSUS                   ((uint8_t)0x04)    /*!< Program operation suspended */
4. #define N25Q128A_FSR_VPPERR                  ((uint8_t)0x08)    /*!< Invalid voltage during program or erase */
5. #define N25Q128A_FSR_PGERR                   ((uint8_t)0x10)    /*!< Program error */
6. #define N25Q128A_FSR_ERERR                   ((uint8_t)0x20)    /*!< Erase error */
7. #define N25Q128A_FSR_ERSUS                   ((uint8_t)0x40)    /*!< Erase operation suspended */
8. #define N25Q128A_FSR_READY                   ((uint8_t)0x80)    /*!< Ready or command in progress */
10. /* Registers */
11. #define N25Q128A_SR_WIP                      ((uint8_t)0x01)
12. #define N25Q128A_VCR_NB_DUMMY                ((uint8_t)0xF0)
13. #define N25Q128A_SR_WREN                     ((uint8_t)0x02)
15. /* Register Operations */
16. #define READ_FLAG_STATUS_REG_CMD             0x70
17. #define WRITE_STATUS_REG_CMD                 0x01
19. /* Commands */
20. /* Reset operations */
21. #define RESET_ENABLE_CMD                     0x66
22. #define RESET_MEMORY_CMD                     0x99
24. /* Identification Operations */
25. #define READ_ID_CMD                          0x9E
26. #define READ_ID_CMD2                         0x9F
27. #define MULTIPLE_IO_READ_ID_CMD              0xAF
28. #define READ_SERIAL_FLASH_DISCO_PARAM_CMD    0x5A
30. /* Read Operations */
31. #define READ_CMD                             0x03
32. #define FAST_READ_CMD                        0x0B
33. #define DUAL_OUT_FAST_READ_CMD               0x3B
34. #define DUAL_INOUT_FAST_READ_CMD             0xBB
35. #define QUAD_OUT_FAST_READ_CMD               0x6B
36. #define QUAD_INOUT_FAST_READ_CMD             0xEB
38. #define READ_VOL_CFG_REG_CMD                 0x85
39. #define WRITE_VOL_CFG_REG_CMD                0x81
40. #define READ_STATUS_REG_CMD                  0x05
41. #define WRITE_STATUS_REG_CMD                 0x01
42. #define WRITE_ENABLE_CMD                     0x06
43. #define WRITE_DISABLE_CMD                    0x04
44. #define SUBSECTOR_ERASE_CMD                  0x20
45. #define SECTOR_ERASE_CMD                     0xD8
46. #define BULK_ERASE_CMD                       0xC7
47. #define EXT_QUAD_IN_FAST_PROG_CMD            0x12

W pliku nagłówkowym zdefiniowałem także funkcje globalne, które będą dostępne dla całego projektu:

1. uint8_t  __attribute__((unused)) QSPI_Flash_Init(void);
2. uint8_t QSPI_Flash_Erase_Complete(void);
3. uint8_t QSPI_Flash_Erase_SubSector(uint32_t subsector_nr);
4. uint8_t QSPI_Flash_Read_Block_Byte(uint32_t startAddr, uint32_t size, uint8_t* data_buf);
5. uint8_t QSPI_Flash_Write_Block_Byte(uint32_t startAddr, uint32_t size, uint8_t* data_buf);
7. uint8_t QSPI_Flash_Write_SubSector(uint32_t subsectorNumber, uint8_t* data_buf, uint32_t size);
8. uint8_t QSPI_Flash_Write_Page(uint32_t startAddr, uint8_t* data_buf);
10. uint8_t QSPI_Flash_Read_Unique_ID(uint8_t *dataBuffer);
12. uint8_t QSPI_ResetMemory(QSPI_HandleTypeDef *hqspi);        /* Used after initialization in main function */
13. uint8_t QSPI_DummyCyclesCfg(QSPI_HandleTypeDef *hqspi);     /* Used after initialization in main function */

QSPI_Flash_Init zdefiniowany w tym pliku jest prze zemnie nie wykorzystywany ponieważ, wykorzystuje procedurę inicjalizacyjną wygenerowaną przez program CubeMx.

Funkcja włączająca QSPI, która została wygenerowana z programu CubeMx, wygląda następująco:

1. /* QUADSPI init function */
2. static void MX_QUADSPI_Init(void)
3. {
4.   hqspi.Instance = QUADSPI;
5.   hqspi.Init.ClockPrescaler = 2;
6.   hqspi.Init.FifoThreshold = 4;
7.   hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
8.   hqspi.Init.FlashSize = 23;
9.   hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_2_CYCLE;
10.   hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
11.   hqspi.Init.FlashID = QSPI_FLASH_ID_1;
12.   hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
13.   if (HAL_QSPI_Init(&hqspi) != HAL_OK)
14.   {
15.     Error_Handler();
16.   }
17. }

Funkcja przygotowana w bibliotece prezentuje się następująco:

1. uint8_t  QSPI_Flash_Init(void)
2. {
3.     hqspi.Instance = QUADSPI;
4.     HAL_QSPI_DeInit(&hqspi);
6.     Statiic_QSPI_MspInit(&hqspi);
8.     hqspi.Init.ClockPrescaler     = 2;
9.     hqspi.Init.FifoThreshold      = 4;
10.     hqspi.Init.SampleShifting     = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
11.     hqspi.Init.FlashSize          = POSITION_VAL(N25Q128A_FLASH_SIZE) - 1;
12.     hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_2_CYCLE;
13.     hqspi.Init.ClockMode          = QSPI_CLOCK_MODE_0;
14.     hqspi.Init.FlashID            = QSPI_FLASH_ID_1;
15.     hqspi.Init.DualFlash          = QSPI_DUALFLASH_DISABLE;
16.     HAL_QSPI_Init(&hqspi);
18.     /* QSPI reset */
19.     if(QSPI_ResetMemory(&hqspi) != QSPI_OK){
20.         return QSPI_NOT_SUPPORTED;
21.     }
23.     /* Wait before config */
24.     if(QSPI_DummyCyclesCfg(&hqspi) != QSPI_OK){
25.         return QSPI_NOT_SUPPORTED;
26.     }
28.     return QSPI_OK;
29. }

Uruchomienie pinów w bibliotece, bez użycia funkcji wygenerowanej z Cuba wygląda następująco:

1. __weak void Statiic_QSPI_MspInit(QSPI_HandleTypeDef *hqspi, void *Params)
2. {
3.   GPIO_InitTypeDef gpio_init_structure;
5.   //QSPI enable Clock
6.   __HAL_RCC_QSPI_CLK_ENABLE();
8.   //QSPI Reset
9.   __HAL_RCC_QSPI_FORCE_RESET();
10.   __HAL_RCC_QSPI_RELEASE_RESET();
12.   //Enable Clocks
13.   PORT_CLOCK_ENABLE(QSPI_CS_GPIO_PORT);
14.   PORT_CLOCK_ENABLE(QSPI_CLK_GPIO_PORT);
15.   PORT_CLOCK_ENABLE(QSPI_D0_GPIO_PORT);
16.   PORT_CLOCK_ENABLE(QSPI_D1_GPIO_PORT);
17.   PORT_CLOCK_ENABLE(QSPI_D2_GPIO_PORT);
18.   PORT_CLOCK_ENABLE(QSPI_D3_GPIO_PORT);
20.   // QSPI CS GPIO pin configuration
21.   gpio_init_structure.Pin       = QSPI_CS_PIN;
22.   gpio_init_structure.Mode      = GPIO_MODE_AF_PP;
23.   gpio_init_structure.Pull      = GPIO_PULLUP;
24.   gpio_init_structure.Speed     = GPIO_SPEED_HIGH;
25.   gpio_init_structure.Alternate = GPIO_AF10_QUADSPI;
26.   HAL_GPIO_Init(QSPI_CS_GPIO_PORT, &gpio_init_structure);
28.   // QSPI CLK GPIO pin configuration
29.   gpio_init_structure.Pin       = QSPI_CLK_PIN;
30.   gpio_init_structure.Pull      = GPIO_NOPULL;
31.   gpio_init_structure.Alternate = GPIO_AF9_QUADSPI;
32.   HAL_GPIO_Init(QSPI_CLK_GPIO_PORT, &gpio_init_structure);
34.   // QSPI D0 GPIO pin configuration
35.   gpio_init_structure.Pin       = QSPI_D0_PIN;
36.   gpio_init_structure.Alternate = GPIO_AF9_QUADSPI;
37.   HAL_GPIO_Init(QSPI_D0_GPIO_PORT, &gpio_init_structure);
39.   // QSPI D1 GPIO pin configuration
40.   gpio_init_structure.Pin       = QSPI_D1_PIN;
41.   gpio_init_structure.Alternate = GPIO_AF9_QUADSPI;
42.   HAL_GPIO_Init(QSPI_D1_GPIO_PORT, &gpio_init_structure);
44.   // QSPI D2 GPIO pin configuration
45.   gpio_init_structure.Pin       = QSPI_D2_PIN;
46.   gpio_init_structure.Alternate = GPIO_AF9_QUADSPI;
47.   HAL_GPIO_Init(QSPI_D2_GPIO_PORT, &gpio_init_structure);
49.   // QSPI D3 GPIO pin configuration
50.   gpio_init_structure.Pin       = QSPI_D3_PIN;
51.   gpio_init_structure.Alternate = GPIO_AF9_QUADSPI;
52.   HAL_GPIO_Init(QSPI_D3_GPIO_PORT, &gpio_init_structure);
54.   // NVIC configuration for QSPI interrupt
55.   HAL_NVIC_SetPriority(QUADSPI_IRQn, 0x0F, 0);
56.   HAL_NVIC_EnableIRQ(QUADSPI_IRQn);
57. }

Po włączeniu należy jeszcze pamięć zresetować i poczekać na zakończenie operacji:

1.   if(P_QSPI_ResetMemory(&hqspi) != QSPI_OK)     { /* Error QSPI_NOT_SUPPORTED */    }
2.   if(P_QSPI_DummyCyclesCfg(&hqspi) != QSPI_OK)  { /* Error QSPI_NOT_SUPPORTED */    }

Funkcja odczytująca dane dotyczące id pamięci wygląda następująco:

1. uint8_t QSPI_Flash_Read_Unique_ID(uint8_t* data_buf)
2. {
3.     #if DEBUG_USART == 1
4.     char tmpUsartBuffer[40] = {0};
5.     #endif
6.    
7.     QSPI_CommandTypeDef command;
9.     command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
10.     command.Instruction       = READ_ID_CMD;
11.     command.AddressMode       = QSPI_ADDRESS_1_LINE;
12.     command.AddressSize       = QSPI_ADDRESS_24_BITS;
13.     command.Address           = 0x000000;
14.     command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
15.     command.DataMode          = QSPI_DATA_1_LINE;
16.     command.DummyCycles       = 0;
17.     command.NbData            = 2;
18.     command.DdrMode           = QSPI_DDR_MODE_DISABLE;
19.     command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
20.     command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
22.     if(HAL_QSPI_Command(&hqspi, &command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
23.     #if DEBUG_USART == 1
24.         HAL_UART_Transmit(&huart1, (uint8_t*)"ERROR1\r\n",8,0x1000);
25.     #endif
26.         return QSPI_ERROR;
27.     }
28.     if (HAL_QSPI_Receive(&hqspi, data_buf, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
29.     #if DEBUG_USART == 1
30.         HAL_UART_Transmit(&huart1, (uint8_t*)"ERROR2\r\n",8,0x1000);
31.     #endif
32.         return QSPI_ERROR;
33.     }
35.     #if DEBUG_USART == 1
36.    
37.     sprintf(tmpUsartBuffer, "Unique ID [HEX]\r\n");
38.     HAL_UART_Transmit(&huart1, (uint8_t*)tmpUsartBuffer,strlen(tmpUsartBuffer),0x1000);
40.     for(uint8_t loop = 0; loop<sizeof(data_buf); loop++)
41.     {
42.         sprintf(tmpUsartBuffer, (uint8_t*)"[%u] 0x%2X\r\n", loop, (uint8_t)data_buf[loop]);
43.         HAL_UART_Transmit(&huart1, (uint8_t*)tmpUsartBuffer,strlen(tmpUsartBuffer),0x1000);
44.     }
45.    
46.     #endif
48.     return QSPI_OK;
49. }

Dane są odbierane od czytnika i wypisywane na ekranie przez USART1.

Pamięć może być czyszczona przez wymazanie całego sektora, pod sektora lub całości. Nie ma możliwości czyszczenia pojedynczej strony z danymi. Aby bez problemów można było zapisać w trakcie pracy nowe dane do układu, to należy wymazać cały sektor danych. 

Wymazywanie całej pamięci:

1. uint8_t QSPI_Flash_Erase_Complete(void)
2. {
3.   QSPI_CommandTypeDef command;
5.   // Initialize the erase command
6.   command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
7.   command.Instruction       = BULK_ERASE_CMD;
8.   command.AddressMode       = QSPI_ADDRESS_NONE;
9.   command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
10.   command.DataMode          = QSPI_DATA_NONE;
11.   command.DummyCycles       = 0;
12.   command.DdrMode           = QSPI_DDR_MODE_DISABLE;
13.   command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
14.   command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
16.   // Enable write operations
17.   if(Static_QSPI_WriteEnable(&hqspi) != QSPI_OK){
18.       return QSPI_ERROR;
19.   }
21.   // Send the command
22.   if(HAL_QSPI_Command(&hqspi, &command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
23.       return QSPI_ERROR;
24.   }
26.   // Configure automatic polling mode to wait for end of erase
27.   if(Static_QSPI_AutoPollingMemReady(&hqspi, N25Q128A_BULK_ERASE_MAX_TIME) != QSPI_OK){
28.       return QSPI_ERROR;
29.   }
31.   return QSPI_OK;
32. }

Czyszczenie całego sektora:

1. uint8_t QSPI_Flash_Erase_Sector(uint32_t sectorNumber)
2. {
3.   QSPI_CommandTypeDef command;
5.   if(sectorNumber>=N25Q128A_SECTOR_CNT) {
6.       return QSPI_ERROR;
7.   }
9.   // Initialize the erase command
10.   command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
11.   command.Instruction       = SECTOR_ERASE_CMD;
12.   command.AddressMode       = QSPI_ADDRESS_1_LINE;
13.   command.AddressSize       = QSPI_ADDRESS_24_BITS;
14.   command.Address           = sectorNumber;
15.   command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
16.   command.DataMode          = QSPI_DATA_NONE;
17.   command.DummyCycles       = 0;
18.   command.DdrMode           = QSPI_DDR_MODE_DISABLE;
19.   command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
20.   command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
22.   // Enable write operations
23.   if(Static_QSPI_WriteEnable(&hqspi) != QSPI_OK){
24.       return QSPI_ERROR;
25.   }
27.   // Send the command
28.   if(HAL_QSPI_Command(&hqspi, &command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
29.       return QSPI_ERROR;
30.   }
32.   // Configure automatic polling mode to wait for end of erase
33.   if(Static_QSPI_AutoPollingMemReady(&hqspi, N25Q128A_SUBSECTOR_ERASE_MAX_TIME) != QSPI_OK){
34.       return QSPI_ERROR;
35.   }
37.   return QSPI_OK;
38. }

Czyszczenie pod-sektora:

1. uint8_t QSPI_Flash_Erase_SubSector(uint32_t subsectorNumber)
2. {
3.   uint32_t subsectorAdress = 0;
5.   QSPI_CommandTypeDef command;
7.   if(subsectorNumber>=N25Q128A_SUBSECTOR_CNT) {
8.       return QSPI_ERROR;
9.   }
11.   subsectorAdress = subsectorNumber * N25Q128A_SUBSECTOR_SIZE;
13.   // Initialize the erase command
14.   command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
15.   command.Instruction       = SUBSECTOR_ERASE_CMD;
16.   command.AddressMode       = QSPI_ADDRESS_1_LINE;
17.   command.AddressSize       = QSPI_ADDRESS_24_BITS;
18.   command.Address           = subsectorAdress;
19.   command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
20.   command.DataMode          = QSPI_DATA_NONE;
21.   command.DummyCycles       = 0;
22.   command.DdrMode           = QSPI_DDR_MODE_DISABLE;
23.   command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
24.   command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
26.   // Enable write operations
27.   if(Static_QSPI_WriteEnable(&hqspi) != QSPI_OK){
28.       return QSPI_ERROR;
29.   }
31.   // Send the command
32.   if(HAL_QSPI_Command(&hqspi, &command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
33.       return QSPI_ERROR;
34.   }
36.   // Configure automatic polling mode to wait for end of erase
37.   if(Static_QSPI_AutoPollingMemReady(&hqspi, N25Q128A_SUBSECTOR_ERASE_MAX_TIME) != QSPI_OK){
38.       return QSPI_ERROR;
39.   }
41.   return QSPI_OK;
42. }

Aby odczytać dane należy posłużyć się następującą funkcją:

1. uint8_t QSPI_Flash_Read_Block_Byte(uint32_t startAddr, uint32_t size, uint8_t* data_buf)
2. {
3.   QSPI_CommandTypeDef command;
5.   if(startAddr>=N25Q128A_FLASH_SIZE)        { return QSPI_ERROR; }
6.   if((startAddr+size)>=N25Q128A_FLASH_SIZE) { return QSPI_ERROR; }
7.   if(size==0)                               { return QSPI_ERROR; }
9.   // Initialize the read command
10.   command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
11.   command.Instruction       = QUAD_INOUT_FAST_READ_CMD;
12.   command.AddressMode       = QSPI_ADDRESS_4_LINES;
13.   command.AddressSize       = QSPI_ADDRESS_24_BITS;
14.   command.Address           = startAddr;
15.   command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
16.   command.DataMode          = QSPI_DATA_4_LINES;
17.   command.DummyCycles       = N25Q128A_DUMMY_CYCLES_READ_QUAD;
18.   command.NbData            = size;
19.   command.DdrMode           = QSPI_DDR_MODE_DISABLE;
20.   command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
21.   command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
23.   // Configure the command
24.   if(HAL_QSPI_Command(&hqspi, &command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
25.       return QSPI_ERROR;
26.   }
28.   // Reception of the data
29.   if(HAL_QSPI_Receive(&hqspi, data_buf, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
30.       return QSPI_ERROR;
31.   }
33.   return QSPI_OK;
34. }

Aby wykonać zapis danych należy do funkcji podać adres startowy, ilość danych oraz wskaźnik do nich. Należy pamiętać przy tym, że aby wykonać zapis to należy zezwolić poprzez ustawienie bitu WriteEnable. Następnie należy wyczyścić miejsce do którego będzie wykonywany zapis, po tym możliwe jest już prowadzenie danych do układu. Należy pamiętać, że najmniejsza możliwa ilość danych do zapisu to 256 bajtów (0x100) czyli jedna strona.

Funkcja zapisująca dane:

1. uint8_t QSPI_Flash_Write_Block_Byte(uint32_t startAddr, uint32_t size, uint8_t* dataBuffer)
2. {
3.   QSPI_CommandTypeDef command;
4.   uint32_t end_addr = 0;
5.   uint32_t current_size = 0;
6.   uint32_t current_addr = 0;
8.   if(startAddr>=N25Q128A_FLASH_SIZE)        { return QSPI_ERROR; }
9.   if((startAddr+size)>=N25Q128A_FLASH_SIZE) { return QSPI_ERROR; }
10.   if(size==0)                               { return QSPI_ERROR; }
12.   current_addr = 0;
13.   while (current_addr <= startAddr)         {   current_addr += N25Q128A_PAGE_SIZE; }
14.   current_size = current_addr - startAddr;
16.   // set variables
17.   if(current_size > size)   {   current_size = size;    }
19.   current_addr = startAddr;
20.   end_addr = startAddr + size;
22.   /* Initialize the program command */
23.   command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
24.   command.Instruction       = EXT_QUAD_IN_FAST_PROG_CMD;
25.   command.AddressMode       = QSPI_ADDRESS_4_LINES;
26.   command.AddressSize       = QSPI_ADDRESS_24_BITS;
27.   command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
28.   command.DataMode          = QSPI_DATA_4_LINES;
29.   command.DummyCycles       = 0;
30.   command.DdrMode           = QSPI_DDR_MODE_DISABLE;
31.   command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
32.   command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
34.   /* Write all pages of data */
35.   do{
36.       command.Address = current_addr;
37.       command.NbData  = current_size;
39.     /* Enable write mode */
40.     if(Static_QSPI_WriteEnable(&hqspi) != QSPI_OK){
41.         return QSPI_ERROR;
42.     }
43.    
44.     /* Configure the command */
45.     if(HAL_QSPI_Command(&hqspi, &command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
46.         return QSPI_ERROR;
47.     }
48.    
49.     /* Transmission of the data */
50.     if(HAL_QSPI_Transmit(&hqspi, dataBuffer, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
51.         return QSPI_ERROR;
52.     }
53.    
54.     /* Configure automatic polling mode to wait for end of program */
55.     if(Static_QSPI_AutoPollingMemReady(&hqspi, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != QSPI_OK){
56.         return QSPI_ERROR;
57.     }
58.    
59.     /* Update the address and size variables for next page programming */
60.     current_addr += current_size;
61.     dataBuffer += current_size;
62.     current_size = ((current_addr + N25Q128A_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : N25Q128A_PAGE_SIZE;
63.   } while (current_addr < end_addr);
65.   return QSPI_OK;
66. }

Za pomocą powyższej funkcji każda ilość danych może zostać zapisana do pamięci. Wykorzystałem ją w kolejnych funkcjach pozwalających na zapis większej ilości danych wraz z kasowaniem oraz sprawdzaniem.

Funkcja zapisująca cały pod sektor podanymi danymi:

1. uint8_t QSPI_Flash_Write_SubSector(uint32_t subsectorNumber, uint8_t* dataBuffer)
2. {
3.     char usartBuffer[40] = {0};
4.     uint32_t start_addr = 0;
5.     uint8_t readDataSubsector[N25Q128A_SUBSECTOR_SIZE] = {0};
6.     uint8_t dataRead2[1] = {0};
8.     /* Clear selected subsector */
9.     if(QSPI_Flash_Erase_SubSector(subsectorNumber) != QSPI_OK){
10.         sprintf(usartBuffer,"Error %lu", subsectorNumber);
11.         HAL_UART_Transmit(&huart1, (uint8_t*)usartBuffer,strlen(usartBuffer),0x1000);
12.         return QSPI_ERROR;
13.     }
15.     /* Calculate start address */
16.     start_addr = N25Q128A_SUBSECTOR_SIZE * subsectorNumber;
18.     QSPI_Flash_Read_Block_Byte(start_addr, 0x01, dataRead2);
20.     sprintf(usartBuffer,"Adress %lu. 0x%X \r\n", subsectorNumber, dataRead2[0]);
21.     HAL_UART_Transmit(&huart1, (uint8_t*)usartBuffer,strlen(usartBuffer),0x1000);
23.     /* Write data into flash */
24.     if(QSPI_Flash_Write_Block_Byte(start_addr, N25Q128A_SUBSECTOR_SIZE, dataBuffer) != QSPI_OK){
25.         return QSPI_ERROR;
26.     }
28.     /* Read data from flash*/
29.     if(QSPI_Flash_Read_Block_Byte(start_addr, N25Q128A_SUBSECTOR_SIZE, readDataSubsector) != QSPI_OK){
30.         return QSPI_ERROR;
31.     }
33.     /* Check if data was correctly write into flash */
34.     if(memcmp(dataBuffer,readDataSubsector,N25Q128A_SUBSECTOR_SIZE) == 0 ){
35.         return QSPI_OK;
36.     }
37.     else{
38.         return QSPI_ERROR;
39.     }
41.     /* return operation status */
42.     return QSPI_OK;
43. }

Kolejna funkcja zapisuje całą stronę z danymi w podanej lokalizacji. W związku z tym, że pamięć można wymazywać jedynie po całym pod-sektorze (0x1000), a każde wgranie pamięci musi być poprzedzone jej czyszczeniem, to należy stosować odpowiednie mechanizmy kontroli pozostałych danych:

1. uint8_t QSPI_Flash_Write_Page(uint32_t startAddr, uint8_t* data_buf)
2. {
3.     uint32_t subsector_number = 0;
4.     uint32_t addres_with_sub_data = 0;
5.     uint8_t copy_of_subsector_data[N25Q128A_SUBSECTOR_SIZE] = {0};
6.     uint8_t tmp_buffer_with_data[N25Q128A_SUBSECTOR_SIZE] = {0};
8.     /* calculate subsector number */
9.     subsector_number = startAddr/N25Q128A_SUBSECTOR_SIZE;
10.     addres_with_sub_data = N25Q128A_SUBSECTOR_SIZE * subsector_number;
12.     /* Read data from flash */
13.     if(QSPI_Flash_Read_Block_Byte(addres_with_sub_data, N25Q128A_SUBSECTOR_SIZE, copy_of_subsector_data) != QSPI_OK){
14.         return QSPI_ERROR;
15.     }
17.     uint32_t addres = (startAddr - addres_with_sub_data);
19.     /* Erase subsector */
20.     if(QSPI_Flash_Erase_SubSector(subsector_number) != QSPI_OK){ return QSPI_ERROR; }
22.     /* write data to appropriate memory place */
23.     for(uint32_t loop = 0; loop < N25Q128A_PAGE_SIZE; loop++)
24.     {
25.         copy_of_subsector_data[addres + loop] = data_buf[loop];
26.     }
28.     /* Write data */
29.     if(QSPI_Flash_Write_Block_Byte(addres_with_sub_data, N25Q128A_SUBSECTOR_SIZE, copy_of_subsector_data) != QSPI_OK){
30.         return QSPI_ERROR;
31.     }
33.     /* Check if data are correct: Read data again then check */
34.     if(QSPI_Flash_Read_Block_Byte(addres_with_sub_data, N25Q128A_SUBSECTOR_SIZE, tmp_buffer_with_data) != QSPI_OK){
35.         return QSPI_ERROR;
36.     }
38.     if(memcmp(copy_of_subsector_data,tmp_buffer_with_data,N25Q128A_SUBSECTOR_SIZE) != 0 ){ return QSPI_ERROR; }
40.     /* return status */
41.     return QSPI_OK;
42. }

W tym przypadku kopiowany jest cały pod-sektor danych, następnie w wybrane miejsce dane są dopisywane po czym następuje wpisanie danych do pamięci. Po takiej operacji dane są odczytywane z pamięci do bufora tymczasowego i następuję sprawdzenie czy zostały one poprawnie wprowadzone do flasha.

Funkcja odczytująca dane prezentuje się następująco:

1. uint8_t QSPI_Flash_Read_Block_Byte(uint32_t startAddr, uint32_t size, uint8_t* dataBuffer)
2. {
3.   QSPI_CommandTypeDef command;
5.   if(startAddr>=N25Q128A_FLASH_SIZE)        { return QSPI_ERROR; }
6.   if((startAddr+size)>=N25Q128A_FLASH_SIZE) { return QSPI_ERROR; }
7.   if(size==0)                               { return QSPI_ERROR; }
9.   // Initialize the read command
10.   command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
11.   command.Instruction       = QUAD_INOUT_FAST_READ_CMD;
12.   command.AddressMode       = QSPI_ADDRESS_4_LINES;
13.   command.AddressSize       = QSPI_ADDRESS_24_BITS;
14.   command.Address           = startAddr;
15.   command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
16.   command.DataMode          = QSPI_DATA_4_LINES;
17.   command.DummyCycles       = N25Q128A_DUMMY_CYCLES_READ_QUAD;
18.   command.NbData            = size;
19.   command.DdrMode           = QSPI_DDR_MODE_DISABLE;
20.   command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
21.   command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
23.   // Configure the command
24.   if(HAL_QSPI_Command(&hqspi, &command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
25.       return QSPI_ERROR;
26.   }
28.   // Reception of the data
29.   if(HAL_QSPI_Receive(&hqspi, dataBuffer, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK){
30.       return QSPI_ERROR;
31.   }
33.   return QSPI_OK;
34. }

Podobnie jak podstawowa funkcja zapisu ona odczyta podaną ilość danych i zapisze ją w buforze.

Wyłączenie QSPI wygląda następująco:

1. __weak void BSP_QSPI_MspDeInit(QSPI_HandleTypeDef *hqspi)
2. {
3.   /* Disable the NVIC for QSPI */
4.   HAL_NVIC_DisableIRQ(QUADSPI_IRQn);
6.   /* Disable peripherals and GPIO Clocks */
7.   HAL_GPIO_DeInit(QSPI_CS_GPIO_PORT, QSPI_CS_PIN);
8.   HAL_GPIO_DeInit(QSPI_CLK_GPIO_PORT, QSPI_CLK_PIN);
9.   HAL_GPIO_DeInit(QSPI_D0_GPIO_PORT, QSPI_D0_PIN);
10.   HAL_GPIO_DeInit(QSPI_D1_GPIO_PORT, QSPI_D1_PIN);
11.   HAL_GPIO_DeInit(QSPI_D2_GPIO_PORT, QSPI_D2_PIN);
12.   HAL_GPIO_DeInit(QSPI_D3_GPIO_PORT, QSPI_D3_PIN);
14.   /* Reset peripherals */
15.   __HAL_RCC_QSPI_FORCE_RESET();
16.   __HAL_RCC_QSPI_RELEASE_RESET();
18.   /* Disable the QuadSPI memory interface clock */
19.   __HAL_RCC_QSPI_CLK_DISABLE();
20. }

W funkcji wyłączane są przerwania, poszczególne piny są zwalniane po czym QSPI jest resetowany i następuje wyłączenie zegarów.

Jeśli pamięć jest czyszczona za pomocą zdefiniowanych komend to dane znajdujące się w komórkach mają wartość 0xFF.

Pozostałe funkcje zdefiniowane w bibliotece są funkcjami statycznymi (poza QSPI_DummyCyclesCfg oraz QSPI_ResetMemory), służą one do ustawienia parametrów pracy, resetu bądź czekania na odpowiedź.

Przykładowa pętla główna programu:

1. int main(void)
2. {
3.   /* USER CODE BEGIN 1 */
4.   char usartBuffer[50] = {0};
5.   uint8_t dataWrite4[0x100] = {0x34};
6.   uint8_t dataRead4[0x100] = {0x00};
8.   /* USER CODE END 1 */
10.   /* MPU Configuration----------------------------------------------------------*/
11.   MPU_Config();
13.   /* Enable I-Cache-------------------------------------------------------------*/
14.   SCB_EnableICache();
16.   /* Enable D-Cache-------------------------------------------------------------*/
17.   SCB_EnableDCache();
19.   /* MCU Configuration----------------------------------------------------------*/
21.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
22.   HAL_Init();
24.   /* Configure the system clock */
25.   SystemClock_Config();
27.   /* Initialize all configured peripherals */
28.   MX_GPIO_Init();
29.   MX_RTC_Init();
30.   MX_USART1_UART_Init();
32.   //MX_QUADSPI_Init();
33.   //if(QSPI_ResetMemory(&hqspi) != QSPI_OK)     {   return QSPI_NOT_SUPPORTED;  }
34.   // if(QSPI_DummyCyclesCfg(&hqspi) != QSPI_OK) {   return QSPI_NOT_SUPPORTED;  }
35.   //WRITE_REG(QUADSPI->LPTR, 0xFFF);
37.   /* USER CODE BEGIN 2 */
38.   GPIO_LED_INIT();
40.   /* Initial quadSpi */
41.   QSPI_Flash_Init();
42.   WRITE_REG(QUADSPI->LPTR, 0xFFF);
44.   for(uint32_t i = 0; i<6; i++)
45.   {
46.       QSPI_Flash_Erase_SubSector(i);
47.   }
49.   for(uint32_t i = 0; i<40; i++)
50.   {
51.       QSPI_Flash_Write_Page(i*0x1000, dataWrite4);
53.       QSPI_Flash_Read_Block_Byte(i*0x1000, 0x100, dataRead4);
55.       if(memcmp(dataWrite4,dataRead4,0x100) == 0 ){
56.           sprintf(usartBuffer,"OK OK OK OK\r\n");
57.           HAL_UART_Transmit(&huart1, (uint8_t*)usartBuffer,strlen(usartBuffer),0x1000);
58.       }
59.       else{
60.           sprintf(usartBuffer,"Error Error Error!!!\r\n");
61.           HAL_UART_Transmit(&huart1, (uint8_t*)usartBuffer,strlen(usartBuffer),0x1000);
62.       }
63.   }
65.   /* USER CODE END 2 */
67.   /* Infinite loop */
68.   /* USER CODE BEGIN WHILE */
69.   while (1)
70.   {
71.   /* USER CODE END WHILE */
73.   /* USER CODE BEGIN 3 */
74.         LED_HIGH(LED_PORT, LED_PIN);
75.         HAL_Delay(1000);
76.         LED_LOW(LED_PORT, LED_PIN);
77.         HAL_Delay(1000);
78.   }
79.   /* USER CODE END 3 */
81. }

Pliki z projektem można znaleźć na dysku Google pod tym linkiem.