Merge pull request #39 from ninjasource/pico2-support

Add support for family ids other than RP2040 like RP2350

Author: datdenkikniet

src/address_range.rs

@@ -32,29 +32,84 @@ impl Default for AddressRange {
 }
 
 pub const FLASH_SECTOR_ERASE_SIZE: u64 = 4096;
-pub const MAIN_RAM_START: u64 = 0x20000000;
-pub const MAIN_RAM_END: u64 = 0x20042000;
-pub const FLASH_START: u64 = 0x10000000;
-pub const FLASH_END: u64 = 0x15000000;
-pub const XIP_SRAM_START: u64 = 0x15000000;
-pub const XIP_SRAM_END: u64 = 0x15004000;
-pub const MAIN_RAM_BANKED_START: u64 = 0x21000000;
-pub const MAIN_RAM_BANKED_END: u64 = 0x21040000;
-pub const ROM_START: u64 = 0x00000000;
-pub const ROM_END: u64 = 0x00004000;
+pub const MAIN_RAM_START_RP2040: u64 = 0x20000000;
+pub const MAIN_RAM_END_RP2040: u64 = 0x20042000;
+pub const MAIN_RAM_START_RP2350: u64 = 0x20000000;
+pub const MAIN_RAM_END_RP2350: u64 = 0x20082000;
+pub const FLASH_START_RP2040: u64 = 0x10000000;
+pub const FLASH_END_RP2040: u64 = 0x15000000;
+// From RP2350 datasheet:
+// RP2040 required images to be stored at the beginning of flash (0x10000000). RP2350 supports storing executable images
+// in a partitions at arbitrary locations, to support more robust upgrade cycles via A/B versions, among other uses.
+// Therefore, the values below are possibly incorrect but FLASH_END_RP2040 appears to be incorrect too
+pub const FLASH_START_RP2350: u64 = 0x10000000;
+pub const FLASH_END_RP2350: u64 = 0x15000000;
+pub const XIP_SRAM_START_RP2040: u64 = 0x15000000;
+pub const XIP_SRAM_END_RP2040: u64 = 0x15004000;
+pub const XIP_SRAM_START_RP2350: u64 = 0x13ffc000;
+pub const XIP_SRAM_END_RP2350: u64 = 0x14000000;
+pub const MAIN_RAM_BANKED_START_RP2040: u64 = 0x21000000;
+pub const MAIN_RAM_BANKED_END_RP2040: u64 = 0x21040000;
+pub const ROM_START_RP2040: u64 = 0x00000000;
+pub const ROM_END_RP2040: u64 = 0x00004000;
+pub const ROM_START_RP2350: u64 = 0x00000000;
+pub const ROM_END_RP2350: u64 = 0x00008000;
 
 pub const RP2040_ADDRESS_RANGES_FLASH: &[AddressRange] = &[
-    AddressRange::new(FLASH_START, FLASH_END, AddressRangeType::Contents),
-    AddressRange::new(MAIN_RAM_START, MAIN_RAM_END, AddressRangeType::NoContents),
     AddressRange::new(
-        MAIN_RAM_BANKED_START,
-        MAIN_RAM_BANKED_END,
+        FLASH_START_RP2040,
+        FLASH_END_RP2040,
+        AddressRangeType::Contents,
+    ),
+    AddressRange::new(
+        MAIN_RAM_START_RP2040,
+        MAIN_RAM_END_RP2040,
+        AddressRangeType::NoContents,
+    ),
+    AddressRange::new(
+        MAIN_RAM_BANKED_START_RP2040,
+        MAIN_RAM_BANKED_END_RP2040,
         AddressRangeType::NoContents,
     ),
 ];
 
 pub const RP2040_ADDRESS_RANGES_RAM: &[AddressRange] = &[
-    AddressRange::new(MAIN_RAM_START, MAIN_RAM_END, AddressRangeType::Contents),
-    AddressRange::new(XIP_SRAM_START, XIP_SRAM_END, AddressRangeType::Contents),
-    AddressRange::new(ROM_START, ROM_END, AddressRangeType::Ignore), // for now we ignore the bootrom if present
+    AddressRange::new(
+        MAIN_RAM_START_RP2040,
+        MAIN_RAM_END_RP2040,
+        AddressRangeType::Contents,
+    ),
+    AddressRange::new(
+        XIP_SRAM_START_RP2040,
+        XIP_SRAM_END_RP2040,
+        AddressRangeType::Contents,
+    ),
+    AddressRange::new(ROM_START_RP2040, ROM_END_RP2040, AddressRangeType::Ignore), // for now we ignore the bootrom if present
+];
+
+pub const RP2350_ADDRESS_RANGES_FLASH: &[AddressRange] = &[
+    AddressRange::new(
+        FLASH_START_RP2350,
+        FLASH_END_RP2350,
+        AddressRangeType::Contents,
+    ),
+    AddressRange::new(
+        MAIN_RAM_START_RP2350,
+        MAIN_RAM_END_RP2350,
+        AddressRangeType::NoContents,
+    ),
+];
+
+pub const RP2350_ADDRESS_RANGES_RAM: &[AddressRange] = &[
+    AddressRange::new(
+        MAIN_RAM_START_RP2350,
+        MAIN_RAM_END_RP2350,
+        AddressRangeType::Contents,
+    ),
+    AddressRange::new(
+        XIP_SRAM_START_RP2350,
+        XIP_SRAM_END_RP2350,
+        AddressRangeType::Contents,
+    ),
+    AddressRange::new(ROM_START_RP2350, ROM_END_RP2350, AddressRangeType::Ignore), // for now we ignore the bootrom if present
 ];

