Earle F. Philhower, III
da86a8942b
Adds a 12K OTA stub 3rd stage bootloader, which reads new firmware from the LittleFS filesystem and flashes on reboot. By storing the OTA commands in a file in flash, it is possible to recover from a power failure during OTA programming. On power resume, the OTA block will simply re-program from the beginning. Support cryptographic signed OTA updates, if desired. Includes host-side signing logic via openssl. Add PicoOTA library which encapsulates the file format for the updater, including CRC32 checking. Add LEAmDNS support to allow Arduino IDE discovery Add ArduinoOTA class for IDE uploads Add MD5Builder class Add Updater class which supports writing and validating cryptographically signed binaries from any source (http, Ethernet, WiFi, Serial, etc.) Add documentation and readmes.
279 lines
7.5 KiB
Plaintext
279 lines
7.5 KiB
Plaintext
/* Based on GCC ARM embedded samples.
|
|
Defines the following symbols for use by code:
|
|
__exidx_start
|
|
__exidx_end
|
|
__etext
|
|
__data_start__
|
|
__preinit_array_start
|
|
__preinit_array_end
|
|
__init_array_start
|
|
__init_array_end
|
|
__fini_array_start
|
|
__fini_array_end
|
|
__data_end__
|
|
__bss_start__
|
|
__bss_end__
|
|
__end__
|
|
end
|
|
__HeapLimit
|
|
__StackLimit
|
|
__StackTop
|
|
__stack (== StackTop)
|
|
*/
|
|
|
|
MEMORY
|
|
{
|
|
FLASH(rx) : ORIGIN = 0x10000000, LENGTH = __FLASH_LENGTH__
|
|
RAM(rwx) : ORIGIN = 0x20000000, LENGTH = __RAM_LENGTH__
|
|
SCRATCH_X(rwx) : ORIGIN = 0x20040000, LENGTH = 4k
|
|
SCRATCH_Y(rwx) : ORIGIN = 0x20041000, LENGTH = 4k
|
|
}
|
|
PROVIDE ( _EEPROM_start = __EEPROM_START__ );
|
|
PROVIDE ( _FS_start = __FS_START__ );
|
|
PROVIDE ( _FS_end = __FS_END__ );
|
|
|
|
|
|
ENTRY(_entry_point)
|
|
|
|
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")
|
|
|
|
.ota : {
|
|
/* Start image with OTA */
|
|
KEEP (*(.OTA))
|
|
/* Align to the last 16-bytes of the OTA region */
|
|
/* If anyone has a better way of doing this, please submit a PR! */
|
|
/* . = __flash_binary_start + 0x2ff0;
|
|
LONG(__FS_START__)
|
|
LONG(__FS_END__)
|
|
LONG(__EEPROM_START__)
|
|
LONG(__FLASH_LENGTH__)*/
|
|
} > FLASH
|
|
|
|
.partition : {
|
|
/* Align to the last 16-bytes of the OTA region */
|
|
/* If anyone has a better way of doing this, please submit a PR! */
|
|
. = __flash_binary_start + 0x2ff0;
|
|
LONG(__FS_START__)
|
|
LONG(__FS_END__)
|
|
LONG(__EEPROM_START__)
|
|
LONG(__FLASH_LENGTH__)
|
|
} > FLASH
|
|
|
|
/* 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)
|
|
*(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .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* .big_const*)
|
|
. = 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);
|
|
|
|
*(.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
|
|
|
|
/* 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);
|
|
|
|
.bss : {
|
|
. = ALIGN(4);
|
|
__bss_start__ = .;
|
|
*(SORT_BY_ALIGNMENT(SORT_BY_NAME(.bss*)))
|
|
*(COMMON)
|
|
. = ALIGN(4);
|
|
__bss_end__ = .;
|
|
} > RAM
|
|
|
|
.heap (COPY):
|
|
{
|
|
__end__ = .;
|
|
end = __end__;
|
|
*(.heap*)
|
|
__HeapLimit = .;
|
|
} > RAM
|
|
|
|
/* .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 */
|
|
}
|
|
|