Ensure that FlashMode, FlashSize, and FlashFrequency can all be serialized/deserialized

Author: jessebraham

espflash/src/elf.rs

@@ -1,37 +1,81 @@
-use std::borrow::Cow;
-use std::cmp::Ordering;
-
-use crate::chip::Chip;
-use crate::error::{ElfError, Error};
-use crate::flasher::FlashSize;
-use std::fmt::{Debug, Formatter};
-use std::mem::take;
-use std::ops::AddAssign;
-use xmas_elf::program::Type;
-use xmas_elf::sections::{SectionData, ShType};
-use xmas_elf::ElfFile;
+use std::{
+    borrow::Cow,
+    cmp::Ordering,
+    fmt::{Debug, Formatter},
+    mem::take,
+    ops::AddAssign,
+    str::FromStr,
+};
+
+use strum_macros::EnumVariantNames;
+use xmas_elf::{
+    program::Type,
+    sections::{SectionData, ShType},
+    ElfFile,
+};
+
+use crate::{
+    chip::Chip,
+    error::{ElfError, Error},
+    flasher::FlashSize,
+};
 
 pub const ESP_CHECKSUM_MAGIC: u8 = 0xef;
 
-#[derive(Copy, Clone)]
-#[allow(dead_code)]
+#[derive(Copy, Clone, EnumVariantNames)]
+#[strum(serialize_all = "UPPERCASE")]
 pub enum FlashMode {
     Qio,
     Qout,
     Dio,
     Dout,
 }
 
-#[derive(Copy, Clone)]
+impl FromStr for FlashMode {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mode = match s.to_uppercase().as_str() {
+            "QIO" => FlashMode::Qio,
+            "QOUT" => FlashMode::Qout,
+            "DIO" => FlashMode::Dio,
+            "DOUT" => FlashMode::Dout,
+            _ => return Err(Error::InvalidFlashMode(s.to_string())),
+        };
+
+        Ok(mode)
+    }
+}
+
+#[derive(Copy, Clone, EnumVariantNames)]
 #[repr(u8)]
-#[allow(dead_code)]
 pub enum FlashFrequency {
-    Flash40M = 0,
-    Flash26M = 1,
-    Flash20M = 2,
+    #[strum(serialize = "20M")]
+    Flash20M = 0x2,
+    #[strum(serialize = "26M")]
+    Flash26M = 0x1,
+    #[strum(serialize = "40M")]
+    Flash40M = 0x0,
+    #[strum(serialize = "80M")]
     Flash80M = 0xf,
 }
 
+impl FromStr for FlashFrequency {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let freq = match s.to_uppercase().as_str() {
+            "20M" => FlashFrequency::Flash20M,
+            "26M" => FlashFrequency::Flash26M,
+            "40M" => FlashFrequency::Flash40M,
+            "80M" => FlashFrequency::Flash80M,
+            _ => return Err(Error::InvalidFlashFrequency(s.to_string())),
+        };
+
+        Ok(freq)
+    }
+}
+
 pub struct FirmwareImage<'a> {
     pub entry: u32,
     pub elf: ElfFile<'a>,

espflash/src/error.rs

@@ -10,6 +10,8 @@ use thiserror::Error;
 
 use crate::{
     command::CommandType,
+    elf::{FlashFrequency, FlashMode},
+    flasher::FlashSize,
     image_format::ImageFormatId,
     partition_table::{SubType, Type},
     Chip,
@@ -89,6 +91,24 @@ https://github.com/espressif/esp32c3-direct-boot-example"
     SerialNotFound(String),
     #[error("Canceled by user")]
     Canceled,
+    #[error("The flash mode '{0}' is not valid")]
+    #[diagnostic(
+        code(espflash::invalid_flash_mode),
+        help("The accepted values are: {:?}", FlashMode::VARIANTS)
+    )]
+    InvalidFlashMode(String),
+    #[error("The flash frequency '{0}' is not valid")]
+    #[diagnostic(
+        code(espflash::invalid_flash_frequency),
+        help("The accepted values are: {:?}", FlashFrequency::VARIANTS)
+    )]
+    InvalidFlashFrequency(String),
+    #[error("The flash size '{0}' is not valid")]
+    #[diagnostic(
+        code(espflash::invalid_flash_size),
+        help("The accepted values are: {:?}", FlashSize::VARIANTS)
+    )]
+    InvalidFlashSize(String),
 }
 
 #[derive(Error, Debug, Diagnostic)]

espflash/src/flasher.rs

@@ -1,8 +1,8 @@
-use std::{borrow::Cow, thread::sleep};
+use std::{borrow::Cow, str::FromStr, thread::sleep};
 
 use bytemuck::{Pod, Zeroable, __core::time::Duration};
 use serialport::{SerialPort, UsbPortInfo};
-use strum_macros::Display;
+use strum_macros::{Display, EnumVariantNames};
 
 use crate::{
     chip::Chip,
@@ -25,7 +25,7 @@ const FLASH_SECTORS_PER_BLOCK: usize = FLASH_SECTOR_SIZE / FLASH_BLOCK_SIZE;
 // register used for chip detect
 const CHIP_DETECT_MAGIC_REG_ADDR: u32 = 0x40001000;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Display)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Display, EnumVariantNames)]
 #[repr(u8)]
 pub enum FlashSize {
     #[strum(serialize = "256KB")]
@@ -62,11 +62,34 @@ impl FlashSize {
             0x18 => Ok(FlashSize::Flash16Mb),
             0x19 => Ok(FlashSize::Flash32Mb),
             0x1a => Ok(FlashSize::Flash64Mb),
+            0x21 => Ok(FlashSize::Flash128Mb),
             _ => Err(Error::UnsupportedFlash(FlashDetectError::from(value))),
         }
     }
 }
 
+impl FromStr for FlashSize {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let size = match s.to_uppercase().as_str() {
+            "256KB" => FlashSize::Flash256Kb,
+            "512KB" => FlashSize::Flash512Kb,
+            "1MB" => FlashSize::Flash1Mb,
+            "2MB" => FlashSize::Flash2Mb,
+            "4MB" => FlashSize::Flash4Mb,
+            "8MB" => FlashSize::Flash8Mb,
+            "16MB" => FlashSize::Flash16Mb,
+            "32MB" => FlashSize::Flash32Mb,
+            "64MB" => FlashSize::Flash64Mb,
+            "128MB" => FlashSize::Flash128Mb,
+            _ => return Err(Error::InvalidFlashSize(s.to_string())),
+        };
+
+        Ok(size)
+    }
+}
+
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct SpiAttachParams {

espflash/src/lib.rs

@@ -1,8 +1,8 @@
 pub use chip::Chip;
 pub use cli::config::Config;
-pub use elf::FirmwareImage;
+pub use elf::{FlashFrequency, FlashMode};
 pub use error::Error;
-pub use flasher::Flasher;
+pub use flasher::{FlashSize, Flasher};
 pub use image_format::ImageFormatId;
 pub use partition_table::PartitionTable;