src/link/stm32_flash_h743_2m.ld

   1 /*
   2 *****************************************************************************
   3 **
   4 **  File        : stm32_flash_h7x3_2m.ld
   5 **
   6 **  Abstract    : Linker script for STM32H743xI Device with
   7 **                512K AXI-RAM mapped onto AXI bus on D1 domain
   8 **                128K SRAM1 mapped on D2 domain
   9 **                128K SRAM2 mapped on D2 domain
  10 **                 32K SRAM3 mapped on D2 domain
  11 **                 64K SRAM4 mapped on D3 domain
  12 **                 64K ITCM
  13 **                128K DTCM
  14 **
  15 *****************************************************************************
  16 */
  17
  18 /* Entry Point */
  19 ENTRY(Reset_Handler)
  20
  21 /*
  22 0x00000000 to 0x0000FFFF   64K ITCM
  23 0x20000000 to 0x2001FFFF  128K DTCM
  24 0x24000000 to 0x2407FFFF  512K AXI SRAM, D1 domain, main RAM
  25 0x30000000 to 0x3001FFFF  128K SRAM1, D2 domain
  26 0x30020000 to 0x3003FFFF  128K SRAM2, D2 domain
  27 0x30040000 to 0x30047FFF   32K SRAM3, D2 domain, unused
  28 0x38000000 to 0x3800FFFF   64K SRAM4, D3 domain, unused
  29 0x38800000 to 0x38800FFF    4K BACKUP SRAM, Backup domain, unused
  30
  31 0x08000000 to 0x081FFFFF 2048K full flash,
  32 0x08000000 to 0x0801FFFF  128K isr vector, startup code,
  33 0x08020000 to 0x0803FFFF  128K config,                  // FLASH_Sector_1
  34 0x08040000 to 0x081FFFFF 1792K firmware,
  35 */
  36
  37 /* Specify the memory areas */
  38 MEMORY
  39 {
  40     FLASH (rx)        : ORIGIN = 0x08000000, LENGTH = 10K
  41     FLASH_CUSTOM_DEFAULTS (r) : ORIGIN = 0x08002800, LENGTH = 10K
  42     FLASH_UNUSED (r)     : ORIGIN = 0x08005000, LENGTH = 108K
  43
  44     FLASH_CONFIG (r)  : ORIGIN = 0x08020000, LENGTH = 128K
  45     FLASH1 (rx)       : ORIGIN = 0x08040000, LENGTH = DEFINED(USE_CUSTOM_DEFAULTS_EXTENDED) ? 1664K : 1792K
  46     FLASH_CUSTOM_DEFAULTS_EXTENDED (r): ORIGIN = DEFINED(USE_CUSTOM_DEFAULTS_EXTENDED) ? 0x081E0000 : 0x08200000, LENGTH = DEFINED(USE_CUSTOM_DEFAULTS_EXTENDED) ? 128K : 0K
  47
  48     ITCM_RAM (rwx)    : ORIGIN = 0x00000000, LENGTH = 64K
  49     DTCM_RAM (rwx)    : ORIGIN = 0x20000000, LENGTH = 128K
  50     RAM (rwx)         : ORIGIN = 0x24000000, LENGTH = 512K
  51
  52     D2_RAM (rwx)      : ORIGIN = 0x30000000, LENGTH = 256K /* SRAM1 + SRAM2 */
  53
  54     MEMORY_B1 (rx)    : ORIGIN = 0x60000000, LENGTH = 0K
  55 }
  56
  57 REGION_ALIAS("STACKRAM", DTCM_RAM)
  58 REGION_ALIAS("FASTRAM", DTCM_RAM)
  59
  60 /* Entry Point */
  61 ENTRY(Reset_Handler)
  62
  63 /* Highest address of the user mode stack */
  64 _estack = ORIGIN(STACKRAM) + LENGTH(STACKRAM) - 8; /* Reserve 2 x 4bytes for info across reset */
  65
  66 /* Base address where the config is stored. */
  67 __config_start = ORIGIN(FLASH_CONFIG);
  68 __config_end = ORIGIN(FLASH_CONFIG) + LENGTH(FLASH_CONFIG);
  69
  70 /* Generate a link error if heap and stack don't fit into RAM */
  71 _Min_Heap_Size = 0;      /* required amount of heap  */
  72 _Min_Stack_Size = 0x800; /* required amount of stack */
  73
  74 /* Define output sections */
  75 SECTIONS
  76 {
  77   /* The startup code goes first into FLASH */
  78   .isr_vector :
  79   {
  80     . = ALIGN(512);
  81     PROVIDE (isr_vector_table_base = .);
  82     KEEP(*(.isr_vector)) /* Startup code */
  83     . = ALIGN(4);
  84   } >FLASH
  85
  86   /* The program code and other data goes into FLASH */
  87   .text :
  88   {
  89     . = ALIGN(4);
  90     *(.text)           /* .text sections (code) */
  91     *(.text*)          /* .text* sections (code) */
  92     *(.rodata)         /* .rodata sections (constants, strings, etc.) */
  93     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
  94     *(.glue_7)         /* glue arm to thumb code */
  95     *(.glue_7t)        /* glue thumb to arm code */
  96     *(.eh_frame)
  97
  98     KEEP (*(.init))
  99     KEEP (*(.fini))
 100
 101     . = ALIGN(4);
 102     _etext = .;        /* define a global symbols at end of code */
 103   } >FLASH1
 104
 105   /* Critical program code goes into ITCM RAM */
 106   /* Copy specific fast-executing code to ITCM RAM */
 107   tcm_code = LOADADDR(.tcm_code);
 108   .tcm_code :
 109   {
 110     . = ALIGN(4);
 111     tcm_code_start = .;
 112     *(.tcm_code)
 113     *(.tcm_code*)
 114     . = ALIGN(4);
 115     tcm_code_end = .;
 116   } >ITCM_RAM AT >FLASH1
 117
 118   .ARM.extab   :
 119   {
 120     *(.ARM.extab* .gnu.linkonce.armextab.*)
 121   } >FLASH1
 122
 123   .ARM :
 124   {
 125     __exidx_start = .;
 126     *(.ARM.exidx*) __exidx_end = .;
 127   } >FLASH1
 128
 129   .pg_registry :
 130   {
 131     PROVIDE_HIDDEN (__pg_registry_start = .);
 132     KEEP (*(.pg_registry))
 133     KEEP (*(SORT(.pg_registry.*)))
 134     PROVIDE_HIDDEN (__pg_registry_end = .);
 135   } >FLASH1
 136
 137   .pg_resetdata :
 138   {
 139     PROVIDE_HIDDEN (__pg_resetdata_start = .);
 140     KEEP (*(.pg_resetdata))
 141     PROVIDE_HIDDEN (__pg_resetdata_end = .);
 142   } >FLASH1
 143
 144   /* Storage for the address for the configuration section so we can grab it out of the hex file */
 145   .custom_defaults :
 146   {
 147     . = ALIGN(4);
 148     KEEP (*(.custom_defaults_start_address))
 149     . = ALIGN(4);
 150     KEEP (*(.custom_defaults_end_address))
 151     . = ALIGN(4);
 152     __custom_defaults_internal_start = .;
 153     *(.custom_defaults);
 154   } >FLASH_CUSTOM_DEFAULTS
 155
 156   PROVIDE_HIDDEN (__custom_defaults_start = DEFINED(USE_CUSTOM_DEFAULTS_EXTENDED) ? ORIGIN(FLASH_CUSTOM_DEFAULTS_EXTENDED) : __custom_defaults_internal_start);
 157   PROVIDE_HIDDEN (__custom_defaults_end = DEFINED(USE_CUSTOM_DEFAULTS_EXTENDED) ? ORIGIN(FLASH_CUSTOM_DEFAULTS_EXTENDED) + LENGTH(FLASH_CUSTOM_DEFAULTS_EXTENDED) : ORIGIN(FLASH_CUSTOM_DEFAULTS) + LENGTH(FLASH_CUSTOM_DEFAULTS));
 158
 159   /* used by the startup to initialize data */
 160   _sidata = LOADADDR(.data);
 161
 162   /* Initialized data sections goes into RAM, load LMA copy after code */
 163   .data :
 164   {
 165     . = ALIGN(4);
 166     _sdata = .;        /* create a global symbol at data start */
 167     *(.data)           /* .data sections */
 168     *(.data*)          /* .data* sections */
 169
 170     . = ALIGN(4);
 171     _edata = .;        /* define a global symbol at data end */
 172   } >RAM AT >FLASH1
 173
 174   /* Uninitialized data section */
 175   . = ALIGN(4);
 176   .bss (NOLOAD) :
 177   {
 178     /* This is used by the startup in order to initialize the .bss secion */
 179     _sbss = .;         /* define a global symbol at bss start */
 180     __bss_start__ = _sbss;
 181     *(.bss)
 182     *(SORT_BY_ALIGNMENT(.bss*))
 183     *(COMMON)
 184
 185     . = ALIGN(4);
 186     _ebss = .;         /* define a global symbol at bss end */
 187     __bss_end__ = _ebss;
 188   } >RAM
 189
 190   /* Uninitialized data section */
 191   . = ALIGN(4);
 192   .sram2 (NOLOAD) :
 193   {
 194     /* This is used by the startup in order to initialize the .sram2 secion */
 195     _ssram2 = .;         /* define a global symbol at sram2 start */
 196     __sram2_start__ = _ssram2;
 197     *(.sram2)
 198     *(SORT_BY_ALIGNMENT(.sram2*))
 199
 200     . = ALIGN(4);
 201     _esram2 = .;         /* define a global symbol at sram2 end */
 202     __sram2_end__ = _esram2;
 203   } >RAM
 204
 205   /* used during startup to initialized fastram_data */
 206   _sfastram_idata = LOADADDR(.fastram_data);
 207
 208   /* Initialized FAST_DATA section for unsuspecting developers */
 209   .fastram_data :
 210   {
 211     . = ALIGN(4);
 212     _sfastram_data = .;        /* create a global symbol at data start */
 213     *(.fastram_data)           /* .data sections */
 214     *(.fastram_data*)          /* .data* sections */
 215
 216     . = ALIGN(4);
 217     _efastram_data = .;        /* define a global symbol at data end */
 218   } >FASTRAM AT >FLASH1
 219
 220   . = ALIGN(4);
 221   .fastram_bss (NOLOAD) :
 222   {
 223     _sfastram_bss = .;
 224     __fastram_bss_start__ = _sfastram_bss;
 225     *(.fastram_bss)
 226     *(SORT_BY_ALIGNMENT(.fastram_bss*))
 227
 228     . = ALIGN(4);
 229     _efastram_bss = .;
 230     __fastram_bss_end__ = _efastram_bss;
 231   } >FASTRAM
 232
 233   /* used during startup to initialized dmaram_data */
 234   _sdmaram_idata = LOADADDR(.dmaram_data);
 235
 236   . = ALIGN(32);
 237   .dmaram_data :
 238   {
 239     PROVIDE(dmaram_start = .);
 240     _sdmaram = .;
 241     _dmaram_start__ = _sdmaram;
 242     _sdmaram_data = .;        /* create a global symbol at data start */
 243     *(.dmaram_data)           /* .data sections */
 244     *(.dmaram_data*)          /* .data* sections */
 245     . = ALIGN(32);
 246     _edmaram_data = .;        /* define a global symbol at data end */
 247   } >RAM AT >FLASH1
 248
 249   . = ALIGN(32);
 250   .dmaram_bss (NOLOAD) :
 251   {
 252     _sdmaram_bss = .;
 253     __dmaram_bss_start__ = _sdmaram_bss;
 254     *(.dmaram_bss)
 255     *(SORT_BY_ALIGNMENT(.dmaram_bss*))
 256     . = ALIGN(32);
 257     _edmaram_bss = .;
 258     __dmaram_bss_end__ = _edmaram_bss;
 259   } >RAM
 260
 261   . = ALIGN(32);
 262   .DMA_RAM (NOLOAD) :
 263   {
 264     KEEP(*(.DMA_RAM))
 265     PROVIDE(dmaram_end = .);
 266     _edmaram = .;
 267     _dmaram_end__ = _edmaram;
 268   } >RAM
 269
 270   .DMA_RW_D2 (NOLOAD) :
 271   {
 272     . = ALIGN(32);
 273     PROVIDE(dmarw_start = .);
 274     _sdmarw = .;
 275     _dmarw_start__ = _sdmarw;
 276     KEEP(*(.DMA_RW))
 277     PROVIDE(dmarw_end = .);
 278     _edmarw = .;
 279     _dmarw_end__ = _edmarw;
 280   } >D2_RAM
 281
 282   .DMA_RW_AXI (NOLOAD) :
 283   {
 284     . = ALIGN(32);
 285     PROVIDE(dmarwaxi_start = .);
 286     _sdmarwaxi = .;
 287     _dmarwaxi_start__ = _sdmarwaxi;
 288     KEEP(*(.DMA_RW_AXI))
 289     PROVIDE(dmarwaxi_end = .);
 290     _edmarwaxi = .;
 291     _dmarwaxi_end__ = _edmarwaxi;
 292   } >RAM
 293
 294   .persistent_data (NOLOAD) :
 295   {
 296     __persistent_data_start__ = .;
 297     *(.persistent_data)
 298     . = ALIGN(4);
 299     __persistent_data_end__ = .;
 300   } >RAM
 301
 302
 303   /* User_heap_stack section, used to check that there is enough RAM left */
 304   _heap_stack_end = ORIGIN(STACKRAM)+LENGTH(STACKRAM) - 8; /* 8 bytes to allow for alignment */
 305   _heap_stack_begin = _heap_stack_end - _Min_Stack_Size  - _Min_Heap_Size;
 306   . = _heap_stack_begin;
 307   ._user_heap_stack :
 308   {
 309     . = ALIGN(4);
 310     PROVIDE ( end = . );
 311     PROVIDE ( _end = . );
 312     . = . + _Min_Heap_Size;
 313     . = . + _Min_Stack_Size;
 314     . = ALIGN(4);
 315   } >STACKRAM = 0xa5
 316
 317   /* MEMORY_bank1 section, code must be located here explicitly            */
 318   /* Example: extern int foo(void) __attribute__ ((section (".mb1text"))); */
 319   .memory_b1_text :
 320   {
 321     *(.mb1text)        /* .mb1text sections (code) */
 322     *(.mb1text*)       /* .mb1text* sections (code)  */
 323     *(.mb1rodata)      /* read-only data (constants) */
 324     *(.mb1rodata*)
 325   } >MEMORY_B1
 326
 327   /* Remove information from the standard libraries */
 328   /DISCARD/ :
 329   {
 330     libc.a ( * )
 331     libm.a ( * )
 332     libgcc.a ( * )
 333   }
 334
 335   .ARM.attributes 0 : { *(.ARM.attributes) }
 336 }