src/elf.rs

@@ -1,5 +1,9 @@
-use crate::address_range::{
-    self, AddressRange, RP2040_ADDRESS_RANGES_FLASH, RP2040_ADDRESS_RANGES_RAM,
+use crate::{
+    address_range::{
+        self, AddressRange, RP2040_ADDRESS_RANGES_FLASH, RP2040_ADDRESS_RANGES_RAM,
+        RP2350_ADDRESS_RANGES_FLASH, RP2350_ADDRESS_RANGES_RAM,
+    },
+    Family,
 };
 use assert_into::AssertInto;
 use elf::{abi::PT_LOAD, endian::EndianParse, segment::ProgramHeader, ElfStream, ParseError};
@@ -17,9 +21,21 @@ pub const PAGE_SIZE: u64 = 1 << LOG2_PAGE_SIZE;
 pub type PageMap = BTreeMap<u64, Vec<PageFragment>>;
 
 // "determine_binary_type"
-pub fn is_ram_binary<E: EndianParse, S: Read + Seek>(file: &ElfStream<E, S>) -> Option<bool> {
+pub fn is_ram_binary<E: EndianParse, S: Read + Seek>(
+    file: &ElfStream<E, S>,
+    family: Family,
+) -> Option<bool> {
     let entry = file.ehdr.e_entry;
 
+    let (address_ranges_ram, address_ranges_flash) = match family {
+        Family::RP2040 => (RP2040_ADDRESS_RANGES_RAM, RP2040_ADDRESS_RANGES_FLASH),
+        Family::RP2XXX_ABSOLUTE
+        | Family::RP2XXX_DATA
+        | Family::RP2350_ARM_S
+        | Family::RP2350_RISCV
+        | Family::RP2350_ARM_NS => (RP2350_ADDRESS_RANGES_RAM, RP2350_ADDRESS_RANGES_FLASH),
+    };
+
     for segment in file.segments() {
         if segment.p_type == PT_LOAD && segment.p_memsz > 0 {
             let mapped_size = segment.p_filesz.min(segment.p_memsz);
@@ -28,9 +44,9 @@ pub fn is_ram_binary<E: EndianParse, S: Read + Seek>(file: &ElfStream<E, S>) ->
                 // so call THAT a flash binary
                 if entry >= segment.p_vaddr && entry < segment.p_vaddr + mapped_size {
                     let effective_entry = entry + segment.p_paddr - segment.p_vaddr;
-                    if RP2040_ADDRESS_RANGES_RAM.is_address_initialized(effective_entry) {
+                    if address_ranges_ram.is_address_initialized(effective_entry) {
                         return Some(true);
-                    } else if RP2040_ADDRESS_RANGES_FLASH.is_address_initialized(effective_entry) {
+                    } else if address_ranges_flash.is_address_initialized(effective_entry) {
                         return Some(false);
                     }
                 }

src/main.rs

@@ -1,18 +1,19 @@
 use crate::{
-    address_range::{MAIN_RAM_END, XIP_SRAM_END, XIP_SRAM_START},
+    address_range::{
+        FLASH_SECTOR_ERASE_SIZE, MAIN_RAM_END_RP2040, MAIN_RAM_END_RP2350, MAIN_RAM_START_RP2040,
+        MAIN_RAM_START_RP2350, RP2040_ADDRESS_RANGES_FLASH, RP2040_ADDRESS_RANGES_RAM,
+        RP2350_ADDRESS_RANGES_FLASH, RP2350_ADDRESS_RANGES_RAM, XIP_SRAM_END_RP2040,
+        XIP_SRAM_END_RP2350, XIP_SRAM_START_RP2040, XIP_SRAM_START_RP2350,
+    },
     elf::{is_ram_binary, AddressRangesFromElfError, PageMap},
     reporter::ProgressBarReporter,
 };
 use ::elf::{endian::AnyEndian, ElfStream, ParseError};
-use address_range::{
-    FLASH_SECTOR_ERASE_SIZE, MAIN_RAM_START, RP2040_ADDRESS_RANGES_FLASH, RP2040_ADDRESS_RANGES_RAM,
-};
 use assert_into::AssertInto;
-use clap::Parser;
+use clap::{Parser, ValueEnum};
 use elf::{realize_page, AddressRangesExt, PAGE_SIZE};
 use env_logger::Env;
 use log::{debug, info, Level, LevelFilter};
-use static_assertions::const_assert;
 use std::{
     collections::HashSet,
     error::Error,
@@ -23,8 +24,8 @@ use std::{
 use sysinfo::Disks;
 use thiserror::Error;
 use uf2::{
-    Uf2BlockData, Uf2BlockFooter, Uf2BlockHeader, RP2040_FAMILY_ID, UF2_FLAG_FAMILY_ID_PRESENT,
-    UF2_MAGIC_END, UF2_MAGIC_START0, UF2_MAGIC_START1,
+    Uf2BlockData, Uf2BlockFooter, Uf2BlockHeader, UF2_FLAG_FAMILY_ID_PRESENT, UF2_MAGIC_END,
+    UF2_MAGIC_START0, UF2_MAGIC_START1,
 };
 use zerocopy::IntoBytes;
 
@@ -44,6 +45,10 @@ struct Opts {
     #[clap(short, long)]
     deploy: bool,
 
+    /// Select family short name for UF2
+    #[clap(value_enum, short, long, default_value_t = Family::default())]
+    family: Family,
+
     /// Connect to serial after deploy
     #[cfg(feature = "serial")]
     #[clap(short, long)]
@@ -61,6 +66,36 @@ struct Opts {
     output: Option<String>,
 }
 
+// See https://github.com/microsoft/uf2/blob/master/utils/uf2families.json for list
+#[derive(Debug, ValueEnum, Clone, Copy)]
+#[repr(u32)]
+#[allow(non_camel_case_types)]
+pub enum Family {
+    /// Raspberry Pi RP2040
+    RP2040 = 0xe48bff56,
+
+    /// Raspberry Pi Microcontrollers: Absolute (unpartitioned) download
+    RP2XXX_ABSOLUTE = 0xe48bff57,
+
+    /// Raspberry Pi Microcontrollers: Data partition download
+    RP2XXX_DATA = 0xe48bff58,
+
+    /// Raspberry Pi RP2350, Secure Arm image
+    RP2350_ARM_S = 0xe48bff59,
+
+    /// Raspberry Pi RP2350, RISC-V image
+    RP2350_RISCV = 0xe48bff5a,
+
+    /// Raspberry Pi RP2350, Non-secure Arm image
+    RP2350_ARM_NS = 0xe48bff5b,
+}
+
+impl Default for Family {
+    fn default() -> Self {
+        Self::RP2040
+    }
+}
+
 #[derive(Error, Debug)]
 pub enum Elf2Uf2Error {
     #[error("Failed to get address ranges from elf")]
@@ -81,19 +116,52 @@ pub enum Elf2Uf2Error {
     EntryPointNotMapped,
 }
 
-fn build_page_map(elf: &ElfStream<AnyEndian, impl Read + Seek>) -> Result<PageMap, Elf2Uf2Error> {
-    let ram_style = is_ram_binary(elf).ok_or(Elf2Uf2Error::EntryPointNotMapped)?;
+fn build_page_map(
+    elf: &ElfStream<AnyEndian, impl Read + Seek>,
+    family: Family,
+) -> Result<PageMap, Elf2Uf2Error> {
+    let ram_style = is_ram_binary(elf, family).ok_or(Elf2Uf2Error::EntryPointNotMapped)?;
 
     if ram_style {
         debug!("Detected RAM binary");
     } else {
         debug!("Detected FLASH binary");
     }
 
+    let (
+        address_ranges_ram,
+        address_ranges_flash,
+        main_ram_start,
+        main_ram_end,
+        xip_sram_start,
+        xip_sram_end,
+    ) = match family {
+        Family::RP2040 => (
+            RP2040_ADDRESS_RANGES_RAM,
+            RP2040_ADDRESS_RANGES_FLASH,
+            MAIN_RAM_START_RP2040,
+            MAIN_RAM_END_RP2040,
+            XIP_SRAM_START_RP2040,
+            XIP_SRAM_END_RP2040,
+        ),
+        Family::RP2XXX_ABSOLUTE
+        | Family::RP2XXX_DATA
+        | Family::RP2350_ARM_S
+        | Family::RP2350_RISCV
+        | Family::RP2350_ARM_NS => (
+            RP2350_ADDRESS_RANGES_RAM,
+            RP2350_ADDRESS_RANGES_FLASH,
+            MAIN_RAM_START_RP2350,
+            MAIN_RAM_END_RP2350,
+            XIP_SRAM_START_RP2350,
+            XIP_SRAM_END_RP2350,
+        ),
+    };
+
     let valid_ranges = if ram_style {
-        RP2040_ADDRESS_RANGES_RAM
+        address_ranges_ram
     } else {
-        RP2040_ADDRESS_RANGES_FLASH
+        address_ranges_flash
     };
 
     let mut pages = valid_ranges
@@ -110,9 +178,9 @@ fn build_page_map(elf: &ElfStream<AnyEndian, impl Read + Seek>) -> Result<PageMa
 
         #[allow(clippy::manual_range_contains)]
         pages.keys().copied().for_each(|addr| {
-            if addr >= MAIN_RAM_START && addr <= MAIN_RAM_END {
+            if addr >= main_ram_start && addr <= main_ram_end {
                 expected_ep_main_ram = expected_ep_main_ram.min(addr) | 0x1;
-            } else if addr >= XIP_SRAM_START && addr < XIP_SRAM_END {
+            } else if addr >= xip_sram_start && addr < xip_sram_end {
                 expected_ep_xip_sram = expected_ep_xip_sram.min(addr) | 0x1;
             }
         });
@@ -132,7 +200,7 @@ fn build_page_map(elf: &ElfStream<AnyEndian, impl Read + Seek>) -> Result<PageMa
                 elf.ehdr.e_entry as u32,
             ));
         }
-        const_assert!(0 == (MAIN_RAM_START & (PAGE_SIZE - 1)));
+        assert!(0 == (main_ram_start & (PAGE_SIZE - 1)));
 
         // TODO: check vector table start up
         // currently don't require this as entry point is now at the start, we don't know where reset vector is
@@ -167,6 +235,7 @@ fn write_output(
     elf_file: &mut ElfStream<AnyEndian, impl Read + Seek>,
     pages: &PageMap,
     mut output: impl Write,
+    family: Family,
 ) -> Result<(), Elf2Uf2Error> {
     let mut block_header = Uf2BlockHeader {
         magic_start0: UF2_MAGIC_START0,
@@ -176,7 +245,7 @@ fn write_output(
         payload_size: PAGE_SIZE.assert_into(),
         block_no: 0,
         num_blocks: pages.len().assert_into(),
-        file_size: RP2040_FAMILY_ID,
+        file_size: family as u32,
     };
 
     let mut block_data: Uf2BlockData = [0; 476];
@@ -220,10 +289,14 @@ fn open_elf<T: Read + Seek>(input: T) -> Result<ElfStream<AnyEndian, T>, Elf2Uf2
 }
 
 #[cfg_attr(not(test), expect(unused))]
-fn elf2uf2(input: impl Read + Seek, output: impl Write) -> Result<(), Elf2Uf2Error> {
+fn elf2uf2(
+    input: impl Read + Seek,
+    output: impl Write,
+    family: Family,
+) -> Result<(), Elf2Uf2Error> {
     let mut elf = open_elf(input)?;
-    let pages = build_page_map(&elf)?;
-    write_output(&mut elf, &pages, output)
+    let pages = build_page_map(&elf, family)?;
+    write_output(&mut elf, &pages, output, family)
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -280,19 +353,25 @@ fn main() -> Result<(), Box<dyn Error>> {
         (File::create(&output_path)?, output_path)
     };
 
+    let family = options.family;
+
+    if options.verbose {
+        info!("Using UF2 Family {:?}", family);
+    }
+
     let writer = BufWriter::new(output);
     let mut elf = open_elf(input)?;
     let should_print_progress = log::max_level() >= LevelFilter::Info;
-    let pages = build_page_map(&elf)?;
+    let pages = build_page_map(&elf, family)?;
 
     let result = if should_print_progress {
         let len = pages.len() as u64 * 512;
         let mut reporter = ProgressBarReporter::new(len, writer);
-        let result = write_output(&mut elf, &pages, &mut reporter);
+        let result = write_output(&mut elf, &pages, &mut reporter, family);
         reporter.finish();
         result
     } else {
-        write_output(&mut elf, &pages, writer)
+        write_output(&mut elf, &pages, writer, family)
     };
 
     if let Err(err) = result {
@@ -399,7 +478,7 @@ mod tests {
     pub fn hello_usb() {
         let bytes_in = io::Cursor::new(&include_bytes!("../hello_usb.elf")[..]);
         let mut bytes_out = Vec::new();
-        elf2uf2(bytes_in, &mut bytes_out).unwrap();
+        elf2uf2(bytes_in, &mut bytes_out, Family::RP2040).unwrap();
 
         assert_eq!(bytes_out, include_bytes!("../hello_usb.uf2"));
     }
@@ -408,7 +487,7 @@ mod tests {
     pub fn hello_serial() {
         let bytes_in = io::Cursor::new(&include_bytes!("../hello_serial.elf")[..]);
         let mut bytes_out = Vec::new();
-        elf2uf2(bytes_in, &mut bytes_out).unwrap();
+        elf2uf2(bytes_in, &mut bytes_out, Family::RP2040).unwrap();
 
         assert_eq!(bytes_out, include_bytes!("../hello_serial.uf2"));
     }