Add support for flashing the ESP32-C3

Author: jessebraham

cargo-espflash/src/main.rs

@@ -76,7 +76,7 @@ fn usage() -> Result<()> {
       [--ram] \
       [--release] \
       [--example EXAMPLE] \
-      [--chip {{esp32,esp8266}}] \
+      [--chip {{esp32,esp32c3,esp8266}}] \
       [--speed BAUD] \
       <serial>";
 

espflash/bootloader/esp32c3-bootloader.bin

@@ -0,0 +1,156 @@
+use bytemuck::bytes_of;
+use sha2::{Digest, Sha256};
+
+use crate::{
+    chip::{
+        encode_flash_size, get_segment_padding, save_flash_segment, save_segment, Chip, ChipType,
+        EspCommonHeader, ExtendedHeader, SegmentHeader, SpiRegisters, ESP_MAGIC, SEG_HEADER_LEN,
+        WP_PIN_DISABLED,
+    },
+    elf::{FirmwareImage, RomSegment, ESP_CHECKSUM_MAGIC},
+    partition_table::PartitionTable,
+    Error,
+};
+
+use std::{borrow::Cow, io::Write, iter::once};
+
+pub struct Esp32c3;
+
+const IROM_MAP_START: u32 = 0x42000000;
+const IROM_MAP_END: u32 = 0x42800000;
+
+const DROM_MAP_START: u32 = 0x3c000000;
+const DROM_MAP_END: u32 = 0x3c800000;
+
+const BOOT_ADDR: u32 = 0x0;
+const PARTITION_ADDR: u32 = 0x8000;
+const APP_ADDR: u32 = 0x10000;
+
+impl ChipType for Esp32c3 {
+    const CHIP_DETECT_MAGIC_VALUE: u32 = 0x6921506f;
+    const CHIP_DETECT_MAGIC_VALUE2: u32 = 0x1b31506f;
+
+    const SPI_REGISTERS: SpiRegisters = SpiRegisters {
+        base: 0x60002000,
+        usr_offset: 0x18,
+        usr1_offset: 0x1C,
+        usr2_offset: 0x20,
+        w0_offset: 0x58,
+        mosi_length_offset: Some(0x24),
+        miso_length_offset: Some(0x28),
+    };
+
+    fn addr_is_flash(addr: u32) -> bool {
+        (IROM_MAP_START..IROM_MAP_END).contains(&addr)
+            || (DROM_MAP_START..DROM_MAP_END).contains(&addr)
+    }
+
+    fn get_flash_segments<'a>(
+        image: &'a FirmwareImage,
+    ) -> Box<dyn Iterator<Item = Result<RomSegment<'a>, Error>> + 'a> {
+        let bootloader = include_bytes!("../../bootloader/esp32c3-bootloader.bin");
+
+        let partition_table = PartitionTable::basic(0x10000, 0x3f0000).to_bytes();
+
+        fn get_data<'a>(image: &'a FirmwareImage) -> Result<RomSegment<'a>, Error> {
+            let mut data = Vec::new();
+
+            let header = EspCommonHeader {
+                magic: ESP_MAGIC,
+                segment_count: 0,
+                flash_mode: image.flash_mode as u8,
+                flash_config: encode_flash_size(image.flash_size)? + image.flash_frequency as u8,
+                entry: image.entry,
+            };
+            data.write_all(bytes_of(&header))?;
+
+            let extended_header = ExtendedHeader {
+                wp_pin: WP_PIN_DISABLED,
+                clk_q_drv: 0,
+                d_cs_drv: 0,
+                gd_wp_drv: 0,
+                chip_id: 5,
+                min_rev: 0,
+                padding: [0; 8],
+                append_digest: 1,
+            };
+            data.write_all(bytes_of(&extended_header))?;
+
+            let mut checksum = ESP_CHECKSUM_MAGIC;
+
+            let _ = image.segments().collect::<Vec<_>>();
+
+            let mut flash_segments: Vec<_> = image.rom_segments(Chip::Esp32c3).collect();
+            flash_segments.sort();
+            let mut ram_segments: Vec<_> = image.ram_segments(Chip::Esp32c3).collect();
+            ram_segments.sort();
+            let mut ram_segments = ram_segments.into_iter();
+
+            let mut segment_count = 0;
+
+            for segment in flash_segments {
+                loop {
+                    let pad_len = get_segment_padding(data.len(), &segment);
+                    if pad_len > 0 {
+                        if pad_len > SEG_HEADER_LEN {
+                            if let Some(ram_segment) = ram_segments.next() {
+                                checksum = save_segment(&mut data, &ram_segment, checksum)?;
+                                segment_count += 1;
+                                continue;
+                            }
+                        }
+                        let pad_header = SegmentHeader {
+                            addr: 0,
+                            length: pad_len as u32,
+                        };
+                        data.write_all(bytes_of(&pad_header))?;
+                        for _ in 0..pad_len {
+                            data.write_all(&[0])?;
+                        }
+                        segment_count += 1;
+                    } else {
+                        break;
+                    }
+                }
+                checksum = save_flash_segment(&mut data, &segment, checksum)?;
+                segment_count += 1;
+            }
+
+            for segment in ram_segments {
+                checksum = save_segment(&mut data, &segment, checksum)?;
+                segment_count += 1;
+            }
+
+            let padding = 15 - (data.len() % 16);
+            let padding = &[0u8; 16][0..padding as usize];
+            data.write_all(padding)?;
+
+            data.write_all(&[checksum])?;
+
+            // since we added some dummy segments, we need to patch the segment count
+            data[1] = segment_count as u8;
+
+            let mut hasher = Sha256::new();
+            hasher.update(&data);
+            let hash = hasher.finalize();
+            data.write_all(&hash)?;
+
+            Ok(RomSegment {
+                addr: APP_ADDR,
+                data: Cow::Owned(data),
+            })
+        }
+
+        Box::new(
+            once(Ok(RomSegment {
+                addr: BOOT_ADDR,
+                data: Cow::Borrowed(bootloader),
+            }))
+            .chain(once(Ok(RomSegment {
+                addr: PARTITION_ADDR,
+                data: Cow::Owned(partition_table),
+            })))
+            .chain(once(get_data(image))),
+        )
+    }
+}

