split of esp8266 flash target

Author: icewind1991

espflash/src/chip/mod.rs

@@ -10,7 +10,7 @@ use crate::{
 use std::{io::Write, str::FromStr};
 
 use crate::flasher::SpiAttachParams;
-use crate::flashtarget::{ChipTarget, FlashTarget, RamTarget};
+use crate::flashtarget::{Esp32Target, Esp8266Target, FlashTarget, RamTarget};
 pub use esp32::Esp32;
 pub use esp32c3::Esp32c3;
 pub use esp8266::Esp8266;
@@ -147,7 +147,10 @@ impl Chip {
     }
 
     pub fn flash_target(&self, spi_params: SpiAttachParams) -> Box<dyn FlashTarget> {
-        Box::new(ChipTarget::new(*self, spi_params))
+        match self {
+            Chip::Esp8266 => Box::new(Esp8266Target::new()),
+            _ => Box::new(Esp32Target::new(*self, spi_params)),
+        }
     }
 }
 

espflash/src/flashtarget/chip.rs renamed to espflash/src/flashtarget/esp32.rs

@@ -6,41 +6,26 @@ use crate::flashtarget::{begin_command, block_command, FlashTarget};
 use crate::Chip;
 use indicatif::{ProgressBar, ProgressStyle};
 
-pub struct ChipTarget {
+pub struct Esp32Target {
     chip: Chip,
     spi_attach_params: SpiAttachParams,
 }
 
-impl ChipTarget {
+impl Esp32Target {
     pub fn new(chip: Chip, spi_attach_params: SpiAttachParams) -> Self {
-        ChipTarget {
+        Esp32Target {
             chip,
             spi_attach_params,
         }
     }
 }
 
-impl FlashTarget for ChipTarget {
+impl FlashTarget for Esp32Target {
     fn begin(&mut self, connection: &mut Connection, _image: &FirmwareImage) -> Result<(), Error> {
-        match self.chip {
-            Chip::Esp8266 => {
-                begin_command(
-                    connection,
-                    Command::FlashBegin,
-                    0,
-                    0,
-                    FLASH_WRITE_SIZE as u32,
-                    0,
-                    !(self.chip == Chip::Esp32 || self.chip == Chip::Esp8266),
-                )?;
-            }
-            _ => {
-                let spi_params = self.spi_attach_params.encode();
-                connection.with_timeout(Command::SpiAttach.timeout(), |connection| {
-                    connection.command(Command::SpiAttach as u8, spi_params.as_slice(), 0)
-                })?;
-            }
-        }
+        let spi_params = self.spi_attach_params.encode();
+        connection.with_timeout(Command::SpiAttach.timeout(), |connection| {
+            connection.command(Command::SpiAttach as u8, spi_params.as_slice(), 0)
+        })?;
         Ok(())
     }
 
@@ -52,10 +37,7 @@ impl FlashTarget for ChipTarget {
         let addr = segment.addr;
         let block_count = (segment.data.len() + FLASH_WRITE_SIZE - 1) / FLASH_WRITE_SIZE;
 
-        let erase_size = match self.chip {
-            Chip::Esp8266 => get_erase_size(addr as usize, segment.data.len()) as u32,
-            _ => segment.data.len() as u32,
-        };
+        let erase_size = segment.data.len() as u32;
 
         begin_command(
             connection,
@@ -64,7 +46,7 @@ impl FlashTarget for ChipTarget {
             block_count as u32,
             FLASH_WRITE_SIZE as u32,
             addr,
-            !(self.chip == Chip::Esp32 || self.chip == Chip::Esp8266),
+            self.chip != Chip::Esp32,
         )?;
 
         let chunks = segment.data.chunks(FLASH_WRITE_SIZE);

espflash/src/flashtarget/esp8266.rs

@@ -0,0 +1,89 @@
+use crate::connection::Connection;
+use crate::elf::{FirmwareImage, RomSegment};
+use crate::error::Error;
+use crate::flasher::{get_erase_size, Command, FLASH_WRITE_SIZE};
+use crate::flashtarget::{begin_command, block_command, FlashTarget};
+use indicatif::{ProgressBar, ProgressStyle};
+
+pub struct Esp8266Target;
+
+impl Esp8266Target {
+    pub fn new() -> Self {
+        Esp8266Target
+    }
+}
+
+impl FlashTarget for Esp8266Target {
+    fn begin(&mut self, connection: &mut Connection, _image: &FirmwareImage) -> Result<(), Error> {
+        begin_command(
+            connection,
+            Command::FlashBegin,
+            0,
+            0,
+            FLASH_WRITE_SIZE as u32,
+            0,
+            false,
+        )
+    }
+
+    fn write_segment(
+        &mut self,
+        connection: &mut Connection,
+        segment: RomSegment,
+    ) -> Result<(), Error> {
+        let addr = segment.addr;
+        let block_count = (segment.data.len() + FLASH_WRITE_SIZE - 1) / FLASH_WRITE_SIZE;
+
+        let erase_size = get_erase_size(addr as usize, segment.data.len()) as u32;
+
+        begin_command(
+            connection,
+            Command::FlashBegin,
+            erase_size,
+            block_count as u32,
+            FLASH_WRITE_SIZE as u32,
+            addr,
+            false,
+        )?;
+
+        let chunks = segment.data.chunks(FLASH_WRITE_SIZE);
+
+        let (_, chunk_size) = chunks.size_hint();
+        let chunk_size = chunk_size.unwrap_or(0) as u64;
+        let pb_chunk = ProgressBar::new(chunk_size);
+        pb_chunk.set_style(
+            ProgressStyle::default_bar()
+                .template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")
+                .progress_chars("#>-"),
+        );
+
+        for (i, block) in chunks.enumerate() {
+            pb_chunk.set_message(format!("segment 0x{:X} writing chunks", addr));
+            let block_padding = FLASH_WRITE_SIZE - block.len();
+            block_command(
+                connection,
+                Command::FlashData,
+                block,
+                block_padding,
+                0xff,
+                i as u32,
+            )?;
+            pb_chunk.inc(1);
+        }
+
+        pb_chunk.finish_with_message(format!("segment 0x{:X}", addr));
+
+        Ok(())
+    }
+
+    fn finish(&mut self, connection: &mut Connection, reboot: bool) -> Result<(), Error> {
+        connection.with_timeout(Command::FlashEnd.timeout(), |connection| {
+            connection.write_command(Command::FlashEnd as u8, &[1][..], 0)
+        })?;
+        if reboot {
+            connection.reset()
+        } else {
+            Ok(())
+        }
+    }
+}

espflash/src/flashtarget/mod.rs

@@ -1,12 +1,14 @@
-mod chip;
+mod esp32;
+mod esp8266;
 mod ram;
 
 use crate::connection::Connection;
 use crate::elf::{FirmwareImage, RomSegment};
 use crate::error::Error;
 use crate::flasher::{checksum, Command, Encoder, CHECKSUM_INIT, FLASH_WRITE_SIZE};
 use bytemuck::{bytes_of, Pod, Zeroable};
-pub use chip::ChipTarget;
+pub use esp32::Esp32Target;
+pub use esp8266::Esp8266Target;
 pub use ram::RamTarget;
 use std::mem::size_of;