Add methods for reading the crystal frequency and revision for applicable chips

Author: jessebraham

cargo-espflash/src/main.rs

@@ -1,5 +1,10 @@
-use crate::cargo_config::parse_cargo_config;
-use crate::error::UnsupportedTargetError;
+use std::{
+    fs,
+    path::PathBuf,
+    process::{exit, Command, ExitStatus, Stdio},
+    string::ToString,
+};
+
 use cargo_metadata::Message;
 use clap::{App, Arg, SubCommand};
 use error::Error;
@@ -8,12 +13,8 @@ use miette::{IntoDiagnostic, Result, WrapErr};
 use monitor::monitor;
 use package_metadata::CargoEspFlashMeta;
 use serial::{BaudRate, FlowControl, SerialPort};
-use std::{
-    fs,
-    path::PathBuf,
-    process::{exit, Command, ExitStatus, Stdio},
-    string::ToString,
-};
+
+use crate::{cargo_config::parse_cargo_config, error::UnsupportedTargetError};
 
 mod cargo_config;
 mod error;
@@ -23,6 +24,7 @@ mod package_metadata;
 
 fn main() -> Result<()> {
     miette::set_panic_hook();
+
     let mut app = App::new(env!("CARGO_PKG_NAME"))
         .bin_name("cargo")
         .subcommand(
@@ -143,7 +145,7 @@ fn main() -> Result<()> {
     // provided, display the board info and terminate the application.
     let mut flasher = Flasher::connect(serial, speed)?;
     if matches.is_present("board_info") {
-        board_info(&flasher);
+        board_info(&mut flasher)?;
         return Ok(());
     }
 
@@ -200,9 +202,23 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn board_info(flasher: &Flasher) {
-    println!("Chip type:  {}", flasher.chip());
-    println!("Flash size: {}", flasher.flash_size());
+fn board_info(flasher: &mut Flasher) -> Result<()> {
+    let chip = flasher.chip();
+    let revision = chip.chip_revision(flasher.connection())?;
+    let freq = chip.crystal_freq(flasher.connection())?;
+
+    // Print the detected chip type, and if available the silicon revision.
+    print!("Chip type:         {}", chip);
+    if let Some(revision) = revision {
+        println!(" (revision {})", revision);
+    } else {
+        println!();
+    }
+
+    println!("Crystal frequency: {}MHz", freq);
+    println!("Flash size:        {}", flasher.flash_size());
+
+    Ok(())
 }
 
 fn build(

espflash/src/chip/esp32/esp32.rs

@@ -3,6 +3,7 @@ use std::ops::Range;
 use super::Esp32Params;
 use crate::{
     chip::{Chip, ChipType, ReadEFuse, SpiRegisters},
+    connection::Connection,
     elf::FirmwareImage,
     image_format::{Esp32BootloaderFormat, ImageFormat, ImageFormatId},
     Error, PartitionTable,
@@ -32,6 +33,8 @@ pub const PARAMS: Esp32Params = Esp32Params {
 impl ChipType for Esp32 {
     const CHIP_DETECT_MAGIC_VALUE: u32 = 0x00f01d83;
 
+    const UART_CLKDIV_REG: u32 = 0x3ff40014;
+
     const SPI_REGISTERS: SpiRegisters = SpiRegisters {
         base: 0x3ff42000,
         usr_offset: 0x1c,
@@ -80,6 +83,28 @@ impl ReadEFuse for Esp32 {
     const EFUSE_REG_BASE: u32 = 0x3ff5a000;
 }
 
+impl Esp32 {
+    pub fn chip_revision(&self, connection: &mut Connection) -> Result<u32, Error> {
+        let word3 = self.read_efuse(connection, 3)?;
+        let word5 = self.read_efuse(connection, 5)?;
+
+        let apb_ctrl_date = connection.read_reg(0x3FF6607C)?;
+
+        let rev_bit0 = (word3 >> 15) & 0x1 != 0;
+        let rev_bit1 = (word5 >> 20) & 0x1 != 0;
+        let rev_bit2 = (apb_ctrl_date >> 31) & 0x1 != 0;
+
+        let revision = match (rev_bit0, rev_bit1, rev_bit2) {
+            (true, true, true) => 3,
+            (true, true, false) => 2,
+            (true, false, _) => 1,
+            (false, _, _) => 0,
+        };
+
+        Ok(revision)
+    }
+}
+
 #[test]
 fn test_esp32_rom() {
     use std::fs::read;

espflash/src/chip/esp32/esp32c3.rs

@@ -3,6 +3,7 @@ use std::ops::Range;
 use super::Esp32Params;
 use crate::{
     chip::{ChipType, ReadEFuse, SpiRegisters},
+    connection::Connection,
     elf::FirmwareImage,
     image_format::{Esp32BootloaderFormat, ImageFormat, ImageFormatId},
     Chip, Error, PartitionTable,
@@ -33,6 +34,8 @@ impl ChipType for Esp32c3 {
     const CHIP_DETECT_MAGIC_VALUE: u32 = 0x6921506f;
     const CHIP_DETECT_MAGIC_VALUE2: u32 = 0x1b31506f;
 
+    const UART_CLKDIV_REG: u32 = 0x3ff40014;
+
     const SPI_REGISTERS: SpiRegisters = SpiRegisters {
         base: 0x60002000,
         usr_offset: 0x18,
@@ -53,6 +56,11 @@ impl ChipType for Esp32c3 {
     const SUPPORTED_TARGETS: &'static [&'static str] =
         &["riscv32imc-uknown-none-elf", "riscv32imc-esp-espidf"];
 
+    fn crystal_freq(&self, _connection: &mut Connection) -> Result<u32, Error> {
+        // The ESP32-C3's XTAL has a fixed frequency of 40MHz.
+        Ok(40)
+    }
+
     fn get_flash_segments<'a>(
         image: &'a FirmwareImage,
         bootloader: Option<Vec<u8>>,
@@ -81,3 +89,16 @@ impl ChipType for Esp32c3 {
 impl ReadEFuse for Esp32c3 {
     const EFUSE_REG_BASE: u32 = 0x60008830;
 }
+
+impl Esp32c3 {
+    pub fn chip_revision(&self, connection: &mut Connection) -> Result<u32, Error> {
+        let block1_addr = Self::EFUSE_REG_BASE + 0x14;
+        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)
+    }
+}

espflash/src/chip/esp32/esp32s2.rs

@@ -3,6 +3,7 @@ use std::ops::Range;
 use super::Esp32Params;
 use crate::{
     chip::{ChipType, ReadEFuse, SpiRegisters},
+    connection::Connection,
     elf::FirmwareImage,
     image_format::{Esp32BootloaderFormat, ImageFormat, ImageFormatId},
     Chip, Error, PartitionTable,
@@ -32,6 +33,8 @@ pub const PARAMS: Esp32Params = Esp32Params {
 impl ChipType for Esp32s2 {
     const CHIP_DETECT_MAGIC_VALUE: u32 = 0x000007c6;
 
+    const UART_CLKDIV_REG: u32 = 0x3f400014;
+
     const SPI_REGISTERS: SpiRegisters = SpiRegisters {
         base: 0x3f402000,
         usr_offset: 0x18,
@@ -51,6 +54,11 @@ impl ChipType for Esp32s2 {
     const SUPPORTED_TARGETS: &'static [&'static str] =
         &["xtensa-esp32s2-none-elf", "xtensa-esp32s2-espidf"];
 
+    fn crystal_freq(&self, _connection: &mut Connection) -> Result<u32, Error> {
+        // The ESP32-S2's XTAL has a fixed frequency of 40MHz.
+        Ok(40)
+    }
+
     fn get_flash_segments<'a>(
         image: &'a FirmwareImage,
         bootloader: Option<Vec<u8>>,

espflash/src/chip/esp32/mod.rs

@@ -1,5 +1,6 @@
 use crate::PartitionTable;
 
+#[allow(clippy::module_inception)]
 mod esp32;
 mod esp32c3;
 mod esp32s2;

espflash/src/chip/esp8266.rs

@@ -17,6 +17,9 @@ pub struct Esp8266;
 impl ChipType for Esp8266 {
     const CHIP_DETECT_MAGIC_VALUE: u32 = 0xfff0c101;
 
+    const UART_CLKDIV_REG: u32 = 0x60000014;
+    const XTAL_CLK_DIVIDER: u32 = 2;
+
     const SPI_REGISTERS: SpiRegisters = SpiRegisters {
         base: 0x60000200,
         usr_offset: 0x1c,

espflash/src/chip/mod.rs

@@ -22,6 +22,10 @@ pub trait ChipType {
     const CHIP_DETECT_MAGIC_VALUE: u32;
     const CHIP_DETECT_MAGIC_VALUE2: u32 = 0x0; // give default value, as most chips don't only have one
 
+    const UART_CLKDIV_REG: u32;
+    const UART_CLKDIV_MASK: u32 = 0xFFFFF;
+    const XTAL_CLK_DIVIDER: u32 = 1;
+
     const SPI_REGISTERS: SpiRegisters;
     const FLASH_RANGES: &'static [Range<u32>];
 
@@ -30,6 +34,16 @@ pub trait ChipType {
 
     const SUPPORTED_TARGETS: &'static [&'static str];
 
+    /// Determine the frequency of the crytal on the connected chip.
+    fn crystal_freq(&self, connection: &mut Connection) -> Result<u32, Error> {
+        let uart_div = connection.read_reg(Self::UART_CLKDIV_REG)? & Self::UART_CLKDIV_MASK;
+        let est_xtal =
+            (connection.get_baud().speed() as u32 * uart_div) / 1_000_000 / Self::XTAL_CLK_DIVIDER;
+        let norm_xtal = if est_xtal > 33 { 40 } else { 26 };
+
+        Ok(norm_xtal)
+    }
+
     /// Get the firmware segments for writing an image to flash
     fn get_flash_segments<'a>(
         image: &'a FirmwareImage,
@@ -206,12 +220,22 @@ impl Chip {
         }
     }
 
-    pub fn read_efuse(&self, connection: &mut Connection, n: u32) -> Result<u32, Error> {
+    pub fn crystal_freq(&self, connection: &mut Connection) -> Result<u32, Error> {
         match self {
-            Chip::Esp32 => Esp32.read_efuse(connection, n),
-            Chip::Esp32c3 => Esp32c3.read_efuse(connection, n),
-            Chip::Esp32s2 => Esp32s2.read_efuse(connection, n),
-            Chip::Esp8266 => Esp8266.read_efuse(connection, n),
+            Chip::Esp32 => Esp32.crystal_freq(connection),
+            Chip::Esp32c3 => Esp32c3.crystal_freq(connection),
+            Chip::Esp32s2 => Esp32s2.crystal_freq(connection),
+            Chip::Esp8266 => Esp8266.crystal_freq(connection),
         }
     }
+
+    pub fn chip_revision(&self, connection: &mut Connection) -> Result<Option<u32>, Error> {
+        let rev = match self {
+            Chip::Esp32 => Some(Esp32.chip_revision(connection)?),
+            Chip::Esp32c3 => Some(Esp32c3.chip_revision(connection)?),
+            _ => None,
+        };
+
+        Ok(rev)
+    }
 }

espflash/src/connection.rs

@@ -11,11 +11,6 @@ use crate::{
     flasher::Command,
 };
 
-pub struct Connection {
-    serial: SystemPort,
-    decoder: Decoder,
-}
-
 #[derive(Debug, Copy, Clone, BinRead)]
 pub struct CommandResponse {
     pub resp: u8,
@@ -26,6 +21,12 @@ pub struct CommandResponse {
     pub error: u8,
 }
 
+pub struct Connection {
+    serial: SystemPort,
+    speed: BaudRate,
+    decoder: Decoder,
+}
+
 #[derive(Zeroable, Pod, Copy, Clone, Debug)]
 #[repr(C)]
 struct WriteRegParams {
@@ -39,6 +40,7 @@ impl Connection {
     pub fn new(serial: SystemPort) -> Self {
         Connection {
             serial,
+            speed: BaudRate::Baud115200,
             decoder: Decoder::new(),
         }
     }
@@ -78,11 +80,17 @@ impl Connection {
     }
 
     pub fn set_baud(&mut self, speed: BaudRate) -> Result<(), Error> {
+        self.speed = speed;
         self.serial
             .reconfigure(&|setup: &mut dyn SerialPortSettings| setup.set_baud_rate(speed))?;
+
         Ok(())
     }
 
+    pub fn get_baud(&self) -> BaudRate {
+        self.speed
+    }
+
     pub fn with_timeout<T, F: FnMut(&mut Connection) -> Result<T, Error>>(
         &mut self,
         timeout: Duration,

espflash/src/flasher.rs

@@ -444,6 +444,11 @@ impl Flasher {
         Ok(result)
     }
 
+    /// The active serial connection being used by the flasher
+    pub fn connection(&mut self) -> &mut Connection {
+        &mut self.connection
+    }
+
     /// The chip type that the flasher is connected to
     pub fn chip(&self) -> Chip {
         self.chip