Create and implement a trait for reading eFuse values

Author: jessebraham

espflash/src/chip/esp32/esp32.rs

@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use super::Esp32Params;
 use crate::{
-    chip::{Chip, ChipType, SpiRegisters},
+    chip::{Chip, ChipType, ReadEFuse, SpiRegisters},
     elf::FirmwareImage,
     image_format::{Esp32BootloaderFormat, ImageFormat, ImageFormatId},
     Error, PartitionTable,
@@ -76,6 +76,10 @@ impl ChipType for Esp32 {
     }
 }
 
+impl ReadEFuse for Esp32 {
+    const EFUSE_REG_BASE: u32 = 0x3ff5a000;
+}
+
 #[test]
 fn test_esp32_rom() {
     use std::fs::read;

espflash/src/chip/esp32/esp32c3.rs

@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use super::Esp32Params;
 use crate::{
-    chip::{ChipType, SpiRegisters},
+    chip::{ChipType, ReadEFuse, SpiRegisters},
     elf::FirmwareImage,
     image_format::{Esp32BootloaderFormat, ImageFormat, ImageFormatId},
     Chip, Error, PartitionTable,
@@ -77,3 +77,7 @@ impl ChipType for Esp32c3 {
         target.starts_with("riscv32imc-")
     }
 }
+
+impl ReadEFuse for Esp32c3 {
+    const EFUSE_REG_BASE: u32 = 0x60008830;
+}

espflash/src/chip/esp32/esp32s2.rs

@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use super::Esp32Params;
 use crate::{
-    chip::{ChipType, SpiRegisters},
+    chip::{ChipType, ReadEFuse, SpiRegisters},
     elf::FirmwareImage,
     image_format::{Esp32BootloaderFormat, ImageFormat, ImageFormatId},
     Chip, Error, PartitionTable,
@@ -75,3 +75,7 @@ impl ChipType for Esp32s2 {
         target.starts_with("xtensa-esp32s2-")
     }
 }
+
+impl ReadEFuse for Esp32s2 {
+    const EFUSE_REG_BASE: u32 = 0x3F41A030;
+}

espflash/src/chip/esp8266.rs

@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use super::ChipType;
 use crate::{
-    chip::SpiRegisters,
+    chip::{ReadEFuse, SpiRegisters},
     elf::FirmwareImage,
     error::UnsupportedImageFormatError,
     image_format::{Esp8266Format, ImageFormat, ImageFormatId},
@@ -51,11 +51,16 @@ impl ChipType for Esp8266 {
     }
 }
 
+impl ReadEFuse for Esp8266 {
+    const EFUSE_REG_BASE: u32 = 0x3ff00050;
+}
+
 #[test]
 fn test_esp8266_rom() {
-    use pretty_assertions::assert_eq;
     use std::fs::read;
 
+    use pretty_assertions::assert_eq;
+
     let input_bytes = read("./tests/data/esp8266").unwrap();
     let expected_bin = read("./tests/data/esp8266.bin").unwrap();
 

espflash/src/chip/mod.rs

@@ -3,6 +3,7 @@ use std::ops::Range;
 use strum_macros::Display;
 
 use crate::{
+    connection::Connection,
     elf::FirmwareImage,
     error::ChipDetectError,
     flash_target::{Esp32Target, Esp8266Target, FlashTarget, RamTarget},
@@ -40,6 +41,16 @@ pub trait ChipType {
     fn supports_target(target: &str) -> bool;
 }
 
+pub trait ReadEFuse {
+    const EFUSE_REG_BASE: u32;
+
+    /// Given an active connection, read the nth word of the eFuse region.
+    fn read_efuse(&self, connection: &mut Connection, n: u32) -> Result<u32, Error> {
+        let reg = Self::EFUSE_REG_BASE + (n * 0x4);
+        connection.read_reg(reg)
+    }
+}
+
 pub struct SpiRegisters {
     base: u32,
     usr_offset: u32,
@@ -194,4 +205,13 @@ impl Chip {
             Chip::Esp8266 => Esp8266::SUPPORTED_TARGETS,
         }
     }
+
+    pub fn read_efuse(&self, connection: &mut Connection, n: u32) -> 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),
+        }
+    }
 }

espflash/src/connection.rs

