🎉

Author: Dirbaio

.cargo/config

@@ -0,0 +1,26 @@
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+
+rustflags = [
+  "-C", "link-arg=--nmagic",
+  "-C", "link-arg=-Tlink.x",
+
+  # Code-size optimizations.
+  "-Z", "trap-unreachable=no",
+  "-C", "inline-threshold=5",
+  "-C", "no-vectorize-loops",
+  "-C", "force-frame-pointers=no",
+
+  # We don't know where the flash loader will be
+  # placed in memory, so we need to create
+  # position independent code (pic).
+  "-C", "relocation-model=pic",
+]
+
+[build]
+target = "thumbv6m-none-eabi"        # Cortex-M0 and Cortex-M0+
+# target = "thumbv7m-none-eabi"        # Cortex-M3
+# target = "thumbv7em-none-eabi"       # Cortex-M4 and Cortex-M7 (no FPU)
+# target = "thumbv7em-none-eabihf"     # Cortex-M4F and Cortex-M7F (with FPU)
+# target = "thumbv8m.base-none-eabi"   # Cortex-M23
+# target = "thumbv8m.main-none-eabi"   # Cortex-M33 (no FPU)
+# target = "thumbv8m.main-none-eabihf" # Cortex-M33 (with FPU)

.gitignore

@@ -0,0 +1,14 @@
+**/*.rs.bk
+.#*
+.gdb_history
+Cargo.lock
+target/
+
+# editor files
+.vscode/*
+!.vscode/*.md
+!.vscode/*.svd
+!.vscode/launch.json
+!.vscode/tasks.json
+!.vscode/extensions.json
+!.vscode/settings.json

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "editor.formatOnSave": true
+}

Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+authors = ["Dario Nieuwenhuis <dirbaio@dirbaio.net>"]
+edition = "2018"
+readme = "README.md"
+name = "flash-algo"
+version = "0.1.0"
+
+[dependencies]
+cortex-m = "0.7.0"
+
+# this lets you use `cargo fix`!
+[[bin]]
+name = "flash-algo"
+test = false
+bench = false
+
+[profile.dev]
+codegen-units = 1
+debug = 2
+debug-assertions = true
+incremental = false
+opt-level = 3
+overflow-checks = true
+
+[profile.release]
+codegen-units = 1
+debug = 2
+debug-assertions = false
+incremental = false
+lto = "fat"
+opt-level = 's'
+overflow-checks = false
+
+# do not optimize proc-macro crates = faster builds from scratch
+[profile.dev.build-override]
+codegen-units = 8
+debug = false
+debug-assertions = false
+opt-level = 0
+overflow-checks = false
+
+[profile.release.build-override]
+codegen-units = 8
+debug = false
+debug-assertions = false
+opt-level = 0
+overflow-checks = false

README.md

@@ -0,0 +1,36 @@
+# RaspberryPi Pico RP2040 flash algorithm
+
+This is a flash algorithm for the RP2040 chip, used in the Raspberry Pi Pico board. 
+It implements the CMSIS-Pack ABI, so it's compatible with any tools that use it, including probe-rs.
+
+## Building
+
+Building requires nightly Rust.
+
+Just run `build.sh`. It spits out the flash algo in the probe-rs YAML format:
+
+    flash-algo$ ./build.sh 
+    instructions: sLUUIACIGUoBRguI...wRwAgcEc=
+    pc_init: 0x00000000
+    pc_uninit: 0x0000007c
+    pc_program_page: 0x00000088
+    pc_erase_sector: 0x00000084
+    pc_erase_all: 0x00000080
+
+## Hacking
+
+The `algo` module contains the FlashAlgo trait, and an `algo!` macro to generate
+the glue functions for a given struct implementing it. This is generic for all chips, so feel free to reuse it!
+
+`main.rs` has the actual implementation for RP2040.
+
+# License
+
+This thingy is licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  http://www.apache.org/licenses/LICENSE-2.0)
+
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.

build.rs

@@ -0,0 +1,21 @@
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    // Put `link.x` in our output directory and ensure it's
+    // on the linker search path.
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("link.x"))
+        .unwrap()
+        .write_all(include_bytes!("link.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // By default, Cargo will re-run a build script whenever
+    // any file in the project changes. By specifying `link.x`
+    // here, we ensure the build script is only re-run when
+    // `link.x` is changed.
+    println!("cargo:rerun-if-changed=link.x");
+}

build.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -euo pipefail
+
+cargo build --release -Zbuild-std=core -Zbuild-std-features=panic_immediate_abort
+ELF=target/thumbv6m-none-eabi/release/flash-algo
+
+llvm-objdump --disassemble $ELF > target/disassembly.s
+llvm-objdump -x $ELF > target/dump.txt
+llvm-nm $ELF -n > target/nm.txt
+
+function bin {
+    llvm-objcopy $ELF -O binary - | base64 -w0
+}
+
+function sym {
+    echo $((0x$(llvm-nm $ELF | grep $1 | cut -d ' ' -f 1) + 1))
+}
+
+cat <<EOF
+    instructions: $(bin)
+    pc_init: $(sym _algo_init)
+    pc_uninit: $(sym _algo_uninit)
+    pc_program_page: $(sym _algo_program_page)
+    pc_erase_sector: $(sym _algo_erase_sector)
+    pc_erase_all: $(sym _algo_erase_all)
+EOF

link.x

@@ -0,0 +1,35 @@
+SECTIONS {
+    . = 0x0;
+
+    .text : {
+        KEEP(*(.entry))
+        KEEP(*(.entry.*))
+
+        *(.text)
+        *(.text.*)
+
+        *(.rodata)
+        *(.rodata.*)
+
+        *(.data)
+        *(.data.*)
+
+        *(.sdata)
+        *(.sdata.*)
+        
+        *(.bss)
+        *(.bss.*)
+
+        *(.uninit)
+        *(.uninit.*)
+
+        . = ALIGN(4);
+    }
+
+    /DISCARD/ : {
+        /* Unused exception related info that only wastes space */
+        *(.ARM.exidx);
+        *(.ARM.exidx.*);
+        *(.ARM.extab.*);
+    }
+}

