Add support for flashing the ESP32-C2 (aka ESP8684) (#204)

* No longer try to detect chip from target, as we will have multiple RISC-V chips

* Reduce the repetition required to define a chip

* Add support for per-chip flash frequency encodings

* Add support for flashing the ESP32-C2 (aka ESP8684)

Author: jessebraham

Cargo.lock

@@ -36,5 +36,6 @@ clap = { version = "3.1", features = ["derive"] }
 espflash = { version = "=1.5.2-dev", path = "../espflash" }
 miette = { version = "4.7", features = ["fancy"] }
 serde = { version = "1.0", features = ["derive"] }
+strum = "0.24"
 thiserror = "1.0"
 toml = "0.5"

cargo-espflash/Cargo.toml

@@ -1,7 +1,10 @@
+use std::{
+    fmt::{Display, Formatter},
+    iter::once,
+};
+
 use espflash::Chip;
 use miette::{Diagnostic, LabeledSpan, SourceCode, SourceOffset};
-use std::fmt::{Display, Formatter};
-use std::iter::once;
 use thiserror::Error;
 
 #[derive(Error, Debug, Diagnostic)]
@@ -48,24 +51,6 @@ pub enum Error {
     #[error(transparent)]
     #[diagnostic(transparent)]
     NoTarget(#[from] NoTargetError),
-    #[error("Failed to detect chip for target {0}")]
-    #[diagnostic(
-        code(cargo_espflash::unknown_target),
-        help(
-            "The following targets are recognized:
-    - ESP32: {}
-    - ESP32-C3: {}
-    - ESP32-S2: {}
-    - ESP32-S3: {}
-    - ESP8266: {}",
-            Chip::Esp32.supported_targets().join(", "),
-            Chip::Esp32c3.supported_targets().join(", "),
-            Chip::Esp32s2.supported_targets().join(", "),
-            Chip::Esp32s3.supported_targets().join(", "),
-            Chip::Esp8266.supported_targets().join(", "),
-        )
-    )]
-    UnknownTarget(String),
 }
 
 #[derive(Debug)]

cargo-espflash/src/error.rs

@@ -15,6 +15,7 @@ use espflash::{
     Chip, Config, ImageFormatId,
 };
 use miette::{IntoDiagnostic, Result, WrapErr};
