store the bootloader baud in boot metadata, settable with Reset

Author: aq1018

CHANGELOG.md

@@ -4,6 +4,42 @@ Releases up through `v0.4.0` were workspace-wide and tagged `vX.Y.Z`. From `0.4.
 
 ## [Unreleased]
 
+## [tinyboot 0.5.0] - 2026-10-20
+
+### Added
+
+- `tinyboot baud <rate>` stores the bootloader's baud and resets the device back into its current mode; in bootloader mode it reconnects at the new rate to check the bootloader answers. `tinyboot baud default` restores the build default.
+
+## [tinyboot-ch32 0.7.0] - 2026-10-20
+
+### Added
+
+- The bootloader runs its USART at the baud stored in boot metadata, falling back to `UsartConfig::baud` when nothing is stored or `pclk` cannot reach the rate (divisor below 16). Divisors are computed at build time, so there is no runtime divide; the CH32V003 example bootloader grows by 64 bytes.
+- `app::BaudRate` re-export for `App::set_baud` / `App::baud`.
+
+### Changed
+
+- **Breaking:** `BaudRate` is `tinyboot_protocol::BaudRate`, a `u8` index enum with `hz()`, instead of a `u32` enum whose discriminant was the rate.
+- **Breaking:** boot metadata is 12 bytes: a `baud` index byte (`0xFF` = build default) and 3 reserved bytes follow `app_size`. Existing metadata reads as the build default.
+
+## [tinyboot-core 0.6.0] - 2026-10-20
+
+### Added
+
+- `Reset` with `ResetFlags::BAUD` stores addr byte 0 as the bootloader's baud before resetting, in the bootloader and in `App::poll`.
+- `App::baud` returns the stored bootloader baud; `App::set_baud` stores one, skipping the flash write when it is already stored.
+
+### Changed
+
+- **Breaking:** `BootMetaStore` has `baud` and `set_baud`, and `refresh` keeps the stored baud.
+
+## [tinyboot-protocol 0.5.0] - 2026-10-20
+
+### Added
+
+- `BaudRate`, the 14 rates from 9600 to 3M as append-only `u8` indices, with `hz`, `from_u8`, `from_hz` and `ALL`.
+- `ResetFlags::BAUD`: store addr byte 0 as the bootloader's baud before resetting.
+
 ## [tinyboot-protocol 0.4.1] - 2026-10-19
 
 ### Fixed

ch32/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tinyboot-ch32"
 description = "tinyboot ch32 implementation"
-version = "0.6.0"
+version = "0.7.0"
 edition.workspace = true
 repository.workspace = true
 license.workspace = true
@@ -56,8 +56,8 @@ repository = "https://github.com/OpenServoCore/tinyboot"
 license = "MIT OR Apache-2.0"
 
 [workspace.dependencies]
-tinyboot-core = { version = "0.5.0", path = "../lib/core", default-features = false }
-tinyboot-ch32 = { version = "0.6.0", path = ".", default-features = false }
+tinyboot-core = { version = "0.6.0", path = "../lib/core", default-features = false }
+tinyboot-ch32 = { version = "0.7.0", path = ".", default-features = false }
 embedded-hal = "1"
 embedded-io = "0.7"
 embedded-storage = "0.3"

ch32/src/app.rs

@@ -6,6 +6,7 @@ use crate::platform::BootMetaStore;
 pub use crate::hal::Pin;
 pub use crate::hal::gpio::Level;
 pub use crate::platform::BootCtl;
+pub use tinyboot_core::BaudRate;
 pub use tinyboot_core::app::{App, AppConfig};
 pub use tinyboot_core::traits;
 pub use tinyboot_core::{app_version, pkg_version};

ch32/src/hal/usart/usart_common.rs

@@ -1,7 +1,7 @@
 pub use ch32_metapac::usart::Usart as Regs;
 
 #[inline(always)]
-pub fn init(r: Regs, pclk: u32, baud: u32, half_duplex: bool) {
+pub fn init(r: Regs, brr: u32, half_duplex: bool) {
     // HDSEL before TE — the reverse order latches the TX output LOW until
     // the first own transmission, clamping the wire from init.
     if half_duplex {
@@ -14,7 +14,6 @@ pub fn init(r: Regs, pclk: u32, baud: u32, half_duplex: bool) {
         w.set_re(true);
     });
 
-    let brr = (pclk + baud / 2) / baud;
     r.brr().write_value(ch32_metapac::usart::regs::Brr(brr));
 
     r.ctlr1().modify(|w| w.set_ue(true));

ch32/src/platform/boot_meta_store.rs

@@ -17,6 +17,16 @@ pub struct BootMetaStore {
     trials: u8,
     checksum: u16,
     app_size: u32,
+    baud: u8,
+    // Pads the flash write to whole words; carried as read.
+    _reserved: [u8; 3],
+}
+
+/// Stored bootloader baud index, read straight from flash.
+#[inline(always)]
+pub fn stored_baud() -> u8 {
+    let addr = flash::meta_addr() as usize + core::mem::offset_of!(BootMetaStore, baud);
+    unsafe { core::ptr::read_volatile(addr as *const u8) }
 }
 
 impl Default for BootMetaStore {
@@ -72,6 +82,16 @@ impl TBBootMetaStore for BootMetaStore {
         self.app_size
     }
 
+    fn baud(&self) -> u8 {
+        self.baud
+    }
+
+    fn set_baud(&mut self, baud: u8) -> Result<(), Self::Error> {
+        self.baud = baud;
+        self.write();
+        Ok(())
+    }
+
     fn advance(&mut self) -> Result<BootState, Self::Error> {
         let next = self
             .step_down(0, BootState::Validating as u8)

ch32/src/platform/transport/usart/mod.rs

@@ -7,24 +7,47 @@ use crate::hal::gpio::PinMode;
 use crate::hal::gpio::Pull;
 use crate::hal::{Pin, UsartMapping};
 use crate::hal::{afio, gpio, rcc, usart};
+use crate::platform::boot_meta_store;
 
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum BaudRate {
-    B9600 = 9600,
-    B19200 = 19200,
-    B38400 = 38400,
-    B57600 = 57600,
-    B115200 = 115200,
-    B230400 = 230_400,
-    B460800 = 460_800,
-    B500000 = 500_000,
-    B921600 = 921_600,
-    B1000000 = 1_000_000,
-    B1500000 = 1_500_000,
-    B2000000 = 2_000_000,
-    B2500000 = 2_500_000,
-    B3000000 = 3_000_000,
+pub use tinyboot_core::BaudRate;
+
+/// Rounded BRR for `hz`; folds to a constant when both args are.
+#[inline(always)]
+const fn brr(pclk: u32, hz: u32) -> u32 {
+    (pclk + hz / 2) / hz
+}
+
+/// BRR for the stored baud index, or `default` when the index is unknown
+/// or the rate is out of reach (BRR < 16) from `pclk`. Every arm divides
+/// constants, so this compiles to a table lookup with no runtime divide.
+#[inline(always)]
+fn stored_brr(pclk: u32, default: u32) -> u32 {
+    macro_rules! arms {
+        ($idx:expr, $($b:ident),*) => {
+            match $idx {
+                $(i if i == BaudRate::$b as u8 => brr(pclk, BaudRate::$b.hz()),)*
+                _ => default,
+            }
+        };
+    }
+    let v = arms!(
+        boot_meta_store::stored_baud(),
+        B9600,
+        B19200,
+        B38400,
+        B57600,
+        B115200,
+        B230400,
+        B460800,
+        B500000,
+        B921600,
+        B1000000,
+        B1500000,
+        B2000000,
+        B2500000,
+        B3000000
+    );
+    if v < 16 { default } else { v }
 }
 
 /// RS-485 DE/RE pin configuration.
@@ -36,6 +59,9 @@ pub struct TxEnConfig {
 }
 
 pub struct UsartConfig {
+    /// Build default. A baud stored in boot metadata (`Reset` with the
+    /// `BAUD` flag, or the app's `set_baud`) overrides it when `pclk`
+    /// can reach it.
     pub baud: BaudRate,
     /// USART peripheral clock (Hz). Used for BRR = pclk / baud.
     ///
@@ -104,12 +130,8 @@ impl Usart {
             gpio::set_level(tx_en.pin, invert(tx_en.tx_level));
         }
 
-        usart::init(
-            regs,
-            config.pclk,
-            config.baud as u32,
-            cfg!(feature = "half-duplex"),
-        );
+        let brr = stored_brr(config.pclk, brr(config.pclk, config.baud.hz()));
+        usart::init(regs, brr, cfg!(feature = "half-duplex"));
 
         Usart {
             regs,

cli/Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "tinyboot"
 description = "CLI firmware flasher for tinyboot bootloader"
-version = "0.4.1"
+version = "0.5.0"
 edition = "2024"
 repository = "https://github.com/OpenServoCore/tinyboot"
 license = "MIT OR Apache-2.0"
@@ -14,7 +14,7 @@ name = "tinyboot"
 path = "src/main.rs"
 
 [dependencies]
-tinyboot-protocol = { version = "0.4.0", path = "../lib/protocol" }
+tinyboot-protocol = { version = "0.5.0", path = "../lib/protocol" }
 embedded-io = "0.7"
 serialport = "4"
 clap = { version = "4", features = ["derive"] }

cli/Cargo.toml

@@ -50,6 +50,15 @@ Reset the device. Use `--bootloader` to reboot into the bootloader instead of th
 tinyboot reset [--port /dev/ttyUSB0] [--baud 115200] [--bootloader]
 ```
 
