[ABANDONED] Open flash loader is too slow

This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

  • [ABANDONED] Open flash loader is too slow

    Hello! I made an open loader for my custom board based on this instruction wiki.segger.com/Open_Flashloader . And it works correctly, but very slowly. I checked all functions, complete erasure, loadbin command with verify and also J-Flash read range (full 32 Mbytes). My custom board consists of MCU STM32H753XI and QSPI flash s25fl256 (32 Mbytes). In result I have very slow read/verify speed. For example, I try read 2 Mb internal MCU flash and 2 Mb external QSPI:
    Read range 0x08000000 - 0x081FFFFF (MCU flash 2 Mbytes) 8.824 second
    Read range 0x90000000 - 0x901FFFFF (External flash 2 Mbytes) 45.867 second
    Therefore, I think I can increase the read speed of an external flash. For reading and verification I use the built-in MCU memory mapped mode

    C Source Code: FlashOrg.c

    1. //for example verify function
    2. U32 Verify (U32 Addr, U32 NumBytes, U8 *pSrcBuff )
    3. {
    4. U8* pData = (U8 *)Addr;
    6. _FeedWatchdog();
    8. do {
    9. if (*pData++ != *pSrcBuff++) {
    10. return (U32) pData--;
    11. }
    12. } while (--NumBytes);
    14. return (U32) pData;
    15. }
    Display All
    So, I have some questions:
    1. What do you recommend to increase reading speed?
    2. Can I use data cache and instruction cache?
    3. What I can not use in the open flash loader?
    4. Do I need to reset the watchdog?

    Regards, Maxim Hunko

    The post was edited 1 time, last by MaximHunko ().

  • I managed to discover one pattern, the more I set the size of the PageSize field, the faster the reading process is going on. The maximum that I managed to achieve is 16 Kbytes versus 256 bytes. With such settings, the reading results are as follows:
    Read range 0x08000000 - 0x081FFFFF (MCU flash 2 Mbytes) 0.224 second
    Read range 0x90000000 - 0x901FFFFF (External flash 2 Mbytes) 11.975 second
    I am attaching my FlashDevice array

    C Source Code: FlashDev.c

    1. #define ONCHIP (1) // On-chip Flash Memory
    3. #define MAX_NUM_SECTORS (512) // Max. number of sectors, must not be modified.
    4. #define ALGO_VERSION (0x0101) // Algo version, must not be modified.
    6. #define FLASH_BASE_ADDR (0x90000000)
    8. #define READ_WRITE_BYTES (16 * 1024)
    9. #define PROGRAM_PAGE_TIMEOUT_MS (S25FL256_TIMEOUT_PAGE_WRITE_MAX_MS * 100)
    10. #define ERASE_SECTOR_TIMEOUT_MS (S25FL256_TIMEOUT_SECTOR_ERASE_MAX_MS * 10)
    12. struct FlashDevice const FlashDevice __attribute__ ((section ("DevDscr"))) = {
    13. ALGO_VERSION, // Algo version
    14. "S25FL256S_32H753XI", // Flash device name
    15. ONCHIP, // Flash device type
    16. FLASH_BASE_ADDR, // Flash base address
    17. EXT_FLASH_SIZE, // Total flash device size in Bytes (32 Mbyte)
    18. READ_WRITE_BYTES, // Page Size (number of bytes that will be passed to ProgramPage().
    19. 0, // Reserved, should be 0
    20. 0xFF, // Flash erased value
    21. PROGRAM_PAGE_TIMEOUT_MS, // Program page timeout in ms
    22. ERASE_SECTOR_TIMEOUT_MS, // Erase sector timeout in ms
    23. //
    24. // Flash sector layout definition
    25. //
    26. {
    27. { EXT_FLASH_SECTOR_SIZE, 0x00000000 },
    28. { 0xFFFFFFFF, 0xFFFFFFFF }
    29. }
    30. };
    Display All

  • Today I noticed another detail. When I start erasing in J-Flash, I see in the log that when erasing the internal memory, the CPU is running at 185 MHz. And when the external memory is erased, the log says: CPU speed could not be measured.
    What does that mean? What am I doing wrong initialization? Here is the code of my function init.

    C Source Code: FlashPrg.c

    1. int Init(U32 Addr, U32 Freq, U32 Func)
    2. {
    3. U32 v;
    4. (void)Addr;
    5. (void)Freq;
    6. (void)Func;
    8. driverInit(); //init gpio and qspi
    9. int result = ExtFlash_Init() ? 0 : 1; //try read jdec id and ret 0 if success
    11. if (Func == 3) { //if read operation -> turn on qspi memory mapped mode
    12. ExtFlash_SetMemoryMappedMode();
    13. }
    15. return result;
    16. }
    Display All
    As you can see, I ignore the Freq parameter. Do I have to manually configure PLL in the Init function?
    Images

    • 2.jpg

      74.25 kB, 383×478, viewed 423 times

  • Hello all! In the process of studying the architecture of the flash loader, I discovered the fact that there is no exact description of how reading works: wiki.segger.com/Open_Flashloader#Flash_Read_Procedure
    Dear forum participants, if you are interested in this topic, please write here, what do you think about this. Maybe we can study this issue together faster!
    Now I have managed to achieve the following results:
    • Full chip erase 69 second
    • Full chip blank check 5.5 second
    • Read full memory (after erasing) 5.5 second
    • Program full memory 174 seconds
    • Read full memory (random data) 146 seconds


    The results show that reading blanked memory is much faster than reading memory with random data. Therefore, I think that the j-link first tries to check whether the page is erased (using function BlankCheck(addr, SECTORSIZE, 0xFF) ), and if it is not erased, goes to direct reading, using function SEGGER_OPEN_Read(addr, size, pData)
    Anyone have any ideas on how to increase read speed? Thanks
    Images

    • result.jpg

      96.94 kB, 539×724, viewed 438 times

  • Hi MaximHunko,

    Glad to meet you here, and I'm working on this open flash loader too for our products.
    I saw you've done a lot on the open flash loader.
    If you don't mind, could you share some insensitive source code with me please?
    For the external nor flash with JLink, often some unexpected programming or verifying error comes up.
    To fix it, we only could erase the whole external nor flash, and do the programming again.

    Also, some last bytes in the external nor flash cannot be read out from the STM32 errata.

    Thank you.

  • hi Maxim,

    Thank you for you kind.

    And one more question, have you ever encounter the issue that STM32L4R9 OSPI memory-map read the whole exernal NorFlash, like whole 16MB,
    errors will come up for the last few bytes, like 0x90FFFFFA to 0x90FFFFFF, memory-map read will cause excetpion.

    so a workaround, when the memory-map flash pointer points to an address that is larger than 0x90FFFFFA, I will cancel the read, with __DSB(), and OSPI abort API.

    and then reconfigure the OSPI controller. but for this, a weird issue comes as below,
    when in Segger embedded studio debugger mode, it works fine to memory-map read the higher address flash part, including the last few bytes at the end of flash memory,
    but when flash loader is built as Release version, and put it into STM32L4 folder in JLink install dir, and then run JFlash to read whole external flash chip, it seems, the last few bytes read out are not the bytes as expected.

    if you don't mind, could you do me a favour send source code to me programassem@hotmail.com.

    Thank you so much.

    Shawn

  • I came across a similar problem when I read the full 32 megabytes, the last byte was 0 instead of the correct value. But there was no exception. Later I did this:

    #define SUPPORT_SEGGER_OPEN_READ (1)
    #define SUPPORT_NATIVE_READ_FUNCTION (0)

    In order for the segger software to understand that the data can be read directly in the memory mapped mode, and of course, in Init function, for read, I call ExtFlash_SetMemoryMappedMode();
    It works good for me.
    Here is my FlashPrg.c file:

    C Source Code: FlashPrg.c

    1. /*********************************************************************
    2. * (c) 1995 - 2018 SEGGER Microcontroller GmbH *
    3. * The Embedded Experts *
    4. * www.segger.com *
    5. **********************************************************************
    6. ----------------------------------------------------------------------
    7. File : FlashPrg.c
    8. Purpose : Implementation of RAMCode for ST STM32H753XI/BI
    9. -------- END-OF-HEADER ---------------------------------------------
    10. */
    11. #include <stdint.h>
    12. #include <stddef.h>
    13. #include <stdbool.h>
    14. #include "FlashOS.H"
    15. #include "s25fl256.h"
    16. #include "Driver.h"
    18. #define SUPPORT_BLANK_CHECK (0) // No separate blank check is required as the flash
    19. // is memory mapped readable
    20. #define SUPPORT_SEGGER_OPEN_READ (1)
    21. #define SUPPORT_SEGGER_OPEN_Program (1)
    22. #define SUPPORT_SEGGER_OPEN_ERASE (1)
    23. #define SUPPORT_NATIVE_READ_FUNCTION (0)
    24. #define SUPPORT_WATCHDOG_RESET (0)
    26. #if SUPPORT_WATCHDOG_RESET
    27. void _FeedWatchdog(void)
    28. {
    29. driverFeedWatchdog();
    30. }
    31. #else
    32. #define _FeedWatchdog() *(volatile U32*)(0x4) // Dummy to make sure that function is linked non-inlined
    33. #endif
    35. /*********************************************************************
    36. *
    37. * Types
    38. *
    39. **********************************************************************
    40. */
    42. typedef struct {
    43. U32 acr;
    44. } RESTORE_INFO;
    46. typedef union {
    47. struct {
    48. void* pSrc;
    49. void* pDest;
    50. U32 NumHWords;
    51. U32 WritePara0;
    52. U32 WritePara1;
    53. U32 WritePara2;
    54. } In;
    56. struct {
    57. void* FailAddr;
    58. } Out;
    59. } IO_PARA;
    61. /*********************************************************************
    62. *
    63. * Static code
    64. *
    65. **********************************************************************
    66. */
    68. const U32 SEGGER_OPEN_FLASHLOADER_FLAGS = 0xFEED;
    69. static RESTORE_INFO _pRestoreInfo;
    70. static U32 gFunc = 0;
    72. /*********************************************************************
    73. *
    74. * Public code
    75. *
    76. **********************************************************************
    77. */
    79. /*********************************************************************
    80. *
    81. * Init
    82. *
    83. * Function description
    84. * Handles the initialization of the flash module.
    85. *
    86. * Parameters
    87. * Addr: Flash base address
    88. * Freq: Clock frequency in Hz
    89. * Func: Specifies the action followed by Init() (e.g.: 1 - Erase, 2 - Program, 3 - Verify / Read)
    90. *
    91. * Return value
    92. * 0 O.K.
    93. * 1 Error
    94. */
    95. int Init(U32 Addr, U32 Freq, U32 Func)
    96. {
    97. (void)Addr;
    98. (void)Freq;
    99. _FeedWatchdog();
    101. gFunc = Func;
    103. mcuFreqInit();
    104. driverInit();
    105. int result = ExtFlash_Init() ? 0 : 1;
    107. if (Func != INIT_FOR_WRITE && Func != INIT_FOR_ERASE) {
    108. _FeedWatchdog();
    109. ExtFlash_SetMemoryMappedMode();
    110. }
    112. return result;
    113. }
    115. /*********************************************************************
    116. *
    117. * UnInit
    118. *
    119. * Function description
    120. * Handles the de-initialization of the flash module.
    121. *
    122. * Parameters
    123. * Func: Caller type (e.g.: 1 - Erase, 2 - Program, 3 - Verify)
    124. *
    125. * Return value
    126. * 0 O.K.
    127. * 1 Error
    128. */
    129. int UnInit(U32 Func)
    130. {
    131. (void)Func;
    133. _FeedWatchdog();
    135. driverDeinit();
    136. mcuFreqDeinit();
    138. return 0;
    139. }
    141. /*********************************************************************
    142. * Function description
    143. *
    144. * Compares a specified number of bytes of a provided data buffer with
    145. * the content of the device
    146. * Parameters
    147. *
    148. * Addr: Start address in memory which should be compared
    149. * NumBytes: Number of bytes to be compared
    150. * pBuff: Pointer to the data to be compared
    151. * Return values
    152. *
    153. * == (Addr + NumBytes): O.K.
    154. * != (Addr + NumBytes): *not* O.K.
    155. * (ideally the fail address is returned)
    156. */
    157. U32 Verify (U32 Addr, U32 NumBytes, U8 *pSrcBuff )
    158. {
    159. U8* pData = (U8 *)Addr;
    161. _FeedWatchdog();
    163. do {
    164. if (*pData++ != *pSrcBuff++) {
    165. return (U32) --pData;
    166. }
    167. } while (--NumBytes);
    169. return (U32) pData;
    170. }
    171. /*********************************************************************
    172. *
    173. * EraseSector
    174. *
    175. * Function description
    176. * Erases one flash sector.
    177. *
    178. * Parameters
    179. * SectorAddr: Absolute address of the sector to be erased
    180. *
    181. * Return value
    182. * 0 O.K.
    183. * 1 Error
    184. */
    185. int EraseSector(U32 SectorAddr)
    186. {
    187. _FeedWatchdog();
    189. ExtFlash_EraseSector(SectorAddr - FLASH_BASE_ADDR);
    191. return 0;
    192. }
    194. #if 1 // We do not support EraseChip() as it is much slower than erase the flash sector by sector
    195. /*********************************************************************
    196. *
    197. * EraseChip
    198. *
    199. * Function description
    200. * Erases the entire flash
    201. *
    202. * Return value
    203. * 0 O.K.
    204. * 1 Error
    205. */
    206. int EraseChip(void)
    207. {
    208. _FeedWatchdog();
    210. ExtFlash_EraseChip();
    212. return 0;
    213. }
    214. #endif
    216. /*********************************************************************
    217. *
    218. * ProgramPage
    219. *
    220. * Function description
    221. * Programs one flash page.
    222. *
    223. * Parameters
    224. * DestAddr: Destination address
    225. * NumBytes: Number of bytes to be programmed (always a multiple of program page size, defined in FlashDev.c)
    226. * pSrcBuff: Point to the source buffer
    227. *
    228. * Return value
    229. * 0 O.K.
    230. * 1 Error
    231. */
    232. int ProgramPage(U32 DestAddr, U32 NumBytes, U8 *pSrcBuff)
    233. {
    234. _FeedWatchdog();
    236. ExtFlash_Write(DestAddr - FLASH_BASE_ADDR, pSrcBuff, NumBytes);
    238. return 0;
    239. }
    241. /*********************************************************************
    242. *
    243. * BlankCheck
    244. *
    245. * Function description
    246. * Checks if a memory region is blank
    247. *
    248. * Parameters
    249. * Addr: Blank check start address
    250. * NumBytes: Number of bytes to be checked
    251. * BlankData: Pointer to the destination data
    252. *
    253. * Return value
    254. * 0: O.K., blank
    255. * 1: O.K., *not* blank
    256. * < 0: Error
    257. *
    258. */
    259. #if SUPPORT_BLANK_CHECK
    260. int BlankCheck(U32 Addr, U32 NumBytes, U8 BlankData)
    261. {
    262. int result = 0;
    263. U8* pData = (U8 *)Addr;
    264. U32 bytesToCheck = NumBytes;
    265. _FeedWatchdog();
    267. if (gFunc != INIT_FOR_READ) {
    268. ExtFlash_SetMemoryMappedMode();
    269. }
    271. do {
    272. if (pData[0] != BlankData) {
    273. result = 1;
    274. break;
    275. }
    277. pData++;
    278. } while (--bytesToCheck);
    280. if (gFunc != INIT_FOR_READ) {
    281. driverDeinit();
    282. driverInit();
    283. ExtFlash_Init();
    284. }
    286. return result;
    287. }
    288. #endif
    290. /*********************************************************************
    291. *
    292. * SEGGER_OPEN_Read
    293. *
    294. * Function description
    295. * Reads a specified number of bytes into the provided buffer
    296. *
    297. * Parameters
    298. * Addr: Start read address
    299. * NumBytes: Number of bytes to be read
    300. * pBuff: Pointer to the destination data
    301. *
    302. * Return value
    303. * >= 0: O.K., NumBytes read
    304. * < 0: Error
    305. *
    306. */
    307. #if SUPPORT_NATIVE_READ_FUNCTION
    308. int SEGGER_OPEN_Read(U32 Addr, U32 NumBytes, U8 *pDestBuff)
    309. {
    310. U8* pData;
    312. pData = (U8 *)Addr;
    313. _FeedWatchdog();
    315. for (int32_t i = 0; i < NumBytes; i++) {
    316. pDestBuff[i] = pData[i];
    317. }
    319. return NumBytes;
    320. }
    321. #endif
    323. /*********************************************************************
    324. *
    325. * SEGGER_OPEN_Program
    326. *
    327. * Function description
    328. * Programs a specified number of bytes into the target flash.
    329. * NumBytes is either FlashDevice.PageSize or a multiple of it.
    330. *
    331. * Notes
    332. * (1) This function can rely on that at least FlashDevice.PageSize will be passed
    333. * (2) This function must be able to handle multiple of FlashDevice.PageSize
    334. *
    335. * Parameters
    336. * Addr: Start read address
    337. * NumBytes: Number of bytes to be read
    338. * pBuff: Pointer to the destination data
    339. *
    340. * Return value
    341. * 0 O.K.
    342. * 1 Error
    343. *
    344. */
    345. #if SUPPORT_SEGGER_OPEN_Program
    346. int SEGGER_OPEN_Program(U32 DestAddr, U32 NumBytes, U8 *pSrcBuff)
    347. {
    348. _FeedWatchdog();
    350. ExtFlash_Write(DestAddr - FLASH_BASE_ADDR, pSrcBuff, NumBytes);
    352. return 0;
    353. }
    354. #endif
    356. /*********************************************************************
    357. *
    358. * SEGGER_OPEN_Erase
    359. *
    360. * Function description
    361. * Erases one or more flash sectors
    362. *
    363. * Notes
    364. * (1) This function can rely on that at least one sector will be passed
    365. * (2) This function must be able to handle multiple sectors at once
    366. * (3) This function can rely on that if sector size changes,
    367. *
    368. * Parameters
    369. * SectorAddr: Address of the start sector to be erased
    370. * SectorIndex: Index of the start sector to be erased
    371. * NumSectors: Number of sectors to be erased. At least 1 sector is passed.
    372. *
    373. * Return value
    374. * 0 O.K.
    375. * 1 Error
    376. *
    377. */
    378. #if SUPPORT_SEGGER_OPEN_ERASE
    379. int SEGGER_OPEN_Erase(U32 SectorAddr, U32 SectorIndex, U32 NumSectors)
    380. {
    381. uint32_t sectorCount = NumSectors;
    382. uint32_t realAddress = SectorAddr - FLASH_BASE_ADDR;
    383. _FeedWatchdog();
    385. do {
    386. ExtFlash_EraseSector(realAddress);
    388. realAddress += EXT_FLASH_SECTOR_SIZE;
    389. } while (sectorCount--);
    391. return 0;
    392. }
    393. #endif
    Display All

  • Hi maxim,

    A few questions here

    1. if memory-map read is supported, is it necessary to implement verify()?
    2. in your init() memorymap mode maybe enabled, but I don't find you do the memorymap mode disabling in Uninit()
    should the enable and disable be present in pair, right?

    3. you have
    #define SUPPORT_SEGGER_OPEN_READ (1)

    but the following code appears

    #if SUPPORT_NATIVE_READ_FUNCTION
    int SEGGER_OPEN_Read(U32 Addr, U32 NumBytes, U8 *pDestBuff)

    is it a typo?


    for the problem we both encounter, you mean by defining SUPPORT_SEGGER_OPEN_READ with 1, and implement SEGGER_OPEN_Read(), which would be enough to go across that read last few bytes exception problem, right?

    One more quesiton in Init() and Uninit() code, so I guess, if we first do a read, ExtFlash_SetMemoryMappedMode() is called to enable memory-map read. and after read, we do a program, do you think, at this moment, previous memory-map enabling will take some effect on this program op?

    1. int Init(U32 Addr, U32 Freq, U32 Func)
    2. {
    3. (void)Addr;
    4. (void)Freq;
    5. _FeedWatchdog();
    6. gFunc = Func;
    7. mcuFreqInit();
    8. driverInit();
    9. int result = ExtFlash_Init() ? 0 : 1;
    10. if (Func != INIT_FOR_WRITE && Func != INIT_FOR_ERASE) {
    11. _FeedWatchdog();
    12. ExtFlash_SetMemoryMappedMode();
    13. }
    14. return result;
    15. }
    16. int UnInit(U32 Func)
    17. {
    18. (void)Func;
    19. _FeedWatchdog();
    20. driverDeinit();
    21. mcuFreqDeinit();
    22. return 0;
    23. }

  • let's go a litter futher, I'm not sure if you've read below in STM32 reference manual.

    /******************************************************************************************************
    RM0432

    19.4.6 OCTOSPI busy bit and abort functionality
    • Once the OCTOSPI starts an operation with the external device,
    the BUSY bit is automatically set in the OCTOSPI_SR.
    • In indirect mode, the BUSY bit is reset once the OCTOSPI has completed the requested
    command sequence and the FIFO is empty.
    • In automatic-polling mode, BUSY goes low only after the last periodic access is complete,
    due to a match when APMS=1, or due to an abort.
    • After the first access in memory-mapped mode, BUSY goes low only on a timeout event or
    on an abort.
    • Any operation can be aborted by setting the ABORT bit in the OCTOSPI_CR.
    Once the abort is completed, the BUSY bit and the ABORT bit are automatically reset,
    and the FIFO is flushed.
    • Before setting the ABORT bit, the software must ensure that all the current transactions are
    finished using the synchronization barriers.
    Note that some devices might misbehave if a write operation to a status registers is aborted.
    19.4.7 OCTOSPI reconfiguration or deactivation
    Prior to any OCTOSPI reconfiguration, the software must ensure that all the transactions
    are completed:
    • After a memory-mapped write, the software shall perform a dummy read followed by a
    synchronization barrier then an ABORT.
    • After a memory-mapped read, the software shall do a synchronization barrier then an
    abort.

    *******************************************************************************************************/

    for a complete switch from memory-map OSPI to indirect mode OSPI to read the last few bytes in the external NorFlash,

    some codes according to forementioned RM's description need to be implemented, have you done that already?

    I will try the OPEN read implement, and comment NATIVE READ, actually the code block should be the same, only the function names are different.
    Some segger open flash loader infos are not known to us, what we only can do is to implement and see if it works or not.