espflash/src/chip/esp32c3.rs

@@ -9,9 +9,11 @@ use crate::{
 use std::{io::Write, str::FromStr};
 
 pub use esp32::Esp32;
+pub use esp32c3::Esp32c3;
 pub use esp8266::Esp8266;
 
 mod esp32;
+mod esp32c3;
 mod esp8266;
 
 const ESP_MAGIC: u8 = 0xE9;
@@ -87,13 +89,17 @@ struct ExtendedHeader {
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum Chip {
     Esp32,
+    Esp32c3,
     Esp8266,
 }
 
 impl Chip {
     pub fn from_magic(magic: u32) -> Option<Self> {
         match magic {
             Esp32::CHIP_DETECT_MAGIC_VALUE => Some(Chip::Esp32),
+            Esp32c3::CHIP_DETECT_MAGIC_VALUE | Esp32c3::CHIP_DETECT_MAGIC_VALUE2 => {
+                Some(Chip::Esp32c3)
+            }
             Esp8266::CHIP_DETECT_MAGIC_VALUE => Some(Chip::Esp8266),
             _ => None,
         }
@@ -105,20 +111,23 @@ impl Chip {
     ) -> Box<dyn Iterator<Item = Result<RomSegment<'a>, Error>> + 'a> {
         match self {
             Chip::Esp32 => Esp32::get_flash_segments(image),
+            Chip::Esp32c3 => Esp32c3::get_flash_segments(image),
             Chip::Esp8266 => Esp8266::get_flash_segments(image),
         }
     }
 
     pub fn addr_is_flash(&self, addr: u32) -> bool {
         match self {
             Chip::Esp32 => Esp32::addr_is_flash(addr),
+            Chip::Esp32c3 => Esp32c3::addr_is_flash(addr),
             Chip::Esp8266 => Esp8266::addr_is_flash(addr),
         }
     }
 
     pub fn spi_registers(&self) -> SpiRegisters {
         match self {
             Chip::Esp32 => Esp32::SPI_REGISTERS,
+            Chip::Esp32c3 => Esp32c3::SPI_REGISTERS,
             Chip::Esp8266 => Esp8266::SPI_REGISTERS,
         }
     }
@@ -130,6 +139,7 @@ impl FromStr for Chip {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "esp32" => Ok(Chip::Esp32),
+            "esp32c3" => Ok(Chip::Esp32c3),
             "esp8266" => Ok(Chip::Esp8266),
             _ => Err(Error::UnrecognizedChip),
         }
@@ -153,6 +163,8 @@ struct SegmentHeader {
     length: u32,
 }
 
+// Note that this function ONLY applies to the ESP32 and variants; the ESP8266
+// has defined its own version rather than using this implementation.
 fn encode_flash_size(size: FlashSize) -> Result<u8, Error> {
     match size {
         FlashSize::Flash256Kb => Err(Error::UnsupportedFlash(size as u8)),

espflash/src/chip/mod.rs

@@ -178,7 +178,7 @@ impl Flasher {
         if let Some(b) = speed {
             match flasher.chip {
                 Chip::Esp8266 => (), /* Not available */
-                Chip::Esp32 => {
+                _ => {
                     if b.speed() > BaudRate::Baud115200.speed() {
                         println!("WARN setting baud rate higher than 115200 can cause issues.");
                         flasher.change_baud(b)?;
@@ -357,7 +357,7 @@ impl Flasher {
             Chip::Esp8266 => {
                 self.begin_command(Command::FlashBegin, 0, 0, FLASH_WRITE_SIZE as u32, 0)?;
             }
-            Chip::Esp32 => {
+            _ => {
                 let spi_params = spi_attach_params.encode();
                 self.connection
                     .command(Command::SpiAttach as u8, spi_params.as_slice(), 0)?;
@@ -509,8 +509,8 @@ impl Flasher {
             let block_count = (segment.data.len() + FLASH_WRITE_SIZE - 1) / FLASH_WRITE_SIZE;
 
             let erase_size = match self.chip {
-                Chip::Esp32 => segment.data.len() as u32,
                 Chip::Esp8266 => get_erase_size(addr as usize, segment.data.len()) as u32,
+                _ => segment.data.len() as u32,
             };
 
             self.begin_command(
@@ -538,6 +538,7 @@ impl Flasher {
                 self.block_command(Command::FlashData, block, block_padding, 0xff, i as u32)?;
                 pb_chunk.inc(1);
             }
+
             pb_chunk.finish_with_message(format!("segment 0x{:X}", addr));
         }