better chip and flash detect errors

Author: icewind1991

espflash/src/chip/esp8266.rs

@@ -4,6 +4,7 @@ use super::{ChipType, EspCommonHeader, SegmentHeader, ESP_MAGIC};
 use crate::{
     chip::{Chip, SpiRegisters},
     elf::{update_checksum, CodeSegment, FirmwareImage, RomSegment, ESP_CHECKSUM_MAGIC},
+    error::FlashDetectError,
     flasher::FlashSize,
     Error, PartitionTable,
 };
@@ -96,7 +97,7 @@ impl ChipType for Esp8266 {
     }
 }
 
-fn encode_flash_size(size: FlashSize) -> Result<u8, Error> {
+fn encode_flash_size(size: FlashSize) -> Result<u8, FlashDetectError> {
     match size {
         FlashSize::Flash256Kb => Ok(0x10),
         FlashSize::Flash512Kb => Ok(0x00),
@@ -105,7 +106,7 @@ fn encode_flash_size(size: FlashSize) -> Result<u8, Error> {
         FlashSize::Flash4Mb => Ok(0x40),
         FlashSize::Flash8Mb => Ok(0x80),
         FlashSize::Flash16Mb => Ok(0x90),
-        FlashSize::FlashRetry => Err(Error::UnsupportedFlash(size as u8)),
+        FlashSize::FlashRetry => Err(FlashDetectError::from(size as u8)),
     }
 }
 

espflash/src/chip/mod.rs

@@ -7,8 +7,9 @@ use crate::{
     Error, PartitionTable,
 };
 
-use std::{io::Write, str::FromStr};
+use std::io::Write;
 
+use crate::error::{ChipDetectError, FlashDetectError};
 use crate::flash_target::{Esp32Target, Esp8266Target, FlashTarget, RamTarget};
 use crate::flasher::SpiAttachParams;
 pub use esp32::Esp32;
@@ -102,14 +103,14 @@ pub enum Chip {
 }
 
 impl Chip {
-    pub fn from_magic(magic: u32) -> Option<Self> {
+    pub fn from_magic(magic: u32) -> Result<Self, ChipDetectError> {
         match magic {
-            Esp32::CHIP_DETECT_MAGIC_VALUE => Some(Chip::Esp32),
+            Esp32::CHIP_DETECT_MAGIC_VALUE => Ok(Chip::Esp32),
             Esp32c3::CHIP_DETECT_MAGIC_VALUE | Esp32c3::CHIP_DETECT_MAGIC_VALUE2 => {
-                Some(Chip::Esp32c3)
+                Ok(Chip::Esp32c3)
             }
-            Esp8266::CHIP_DETECT_MAGIC_VALUE => Some(Chip::Esp8266),
-            _ => None,
+            Esp8266::CHIP_DETECT_MAGIC_VALUE => Ok(Chip::Esp8266),
+            _ => Err(ChipDetectError::from(magic)),
         }
     }
 
@@ -154,19 +155,6 @@ impl Chip {
     }
 }
 
-impl FromStr for Chip {
-    type Err = Error;
-
-    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),
-        }
-    }
-}
-
 #[derive(Copy, Clone, Zeroable, Pod, Debug)]
 #[repr(C)]
 struct EspCommonHeader {
@@ -186,16 +174,16 @@ struct SegmentHeader {
 
 // 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> {
+fn encode_flash_size(size: FlashSize) -> Result<u8, FlashDetectError> {
     match size {
-        FlashSize::Flash256Kb => Err(Error::UnsupportedFlash(size as u8)),
-        FlashSize::Flash512Kb => Err(Error::UnsupportedFlash(size as u8)),
+        FlashSize::Flash256Kb => Err(FlashDetectError::from(size as u8)),
+        FlashSize::Flash512Kb => Err(FlashDetectError::from(size as u8)),
         FlashSize::Flash1Mb => Ok(0x00),
         FlashSize::Flash2Mb => Ok(0x10),
         FlashSize::Flash4Mb => Ok(0x20),
         FlashSize::Flash8Mb => Ok(0x30),
         FlashSize::Flash16Mb => Ok(0x40),
-        FlashSize::FlashRetry => Err(Error::UnsupportedFlash(size as u8)),
+        FlashSize::FlashRetry => Err(FlashDetectError::from(size as u8)),
     }
 }
 

espflash/src/error.rs

@@ -27,24 +27,22 @@ pub enum Error {
     ElfNotRamLoadable,
     #[error("The bootloader returned an error")]
     #[diagnostic(transparent)]
-    RomError(#[source] RomError),
+    RomError(#[from] RomError),
     #[error("Chip not recognized, supported chip types are esp8266, esp32 and esp32-c3")]
     #[diagnostic(
         code(espflash::unrecognized_chip),
         help("If your chip is supported, try hard-resetting the device and try again")
     )]
-    UnrecognizedChip,
-    #[error(
-        "Flash chip not supported, flash id: {0:#x}, flash sizes from 1 to 16MB are supported"
-    )]
+    UnrecognizedChip(#[from] ChipDetectError),
+    #[error("Flash chip not supported, flash sizes from 1 to 16MB are supported")]
     #[diagnostic(code(espflash::unrecognized_flash))]
-    UnsupportedFlash(u8),
+    UnsupportedFlash(#[from] FlashDetectError),
     #[error("Failed to connect to on-device flash")]
     #[diagnostic(code(espflash::flash_connect))]
     FlashConnect,
     #[error(transparent)]
     #[diagnostic(transparent)]
-    MalformedPartitionTable(PartitionTableError),
+    MalformedPartitionTable(#[from] PartitionTableError),
 }
 
 #[derive(Error, Debug, Diagnostic)]
@@ -285,3 +283,23 @@ impl From<&'static str> for ElfError {
         ElfError(err)
     }
 }
+
+#[derive(Debug, Error)]
+#[error("Unrecognized magic value {0:#x}")]
+pub struct ChipDetectError(u32);
+
+impl From<u32> for ChipDetectError {
+    fn from(err: u32) -> Self {
+        ChipDetectError(err)
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("Unrecognized flash id {0:#x}")]
+pub struct FlashDetectError(u8);
+
+impl From<u8> for FlashDetectError {
+    fn from(err: u8) -> Self {
+        FlashDetectError(err)
+    }
+}

espflash/src/flasher.rs

@@ -5,7 +5,7 @@ use strum_macros::Display;
 use std::thread::sleep;
 
 use crate::elf::RomSegment;
-use crate::error::{ConnectionError, ElfError, ResultExt};
+use crate::error::{ConnectionError, ElfError, FlashDetectError, ResultExt};
 use crate::{
     chip::Chip, connection::Connection, elf::FirmwareImage, encoder::SlipEncoder, error::RomError,
     Error, PartitionTable,
@@ -108,7 +108,7 @@ impl FlashSize {
             0x17 => Ok(FlashSize::Flash8Mb),
             0x18 => Ok(FlashSize::Flash16Mb),
             0xFF => Ok(FlashSize::FlashRetry),
-            _ => Err(Error::UnsupportedFlash(value)),
+            _ => Err(Error::UnsupportedFlash(FlashDetectError::from(value))),
         }
     }
 }
@@ -253,7 +253,7 @@ impl Flasher {
 
     fn chip_detect(&mut self) -> Result<(), Error> {
         let magic = self.read_reg(CHIP_DETECT_MAGIC_REG_ADDR)?;
-        let chip = Chip::from_magic(magic).ok_or(Error::UnrecognizedChip)?;
+        let chip = Chip::from_magic(magic)?;
 
         self.chip = chip;
         Ok(())