Create a FirmwareImageBuilder which allows setting flash parameters

Author: jessebraham

cargo-espflash/src/main.rs

@@ -12,7 +12,7 @@ use espflash::{
         board_info, connect, flash_elf_image, monitor::monitor, save_elf_as_image, ConnectOpts,
         FlashOpts,
     },
-    Chip, Config, ImageFormatId,
+    Chip, Config, FlashFrequency, FlashMode, FlashSize, ImageFormatId,
 };
 use miette::{IntoDiagnostic, Result, WrapErr};
 
@@ -86,7 +86,7 @@ pub struct BuildOpts {
 #[derive(Parser)]
 pub struct SaveImageOpts {
     #[clap(flatten)]
-    pub build_args: BuildOpts,
+    pub build_opts: BuildOpts,
     /// File name to save the generated image to
     pub file: PathBuf,
 }
@@ -154,12 +154,16 @@ fn flash(
             .transpose()?
             .or(metadata.format);
 
+        // FIXME
         flash_elf_image(
             &mut flasher,
             &elf_data,
             bootloader,
             partition_table,
             image_format,
+            None,
+            None,
+            None,
         )?;
     }
 
@@ -282,7 +286,6 @@ fn build(
 
     // If no target artifact was found, we don't have a path to return.
     let target_artifact = target_artifact.ok_or(Error::NoArtifact)?;
-
     let artifact_path = target_artifact.executable.unwrap().into();
 
     Ok(artifact_path)
@@ -294,7 +297,7 @@ fn save_image(
     cargo_config: CargoConfig,
 ) -> Result<()> {
     let target = opts
-        .build_args
+        .build_opts
         .target
         .as_deref()
         .or_else(|| cargo_config.target())
@@ -303,18 +306,19 @@ fn save_image(
 
     let chip = Chip::from_target(target).ok_or_else(|| Error::UnknownTarget(target.into()))?;
 
-    let path = build(&opts.build_args, &cargo_config, Some(chip))?;
+    let path = build(&opts.build_opts, &cargo_config, Some(chip))?;
     let elf_data = fs::read(path).into_diagnostic()?;
 
     let image_format = opts
-        .build_args
+        .build_opts
         .format
         .as_deref()
         .map(ImageFormatId::from_str)
         .transpose()?
         .or(metadata.format);
 
-    save_elf_as_image(chip, &elf_data, opts.file, image_format)?;
+    // FIXME
+    save_elf_as_image(chip, &elf_data, opts.file, image_format, None, None, None)?;
 
     Ok(())
 }

espflash/src/chip/esp32/esp32.rs

@@ -183,10 +183,12 @@ impl Esp32 {
 fn test_esp32_rom() {
     use std::fs::read;
 
+    use crate::elf::FirmwareImageBuilder;
+
     let input_bytes = read("./tests/data/esp32").unwrap();
     let expected_bin = read("./tests/data/esp32.bin").unwrap();
 
-    let image = FirmwareImage::from_data(&input_bytes).unwrap();
+    let image = FirmwareImageBuilder::new(&input_bytes).build().unwrap();
     let flash_image = Esp32BootloaderFormat::new(&image, Chip::Esp32, PARAMS, None, None).unwrap();
 
     let segments = flash_image.flash_segments().collect::<Vec<_>>();

espflash/src/chip/esp8266.rs

@@ -90,10 +90,12 @@ impl ReadEFuse for Esp8266 {
 fn test_esp8266_rom() {
     use std::fs::read;
 
+    use crate::elf::FirmwareImageBuilder;
+
     let input_bytes = read("./tests/data/esp8266").unwrap();
     let expected_bin = read("./tests/data/esp8266.bin").unwrap();
 
-    let image = FirmwareImage::from_data(&input_bytes).unwrap();
+    let image = FirmwareImageBuilder::new(&input_bytes).build().unwrap();
     let flash_image = Esp8266Format::new(&image).unwrap();
 
     let segments = flash_image.flash_segments().collect::<Vec<_>>();

espflash/src/cli/mod.rs

@@ -13,8 +13,11 @@ use miette::{IntoDiagnostic, Result, WrapErr};
 use serialport::{FlowControl, SerialPortType};
 
 use crate::{
-    cli::serial::get_serial_port_info, error::Error, Chip, FirmwareImage, Flasher, ImageFormatId,
-    PartitionTable,
+    cli::serial::get_serial_port_info,
+    elf::{FirmwareImageBuilder, FlashFrequency, FlashMode},
+    error::Error,
+    flasher::FlashSize,
+    Chip, Flasher, ImageFormatId, PartitionTable,
 };
 
 pub mod config;
@@ -82,8 +85,15 @@ pub fn save_elf_as_image(
     elf_data: &[u8],
     path: PathBuf,
     image_format: Option<ImageFormatId>,
+    flash_mode: Option<FlashMode>,
+    flash_size: Option<FlashSize>,
+    flash_freq: Option<FlashFrequency>,
 ) -> Result<()> {
-    let image = FirmwareImage::from_data(elf_data)?;
+    let image = FirmwareImageBuilder::new(elf_data)
+        .flash_mode(flash_mode)
+        .flash_size(flash_size)
+        .flash_freq(flash_freq)
+        .build()?;
 
     let flash_image = chip.get_flash_image(&image, None, None, image_format, None)?;
     let parts: Vec<_> = flash_image.ota_segments().collect();
@@ -107,6 +117,9 @@ pub fn flash_elf_image(
     bootloader: Option<&Path>,
     partition_table: Option<&Path>,
     image_format: Option<ImageFormatId>,
+    flash_mode: Option<FlashMode>,
+    flash_size: Option<FlashSize>,
+    flash_freq: Option<FlashFrequency>,
 ) -> Result<()> {
     // If the '--bootloader' option is provided, load the binary file at the
     // specified path.
@@ -137,7 +150,15 @@ pub fn flash_elf_image(
 
     // Load the ELF data, optionally using the provider bootloader/partition
     // table/image format, to the device's flash memory.
-    flasher.load_elf_to_flash_with_format(elf_data, bootloader, partition_table, image_format)?;
+    flasher.load_elf_to_flash_with_format(
+        elf_data,
+        bootloader,
+        partition_table,
+        image_format,
+        flash_mode,
+        flash_size,
+        flash_freq,
+    )?;
     println!("\nFlashing has completed!");
 
     Ok(())

espflash/src/elf.rs

@@ -85,18 +85,18 @@ pub struct FirmwareImage<'a> {
 }
 
 impl<'a> FirmwareImage<'a> {
-    pub fn from_data(data: &'a [u8]) -> Result<Self, Error> {
-        let elf = ElfFile::new(data).map_err(ElfError::from)?;
-        Ok(Self::from_elf(elf))
-    }
-
-    pub fn from_elf(elf: ElfFile<'a>) -> Self {
-        FirmwareImage {
+    pub fn new(
+        elf: ElfFile<'a>,
+        flash_mode: FlashMode,
+        flash_size: FlashSize,
+        flash_frequency: FlashFrequency,
+    ) -> Self {
+        Self {
             entry: elf.header.pt2.entry_point() as u32,
             elf,
-            flash_mode: FlashMode::Dio,
-            flash_size: FlashSize::Flash4Mb,
-            flash_frequency: FlashFrequency::Flash40M,
+            flash_mode,
+            flash_size,
+            flash_frequency,
         }
     }
 
@@ -149,6 +149,51 @@ impl<'a> FirmwareImage<'a> {
     }
 }
 
+pub struct FirmwareImageBuilder<'a> {
+    data: &'a [u8],
+    pub flash_mode: Option<FlashMode>,
+    pub flash_size: Option<FlashSize>,
+    pub flash_freq: Option<FlashFrequency>,
+}
+
+impl<'a> FirmwareImageBuilder<'a> {
+    pub fn new(data: &'a [u8]) -> Self {
+        Self {
+            data,
+            flash_mode: None,
+            flash_size: None,
+            flash_freq: None,
+        }
+    }
+
+    pub fn flash_mode(mut self, flash_mode: Option<FlashMode>) -> Self {
+        self.flash_mode = flash_mode;
+        self
+    }
+
+    pub fn flash_size(mut self, flash_size: Option<FlashSize>) -> Self {
+        self.flash_size = flash_size;
+        self
+    }
+
+    pub fn flash_freq(mut self, flash_freq: Option<FlashFrequency>) -> Self {
+        self.flash_freq = flash_freq;
+        self
+    }
+
+    pub fn build(&self) -> Result<FirmwareImage<'a>, Error> {
+        let elf = ElfFile::new(self.data).map_err(ElfError::from)?;
+
+        let flash_mode = self.flash_mode.unwrap_or(FlashMode::Dio);
+        let flash_size = self.flash_size.unwrap_or(FlashSize::Flash4Mb);
+        let flash_freq = self.flash_freq.unwrap_or(FlashFrequency::Flash40M);
+
+        let image = FirmwareImage::new(elf, flash_mode, flash_size, flash_freq);
+
+        Ok(image)
+    }
+}
+
 #[derive(Eq, Clone, Default)]
 /// A segment of code from the source elf
 pub struct CodeSegment<'a> {
@@ -166,7 +211,8 @@ impl<'a> CodeSegment<'a> {
         segment
     }
 
-    /// Split of the first `count` bytes into a new segment, adjusting the remaining segment as needed
+    /// Split of the first `count` bytes into a new segment, adjusting the
+    /// remaining segment as needed
     pub fn split_off(&mut self, count: usize) -> Self {
         if count < self.data.len() {
             let (head, tail) = match take(&mut self.data) {

espflash/src/flasher.rs

@@ -8,7 +8,7 @@ use crate::{
     chip::Chip,
     command::{Command, CommandType},
     connection::Connection,
-    elf::{FirmwareImage, RomSegment},
+    elf::{FirmwareImageBuilder, FlashFrequency, FlashMode, RomSegment},
     error::{ConnectionError, FlashDetectError, ResultExt},
     image_format::ImageFormatId,
     Error, PartitionTable,
@@ -376,15 +376,9 @@ impl Flasher {
         self.chip
     }
 
-    /// The flash size of the board that the flasher is connected to
-    pub fn flash_size(&self) -> FlashSize {
-        self.flash_size
-    }
-
     /// Read and print any information we can about the connected board
     pub fn board_info(&mut self) -> Result<(), Error> {
         let chip = self.chip();
-        let size = self.flash_size();
 
         let maybe_revision = chip.chip_revision(self.connection())?;
         let features = chip.chip_features(self.connection())?;
@@ -397,7 +391,7 @@ impl Flasher {
             None => println!(),
         }
         println!("Crystal frequency: {}MHz", freq);
-        println!("Flash size:        {}", size);
+        println!("Flash size:        {}", self.flash_size);
         println!("Features:          {}", features.join(", "));
         println!("MAC address:       {}", mac);
 
@@ -408,7 +402,7 @@ impl Flasher {
     ///
     /// Note that this will not touch the flash on the device
     pub fn load_elf_to_ram(&mut self, elf_data: &[u8]) -> Result<(), Error> {
-        let image = FirmwareImage::from_data(elf_data)?;
+        let image = FirmwareImageBuilder::new(elf_data).build()?;
 
         let mut target = self.chip.ram_target();
         target.begin(&mut self.connection, &image).flashing()?;
@@ -439,9 +433,20 @@ impl Flasher {
         bootloader: Option<Vec<u8>>,
         partition_table: Option<PartitionTable>,
         image_format: Option<ImageFormatId>,
+        flash_mode: Option<FlashMode>,
+        flash_size: Option<FlashSize>,
+        flash_freq: Option<FlashFrequency>,
     ) -> Result<(), Error> {
-        let mut image = FirmwareImage::from_data(elf_data)?;
-        image.flash_size = self.flash_size();
+        let mut builder = FirmwareImageBuilder::new(elf_data)
+            .flash_mode(flash_mode)
+            .flash_size(flash_size)
+            .flash_freq(flash_freq);
+
+        if builder.flash_size.is_none() {
+            builder = builder.flash_size(Some(self.flash_size));
+        }
+
+        let image = builder.build()?;
 
         let mut target = self.chip.flash_target(self.spi_params);
         target.begin(&mut self.connection, &image).flashing()?;
@@ -471,8 +476,19 @@ impl Flasher {
         elf_data: &[u8],
         bootloader: Option<Vec<u8>>,
         partition_table: Option<PartitionTable>,
+        flash_mode: Option<FlashMode>,
+        flash_size: Option<FlashSize>,
+        flash_freq: Option<FlashFrequency>,
     ) -> Result<(), Error> {
-        self.load_elf_to_flash_with_format(elf_data, bootloader, partition_table, None)
+        self.load_elf_to_flash_with_format(
+            elf_data,
+            bootloader,
+            partition_table,
+            None,
+            flash_mode,
+            flash_size,
+            flash_freq,
+        )
     }
 
     pub fn change_baud(&mut self, speed: u32) -> Result<(), Error> {

espflash/src/main.rs

@@ -6,7 +6,7 @@ use espflash::{
         board_info, connect, flash_elf_image, monitor::monitor, save_elf_as_image, ConnectOpts,
         FlashOpts,
     },
-    Chip, Config, ImageFormatId,
+    Chip, Config, FlashFrequency, FlashMode, FlashSize, ImageFormatId,
 };
 use miette::{IntoDiagnostic, Result, WrapErr};
 
@@ -108,12 +108,16 @@ fn flash(opts: Opts, config: Config) -> Result<()> {
             .map(ImageFormatId::from_str)
             .transpose()?;
 
+        // FIXME
         flash_elf_image(
             &mut flasher,
             &elf_data,
             bootloader,
             partition_table,
             image_format,
+            None,
+            None,
+            None,
         )?;
     }
 
@@ -135,7 +139,16 @@ fn save_image(opts: SaveImageOpts) -> Result<()> {
         .map(ImageFormatId::from_str)
         .transpose()?;
 
-    save_elf_as_image(opts.chip, &elf_data, opts.file, image_format)?;
+    // FIXME
+    save_elf_as_image(
+        opts.chip,
+        &elf_data,
+        opts.file,
+        image_format,
+        None,
+        None,
+        None,
+    )?;
 
     Ok(())
 }