/* DFU transfers can serve two purposes:
 *  - Transfering RAM data between the machine and the host, e.g. Python scripts
 *  - Upgrading the flash memory to perform a software update
 *
 * The second case raises a huge issue: code cannot be executed from memory that
 * is being modified. We're solving this issue by copying the DFU code in RAM.
 *
 * This linker script will generate some code that expects to be executed from a
 * fixed address in RAM. The corresponding instructions will be embedded in the
 * main Epsilon ELF file, and copied to that address before execution.
 *
 * This address needs to live in RAM, and needs to be temporarily overwriteable
 * when the program is being run. Epsilon has a large stack to allow deeply
 * recursive code to run. But when doing DFU transfers it is safe to assume we
 * will need very little stack space. We're therefore using the topmost 8K of
 * the stack reserved by Epsilon.
 *
 * Last but not least, we'll want to jump to a known entry point when running
 * the DFU code (namely, Ion::USB::Device::Calculator::Poll). We're simply
 * making sure this is the first symbol output. */

EPSILON_STACK_END = 0x20000000 + 256K - 32K;

MEMORY {
  RAM_BUFFER (rw) : ORIGIN = EPSILON_STACK_END, LENGTH = 8K
}

SECTIONS {
  .text : {
    . = ALIGN(4);
    KEEP(*(.text._ZN3Ion3USB6Device10Calculator12PollAndResetEb))
    *(.text)
    *(.text.*)
  } >RAM_BUFFER

  .rodata : {
    *(.rodata)
    *(.rodata.*)
  } >RAM_BUFFER

  /DISCARD/ : {
    /* For now, we do not need .bss and .data sections. This allows us to simply
     * skip any rt0-style initialization and jump straight into the PollAndReset
     * routine. */
    *(.bss)
    *(.bss.*)
    *(.data)
    *(.data.*)
  }
}