@@ -1,15 +1,16 @@
-use std::io::Write;
-use std::thread::sleep;
-use std::time::Duration;
-
-use crate::encoder::SlipEncoder;
-use crate::error::{ConnectionError, Error, ResultExt, RomError, RomErrorKind};
-use crate::flasher::Command;
-use binread::io::Cursor;
-use binread::{BinRead, BinReaderExt};
+use std::{io::Write, thread::sleep, time::Duration};
+
+use binread::{io::Cursor, BinRead, BinReaderExt};
+use bytemuck::{bytes_of, Pod, Zeroable};
 use serial::{BaudRate, SerialPort, SerialPortSettings, SystemPort};
 use slip_codec::Decoder;
 
+use crate::{
+    encoder::SlipEncoder,
+    error::{ConnectionError, Error, ResultExt, RomError, RomErrorKind},
+    flasher::Command,
+};
+
 pub struct Connection {
     serial: SystemPort,
     decoder: Decoder,
@@ -25,6 +26,15 @@ pub struct CommandResponse {
     pub error: u8,
 }
 
+#[derive(Zeroable, Pod, Copy, Clone, Debug)]
+#[repr(C)]
+struct WriteRegParams {
+    addr: u32,
+    value: u32,
+    mask: u32,
+    delay_us: u32,
+}
+
 impl Connection {
     pub fn new(serial: SystemPort) -> Self {
         Connection {
@@ -143,6 +153,26 @@ impl Connection {
         Err(Error::Connection(ConnectionError::ConnectionFailed))
     }
 
+    pub fn read_reg(&mut self, reg: u32) -> Result<u32, Error> {
+        self.with_timeout(Command::ReadReg.timeout(), |connection| {
+            connection.command(Command::ReadReg, &reg.to_le_bytes()[..], 0)
+        })
+    }
+
+    pub fn write_reg(&mut self, addr: u32, value: u32, mask: Option<u32>) -> Result<(), Error> {
+        let params = WriteRegParams {
+            addr,
+            value,
+            mask: mask.unwrap_or(0xFFFFFFFF),
+            delay_us: 0,
+        };
+        self.with_timeout(Command::WriteReg.timeout(), |connection| {
+            connection.command(Command::WriteReg, bytes_of(&params), 0)
+        })?;
+
+        Ok(())
+    }
+
     fn read(&mut self) -> Result<Vec<u8>, Error> {
         let mut output = Vec::with_capacity(1024);
         self.decoder.decode(&mut self.serial, &mut output)?;

espflash/src/flasher.rs

@@ -1,16 +1,17 @@
+use std::{borrow::Cow, thread::sleep};
+
 use bytemuck::{__core::time::Duration, bytes_of, Pod, Zeroable};
 use serial::{BaudRate, SystemPort};
 use strum_macros::Display;
 
-use std::thread::sleep;
-
-use crate::elf::RomSegment;
-use crate::error::{ConnectionError, ElfError, FlashDetectError, ResultExt, RomError};
 use crate::{
-    chip::Chip, connection::Connection, elf::FirmwareImage, encoder::SlipEncoder,
-    error::RomErrorKind, Error, PartitionTable,
+    chip::Chip,
+    connection::Connection,
+    elf::{FirmwareImage, RomSegment},
+    encoder::SlipEncoder,
+    error::{ConnectionError, ElfError, FlashDetectError, ResultExt, RomError, RomErrorKind},
+    Error, PartitionTable,
 };
-use std::borrow::Cow;
 
 pub(crate) type Encoder<'a> = SlipEncoder<'a, SystemPort>;
 
@@ -187,15 +188,6 @@ struct BeginParams {
     encrypted: u32,
 }
 
-#[derive(Zeroable, Pod, Copy, Clone, Debug)]
-#[repr(C)]
-struct WriteRegParams {
-    addr: u32,
-    value: u32,
-    mask: u32,
-    delay_us: u32,
-}
-
 #[derive(Zeroable, Pod, Copy, Clone)]
 #[repr(C)]
 struct EntryParams {
@@ -255,7 +247,7 @@ impl Flasher {
     }
 
     fn chip_detect(&mut self) -> Result<(), Error> {
-        let magic = self.read_reg(CHIP_DETECT_MAGIC_REG_ADDR)?;
+        let magic = self.connection.read_reg(CHIP_DETECT_MAGIC_REG_ADDR)?;
         let chip = Chip::from_magic(magic)?;
 
         self.chip = chip;
@@ -375,8 +367,8 @@ impl Flasher {
 
         let spi_registers = self.chip.spi_registers();
 
-        let old_spi_usr = self.read_reg(spi_registers.usr())?;
-        let old_spi_usr2 = self.read_reg(spi_registers.usr2())?;
+        let old_spi_usr = self.connection.read_reg(spi_registers.usr())?;
+        let old_spi_usr2 = self.connection.read_reg(spi_registers.usr2())?;
 
         let mut flags = 1 << 31;
         if !data.is_empty() {
@@ -386,17 +378,21 @@ impl Flasher {
             flags |= 1 << 28;
         }
 
-        self.write_reg(spi_registers.usr(), flags, None)?;
-        self.write_reg(spi_registers.usr2(), 7 << 28 | command as u32, None)?;
+        self.connection
+            .write_reg(spi_registers.usr(), flags, None)?;
+        self.connection
+            .write_reg(spi_registers.usr2(), 7 << 28 | command as u32, None)?;
 
         if let (Some(mosi_data_length), Some(miso_data_length)) =
             (spi_registers.mosi_length(), spi_registers.miso_length())
         {
             if !data.is_empty() {
-                self.write_reg(mosi_data_length, data.len() as u32 * 8 - 1, None)?;
+                self.connection
+                    .write_reg(mosi_data_length, data.len() as u32 * 8 - 1, None)?;
             }
             if read_bits > 0 {
-                self.write_reg(miso_data_length, read_bits - 1, None)?;
+                self.connection
+                    .write_reg(miso_data_length, read_bits - 1, None)?;
             }
         } else {
             let mosi_mask = if data.is_empty() {
@@ -405,26 +401,32 @@ impl Flasher {
                 data.len() as u32 * 8 - 1
             };
             let miso_mask = if read_bits == 0 { 0 } else { read_bits - 1 };
-            self.write_reg(spi_registers.usr1(), miso_mask << 8 | mosi_mask << 17, None)?;
+            self.connection.write_reg(
+                spi_registers.usr1(),
+                miso_mask << 8 | mosi_mask << 17,
+                None,
+            )?;
         }
 
         if data.is_empty() {
-            self.write_reg(spi_registers.w0(), 0, None)?;
+            self.connection.write_reg(spi_registers.w0(), 0, None)?;
         } else {
             for (i, bytes) in data.chunks(4).enumerate() {
                 let mut data_bytes = [0; 4];
                 data_bytes[0..bytes.len()].copy_from_slice(bytes);
                 let data = u32::from_le_bytes(data_bytes);
-                self.write_reg(spi_registers.w0() + i as u32, data, None)?;
+                self.connection
+                    .write_reg(spi_registers.w0() + i as u32, data, None)?;
             }
         }
 
-        self.write_reg(spi_registers.cmd(), 1 << 18, None)?;
+        self.connection
+            .write_reg(spi_registers.cmd(), 1 << 18, None)?;
 
         let mut i = 0;
         loop {
             sleep(Duration::from_millis(1));
-            if self.read_reg(spi_registers.usr())? & (1 << 18) == 0 {
+            if self.connection.read_reg(spi_registers.usr())? & (1 << 18) == 0 {
                 break;
             }
             i += 1;
@@ -433,32 +435,13 @@ impl Flasher {
             }
         }
 
-        let result = self.read_reg(spi_registers.w0())?;
-        self.write_reg(spi_registers.usr(), old_spi_usr, None)?;
-        self.write_reg(spi_registers.usr2(), old_spi_usr2, None)?;
-
-        Ok(result)
-    }
-
-    fn read_reg(&mut self, reg: u32) -> Result<u32, Error> {
+        let result = self.connection.read_reg(spi_registers.w0())?;
         self.connection
-            .with_timeout(Command::ReadReg.timeout(), |connection| {
-                connection.command(Command::ReadReg, &reg.to_le_bytes()[..], 0)
-            })
-    }
-
-    fn write_reg(&mut self, addr: u32, value: u32, mask: Option<u32>) -> Result<(), Error> {
-        let params = WriteRegParams {
-            addr,
-            value,
-            mask: mask.unwrap_or(0xFFFFFFFF),
-            delay_us: 0,
-        };
+            .write_reg(spi_registers.usr(), old_spi_usr, None)?;
         self.connection
-            .with_timeout(Command::WriteReg.timeout(), |connection| {
-                connection.command(Command::WriteReg, bytes_of(&params), 0)
-            })?;
-        Ok(())
+            .write_reg(spi_registers.usr2(), old_spi_usr2, None)?;
+
+        Ok(result)
     }
 
     /// The chip type that the flasher is connected to