/* * SPDX-License-Identifier: MIT * * Copyright (C) 2021-2024 OpenMV, LLC. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. * * Linker script for RP2040 Devices. */ /* Entry Point */ ENTRY(_entry_point) #include "omv_boardconfig.h" MEMORY { FLASH(rx) : ORIGIN = 0x10000000, LENGTH = 2048k RAM(rwx) : ORIGIN = 0x20000000, LENGTH = 256k SCRATCH_X(rwx) : ORIGIN = 0x20040000, LENGTH = 4k SCRATCH_Y(rwx) : ORIGIN = 0x20041000, LENGTH = 4k } SECTIONS { /* Second stage bootloader is prepended to the image. It must be 256 bytes big and checksummed. It is usually built by the boot_stage2 target in the Raspberry Pi Pico SDK */ .flash_begin : { __flash_binary_start = .; } > FLASH .boot2 : { __boot2_start__ = .; KEEP (*(.boot2)) __boot2_end__ = .; } > FLASH ASSERT(__boot2_end__ - __boot2_start__ == 256, "ERROR: Pico second stage bootloader must be 256 bytes in size") /* The second stage will always enter the image at the start of .text. The debugger will use the ELF entry point, which is the _entry_point symbol if present, otherwise defaults to start of .text. This can be used to transfer control back to the bootrom on debugger launches only, to perform proper flash setup. */ .text : { __logical_binary_start = .; KEEP (*(.vectors)) KEEP (*(.binary_info_header)) __binary_info_header_end = .; KEEP (*(.reset)) /* TODO revisit this now memset/memcpy/float in ROM */ /* bit of a hack right now to exclude all floating point and time critical (e.g. memset, memcpy) code from * FLASH ... we will include any thing excluded here in .data below by default */ *(.init) /* Change for MicroPython... exclude gc.c, parse.c, vm.c from flash */ *(EXCLUDE_FILE(*libgcc.a: *libc.a: *lib_a-mem*.o *libm.a: *gc.c.obj *vm.c.obj *parse.c.obj) .text*) *(.fini) /* Pull all c'tors into .text */ *crtbegin.o(.ctors) *crtbegin?.o(.ctors) *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors) *(SORT(.ctors.*)) *(.ctors) /* Followed by destructors */ *crtbegin.o(.dtors) *crtbegin?.o(.dtors) *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors) *(SORT(.dtors.*)) *(.dtors) *(.eh_frame*) . = ALIGN(4); } > FLASH .rodata : { *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .rodata*) . = ALIGN(4); *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.flashdata*))) . = ALIGN(4); } > FLASH .ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } > FLASH __exidx_start = .; .ARM.exidx : { *(.ARM.exidx* .gnu.linkonce.armexidx.*) } > FLASH __exidx_end = .; /* Machine inspectable binary information */ . = ALIGN(4); __binary_info_start = .; .binary_info : { KEEP(*(.binary_info.keep.*)) *(.binary_info.*) } > FLASH __binary_info_end = .; . = ALIGN(4); /* End of .text-like segments */ __etext = .; .ram_vector_table (COPY): { *(.ram_vector_table) } > RAM .data : { __data_start__ = .; *(vtable) *(.time_critical*) /* remaining .text and .rodata; i.e. stuff we exclude above because we want it in RAM */ *(.text*) . = ALIGN(4); *(.rodata*) . = ALIGN(4); _ram_start = .; *(.data*) . = ALIGN(4); *(.after_data.*) . = ALIGN(4); /* preinit data */ PROVIDE_HIDDEN (__mutex_array_start = .); KEEP(*(SORT(.mutex_array.*))) KEEP(*(.mutex_array)) PROVIDE_HIDDEN (__mutex_array_end = .); . = ALIGN(4); /* preinit data */ PROVIDE_HIDDEN (__preinit_array_start = .); KEEP(*(SORT(.preinit_array.*))) KEEP(*(.preinit_array)) PROVIDE_HIDDEN (__preinit_array_end = .); . = ALIGN(4); /* init data */ PROVIDE_HIDDEN (__init_array_start = .); KEEP(*(SORT(.init_array.*))) KEEP(*(.init_array)) PROVIDE_HIDDEN (__init_array_end = .); . = ALIGN(4); /* finit data */ PROVIDE_HIDDEN (__fini_array_start = .); *(SORT(.fini_array.*)) *(.fini_array) PROVIDE_HIDDEN (__fini_array_end = .); *(.jcr) . = ALIGN(4); /* All data end */ __data_end__ = .; } > RAM AT> FLASH .uninitialized_data (COPY): { . = ALIGN(4); *(.uninitialized_data*) } > RAM .bss : { . = ALIGN(4); __bss_start__ = .; *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.bss*))) *(COMMON) . = ALIGN(4); __bss_end__ = .; _ebss = .; } > RAM /* Main framebuffer memory */ .fb_memory (NOLOAD) : { . = ALIGN(4); _fb_memory_start = .; . += OMV_FB_SIZE; . = ALIGN(4); _fb_memory_end = .; . += OMV_FB_ALLOC_SIZE; . = ALIGN(4); _fb_alloc_end = .; . = ALIGN(4); _sb_memory_start = .; . = . + OMV_SB_SIZE; . = ALIGN(4); _sb_memory_end = .; } >OMV_FB_MEMORY .heap (COPY): { __end__ = .; end = __end__; *(.heap*) __HeapLimit = .; } > RAM /* Start and end symbols must be word-aligned */ .scratch_x : { __scratch_x_start__ = .; *(.scratch_x.*) . = ALIGN(4); __scratch_x_end__ = .; } > SCRATCH_X AT > FLASH __scratch_x_source__ = LOADADDR(.scratch_x); .scratch_y : { __scratch_y_start__ = .; *(.scratch_y.*) . = ALIGN(4); __scratch_y_end__ = .; } > SCRATCH_Y AT > FLASH __scratch_y_source__ = LOADADDR(.scratch_y); /* .stack*_dummy section doesn't contains any symbols. It is only * used for linker to calculate size of stack sections, and assign * values to stack symbols later * * stack1 section may be empty/missing if platform_launch_core1 is not used */ /* by default we put core 0 stack at the end of scratch Y, so that if core 1 * stack is not used then all of SCRATCH_X is free. */ .stack1_dummy (COPY): { *(.stack1*) } > SCRATCH_X .stack_dummy (COPY): { *(.stack*) } > SCRATCH_Y .flash_end : { __flash_binary_end = .; } > FLASH /* stack limit is poorly named, but historically is maximum heap ptr */ __StackLimit = ORIGIN(RAM) + LENGTH(RAM); __StackOneTop = ORIGIN(SCRATCH_X) + LENGTH(SCRATCH_X); __StackTop = ORIGIN(SCRATCH_Y) + LENGTH(SCRATCH_Y); __StackOneBottom = __StackOneTop - SIZEOF(.stack1_dummy); __StackBottom = __StackTop - SIZEOF(.stack_dummy); PROVIDE(__stack = __StackTop); /* Check if data + heap + stack exceeds RAM limit */ ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed") ASSERT( __binary_info_header_end - __logical_binary_start <= 256, "Binary info must be in first 256 bytes of the binary") /* todo assert on extra code */ }