+### `tinyboot baud`
+
+Store the baud the bootloader runs at from its next start, then reset the device back into its current mode. In bootloader mode the CLI reconnects at the new rate to check that the bootloader answers. `default` restores the bootloader's build default.
+
+```sh
+tinyboot baud 1000000 [--port /dev/ttyUSB0] [--baud 115200]
+tinyboot baud default [--port /dev/ttyUSB0] [--baud 1000000]
+```
+
 ### `tinyboot bin`
 
 Convert an ELF to a flat binary (same extraction logic as `flash`).

cli/README.md

@@ -239,15 +239,22 @@ impl<T: embedded_io::Read + embedded_io::Write> Client<T> {
     /// Reset the device. Does not wait for a response since the device resets immediately.
     /// `bootloader=true`: enter bootloader. `bootloader=false`: boot app.
     pub fn reset(&mut self, bootloader: bool) {
+        self.send_reset(bootloader, None);
+    }
+
+    /// Store `baud` (a `BaudRate` index; `0xFF` = the build default) for
+    /// the bootloader, then reset into `bootloader` or the app.
+    pub fn set_baud(&mut self, baud: u8, bootloader: bool) {
+        self.send_reset(bootloader, Some(baud));
+    }
+
+    fn send_reset(&mut self, bootloader: bool, baud: Option<u8>) {
+        let mut flags = ResetFlags::empty();
+        flags.set(ResetFlags::BOOTLOADER, bootloader);
+        flags.set(ResetFlags::BAUD, baud.is_some());
         self.frame.cmd = Cmd::Reset;
-        self.frame.set_addr(0);
-        self.frame.flags = Flags {
-            reset: if bootloader {
-                ResetFlags::BOOTLOADER
-            } else {
-                ResetFlags::empty()
-            },
-        };
+        self.frame.set_addr(baud.unwrap_or(0) as u32);
+        self.frame.flags = Flags { reset: flags };
         self.frame.len = 0;
         self.frame.status = Status::Request;
         let _ = self.frame.send(&mut self.transport);