Running code from external flash in qspi mode

[hash002]

Hi,

I've been using a winbond w25q128 external flash for storing bin file for a project and flashing the code from there to my controller. I'm using an stm32l412 as my controller. I've been through many tutorials for developing external loader files, but all of them are specifically for h7. I managed to create an external loader, but when I use cube programmer to upload the bin file, sector erase and chip erase are shown not working, Is this something related to the stldr file I have generated? By the way I'm using qspi and I am able to send and read data from external flash through qspi, but I havent been able to upload bin file.

 

The error generated in cube programmer are: please verify flash memory protection

 

I have referred this site : https://controllerstech.com/w25q-flash-series-part-8-quadspi-external-loader/

 

Thanks

[mƎALLEm]

---

I managed to create an external loader, but when I use cube programmer to upload the bin file, sector erase and chip erase are shown not working,

---

CubeProgrammer flashers are used for a specific ST Boards. So if you are using a custom board you need to adapt the loader to your HW: GPIOs, Memory configs, timings etc ..

[hash002]

I have created a custom loader, but the thing is the programmer is generating the said error. And I don't see any write protection enabled in the external flash.

[hash002]

 

 

/* Entry Point */
ENTRY(Init)

/* Generate 2 segment for Loader code and device info */
PHDRS {Loader PT_LOAD ; SgInfo PT_LOAD ; }

/* Highest address of the user mode stack */
_estack = ORIGIN(RAM_D1) + LENGTH(RAM_D1); /* end of RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200; /* required amount of heap */
_Min_Stack_Size = 0x400; /* required amount of stack */

/* Specify the memory areas */
MEMORY
{
	RAM_D1 (xrw) : ORIGIN = 0x20000000, LENGTH = 40K
}								

/* Define output sections */
SECTIONS
{
 /* The startup code goes first into FLASH */
 .isr_vector :
 {
 	. = . + 0x1FC;
 . = ALIGN(4);
 KEEP(*(.isr_vector)) /* Startup code */
 . = ALIGN(4);
 } >RAM_D1 :Loader

 .ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >RAM_D1
 .ARM : {
 __exidx_start = .;
 *(.ARM.exidx*)
 __exidx_end = .;
 } >RAM_D1 :Loader

 .preinit_array :
 {
 PROVIDE_HIDDEN (__preinit_array_start = .);
 KEEP (*(.preinit_array*))
 PROVIDE_HIDDEN (__preinit_array_end = .);
 } >RAM_D1 :Loader
 
 .init_array :
 {
 PROVIDE_HIDDEN (__init_array_start = .);
 KEEP (*(SORT(.init_array.*)))
 KEEP (*(.init_array*))
 PROVIDE_HIDDEN (__init_array_end = .);
 } >RAM_D1 :Loader
 
 .fini_array :
 {
 PROVIDE_HIDDEN (__fini_array_start = .);
 KEEP (*(SORT(.fini_array.*)))
 KEEP (*(.fini_array*))
 PROVIDE_HIDDEN (__fini_array_end = .);
 } >RAM_D1 :Loader

 /* used by the startup to initialize data */
 _sidata = LOADADDR(.data);

 /* Initialized data sections goes into RAM, load LMA copy after code */
 .data : 
 {
 . = ALIGN(4);
 _sdata = .; /* create a global symbol at data start */
 *(.data) /* .data sections */
 *(.data*) /* .data* sections */

 . = ALIGN(4);
 _edata = .; /* define a global symbol at data end */
 } >RAM_D1 :Loader

 
 /* Uninitialized data section */
 . = ALIGN(4);
 .bss :
 {
 /* This is used by the startup in order to initialize the .bss secion */
 _sbss = .; /* define a global symbol at bss start */
 __bss_start__ = _sbss;
 *(.bss)
 *(.bss*)
 *(COMMON)

 . = ALIGN(4);
 _ebss = .; /* define a global symbol at bss end */
 __bss_end__ = _ebss;
 } >RAM_D1 :Loader

 /* The program code and other data goes into FLASH */
 .text :
 {
 . = ALIGN(4);
 *(.text) /* .text sections (code) */
 *(.text*) /* .text* sections (code) */
 *(.glue_7) /* glue arm to thumb code */
 *(.glue_7t) /* glue thumb to arm code */
 *(.eh_frame)

 KEEP (*(.init))
 KEEP (*(.fini))

 . = ALIGN(4);
 _etext = .; /* define a global symbols at end of code */
 } >RAM_D1 :Loader
 
 .Dev_info :
 {
	KEEP(*Dev_Inf.o ( .rodata* ))
 } :SgInfo
 
 
 /* Constant data goes into FLASH */
 .rodata :
 {
 . = ALIGN(4);
 *(.rodata) /* .rodata sections (constants, strings, etc.) */
 *(.rodata*) /* .rodata* sections (constants, strings, etc.) */
 . = ALIGN(4);
 } >RAM_D1 :Loader
 
 
 /* User_heap_stack section, used to check that there is enough RAM left */
 ._user_heap_stack :
 {
 . = ALIGN(4);
 PROVIDE ( end = . );
 PROVIDE ( _end = . );
 . = . + _Min_Heap_Size;
 . = . + _Min_Stack_Size;
 . = ALIGN(4);
 } >RAM_D1 :Loader

 .ARM.attributes 0 : { *(.ARM.attributes) }
}

 

 

This is the linker I used to create the external loader.