diff --git a/CHANGELOG.md b/CHANGELOG.md index a88e2ed5..e724aedc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,13 +27,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed -- Fixed printing panic backtraces when using `esp-println` and `defmt` (#496) -- Fixed `defmt` parsing when data is read in parts (#503) +- Fix printing panic backtraces when using `esp-println` and `defmt` (#496) +- Fix `defmt` parsing when data is read in parts (#503) - Use partition table instead of hard-coded values for the location of partitions (#516) -- Fixed a missed `flush` call that may be causing communication errors (#521) +- Fix a missed `flush` call that may be causing communication errors (#521) - Fix "SHA-256 comparison failed: [...] attempting to boot anyway..." (#567) - Windows: Update RST/DTR order to avoid issues. - Tolerate non-utf8 data in boot detection (#573) +- Fix flash/monitoring of 26mhz targets (#584) ### Changed @@ -42,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Unify configuration methods (#551) - MSRV bumped to `1.73.0` (#578) - Improved symbol resolving (#581) +- Update ESP32-C2 stub (#584) ### Removed diff --git a/cargo-espflash/src/main.rs b/cargo-espflash/src/main.rs index 3f7ebbe0..45d647c9 100644 --- a/cargo-espflash/src/main.rs +++ b/cargo-espflash/src/main.rs @@ -344,10 +344,8 @@ fn flash(args: FlashArgs, config: &Config) -> Result<()> { let pid = flasher.get_usb_pid()?; // The 26MHz ESP32-C2's need to be treated as a special case. - let default_baud = if chip == Chip::Esp32c2 - && args.connect_args.no_stub - && target_xtal_freq == XtalFrequency::_26Mhz - { + let default_baud = if chip == Chip::Esp32c2 && target_xtal_freq == XtalFrequency::_26Mhz { + // 115_200 * 26 MHz / 40 MHz = 74_880 74_880 } else { 115_200 diff --git a/espflash/resources/stubs/stub_flasher_32c2.toml b/espflash/resources/stubs/stub_flasher_32c2.toml index ffd9a51b..34873954 100644 --- a/espflash/resources/stubs/stub_flasher_32c2.toml +++ b/espflash/resources/stubs/stub_flasher_32c2.toml @@ -1,5 +1,5 @@ entry = 1077411840 -text = "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" +text = "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" text_start = 1077411840 -data = "Tgk4QCoKOEA4CjhATgk4QMQKOEAqCjhANgs4QFALOECWCzhA1gs4QPwTOECoDDhA/BM4QNYMOEBOCThAKgo4QDgKOECcDThAqg44QCAKOEDeDjhANg84QIQKOEAqCjhAsB44QMQeOEDQHjhA3B44QOgeOED0HjhAAB84QAofOEAUHzhAHh84QCgfOEAyHzhAPB84QEYfOEBQHzhAWh84QGQfOEBuHzhAeB84QIIfOECMHzhAlh84QKAfOECqHzhAtB84QL4fOEDIHzhA0h84QNwfOEDmHzhA8B84QAABHAIdDhgDHhYUDxkRBAgfGw0XFRMQBxoMEgYLBQoJ29zb3QEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAJIbOECSGzhAAAAAAJIbOECSGzhAkhs4QAAAAACSGzhAkhs4QJIbOEAAAAAAkhs4QA==" +data = "3As4QLAMOEDsDDhA3As4QEINOECwDDhAoA04QNYNOEAKDjhANg44QJQUOECADjhAlBQ4QJoOOEDcCzhAsAw4QOwMOEA0DzhA+A84QJwMOEAsEDhAhBA4QDgNOECwDDhAsCA4QMQgOEDQIDhA3CA4QOggOED0IDhAACE4QAohOEAUIThAHiE4QCghOEAyIThAPCE4QEYhOEBQIThAWiE4QGQhOEBuIThAeCE4QIIhOECMIThAliE4QKAhOECqIThAtCE4QL4hOEDIIThA0iE4QNwhOEDmIThA8CE4QAABHAIdDhgDHhYUDxkRBAgfGw0XFRMQBxoMEgYLBQoJwNvc290AAAABAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAABEFThARBU4QAAAAABEFThARBU4QEQVOEAAAAAARBU4QEQVOEBEFThAAAAAAEQVOEA=" data_start = 1070268448 diff --git a/espflash/src/bin/espflash.rs b/espflash/src/bin/espflash.rs index 21902f04..80e88611 100644 --- a/espflash/src/bin/espflash.rs +++ b/espflash/src/bin/espflash.rs @@ -279,10 +279,8 @@ fn flash(args: FlashArgs, config: &Config) -> Result<()> { let pid = flasher.get_usb_pid()?; // The 26MHz ESP32-C2's need to be treated as a special case. - let default_baud = if chip == Chip::Esp32c2 - && args.connect_args.no_stub - && target_xtal_freq == XtalFrequency::_26Mhz - { + let default_baud = if chip == Chip::Esp32c2 && target_xtal_freq == XtalFrequency::_26Mhz { + // 115_200 * 26 MHz / 40 MHz = 74_880 74_880 } else { 115_200 diff --git a/espflash/src/cli/mod.rs b/espflash/src/cli/mod.rs index 536e34ef..51a24ab4 100644 --- a/espflash/src/cli/mod.rs +++ b/espflash/src/cli/mod.rs @@ -439,9 +439,9 @@ pub fn serial_monitor(args: MonitorArgs, config: &Config) -> Result<()> { // The 26MHz ESP32-C2's need to be treated as a special case. let default_baud = if chip == Chip::Esp32c2 - && args.connect_args.no_stub && target.crystal_freq(flasher.connection())? == XtalFrequency::_26Mhz { + // 115_200 * 26 MHz / 40 MHz = 74_880 74_880 } else { 115_200 diff --git a/espflash/src/connection/mod.rs b/espflash/src/connection/mod.rs index e9e4db65..a0687251 100644 --- a/espflash/src/connection/mod.rs +++ b/espflash/src/connection/mod.rs @@ -131,14 +131,9 @@ impl Connection { Ok(_) => { return Ok(()); } - Err(e) => match e { - Error::InvalidSerialRead => { - return Err(Error::InvalidSerialRead); - } - _ => { - debug!("Failed to reset, error {:#?}, retrying", e); - } - }, + Err(e) => { + debug!("Failed to reset, error {:#?}, retrying", e); + } } } @@ -173,9 +168,6 @@ impl Connection { } let read_slice = String::from_utf8_lossy(&buff[..read_bytes as usize]).into_owned(); - if !read_slice.contains("boot") { - return Err(Error::InvalidSerialRead); - } let pattern = Regex::new(r"boot:(0x[0-9a-fA-F]+)(.*waiting for download)?").unwrap(); diff --git a/espflash/src/error.rs b/espflash/src/error.rs index 4e727e85..2ec9c1d3 100644 --- a/espflash/src/error.rs +++ b/espflash/src/error.rs @@ -95,13 +95,6 @@ pub enum Error { #[error("The provided bootloader binary is invalid")] InvalidBootloader, - #[error("Invalid byte sequence read from the serial port while trying to detect Boot Mode")] - #[diagnostic( - code(espflash::invalid_serial_read), - help("This might be caused by a xtal frequency mismatch") - )] - InvalidSerialRead, - #[error("Specified bootloader path is not a .bin file")] #[diagnostic(code(espflash::invalid_bootloader_path))] InvalidBootloaderPath, diff --git a/espflash/src/flasher/mod.rs b/espflash/src/flasher/mod.rs index dd8fe507..8ed8812b 100644 --- a/espflash/src/flasher/mod.rs +++ b/espflash/src/flasher/mod.rs @@ -11,9 +11,9 @@ use std::{ path::{Path, PathBuf}, str::FromStr, thread::sleep, + time::Duration, }; -use bytemuck::{Pod, Zeroable, __core::time::Duration}; use esp_idf_part::PartitionTable; use log::{debug, info, warn}; use md5::{Digest, Md5}; @@ -497,32 +497,6 @@ impl SpiAttachParams { const TRY_SPI_PARAMS: [SpiAttachParams; 2] = [SpiAttachParams::default(), SpiAttachParams::esp32_pico_d4()]; -#[derive(Zeroable, Pod, Copy, Clone, Debug)] -#[repr(C)] -struct BlockParams { - size: u32, - sequence: u32, - dummy1: u32, - dummy2: u32, -} - -#[derive(Zeroable, Pod, Copy, Clone, Debug)] -#[repr(C)] -struct BeginParams { - size: u32, - blocks: u32, - block_size: u32, - offset: u32, - encrypted: u32, -} - -#[derive(Zeroable, Pod, Copy, Clone)] -#[repr(C)] -struct EntryParams { - no_entry: u32, - entry: u32, -} - /// Information about the connected device #[derive(Debug, Clone)] pub struct DeviceInfo { diff --git a/espflash/src/targets/esp32.rs b/espflash/src/targets/esp32.rs index 1a05317b..447bb3fb 100644 --- a/espflash/src/targets/esp32.rs +++ b/espflash/src/targets/esp32.rs @@ -17,6 +17,7 @@ const FLASH_RANGES: &[Range] = &[ 0x3f40_0000..0x3f80_0000, // DROM ]; +// UART0_BASE_REG + 0x14 const UART_CLKDIV_REG: u32 = 0x3ff4_0014; const UART_CLKDIV_MASK: u32 = 0xfffff; diff --git a/espflash/src/targets/esp32c2.rs b/espflash/src/targets/esp32c2.rs index f7d9b1f8..ea7c4155 100644 --- a/espflash/src/targets/esp32c2.rs +++ b/espflash/src/targets/esp32c2.rs @@ -20,6 +20,7 @@ const FLASH_RANGES: &[Range] = &[ 0x3c00_0000..0x3c40_0000, // DROM ]; +// UART0_BASE_REG + 0x14 const UART_CLKDIV_REG: u32 = 0x6000_0014; const UART_CLKDIV_MASK: u32 = 0xfffff; diff --git a/espflash/src/targets/flash_target/mod.rs b/espflash/src/targets/flash_target/mod.rs index 505b3c93..d709c940 100644 --- a/espflash/src/targets/flash_target/mod.rs +++ b/espflash/src/targets/flash_target/mod.rs @@ -1,5 +1,3 @@ -use bytemuck::{Pod, Zeroable}; - pub(crate) use self::ram::MAX_RAM_BLOCK_SIZE; pub use self::{esp32::Esp32Target, ram::RamTarget}; #[cfg(feature = "serialport")] @@ -26,13 +24,3 @@ pub trait FlashTarget { /// Complete the flashing operation fn finish(&mut self, connection: &mut Connection, reboot: bool) -> Result<(), Error>; } - -#[derive(Zeroable, Pod, Copy, Clone, Debug)] -#[repr(C)] -struct BeginParams { - size: u32, - blocks: u32, - block_size: u32, - offset: u32, - encrypted: u32, -} diff --git a/espflash/src/targets/flash_target/ram.rs b/espflash/src/targets/flash_target/ram.rs index 0b9816e9..debce3de 100644 --- a/espflash/src/targets/flash_target/ram.rs +++ b/espflash/src/targets/flash_target/ram.rs @@ -1,5 +1,3 @@ -use bytemuck::{Pod, Zeroable}; - use crate::{ command::{Command, CommandType}, elf::RomSegment, @@ -11,13 +9,6 @@ use crate::{connection::Connection, targets::FlashTarget}; pub const MAX_RAM_BLOCK_SIZE: usize = 0x1800; -#[derive(Zeroable, Pod, Copy, Clone)] -#[repr(C)] -struct EntryParams { - no_entry: u32, - entry: u32, -} - /// Applications running in the target device's RAM pub struct RamTarget { entry: Option,