+use strum::VariantNames;
 
 use crate::{
     cargo_config::{parse_cargo_config, CargoConfig},
@@ -100,6 +101,9 @@ pub struct BuildOpts {
 pub struct SaveImageOpts {
     #[clap(flatten)]
     pub build_opts: BuildOpts,
+    /// Chip to create an image for
+    #[clap(possible_values = Chip::VARIANTS)]
+    pub chip: Chip,
     /// File name to save the generated image to
     pub file: PathBuf,
     /// Boolean flag to merge binaries into single binary
@@ -150,7 +154,7 @@ fn flash(
 ) -> Result<()> {
     let mut flasher = connect(&opts.connect_opts, &config)?;
 
-    let build_ctx = build(&opts.build_opts, &cargo_config, Some(flasher.chip()))
+    let build_ctx = build(&opts.build_opts, &cargo_config, flasher.chip())
         .wrap_err("Failed to build project")?;
 
     // Print the board information once the project has successfully built. We do
@@ -209,26 +213,16 @@ fn flash(
 fn build(
     build_options: &BuildOpts,
     cargo_config: &CargoConfig,
-    chip: Option<Chip>,
+    chip: Chip,
 ) -> Result<BuildContext> {
     let target = build_options
         .target
         .as_deref()
         .or_else(|| cargo_config.target())
-        .ok_or_else(|| NoTargetError::new(chip))?;
+        .ok_or_else(|| NoTargetError::new(Some(chip)))?;
 
-    let chip = if chip.is_some() {
-        chip
-    } else {
-        Chip::from_target(target)
-    };
-
-    if let Some(chip) = chip {
-        if !chip.supports_target(target) {
-            return Err(Error::UnsupportedTarget(UnsupportedTargetError::new(target, chip)).into());
-        }
-    } else {
-        return Err(Error::UnknownTarget(target.to_string()).into());
+    if !chip.supports_target(target) {
+        return Err(Error::UnsupportedTarget(UnsupportedTargetError::new(target, chip)).into());
     }
 
     // The 'build-std' unstable cargo feature is required to enable
@@ -369,17 +363,7 @@ fn save_image(
     metadata: CargoEspFlashMeta,
     cargo_config: CargoConfig,
 ) -> Result<()> {
-    let target = opts
-        .build_opts
-        .target
-        .as_deref()
-        .or_else(|| cargo_config.target())
-        .ok_or_else(|| NoTargetError::new(None))
-        .into_diagnostic()?;
-
-    let chip = Chip::from_target(target).ok_or_else(|| Error::UnknownTarget(target.into()))?;
-
-    let build_ctx = build(&opts.build_opts, &cargo_config, Some(chip))?;
+    let build_ctx = build(&opts.build_opts, &cargo_config, opts.chip)?;
     let elf_data = fs::read(build_ctx.artifact_path).into_diagnostic()?;
 
     let bootloader = opts
@@ -405,7 +389,7 @@ fn save_image(
         .or(metadata.format);
 
     save_elf_as_image(
-        chip,
+        opts.chip,
         &elf_data,
         opts.file,
         image_format,

cargo-espflash/src/main.rs

@@ -41,9 +41,10 @@ crossterm = "0.24"
 csv = "1.1"
 dialoguer = "0.10"
 directories-next = "2.0"
-espmonitor = "0.9"
+espmonitor = "0.10"
 flate2 = "1.0"
 indicatif = "0.16"
+maplit = "1.0"
 md5 = "0.7"
 miette = { version = "4.7", features = ["fancy"] }
 parse_int = "0.6"

espflash/Cargo.toml

@@ -1,39 +1,28 @@
 use std::ops::Range;
 
 use super::Esp32Params;
-use crate::error::UnsupportedImageFormatError;
 use crate::{
     chip::{bytes_to_mac_addr, Chip, ChipType, ReadEFuse, SpiRegisters},
     connection::Connection,
     elf::{FirmwareImage, FlashFrequency, FlashMode},
+    error::UnsupportedImageFormatError,
     flasher::FlashSize,
     image_format::{Esp32BootloaderFormat, ImageFormat, ImageFormatId},
     Error, PartitionTable,
 };
 
 pub struct Esp32;
 
-const IROM_MAP_START: u32 = 0x400d0000;
-const IROM_MAP_END: u32 = 0x40400000;
-
-const DROM_MAP_START: u32 = 0x3F400000;
-const DROM_MAP_END: u32 = 0x3F800000;
-
-pub const PARAMS: Esp32Params = Esp32Params {
-    boot_addr: 0x1000,
-    partition_addr: 0x8000,
-    nvs_addr: 0x9000,
-    nvs_size: 0x6000,
-    phy_init_data_addr: 0xf000,
-    phy_init_data_size: 0x1000,
-    app_addr: 0x10000,
-    app_size: 0x3f0000,
-    chip_id: 0,
-    default_bootloader: include_bytes!("../../../bootloader/esp32-bootloader.bin"),
-};
+pub const PARAMS: Esp32Params = Esp32Params::new(
+    0x1000,
+    0x10000,
+    0x3f0000,
+    0,
+    include_bytes!("../../../bootloader/esp32-bootloader.bin"),
+);
 
 impl ChipType for Esp32 {
-    const CHIP_DETECT_MAGIC_VALUE: u32 = 0x00f01d83;
+    const CHIP_DETECT_MAGIC_VALUES: &'static [u32] = &[0x00f01d83];
 
     const UART_CLKDIV_REG: u32 = 0x3ff40014;
 
@@ -47,11 +36,10 @@ impl ChipType for Esp32 {
         miso_length_offset: Some(0x2c),
     };
 
-    const FLASH_RANGES: &'static [Range<u32>] =
-        &[IROM_MAP_START..IROM_MAP_END, DROM_MAP_START..DROM_MAP_END];
-
-    const DEFAULT_IMAGE_FORMAT: ImageFormatId = ImageFormatId::Bootloader;
-    const SUPPORTED_IMAGE_FORMATS: &'static [ImageFormatId] = &[ImageFormatId::Bootloader];
+    const FLASH_RANGES: &'static [Range<u32>] = &[
+        0x400d0000..0x40400000, // IROM
+        0x3F400000..0x3F800000, // DROM
+    ];
 
     const SUPPORTED_TARGETS: &'static [&'static str] =
         &["xtensa-esp32-none-elf", "xtensa-esp32-espidf"];

espflash/bootloader/esp32c2-bootloader.bin

@@ -0,0 +1,118 @@
+use std::{collections::HashMap, ops::Range};
+
+use maplit::hashmap;
+
+use super::Esp32Params;
+use crate::{
+    chip::{ChipType, ReadEFuse, SpiRegisters},
+    connection::Connection,
+    elf::{FirmwareImage, FlashFrequency, FlashMode},
+    flasher::FlashSize,
+    image_format::{Esp32BootloaderFormat, Esp32DirectBootFormat, ImageFormat, ImageFormatId},
+    Chip, Error, PartitionTable,
+};
+
+pub struct Esp32c2;
+
+pub const PARAMS: Esp32Params = Esp32Params::new(
+    0x0,
+    0x10000,
+    0x1f0000,
+    12,
+    include_bytes!("../../../bootloader/esp32c2-bootloader.bin"),
+);
+
+impl ChipType for Esp32c2 {
+    const CHIP_DETECT_MAGIC_VALUES: &'static [u32] = &[
+        0x6F51306F, // ECO0
+        0x7C41A06F, // ECO1
+    ];
+
+    const UART_CLKDIV_REG: u32 = 0x3ff40014;
+
+    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),
+    };
+
+    const FLASH_RANGES: &'static [Range<u32>] = &[
+        0x42000000..0x42400000, // IROM
+        0x3C000000..0x3C400000, // DROM
+    ];
+
+    const SUPPORTED_IMAGE_FORMATS: &'static [ImageFormatId] =
+        &[ImageFormatId::Bootloader, ImageFormatId::DirectBoot];
+
+    const SUPPORTED_TARGETS: &'static [&'static str] = &[
+        "riscv32imac-unknown-none-elf",
+        "riscv32imc-esp-espidf",
+        "riscv32imc-unknown-none-elf",
+    ];
+
+    fn chip_features(&self, _connection: &mut Connection) -> Result<Vec<&str>, Error> {
+        Ok(vec!["WiFi"])
+    }
+
+    fn crystal_freq(&self, _connection: &mut Connection) -> Result<u32, Error> {
+        // The ESP32-C2's XTAL has a fixed frequency of 40MHz.
+        Ok(40)
+    }
+
+    fn get_flash_segments<'a>(
+        image: &'a dyn FirmwareImage<'a>,
+        bootloader: Option<Vec<u8>>,
+        partition_table: Option<PartitionTable>,
+        image_format: ImageFormatId,
+        _chip_revision: Option<u32>,
+        flash_mode: Option<FlashMode>,
+        flash_size: Option<FlashSize>,
+        flash_freq: Option<FlashFrequency>,
+    ) -> Result<Box<dyn ImageFormat<'a> + 'a>, Error> {
+        match image_format {
+            ImageFormatId::Bootloader => Ok(Box::new(Esp32BootloaderFormat::new(
+                image,
+                Chip::Esp32c2,
+                PARAMS,
+                partition_table,
+                bootloader,
+                flash_mode,
+                flash_size,
+                flash_freq,
+            )?)),
+            ImageFormatId::DirectBoot => Ok(Box::new(Esp32DirectBootFormat::new(image)?)),
+        }
+    }
+
+    fn flash_frequency_encodings() -> HashMap<FlashFrequency, u8> {
+        use FlashFrequency::*;
+
+        hashmap! {
+            Flash15M => 0x2,
+            Flash20M => 0x1,
+            Flash30M => 0x0,
+            Flash60M => 0xF,
+        }
+    }
+}
+
+impl ReadEFuse for Esp32c2 {
+    const EFUSE_REG_BASE: u32 = 0x60008800;
+}
+
+impl Esp32c2 {
+    pub fn chip_revision(&self, connection: &mut Connection) -> Result<u32, Error> {
+        let block1_addr = Self::EFUSE_REG_BASE + 0x44;
+        let num_word = 3;
+        let pos = 18;
+
+        let value = connection.read_reg(block1_addr + (num_word * 0x4))?;
+        let value = (value & (0x7 << pos)) >> pos;
+
+        Ok(value)
+    }
+}