src/algo.rs

@@ -0,0 +1,103 @@
+#![macro_use]
+
+
+use core::num::NonZeroU32;
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    unsafe {
+        asm!("udf #0");
+        core::hint::unreachable_unchecked();
+    }
+}
+
+pub const FUNCTION_ERASE: u32 = 1;
+pub const FUNCTION_PROGRAM: u32 = 2;
+pub const FUNCTION_VERIFY: u32 = 3;
+
+pub type ErrorCode = NonZeroU32;
+
+pub trait FlashAlgo: Sized + 'static {
+    /// Initialize the flash algorithm.
+    fn new(address: u32, clock: u32, function: u32) -> Result<Self, ErrorCode>;
+
+    /// Erase entire chip. May only be called after init() with FUNCTION_ERASE
+    fn erase_all(&mut self) -> Result<(), ErrorCode>;
+
+    /// Erase sector. May only be called after init() with FUNCTION_ERASE
+    fn erase_sector(&mut self, addr: u32) -> Result<(), ErrorCode>;
+
+    /// Program bytes. May only be called after init() with FUNCTION_PROGRAM
+    fn program_page(&mut self, addr: u32, size: u32, data: *const u8) -> Result<(), ErrorCode>;
+}
+
+#[macro_export]
+macro_rules! algo {
+    ($type:ty) => {
+        static mut _IS_INIT: bool = false;
+        static mut _ALGO_INSTANCE: MaybeUninit<$type> = MaybeUninit::uninit();
+
+        #[no_mangle]
+        #[link_section = ".entry"]
+        pub unsafe extern "C" fn _algo_init(addr: u32, clock: u32, function: u32) -> u32 {
+            if _IS_INIT {
+                _algo_uninit();
+            }
+            _IS_INIT = true;
+            match <$type as FlashAlgo>::new(addr, clock, function) {
+                Ok(inst) => {
+                    _ALGO_INSTANCE.as_mut_ptr().write(inst);
+                    _IS_INIT = true;
+                    0
+                }
+                Err(e) => e.get(),
+            }
+        }
+        #[no_mangle]
+        #[link_section = ".entry"]
+        pub unsafe extern "C" fn _algo_uninit() -> u32 {
+            if !_IS_INIT {
+                return 1;
+            }
+            _ALGO_INSTANCE.as_mut_ptr().drop_in_place();
+            _IS_INIT = false;
+            0
+        }
+        #[no_mangle]
+        #[link_section = ".entry"]
+        pub unsafe extern "C" fn _algo_erase_all() -> u32 {
+            if !_IS_INIT {
+                return 1;
+            }
+            let this = &mut *_ALGO_INSTANCE.as_mut_ptr();
+            match <$type as FlashAlgo>::erase_all(this) {
+                Ok(()) => 0,
+                Err(e) => e.get(),
+            }
+        }
+        #[no_mangle]
+        #[link_section = ".entry"]
+        pub unsafe extern "C" fn _algo_erase_sector(addr: u32) -> u32 {
+            if !_IS_INIT {
+                return 1;
+            }
+            let this = &mut *_ALGO_INSTANCE.as_mut_ptr();
+            match <$type as FlashAlgo>::erase_sector(this, addr) {
+                Ok(()) => 0,
+                Err(e) => e.get(),
+            }
+        }
+        #[no_mangle]
+        #[link_section = ".entry"]
+        pub unsafe extern "C" fn _algo_program_page(addr: u32, size: u32, data: *const u8) -> u32 {
+            if !_IS_INIT {
+                return 1;
+            }
+            let this = &mut *_ALGO_INSTANCE.as_mut_ptr();
+            match <$type as FlashAlgo>::program_page(this, addr, size, data) {
+                Ok(()) => 0,
+                Err(e) => e.get(),
+            }
+        }
+    };
+}