Merge pull request #141 from MabezDev/feature/firmware-header

Customize firmware image header

Author: jessebraham

.github/workflows/rust.yml

@@ -115,7 +115,8 @@ jobs:
         with:
           command: clippy
           # `identity_op` and `or_fun_call` leads to false positives
-          args: -- -D warnings -A clippy::identity_op -A clippy::or_fun_call
+          # `too-many-arguments` is relatively arbitrary
+          args: -- -D warnings -A clippy::identity_op -A clippy::or_fun_call -A clippy::too-many-arguments
 
   build:
     name: Build Static Binaries

cargo-espflash/src/main.rs

@@ -10,7 +10,7 @@ use clap::Parser;
 use espflash::{
     cli::{
         board_info, connect, flash_elf_image, monitor::monitor, save_elf_as_image, ConnectOpts,
-        FlashOpts,
+        FlashConfigOpts, FlashOpts,
     },
     Chip, Config, ImageFormatId,
 };
@@ -81,12 +81,14 @@ pub struct BuildOpts {
     /// Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
     #[clap(short = 'Z')]
     pub unstable: Option<Vec<String>>,
+    #[clap(flatten)]
+    pub flash_config_opts: FlashConfigOpts,
 }
 
 #[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,
 }
@@ -160,6 +162,9 @@ fn flash(
             bootloader,
             partition_table,
             image_format,
+            opts.build_opts.flash_config_opts.flash_mode,
+            opts.build_opts.flash_config_opts.flash_size,
+            opts.build_opts.flash_config_opts.flash_freq,
         )?;
     }
 
@@ -282,7 +287,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 +298,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 +307,26 @@ 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)?;
+    save_elf_as_image(
+        chip,
+        &elf_data,
+        opts.file,
+        image_format,
+        opts.build_opts.flash_config_opts.flash_mode,
+        opts.build_opts.flash_config_opts.flash_size,
+        opts.build_opts.flash_config_opts.flash_freq,
+    )?;
 
     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

@@ -11,10 +11,14 @@ use clap::Parser;
 use config::Config;
 use miette::{IntoDiagnostic, Result, WrapErr};
 use serialport::{FlowControl, SerialPortType};
+use strum::VariantNames;
 
 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;
@@ -48,6 +52,19 @@ pub struct FlashOpts {
     pub monitor: bool,
 }
 
+#[derive(Parser)]
+pub struct FlashConfigOpts {
+    /// Flash mode to use
+    #[clap(short = 'm', long, possible_values = FlashMode::VARIANTS, value_name = "MODE")]
+    pub flash_mode: Option<FlashMode>,
+    /// Flash size of the target
+    #[clap(short = 's', long, possible_values = FlashSize::VARIANTS, value_name = "SIZE")]
+    pub flash_size: Option<FlashSize>,
+    /// Flash frequency
+    #[clap(short = 'f', long, possible_values = FlashFrequency::VARIANTS, value_name = "FREQUENCY")]
+    pub flash_freq: Option<FlashFrequency>,
+}
+
 pub fn connect(opts: &ConnectOpts, config: &Config) -> Result<Flasher> {
     let port_info = get_serial_port_info(opts, config)?;
 
@@ -82,8 +99,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 +131,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 +164,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/connection.rs

@@ -15,6 +15,7 @@ use crate::{
     error::{ConnectionError, Error, ResultExt, RomError, RomErrorKind},
 };
 
+const DEFAULT_CONNECT_ATTEMPTS: usize = 7;
 const USB_SERIAL_JTAG_PID: u16 = 0x1001;
 
 #[derive(Debug, Copy, Clone, BinRead)]
@@ -51,6 +52,75 @@ impl Connection {
         }
     }
 
+    pub fn begin(&mut self) -> Result<(), Error> {
+        let mut extra_delay = false;
+        for i in 0..DEFAULT_CONNECT_ATTEMPTS {
+            if self.connect_attempt(extra_delay).is_err() {
+                extra_delay = !extra_delay;
+
+                let delay_text = if extra_delay { "extra" } else { "default" };
+                println!("Unable to connect, retrying with {} delay...", delay_text);
+            } else {
+                // Print a blank line if more than one connection attempt was made to visually
+                // separate the status text and whatever comes next.
+                if i > 0 {
+                    println!();
+                }
+                return Ok(());
+            }
+        }
+
+        Err(Error::Connection(ConnectionError::ConnectionFailed))
+    }
+
+    fn connect_attempt(&mut self, extra_delay: bool) -> Result<(), Error> {
+        self.reset_to_flash(extra_delay)?;
+
+        for _ in 0..5 {
+            self.flush()?;
+            if self.sync().is_ok() {
+                return Ok(());
+            }
+        }
+
+        Err(Error::Connection(ConnectionError::ConnectionFailed))
+    }
+
+    fn sync(&mut self) -> Result<(), Error> {
+        self.with_timeout(CommandType::Sync.timeout(), |connection| {
+            connection.write_command(Command::Sync)?;
+            connection.flush()?;
+
+            for _ in 0..100 {
+                match connection.read_response()? {
+                    Some(response) if response.return_op == CommandType::Sync as u8 => {
+                        if response.status == 1 {
+                            let _error = connection.flush();
+                            return Err(Error::RomError(RomError::new(
+                                CommandType::Sync,
+                                RomErrorKind::from(response.error),
+                            )));
+                        } else {
+                            break;
+                        }
+                    }
+                    _ => continue,
+                }
+            }
+
+            Ok(())
+        })?;
+
+        for _ in 0..700 {
+            match self.read_response()? {
+                Some(_) => break,
+                _ => continue,
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn reset(&mut self) -> Result<(), Error> {
         sleep(Duration::from_millis(100));