git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_LPC54018_MCUXpresso/Projects/MCUXpresso/FreeRTOSDemo.ld

   1 GROUP (\r
   2   "libcr_semihost_nf.a"\r
   3   "libcr_c.a"\r
   4   "libcr_eabihelpers.a"\r
   5   "libgcc.a"\r
   6 )\r
   7 \r
   8 /*\r
   9  *   LPC54018 does not execute from Flash but from RAM (SRAMX). As a result, the\r
  10  *   MPU needs to be programmed to set the portion of SRAMX containing kernel\r
  11  *   code as privileged Read Only and the portion of SRAMX containing remaining\r
  12  *   of the code as Read Only. To facilitate this, SRAMX is divided into two\r
  13  *   parts:\r
  14  *       1. SRAMX_CODE - 128KB. Contains code.\r
  15  *       2. SRAMX_DATA - 64 KB. Contains data (only stack and heap as of now).\r
  16  *\r
  17  *   SRAM_0_1_2_3 is of size 160 KB which is not a power of 2. ARM v7 MPU requires\r
  18  *   the size of an MPU region to be a power of two. Since FreeRTOS Cortex M4 MPU\r
  19  *   port programs MPU to grant access to all SRAM (for tasks created using\r
  20  *   xTaskCreate), we need to ensure that the size of SRAM region is a power of\r
  21  *   two. This is why SRAM_0_1_2_3 is divided into two parts:\r
  22  *       1. SRAM_0_1_2_3 - 128 KB. Contains data. Since the size is now a power\r
  23  *          of two, an MPU region can be used to grant access to it.\r
  24  *       2. SRAM_0_1_2_3_UNUSED - 32 KB. Unused.\r
  25  */\r
  26 MEMORY\r
  27 {\r
  28     /* Define each memory region. */\r
  29     BOARD_FLASH (rx)            : ORIGIN = 0x10000000, LENGTH = 0x1000000 /* 16M bytes (alias Flash). */\r
  30     SRAMX_CODE (rwx)            : ORIGIN = 0x0,        LENGTH = 0x20000   /* 128K bytes. */\r
  31     SRAMX_DATA (rwx)            : ORIGIN = 0x20000,    LENGTH = 0x10000   /* 64K bytes (alias RAM). */\r
  32     SRAM_0_1_2_3 (rwx)          : ORIGIN = 0x20000000, LENGTH = 0x20000   /* 128K bytes (alias RAM2). */\r
  33     SRAM_0_1_2_3_UNUSED (rwx)   : ORIGIN = 0x20020000, LENGTH = 0x8000    /* 32K bytes. */\r
  34     USB_RAM (rwx)               : ORIGIN = 0x40100000, LENGTH = 0x2000    /* 8K bytes (alias RAM3). */\r
  35 }\r
  36 \r
  37 /* Initial 32K SRAMX_CODE is used to store kernel functions and\r
  38  * initial 512 bytes of SRAM_0_1_2_3 is used to store kernel data. */\r
  39 __privileged_functions_region_size__  = 32K;\r
  40 __privileged_data_region_size__       = 512;\r
  41 \r
  42 /* Symbols needed by the MPU setup code. */\r
  43 __FLASH_segment_start__ = ORIGIN( SRAMX_CODE );\r
  44 __FLASH_segment_end__   = __FLASH_segment_start__ + LENGTH( SRAMX_CODE );\r
  45 __SRAM_segment_start__  = ORIGIN( SRAM_0_1_2_3 );\r
  46 __SRAM_segment_end__    = __SRAM_segment_start__ + LENGTH( SRAM_0_1_2_3 );\r
  47 \r
  48 /* Entry point. */\r
  49 ENTRY(ResetISR)\r
  50 \r
  51 /* Sections. */\r
  52 SECTIONS\r
  53 {\r
  54     /* The startup code and FreeRTOS kernel code are placed at the beginning\r
  55      * of SRAMX_CODE. */\r
  56     .privileged_functions : ALIGN(4)\r
  57     {\r
  58         FILL(0xff)\r
  59         __vectors_start__ = ABSOLUTE(.);\r
  60         __FLASH_segment_start__ = __vectors_start__;\r
  61         __privileged_functions_start__ = __vectors_start__;\r
  62         KEEP(*(.isr_vector))\r
  63 \r
  64         /* Global Section Table. */\r
  65         . = ALIGN(4);\r
  66         __section_table_start = .;\r
  67 \r
  68         __data_section_table = .;\r
  69         LONG((LOADADDR(.data_RAM) - LOADADDR(.privileged_functions)) + ORIGIN(SRAMX_CODE));\r
  70         LONG(     ADDR(.data_RAM));\r
  71         LONG(   SIZEOF(.data_RAM));\r
  72 \r
  73         LONG((LOADADDR(.data) - LOADADDR(.privileged_functions)) + ORIGIN(SRAMX_CODE));\r
  74         LONG(     ADDR(.data));\r
  75         LONG(   SIZEOF(.data));\r
  76 \r
  77         LONG((LOADADDR(.data_RAM3) - LOADADDR(.privileged_functions)) + ORIGIN(SRAMX_CODE));\r
  78         LONG(     ADDR(.data_RAM3));\r
  79         LONG(   SIZEOF(.data_RAM3));\r
  80         __data_section_table_end = .;\r
  81 \r
  82         __bss_section_table = .;\r
  83         LONG(    ADDR(.bss_RAM));\r
  84         LONG(  SIZEOF(.bss_RAM));\r
  85 \r
  86         LONG(    ADDR(.bss));\r
  87         LONG(  SIZEOF(.bss));\r
  88 \r
  89         LONG(    ADDR(.bss_RAM3));\r
  90         LONG(  SIZEOF(.bss_RAM3));\r
  91         __bss_section_table_end = .;\r
  92 \r
  93         __section_table_end = .;\r
  94         /* End of Global Section Table. */\r
  95 \r
  96         /* Functions placed after vector table. */\r
  97         *(.after_vectors*)\r
  98 \r
  99         /* Kernel code. */\r
 100         *(privileged_functions)\r
 101 \r
 102         FILL(0xDEAD);\r
 103         /* Ensure that non-privileged code is placed after the region reserved for\r
 104          * privileged kernel code. */\r
 105         /* Note that dot (.) actually refers to the byte offset from the start of\r
 106          * the current section (.privileged_functions in this case). As a result,\r
 107          * setting dot (.) to a value sets the size of the section. */\r
 108         . = __privileged_functions_region_size__;\r
 109         __privileged_functions_end__ = .;\r
 110     } > SRAMX_CODE AT> BOARD_FLASH\r
 111 \r
 112     /* Text Section. */\r
 113     .text : ALIGN(4)\r
 114     {\r
 115         /* Place the FreeRTOS System Calls first in the unprivileged region. */\r
 116         __syscalls_flash_start__ = .;\r
 117         *(freertos_system_calls)\r
 118         __syscalls_flash_end__ = .;\r
 119 \r
 120         /* Unprivileged code and RO data. */\r
 121        *(.text*)\r
 122         KEEP(*freertos*/tasks.o(.rodata*)) /* FreeRTOS Debug Config. */\r
 123        *(.rodata .rodata.* .constdata .constdata.*)\r
 124        . = ALIGN(4);\r
 125     } > SRAMX_CODE AT> BOARD_FLASH\r
 126 \r
 127     /* For exception handling/unwind - some Newlib functions (in common\r
 128      * with C++ and STDC++) use this. */\r
 129     .ARM.extab : ALIGN(4)\r
 130     {\r
 131         *(.ARM.extab* .gnu.linkonce.armextab.*)\r
 132     } > SRAMX_CODE AT> BOARD_FLASH\r
 133 \r
 134     __exidx_start = .;\r
 135 \r
 136     .ARM.exidx : ALIGN(4)\r
 137     {\r
 138         *(.ARM.exidx* .gnu.linkonce.armexidx.*)\r
 139     } > SRAMX_CODE AT> BOARD_FLASH\r
 140 \r
 141     __exidx_end = .;\r
 142 \r
 143     /* End of text section. */\r
 144     _etext = .;\r
 145 \r
 146     /* USB_RAM. */\r
 147     .m_usb_data (NOLOAD) :\r
 148     {\r
 149         *(m_usb_global)\r
 150     } > USB_RAM AT> USB_RAM\r
 151 \r
 152     /* Data section for SRAMX_DATA. */\r
 153     .data_RAM : ALIGN(4)\r
 154     {\r
 155         FILL(0xff)\r
 156         PROVIDE(__start_data_RAM = .);\r
 157         PROVIDE(__start_data_SRAMX_DATA = .);\r
 158         *(.ramfunc.$RAM)\r
 159         *(.ramfunc.$SRAMX)\r
 160         *(.data.$RAM)\r
 161         *(.data.$SRAMX)\r
 162         *(.data.$RAM.*)\r
 163         *(.data.$SRAMX.*)\r
 164         . = ALIGN(4);\r
 165         PROVIDE(__end_data_RAM = .);\r
 166         PROVIDE(__end_data_SRAMX_DATA = .);\r
 167     } > SRAMX_DATA AT>BOARD_FLASH\r
 168 \r
 169     /* Data section for USB_RAM. */\r
 170     .data_RAM3 : ALIGN(4)\r
 171     {\r
 172         FILL(0xff)\r
 173         PROVIDE(__start_data_RAM3 = .);\r
 174         PROVIDE(__start_data_USB_RAM = .);\r
 175         *(.ramfunc.$RAM3)\r
 176         *(.ramfunc.$USB_RAM)\r
 177         *(.data.$RAM3)\r
 178         *(.data.$USB_RAM)\r
 179         *(.data.$RAM3.*)\r
 180         *(.data.$USB_RAM.*)\r
 181         . = ALIGN(4);\r
 182         PROVIDE(__end_data_RAM3 = .);\r
 183         PROVIDE(__end_data_USB_RAM = .);\r
 184      } > USB_RAM AT>BOARD_FLASH\r
 185 \r
 186     /* Main Data Section - Reserved. */\r
 187     .uninit_RESERVED (NOLOAD) : ALIGN(4)\r
 188     {\r
 189         _start_uninit_RESERVED = .;\r
 190         __privileged_data_start__ = _start_uninit_RESERVED;\r
 191 \r
 192         KEEP(*(.bss.$RESERVED*))\r
 193        . = ALIGN(4);\r
 194 \r
 195         _end_uninit_RESERVED = .;\r
 196     } > SRAM_0_1_2_3 AT> SRAM_0_1_2_3\r
 197 \r
 198     /* Main DATA section (SRAM_0_1_2_3). */\r
 199     .data : ALIGN(4)\r
 200     {\r
 201         _data = .;\r
 202         PROVIDE(__start_data_RAM2 = .);\r
 203         PROVIDE(__start_data_SRAM_0_1_2_3 = .);\r
 204 \r
 205         /* FreeRTOS kernel data. */\r
 206         *(privileged_data)\r
 207         FILL(0xDEAD);\r
 208         /* Ensure that non-privileged data is placed after the region reserved for\r
 209          * privileged kernel data. */\r
 210         /* Note that dot (.) actually refers to the byte offset from the start of\r
 211          * the current section (.data in this case). As a result, setting\r
 212          * dot (.) to a value extends the size of the section. */\r
 213         . = __privileged_data_region_size__;\r
 214         __privileged_data_end__ = .;\r
 215 \r
 216         FILL(0xff)\r
 217         *(vtable)\r
 218         *(.ramfunc*)\r
 219         KEEP(*(CodeQuickAccess))\r
 220         KEEP(*(DataQuickAccess))\r
 221         *(RamFunction)\r
 222         *(.data*)\r
 223         . = ALIGN(4);\r
 224         _edata = .;\r
 225         PROVIDE(__end_data_RAM2 = .);\r
 226         PROVIDE(__end_data_SRAM_0_1_2_3 = .);\r
 227     } > SRAM_0_1_2_3 AT>BOARD_FLASH\r
 228 \r
 229     /* BSS section for SRAMX_DATA. */\r
 230     .bss_RAM : ALIGN(4)\r
 231     {\r
 232         PROVIDE(__start_bss_RAM = .);\r
 233         PROVIDE(__start_bss_SRAMX_DATA = .);\r
 234         *(.bss.$RAM)\r
 235         *(.bss.$SRAMX)\r
 236         *(.bss.$RAM.*)\r
 237         *(.bss.$SRAMX.*)\r
 238         . = ALIGN (. != 0 ? 4 : 1); /* Avoid empty segment. */\r
 239         PROVIDE(__end_bss_RAM = .);\r
 240         PROVIDE(__end_bss_SRAMX_DATA = .);\r
 241     } > SRAMX_DATA AT> SRAMX_DATA\r
 242 \r
 243     /* BSS section for USB_RAM. */\r
 244     .bss_RAM3 : ALIGN(4)\r
 245     {\r
 246         PROVIDE(__start_bss_RAM3 = .);\r
 247         PROVIDE(__start_bss_USB_RAM = .);\r
 248         *(.bss.$RAM3)\r
 249         *(.bss.$USB_RAM)\r
 250         *(.bss.$RAM3.*)\r
 251         *(.bss.$USB_RAM.*)\r
 252         . = ALIGN (. != 0 ? 4 : 1); /* Avoid empty segment. */\r
 253         PROVIDE(__end_bss_RAM3 = .);\r
 254         PROVIDE(__end_bss_USB_RAM = .);\r
 255     } > USB_RAM AT> USB_RAM\r
 256 \r
 257     /* Main BSS Section. */\r
 258     .bss : ALIGN(4)\r
 259     {\r
 260         _bss = .;\r
 261         PROVIDE(__start_bss_RAM2 = .);\r
 262         PROVIDE(__start_bss_SRAM_0_1_2_3 = .);\r
 263         *(.bss*)\r
 264         *(COMMON)\r
 265         . = ALIGN(4);\r
 266         _ebss = .;\r
 267         PROVIDE(__end_bss_RAM2 = .);\r
 268         PROVIDE(__end_bss_SRAM_0_1_2_3 = .);\r
 269         PROVIDE(end = .);\r
 270     } > SRAM_0_1_2_3 AT> SRAM_0_1_2_3\r
 271 \r
 272     /* NOINIT section for SRAMX_DATA. */\r
 273     .noinit_RAM (NOLOAD) : ALIGN(4)\r
 274     {\r
 275         PROVIDE(__start_noinit_RAM = .);\r
 276         PROVIDE(__start_noinit_SRAMX_DATA = .);\r
 277         *(.noinit.$RAM)\r
 278         *(.noinit.$SRAMX)\r
 279         *(.noinit.$RAM.*)\r
 280         *(.noinit.$SRAMX.*)\r
 281         . = ALIGN(4);\r
 282         PROVIDE(__end_noinit_RAM = .);\r
 283         PROVIDE(__end_noinit_SRAMX_DATA = .);\r
 284     } > SRAMX_DATA AT> SRAMX_DATA\r
 285 \r
 286     /* NOINIT section for USB_RAM. */\r
 287     .noinit_RAM3 (NOLOAD) : ALIGN(4)\r
 288     {\r
 289         PROVIDE(__start_noinit_RAM3 = .);\r
 290         PROVIDE(__start_noinit_USB_RAM = .);\r
 291         *(.noinit.$RAM3)\r
 292         *(.noinit.$USB_RAM)\r
 293         *(.noinit.$RAM3.*)\r
 294         *(.noinit.$USB_RAM.*)\r
 295         . = ALIGN(4);\r
 296         PROVIDE(__end_noinit_RAM3 = .);\r
 297         PROVIDE(__end_noinit_USB_RAM = .);\r
 298     } > USB_RAM AT> USB_RAM\r
 299 \r
 300     /* Default NOINIT Section. */\r
 301     .noinit (NOLOAD): ALIGN(4)\r
 302     {\r
 303         _noinit = .;\r
 304         PROVIDE(__start_noinit_RAM2 = .);\r
 305         PROVIDE(__start_noinit_SRAM_0_1_2_3 = .);\r
 306         *(.noinit*)\r
 307          . = ALIGN(4);\r
 308         _end_noinit = .;\r
 309        PROVIDE(__end_noinit_RAM2 = .);\r
 310        PROVIDE(__end_noinit_SRAM_0_1_2_3 = .);\r
 311     } > SRAM_0_1_2_3 AT> SRAM_0_1_2_3\r
 312 \r
 313     /* Reserve and place Heap within memory map. */\r
 314     _HeapSize = 0x1000;\r
 315     .heap : ALIGN(4)\r
 316     {\r
 317         _pvHeapStart = .;\r
 318         . += _HeapSize;\r
 319         . = ALIGN(4);\r
 320         _pvHeapLimit = .;\r
 321     } > SRAMX_DATA\r
 322 \r
 323      /* Reserve space in memory for Stack. */\r
 324      _StackSize = 0x1000;\r
 325     .heap2stackfill  :\r
 326     {\r
 327         . += _StackSize;\r
 328     } > SRAMX_DATA\r
 329 \r
 330     /* Locate actual Stack in memory map. */\r
 331     .stack ORIGIN(SRAMX_DATA) + LENGTH(SRAMX_DATA) - _StackSize - 0:  ALIGN(4)\r
 332     {\r
 333         _vStackBase = .;\r
 334         . = ALIGN(4);\r
 335         _vStackTop = . + _StackSize;\r
 336     } > SRAMX_DATA\r
 337 \r
 338     /* ## Create checksum value (used in startup). ## */\r
 339     PROVIDE(__valid_user_code_checksum = 0 -\r
 340                                          (_vStackTop\r
 341                                          + (ResetISR + 1)\r
 342                                          + (NMI_Handler + 1)\r
 343                                          + (HardFault_Handler + 1)\r
 344                                          + (( DEFINED(MemManage_Handler) ? MemManage_Handler : 0 ) + 1)   /* MemManage_Handler may not be defined. */\r
 345                                          + (( DEFINED(BusFault_Handler) ? BusFault_Handler : 0 ) + 1)     /* BusFault_Handler may not be defined. */\r
 346                                          + (( DEFINED(UsageFault_Handler) ? UsageFault_Handler : 0 ) + 1) /* UsageFault_Handler may not be defined. */\r
 347                                          ) );\r
 348 \r
 349     /* Provide basic symbols giving location and size of main text\r
 350      * block, including initial values of RW data sections. Note that\r
 351      * these will need extending to give a complete picture with\r
 352      * complex images (e.g multiple Flash banks). */\r
 353     _image_start = LOADADDR(.privileged_functions);\r
 354     _image_end = LOADADDR(.data) + SIZEOF(.data);\r
 355     _image_size = _image_end - _image_start;\r
 356 \r
 357     /* Provide symbols for LPC540xx parts for startup code to use\r
 358      * to set image to be plain load image or XIP.\r
 359      * Config : Plain load image = true. */\r
 360     __imghdr_loadaddress = ADDR(.privileged_functions);\r
 361     __imghdr_imagetype = 1;\r
 362 }