From 704474dd5710c4b85cc48800947d0e0632e7c083 Mon Sep 17 00:00:00 2001 From: cuu Date: Thu, 22 May 2025 00:42:50 +0800 Subject: [PATCH] update code --- ...cf025478994c10930c5d6ffccd511d456b0a.patch | 47 ++++ .../memmap_default.ld.mp.rp2040 | 220 ++++++++++++++++++ .../linker_scripts/rpi-pico.ld | 169 ++++++++++++++ 3 files changed, 436 insertions(+) create mode 100644 Code/MP3Player/320dcf025478994c10930c5d6ffccd511d456b0a.patch create mode 100644 Code/pico_multi_booter/linker_scripts/memmap_default.ld.mp.rp2040 create mode 100644 Code/pico_multi_booter/linker_scripts/rpi-pico.ld diff --git a/Code/MP3Player/320dcf025478994c10930c5d6ffccd511d456b0a.patch b/Code/MP3Player/320dcf025478994c10930c5d6ffccd511d456b0a.patch new file mode 100644 index 0000000..4b9b141 --- /dev/null +++ b/Code/MP3Player/320dcf025478994c10930c5d6ffccd511d456b0a.patch @@ -0,0 +1,47 @@ +diff --git a/Code/MP3Player/main_task.h b/Code/MP3Player/main_task.h +index 640b48c..9ee7110 100644 +--- a/Code/MP3Player/main_task.h ++++ b/Code/MP3Player/main_task.h +@@ -81,22 +81,22 @@ public: + void draw_playing(); + void draw_wrap_text(const char *); + private: +- gpio_rp2040_pin _cs; // CS Line of SD card SPI interface ++ gpio_rp2040 _cs; // CS Line of SD card SPI interface + spi_rp2040 _spi; // SPI interface used for the SD card reader + sd_spi_drv _sd; // SD card low level driver + +- gpio_rp2040_pin _next; // Next button +- gpio_rp2040_pin _part; // Partition button +- gpio_rp2040_pin _ps; // Pico Power save pin ++ gpio_rp2040 _next; // Next button ++ gpio_rp2040 _part; // Partition button ++ gpio_rp2040 _ps; // Pico Power save pin + + FatFs _fs; + FatFs::DIR _dir{}; + FatFs::FILEINFO _finfo{}; + FatFs::FILE _file{}; // MP3 file on SD + +- gpio_rp2040_pin _lcd_rst; +- gpio_rp2040_pin _lcd_dc; +- gpio_rp2040_pin _lcd_cs; ++ gpio_rp2040 _lcd_rst; ++ gpio_rp2040 _lcd_dc; ++ gpio_rp2040 _lcd_cs; + spi_rp2040 _lcd_spi; + ili9488_drv _lcd; + uGUI _gui; +diff --git a/Code/MP3Player/mp3_decoder_task.h b/Code/MP3Player/mp3_decoder_task.h +index 316cae1..094a17c 100644 +--- a/Code/MP3Player/mp3_decoder_task.h ++++ b/Code/MP3Player/mp3_decoder_task.h +@@ -28,7 +28,7 @@ private: + pcm_audio_interface & _pcm_if; + sd_reader_task & _sd_reader; + mad_decoder _decoder{}; +- gpio_rp2040_pin _led; ++ gpio_rp2040 _led; + uint8_t _mp3_buf[MP3_BUF_SIZE]{}; + uint32_t _pcm_rate; + mad_timer_t _timer; diff --git a/Code/pico_multi_booter/linker_scripts/memmap_default.ld.mp.rp2040 b/Code/pico_multi_booter/linker_scripts/memmap_default.ld.mp.rp2040 new file mode 100644 index 0000000..e0c639b --- /dev/null +++ b/Code/pico_multi_booter/linker_scripts/memmap_default.ld.mp.rp2040 @@ -0,0 +1,220 @@ +/*arduino-pico*/ +MEMORY +{ + FLASH(rx) : ORIGIN = 0x10000000 + 940k, LENGTH = __FLASH_LENGTH__ - 940k + RAM(rwx) : ORIGIN = 0x20000000, LENGTH = __RAM_LENGTH__ + SCRATCH_X(rwx) : ORIGIN = 0x20040000, LENGTH = 4k + SCRATCH_Y(rwx) : ORIGIN = 0x20041000, LENGTH = 4k +} + +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 + + /* 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*) + . = 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); + + .ram_vector_table (NOLOAD): { + *(.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 + /* __etext is (for backwards compatibility) the name of the .data init source pointer (...) */ + __etext = LOADADDR(.data); + + .uninitialized_data (NOLOAD): { + . = 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 (NOLOAD): + { + __end__ = .; + end = __end__; + KEEP(*(.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 (NOLOAD): + { + *(.stack1*) + } > SCRATCH_X + .stack_dummy (NOLOAD): + { + KEEP(*(.stack*)) + } > SCRATCH_Y + + .flash_end : { + PROVIDE(__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 */ +} + diff --git a/Code/pico_multi_booter/linker_scripts/rpi-pico.ld b/Code/pico_multi_booter/linker_scripts/rpi-pico.ld new file mode 100644 index 0000000..21c88f4 --- /dev/null +++ b/Code/pico_multi_booter/linker_scripts/rpi-pico.ld @@ -0,0 +1,169 @@ +/*******************************/ +/* YAHAL RPi pico Multi boot GCC linker script */ +/*******************************/ + +MEMORY +{ + FLASH(rx) : ORIGIN = 0x10000000 + 940k, LENGTH = 2048k - 940k + RAM(rwx) : ORIGIN = 0x20000000, LENGTH = 256k + SCRATCH_X(rwx) : ORIGIN = 0x20040000, LENGTH = 4k + SCRATCH_Y(rwx) : ORIGIN = 0x20041000, LENGTH = 4k +} + +ENTRY(_elf_entry_point) + +SECTIONS +{ + /***************************/ + /* Second stage bootloader */ + /***************************/ + + /********/ + /* Code */ + /********/ + .text : { + __image_load__ = LOADADDR(.text); + __image_start__ = .; + + __vector_start__ = .; + KEEP (*(.isr_vector)) + . = ALIGN(4); + KEEP (*(.boot_blocks)) + . = ALIGN(4); + KEEP (*(.reset)) + + *(.text.*) + + *(SORT(.ctors.*)) + *(.ctors) + *(SORT(.dtors.*)) + *(.dtors) + + KEEP (*(.init)) + KEEP (*(.fini)) + + __preinit_array_start = .; + KEEP (*(.preinit_array*)) + __preinit_array_end = .; + + __init_array_start = .; + KEEP (*(.init_array*)) + __init_array_end = .; + + __fini_array_start = .; + KEEP (*(.fini_array*)) + __fini_array_end = .; + + } > FLASH + + /*************************/ + /* Exception information */ + /*************************/ + .ARM.extab : { + KEEP (*(.ARM.extab* .gnu.linkonce.armextab.*)) + } > FLASH + + .ARM.exidx : { + __exidx_start = .; + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + __exidx_end = .; + } > FLASH + + /******************/ + /* Read-only data */ + /******************/ + .rodata : { + . = ALIGN(4); + *(.rodata) + *(.rodata.*) + . = ALIGN(4); + } > FLASH + + /********************************************/ + /* .copy.table used by cmsis_gcc.h */ + /* The CMSIS code handling the copy tables */ + /* copies uint32_t values, so the start/end */ + /* values have to be aligned and the size */ + /* has to be divided by 4. */ + /********************************************/ + .copy.table : { + . = ALIGN(4); + __copy_table_start__ = .; + LONG (__data_load__) + LONG (__data_start__) + LONG ((__data_end__ - __data_start__)/4) + __copy_table_end__ = .; + } > FLASH + + /***********************************/ + /* .zero.table used by cmsis_gcc.h */ + /***********************************/ + .zero.table : { + . = ALIGN(4); + __zero_table_start__ = .; + LONG (__bss_start__) + LONG ((__bss_end__ - __bss_start__)/4) + __zero_table_end__ = .; + } > FLASH + + /****************************************/ + /* data which needs to be copied to RAM */ + /****************************************/ + .data : { + . = ALIGN (4); + __data_load__ = LOADADDR(.data); + __data_start__ = .; + *(.vtable) + *(.move_to_ram*) + *(.data*) + . = ALIGN (4); + __data_end__ = .; + } > RAM AT> FLASH + + __image_end__ = .; + + /***************************************/ + /* uninizialized data (will be zeroed) */ + /***************************************/ + .bss (NOLOAD): { + . = ALIGN (4); + __bss_start__ = .; + *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.bss*))) + *(COMMON) + . = ALIGN (4); + __bss_end__ = .; + } > RAM + + __end__ = .; /* end of written RAM */ + end = __end__; + + /********/ + /* heap */ + /********/ + .heap (NOLOAD): { + __heap_start__ = .; + __HeapBase = .; + *(.heap*) + __heap_end__ = .; + __HeapLimit = ORIGIN(RAM) + LENGTH(RAM) - 1; + } > RAM + + /*********/ + /* stack */ + /*********/ + .stack.x (NOLOAD): { + *(.stack.x*) + } > SCRATCH_X + + .stack.y (NOLOAD): { + *(.stack.y*) + } > SCRATCH_Y + + /* Lower stack limit */ + __StackLimit = ORIGIN(RAM) + LENGTH(RAM); + /* Higher stack limits */ + __StackXTop = ORIGIN(SCRATCH_X) + LENGTH(SCRATCH_X); + __StackYTop = ORIGIN(SCRATCH_Y) + LENGTH(SCRATCH_Y); + __StackTop = __StackYTop; + PROVIDE(__stack = __StackTop); +}