mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
Merge branch 'dev' into fix/kernel-increase-heap-checked-add
This commit is contained in:
commit
752d26885a
32 changed files with 970 additions and 214 deletions
|
|
@ -32,6 +32,29 @@ By participating in this project you agree to abide by the
|
|||
(please read the full text so that you can understand what actions will and
|
||||
will not be tolerated).
|
||||
|
||||
## AI-Assisted Project Contributions
|
||||
|
||||
- You may use AI assistance for contributing to this project in accordance with these principles of accountability and transparency.
|
||||
|
||||
### Accountability
|
||||
|
||||
- When you submit a contribution, you represent that you are the author and that you are fully accountable for the entirety of the contribution.
|
||||
- You are responsible for your contribution, including vouching for the quality, license compliance, and utility of your submission.
|
||||
- Using AI assistance in your contribution does not relieve you of the responsibility to ensure that your contribution meets project standards; your contributions must be modular, reviewable, and clearly explainable.
|
||||
|
||||
### Transparency
|
||||
|
||||
- You **must** disclose the use of AI tools when a significant part of the contribution is generated without changes.
|
||||
- You **should** disclose the use of AI tools where it might be helpful to the maintainer reviewing your contribution.
|
||||
- Using AI tools to correct grammar and spelling does not require disclosure.
|
||||
- Make your disclosure in your commit message as a trailer; e.g. `Assisted-by: ChatGPTv5`
|
||||
- Use the tag "AI" on pull requests that were primarily generated or guided by AI tools
|
||||
|
||||
### Scope and Cadence
|
||||
- Prefer one concern per PR. Bug fixes, refactors, and documentation updates belong in separate PRs even when they touch the same file.
|
||||
- For mechanical changes that span many files or services (e.g. pattern sweeps), split into per-target PRs and open no more than two per week so review stays tractable.
|
||||
- Before a large or cross-cutting change, open an issue or discussion first to align on scope.
|
||||
|
||||
## Contribution Workflow
|
||||
|
||||
This is an overview of the contribution workflow:
|
||||
|
|
|
|||
4
Cargo.lock
generated
4
Cargo.lock
generated
|
|
@ -397,6 +397,7 @@ dependencies = [
|
|||
"bao1x-hal-service",
|
||||
"base64 0.22.1",
|
||||
"blitstr2",
|
||||
"getrandom 0.2.12",
|
||||
"libm 0.2.8",
|
||||
"locales",
|
||||
"log",
|
||||
|
|
@ -404,6 +405,8 @@ dependencies = [
|
|||
"nalgebra",
|
||||
"num-derive 0.4.2",
|
||||
"num-traits",
|
||||
"rand 0.8.5",
|
||||
"rand_core 0.6.4",
|
||||
"rkyv 0.8.8",
|
||||
"rqrr",
|
||||
"utralib 0.1.27",
|
||||
|
|
@ -411,6 +414,7 @@ dependencies = [
|
|||
"xous 0.9.70 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"xous-api-log",
|
||||
"xous-api-names",
|
||||
"xous-api-susres 0.9.68",
|
||||
"xous-api-ticktimer",
|
||||
"xous-ipc 0.10.10 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ namespace Antmicro.Renode.Peripherals.Timers.Betrusted
|
|||
public LiteX_Timer_32(Machine machine, long frequency) : base(machine)
|
||||
{
|
||||
IRQ = new GPIO();
|
||||
innerTimer = new LimitTimer(machine.ClockSource, frequency, this, "LiteXTimer32", eventEnabled: true, autoUpdate: true);
|
||||
innerTimer = new LimitTimer(machine.ClockSource, (ulong)frequency, this, "LiteXTimer32", eventEnabled: true, autoUpdate: true);
|
||||
innerTimer.LimitReached += delegate
|
||||
{
|
||||
this.Log(LogLevel.Noisy, "Limit reached");
|
||||
|
|
|
|||
|
|
@ -51,6 +51,10 @@ pub trait BioApi<'a> {
|
|||
/// that the clocks may have changed.
|
||||
fn update_bio_freq(&mut self, freq: u32) -> u32;
|
||||
|
||||
/// Called before frequency changes to activate any application-specific callbacks
|
||||
/// to avoid glitches.
|
||||
fn prep_freq_change(&mut self);
|
||||
|
||||
/// Returns the frequency, in Hz, of the incoming clock to the BIO cores.
|
||||
fn get_bio_freq(&self) -> u32;
|
||||
|
||||
|
|
@ -192,6 +196,7 @@ pub enum BioOp {
|
|||
InitCore,
|
||||
DeInitCore,
|
||||
UpdateBioFreq,
|
||||
PrepFreqChange,
|
||||
GetCoreFreq,
|
||||
GetBioFreq,
|
||||
CoreState,
|
||||
|
|
|
|||
|
|
@ -80,6 +80,29 @@ impl From<u8> for VbusIrq {
|
|||
}
|
||||
}
|
||||
|
||||
impl From<VbusIrq> for usize {
|
||||
fn from(v: VbusIrq) -> usize {
|
||||
match v {
|
||||
VbusIrq::None => 0,
|
||||
VbusIrq::Insert => 1,
|
||||
VbusIrq::Remove => 2,
|
||||
VbusIrq::InsertAndRemove => 3,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<usize> for VbusIrq {
|
||||
fn from(v: usize) -> VbusIrq {
|
||||
match v {
|
||||
0 => VbusIrq::None,
|
||||
1 => VbusIrq::Insert,
|
||||
2 => VbusIrq::Remove,
|
||||
3 => VbusIrq::InsertAndRemove,
|
||||
_ => VbusIrq::None, // infallible: unknown values collapse to None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(u8)]
|
||||
#[derive(PartialEq, Eq, Clone, Copy)]
|
||||
pub enum WhichLdo {
|
||||
|
|
|
|||
|
|
@ -134,6 +134,14 @@ impl<'a> BioApi<'a> for Bio {
|
|||
}
|
||||
}
|
||||
|
||||
fn prep_freq_change(&mut self) {
|
||||
send_message(
|
||||
self.conn,
|
||||
Message::new_blocking_scalar(BioOp::PrepFreqChange.to_usize().unwrap(), 0, 0, 0, 0),
|
||||
)
|
||||
.ok();
|
||||
}
|
||||
|
||||
fn get_bio_freq(&self) -> u32 {
|
||||
match send_message(
|
||||
self.conn,
|
||||
|
|
|
|||
|
|
@ -502,6 +502,10 @@ impl<'a> BioApi<'a> for BioSharedState {
|
|||
prev_freq
|
||||
}
|
||||
|
||||
fn prep_freq_change(&mut self) {
|
||||
// at the hw level, there's nothing to do; a handler at the `std` level is invoked instead
|
||||
}
|
||||
|
||||
unsafe fn get_core_handle(&self, _fifo: Fifo) -> Result<Option<CoreHandle>, BioError> {
|
||||
unimplemented!("This is managed by the main loop server, not the hardware interface");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,6 +60,8 @@ pub mod rtc;
|
|||
pub mod sigcheck;
|
||||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
pub mod sram_trim;
|
||||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
pub mod wdt;
|
||||
|
||||
#[inline(always)]
|
||||
pub fn cache_flush() {
|
||||
|
|
|
|||
|
|
@ -532,6 +532,11 @@ impl<'a> Oled128x128<'a> {
|
|||
|
||||
pub fn powerdown(&mut self) {
|
||||
self.powerdown = true;
|
||||
let powoff = [Command::DisplayOnOff(DisplayState::Off)];
|
||||
for command in powoff {
|
||||
let bytes = command.encode();
|
||||
self.send_command(bytes).ok();
|
||||
}
|
||||
// assert reset
|
||||
crate::board::assert_periph_reset(self.iox, true);
|
||||
self.iox.set_gpio_pin_value(self.cd_port, self.cd_pin, IoxValue::Low);
|
||||
|
|
@ -604,6 +609,170 @@ impl<'a> Oled128x128<'a> {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A diffusion-transition effect courtesy of Claude Sonnet 4.6. Query fed in `render_bitmap` code
|
||||
/// and asked for a variant that does a "diffusive dither" transition. Applied largely without changes;
|
||||
/// the main change was adjusting the seed to be passed, in instead of fixed, so the transition can be
|
||||
/// different every call.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn render_bitmap_diffuse(
|
||||
&mut self,
|
||||
bitmap: &ux_api::service::api::BaosecBitmap,
|
||||
frames: usize,
|
||||
seed: u64,
|
||||
) -> Result<(), xous::Error> {
|
||||
use std::collections::VecDeque;
|
||||
|
||||
const W: isize = WIDTH as isize;
|
||||
const H: isize = LINES as isize;
|
||||
|
||||
// -- 1. Build per-pixel metadata for the destination region --------------
|
||||
//
|
||||
// We work in framebuffer linear-index space (0..WIDTH*LINES).
|
||||
// Three bitmasks, each 512 u32 words == 16 384 bits == one bit per pixel.
|
||||
|
||||
let mut in_region = [0u32; 512]; // 1 = this fb pixel is touched by the bitmap
|
||||
let mut target_bit = [0u32; 512]; // desired final value for pixels in region
|
||||
let mut settled = [0u32; 512]; // 1 = pixel already written this transition
|
||||
|
||||
// Clamp the source bounding box (mirrors render_bitmap).
|
||||
let src_x0 = bitmap.bounding_box.tl.x.max(0);
|
||||
let src_y0 = bitmap.bounding_box.tl.y.max(0);
|
||||
let src_x1 = bitmap.bounding_box.br.x.min(W);
|
||||
let src_y1 = bitmap.bounding_box.br.y.min(H);
|
||||
|
||||
let mut total: usize = 0;
|
||||
|
||||
for src_y in src_y0..src_y1 {
|
||||
let dst_y = src_y + bitmap.top_left.y;
|
||||
if dst_y < 0 || dst_y >= H {
|
||||
continue;
|
||||
}
|
||||
for src_x in src_x0..src_x1 {
|
||||
let dst_x = src_x + bitmap.top_left.x;
|
||||
if dst_x < 0 || dst_x >= W {
|
||||
continue;
|
||||
}
|
||||
|
||||
let src_lin = (src_x + src_y * W) as usize;
|
||||
let dst_lin = (dst_x + dst_y * W) as usize;
|
||||
|
||||
in_region[dst_lin >> 5] |= 1 << (dst_lin & 31);
|
||||
total += 1;
|
||||
|
||||
let bit = (bitmap.bits[src_lin >> 5] >> (src_lin & 31)) & 1;
|
||||
if bit != 0 {
|
||||
target_bit[dst_lin >> 5] |= 1 << (dst_lin & 31);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if total == 0 || frames == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// -- 2. Collect region pixel indices for random seeding ------------------
|
||||
|
||||
let mut region_pixels: Vec<usize> = Vec::with_capacity(total);
|
||||
for i in 0..(WIDTH as usize * LINES as usize) {
|
||||
if (in_region[i >> 5] >> (i & 31)) & 1 != 0 {
|
||||
region_pixels.push(i);
|
||||
}
|
||||
}
|
||||
|
||||
// -- 3. Tiny xorshift-64 RNG (no std::collections dependency needed) -----
|
||||
|
||||
let mut rng: u64 = seed ^ total as u64;
|
||||
macro_rules! rand {
|
||||
() => {{
|
||||
rng ^= rng << 13;
|
||||
rng ^= rng >> 7;
|
||||
rng ^= rng << 17;
|
||||
rng
|
||||
}};
|
||||
}
|
||||
|
||||
// -- 4. Diffusion loop ----------------------------------------------------
|
||||
|
||||
let pixels_per_frame = (total / frames).max(1);
|
||||
|
||||
// Scatter a handful of seeds so diffusion starts from multiple origins.
|
||||
let mut frontier: VecDeque<usize> = VecDeque::new();
|
||||
let n_seeds = (total / 32).clamp(1, 64);
|
||||
for _ in 0..n_seeds {
|
||||
let dl = region_pixels[(rand!() as usize) % total];
|
||||
if (settled[dl >> 5] >> (dl & 31)) & 1 == 0 {
|
||||
settled[dl >> 5] |= 1 << (dl & 31);
|
||||
frontier.push_back(dl);
|
||||
}
|
||||
}
|
||||
|
||||
let mut committed: usize = 0;
|
||||
|
||||
while committed < total {
|
||||
let mut this_frame: usize = 0;
|
||||
|
||||
while this_frame < pixels_per_frame {
|
||||
// If the frontier runs dry, plant a new random seed.
|
||||
if frontier.is_empty() {
|
||||
let mut planted = false;
|
||||
for _ in 0..64 {
|
||||
let dl = region_pixels[(rand!() as usize) % total];
|
||||
if (settled[dl >> 5] >> (dl & 31)) & 1 == 0 {
|
||||
settled[dl >> 5] |= 1 << (dl & 31);
|
||||
frontier.push_back(dl);
|
||||
planted = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if !planted {
|
||||
break;
|
||||
} // all pixels settled
|
||||
}
|
||||
|
||||
// -- commit the next frontier pixel -------------------------------
|
||||
let dl = frontier.pop_front().unwrap();
|
||||
|
||||
let on = (target_bit[dl >> 5] >> (dl & 31)) & 1;
|
||||
if on != 0 {
|
||||
self.buffer[dl >> 5] |= 1 << (dl & 31);
|
||||
} else {
|
||||
self.buffer[dl >> 5] &= !(1 << (dl & 31));
|
||||
}
|
||||
this_frame += 1;
|
||||
|
||||
// -- expand to unsettled cardinal neighbours in the region ---------
|
||||
let dst_x = (dl % WIDTH as usize) as isize;
|
||||
let dst_y = (dl / WIDTH as usize) as isize;
|
||||
|
||||
for (nx, ny) in
|
||||
[(dst_x - 1, dst_y), (dst_x + 1, dst_y), (dst_x, dst_y - 1), (dst_x, dst_y + 1)]
|
||||
{
|
||||
if nx < 0 || nx >= W || ny < 0 || ny >= H {
|
||||
continue;
|
||||
}
|
||||
let ndl = (nx + ny * W) as usize;
|
||||
if (in_region[ndl >> 5] >> (ndl & 31)) & 1 == 0 {
|
||||
continue;
|
||||
}
|
||||
if (settled[ndl >> 5] >> (ndl & 31)) & 1 != 0 {
|
||||
continue;
|
||||
}
|
||||
settled[ndl >> 5] |= 1 << (ndl & 31);
|
||||
frontier.push_back(ndl);
|
||||
}
|
||||
}
|
||||
|
||||
committed += this_frame;
|
||||
if this_frame > 0 {
|
||||
self.redraw()?;
|
||||
}
|
||||
if this_frame == 0 {
|
||||
break;
|
||||
} // guard against impossible stuck state
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> FrameBuffer for Oled128x128<'a> {
|
||||
|
|
|
|||
315
libs/bao1x-hal/src/wdt.rs
Normal file
315
libs/bao1x-hal/src/wdt.rs
Normal file
|
|
@ -0,0 +1,315 @@
|
|||
use utralib::*;
|
||||
|
||||
// This file mainly machine generated using Claude Sonnet 4.6 Adaptive, by
|
||||
// feeding in the RTC driver as a template, the Crossbar WDG C driver as a reference,
|
||||
// and the verilog source files for the IP block.
|
||||
//
|
||||
// So far, the only tested aspects are enabling and feeding the watchdog; the
|
||||
// interrupt feature set is not yet tested.
|
||||
|
||||
/*
|
||||
This is the ARM "CMSDK APB Watchdog" IP (PrimeCell part number 0x824,
|
||||
designer 0x3B / ARM).
|
||||
|
||||
The full APB address window is 4 KB (PADDR[11:2]), so a single
|
||||
xous::map_memory call of 0x1000 bytes covers every register including
|
||||
LOCK at offset 0xC00.
|
||||
|
||||
Main register block (word indices 0–5, offsets 0x000–0x014)
|
||||
-----------------------------------------------------------
|
||||
LOAD 0x000 32-bit down-counter reload value.
|
||||
Writing here also immediately reloads the running
|
||||
counter (the hardware does a synchronised load on
|
||||
the next WDOGCLK edge).
|
||||
|
||||
VALUE 0x004 Current counter value (read-only).
|
||||
Read-back of wdog_load is returned immediately after
|
||||
a write before the first WDOGCLK edge, so the freshly
|
||||
written value is always visible.
|
||||
|
||||
CONTROL 0x008 [1] RESEN – assert WDOGRES (hardware reset) when the
|
||||
counter expires while the interrupt is already
|
||||
active (i.e. the dog was not fed after the first
|
||||
timeout).
|
||||
[0] INTEN – enable the counter AND the WDOGINT output.
|
||||
The counter only decrements while this bit is set.
|
||||
Clearing it freezes the counter; the reload value
|
||||
is NOT lost.
|
||||
|
||||
INTCLR 0x00C Write 0x5A to feed the dog (reload counter + clear
|
||||
the interrupt). Any other value is ignored by the
|
||||
hardware.
|
||||
|
||||
RAWINTSTAT 0x010 [0] RIS – raw (unmasked) interrupt flag. Set when the
|
||||
counter reaches zero; cleared by writing INTCLR.
|
||||
|
||||
MASKINTSTAT 0x014 [0] MIS – masked interrupt status (RIS & INTEN).
|
||||
This is the signal that actually reaches the interrupt subsystem.
|
||||
|
||||
Lock register (word index 768, offset 0xC00)
|
||||
--------------------------------------------
|
||||
LOCK 0xC00 Write LOCK_MAGIC (0x1ACCE551) to unlock all writable
|
||||
registers. Any other write re-locks them. Reads back
|
||||
the current lock state (0 = unlocked, 1 = locked).
|
||||
Reset state is unlocked (wdog_lock = 0).
|
||||
|
||||
Interrupt / reset behaviour summary
|
||||
------------------------------------
|
||||
First timeout → RAWINTSTAT[0] set, WDOGINT asserted (if INTEN=1).
|
||||
Feed dog → write 0x5A to INTCLR; counter reloads, interrupt clears.
|
||||
Second timeout → WDOGRES asserted (if RESEN=1), counter freezes until
|
||||
LOAD is written again.
|
||||
|
||||
Typical "reset-only, no CPU interrupt" configuration
|
||||
------------------------------------------------------
|
||||
Set CONTROL = 0b11 (RESEN|INTEN). Do NOT wire the interrupt.
|
||||
Feed the dog periodically by writing INTCLR. If the firmware hangs the
|
||||
counter will expire twice and assert the hardware reset line.
|
||||
This matches the usage in the C HAL (daric_hal_wdg.c).
|
||||
*/
|
||||
|
||||
// -- Main registers ------------------------------------------------------------
|
||||
|
||||
/// Down-counter reload value. Write to set; also reloads the running counter.
|
||||
pub const LOAD: Register = Register::new(0, 0xFFFF_FFFF);
|
||||
|
||||
/// Current counter value (read-only).
|
||||
pub const VALUE: Register = Register::new(1, 0xFFFF_FFFF);
|
||||
|
||||
/// Control register.
|
||||
pub const CONTROL: Register = Register::new(2, 0x3);
|
||||
/// CONTROL[0]: counter enable + interrupt output enable.
|
||||
/// The counter only runs while this bit is set.
|
||||
pub const CONTROL_INTEN: Field = Field::new(1, 0, CONTROL);
|
||||
/// CONTROL[1]: hardware reset output enable.
|
||||
pub const CONTROL_RESEN: Field = Field::new(1, 1, CONTROL);
|
||||
|
||||
/// Interrupt clear / dog-feed register. Write [`INTCLR_FEED`] to feed.
|
||||
pub const INTCLR: Register = Register::new(3, 0xFF);
|
||||
|
||||
/// Raw (unmasked) interrupt status.
|
||||
pub const RAWINTSTAT: Register = Register::new(4, 0x1);
|
||||
/// RAWINTSTAT[0]: set when counter reaches zero; cleared by feeding.
|
||||
pub const RAWINTSTAT_RIS: Field = Field::new(1, 0, RAWINTSTAT);
|
||||
|
||||
/// Masked interrupt status (RAWINTSTAT & INTEN).
|
||||
pub const MASKINTSTAT: Register = Register::new(5, 0x1);
|
||||
/// MASKINTSTAT[0]: the interrupt signal seen by the hardware interrupt subsystem.
|
||||
pub const MASKINTSTAT_MIS: Field = Field::new(1, 0, MASKINTSTAT);
|
||||
|
||||
// -- Lock register (offset 0xC00 = word index 768) ----------------------------
|
||||
|
||||
/// Software lock register. Protects all writable registers.
|
||||
/// Word index 768 = byte offset 0xC00, still within the 4 KB APB window.
|
||||
pub const LOCK: Register = Register::new(768, 0xFFFF_FFFF);
|
||||
|
||||
// -- Constants -----------------------------------------------------------------
|
||||
|
||||
/// Write to [`LOCK`] to unlock all writable registers.
|
||||
pub const LOCK_MAGIC: u32 = 0x1ACCE551;
|
||||
/// Write to [`LOCK`] to re-lock all writable registers.
|
||||
pub const LOCK_VALUE: u32 = 0x0000_0000;
|
||||
/// Write to [`INTCLR`] to feed the dog and clear the interrupt.
|
||||
pub const INTCLR_FEED: u32 = 0x5A;
|
||||
|
||||
/// Physical base address of the WDT peripheral.
|
||||
pub const HW_WDT_BASE: usize = 0x40041000;
|
||||
/// Number of 32-bit words needed to cover LOAD … LOCK (inclusive).
|
||||
/// 769 = indices 0–5 (main regs) + index 768 (LOCK).
|
||||
pub const WDT_NUMREGS: usize = 769;
|
||||
|
||||
// -- Op enum (for future message-passing integration) -------------------------
|
||||
|
||||
/// Operations that can be sent to a WDT service.
|
||||
///
|
||||
/// Variants 0–127 are for externally-visible APIs; 1024+ are for
|
||||
/// implementation-private operations (mirroring the TimeOp convention).
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub enum WdgOp {
|
||||
/// Enable the watchdog.
|
||||
/// arg1: load value (ticks); arg2: enable_reset (bool); arg3: enable_irq (bool)
|
||||
Enable = 0,
|
||||
|
||||
/// Disable the watchdog (freeze counter, clear CONTROL).
|
||||
Disable = 1,
|
||||
|
||||
/// Feed the dog — reset the counter and clear any pending interrupt.
|
||||
Feed = 2,
|
||||
|
||||
/// Returns the current counter value in arg1.
|
||||
GetValue = 3,
|
||||
|
||||
/// Returns 1 in arg1 if the watchdog is currently running (CONTROL != 0).
|
||||
IsEnabled = 4,
|
||||
|
||||
/// Returns raw interrupt status in arg1 and masked status in arg2.
|
||||
GetInterruptStatus = 5,
|
||||
|
||||
// -- Implementation-private ops ----------------------------------------
|
||||
/// Enable the interrupt output (sets CONTROL[INTEN]; preserves RESEN).
|
||||
/// Does NOT connect the interrupt — use xous::claim_interrupt separately.
|
||||
UnmaskInterrupt = 1024,
|
||||
|
||||
/// Disable the interrupt output (clears CONTROL[INTEN]; preserves RESEN).
|
||||
/// Leaves the counter running if RESEN is still set.
|
||||
MaskInterrupt = 1025,
|
||||
}
|
||||
|
||||
// -- Driver -------------------------------------------------------------------
|
||||
|
||||
/// Single-owner driver for the ARM CMSDK APB Watchdog.
|
||||
///
|
||||
/// # Memory mapping
|
||||
/// When compiled with the `std` feature (Xous userspace), `new()` calls
|
||||
/// `xous::map_memory` to obtain a virtual mapping of the 4 KB APB window.
|
||||
/// Without `std` (bare-metal / privileged context) it uses the physical
|
||||
/// address directly.
|
||||
///
|
||||
/// # Lock protocol
|
||||
/// Every write to a protected register must be bracketed by `unlock` /
|
||||
/// `lock`. Reads do not require unlocking.
|
||||
///
|
||||
/// # Typical "reset-only" setup
|
||||
/// ```ignore
|
||||
/// let mut wdt = Wdt::new();
|
||||
/// // Feed interval (e.g. 500 ms) expressed in watchdog clock ticks.
|
||||
/// // Use the WDG_TICKS_PER_MS macro / constant from the BSP.
|
||||
/// wdt.enable(500 * TICKS_PER_MS, /*enable_reset=*/ true, /*enable_irq=*/ false);
|
||||
///
|
||||
/// loop {
|
||||
/// do_work();
|
||||
/// wdt.feed();
|
||||
/// }
|
||||
/// ```
|
||||
pub struct Wdt {
|
||||
csr: CSR<u32>,
|
||||
}
|
||||
|
||||
impl Wdt {
|
||||
/// Construct a new `Wdt` driver, mapping hardware memory as required.
|
||||
pub fn new() -> Self {
|
||||
#[cfg(feature = "std")]
|
||||
{
|
||||
let wdt_range = xous::map_memory(
|
||||
xous::MemoryAddress::new(HW_WDT_BASE),
|
||||
None,
|
||||
// 4 KB covers the full APB window including LOCK at 0xC00
|
||||
// and the ID registers at 0xFE0–0xFFC.
|
||||
4096,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.expect("couldn't map WDT range");
|
||||
Wdt { csr: CSR::new(wdt_range.as_mut_ptr() as *mut u32) }
|
||||
}
|
||||
#[cfg(not(feature = "std"))]
|
||||
{
|
||||
Wdt { csr: CSR::new(HW_WDT_BASE as *mut u32) }
|
||||
}
|
||||
}
|
||||
|
||||
// -- Lock helpers ---------------------------------------------------------
|
||||
|
||||
#[inline]
|
||||
fn unlock(&mut self) { self.csr.wo(LOCK, LOCK_MAGIC); }
|
||||
|
||||
#[inline]
|
||||
fn lock(&mut self) { self.csr.wo(LOCK, LOCK_VALUE); }
|
||||
|
||||
// -- Public API -----------------------------------------------------------
|
||||
|
||||
/// Enable the watchdog and start the counter.
|
||||
///
|
||||
/// - `load_value`: initial (and reload) counter value in watchdog clock ticks. The counter counts down
|
||||
/// from this value. The clock runs at (pclk / 2)
|
||||
/// - `enable_reset`: assert the hardware reset output on the *second* consecutive timeout (i.e. when the
|
||||
/// dog was not fed after the first expiry). Set this `true` for a normal watchdog reset.
|
||||
/// - `enable_irq`: set CONTROL[INTEN], which both starts the counter *and* drives the WDOGINT output to
|
||||
/// the interrupt system. For reset-only usage (no CPU interrupt desired) pass `false` here — the
|
||||
/// counter will still run because INTEN is always forced set internally; see note.
|
||||
///
|
||||
/// # Note on INTEN and the counter
|
||||
/// The ARM CMSDK watchdog only decrements the counter while INTEN=1
|
||||
/// (CONTROL[0]). To use the watchdog *purely* for reset (no interrupt
|
||||
/// servicing) you still need the counter running, so this function always
|
||||
/// sets INTEN regardless of whether the interrupt is registered or not
|
||||
/// with the rest of the system.
|
||||
pub fn enable(&mut self, load_value: u32, enable_reset: bool) {
|
||||
self.unlock();
|
||||
self.csr.wo(LOAD, load_value);
|
||||
// INTEN (bit 0) must always be set to start the counter.
|
||||
// RESEN (bit 1) gates the hardware reset output.
|
||||
let ctrl = 0b01 | if enable_reset { 0b10 } else { 0 };
|
||||
self.csr.wo(CONTROL, ctrl);
|
||||
self.lock();
|
||||
}
|
||||
|
||||
/// Disable the watchdog.
|
||||
///
|
||||
/// Clears CONTROL (freezes the counter and de-asserts outputs) and
|
||||
/// resets LOAD to the all-ones sentinel so that if the watchdog is
|
||||
/// inadvertently re-enabled it will take the maximum possible time
|
||||
/// before expiring.
|
||||
pub fn disable(&mut self) {
|
||||
self.unlock();
|
||||
self.csr.wo(CONTROL, 0x0);
|
||||
self.csr.wo(LOAD, 0xFFFF_FFFF);
|
||||
self.lock();
|
||||
}
|
||||
|
||||
/// Feed the dog — reload the counter and clear any pending interrupt.
|
||||
///
|
||||
/// Writes the magic byte `0x5A` to INTCLR. The hardware ignores any
|
||||
/// other value, so there is no need to check the current state first.
|
||||
pub fn feed(&mut self) {
|
||||
self.unlock();
|
||||
self.csr.wo(INTCLR, INTCLR_FEED);
|
||||
self.lock();
|
||||
}
|
||||
|
||||
/// Returns `true` if the watchdog counter is currently running
|
||||
/// (CONTROL != 0).
|
||||
pub fn is_enabled(&self) -> bool { self.csr.r(CONTROL) != 0 }
|
||||
|
||||
/// Returns the current value of the down-counter.
|
||||
///
|
||||
/// Immediately after writing [`enable`], this reflects the freshly loaded
|
||||
/// value before the first WDOGCLK edge.
|
||||
pub fn current_value(&self) -> u32 { self.csr.r(VALUE) }
|
||||
|
||||
/// Returns the raw (unmasked) interrupt flag.
|
||||
///
|
||||
/// Set when the counter reaches zero. Cleared by [`feed`].
|
||||
/// This flag is independent of INTEN, so it is visible even when
|
||||
/// the counter-enable bit is cleared.
|
||||
pub fn raw_interrupt_pending(&self) -> bool { self.csr.rf(RAWINTSTAT_RIS) != 0 }
|
||||
|
||||
/// Returns the masked interrupt status (RAWINTSTAT & INTEN).
|
||||
///
|
||||
/// This is the signal that would be presented to the CPU if the
|
||||
/// interrupt line were connected via `xous::claim_interrupt`.
|
||||
pub fn masked_interrupt_pending(&self) -> bool { self.csr.rf(MASKINTSTAT_MIS) != 0 }
|
||||
|
||||
/// Enable the WDOGINT interrupt output (set CONTROL[INTEN]).
|
||||
///
|
||||
/// Preserves the current RESEN setting. Does NOT connect the CPU —
|
||||
/// call `xous::claim_interrupt` separately when you are ready to handle
|
||||
/// the interrupt in software.
|
||||
pub fn unmask_interrupt(&mut self) {
|
||||
self.unlock();
|
||||
let ctrl = self.csr.r(CONTROL) | 0b01;
|
||||
self.csr.wo(CONTROL, ctrl);
|
||||
self.lock();
|
||||
}
|
||||
|
||||
/// Disable the WDOGINT interrupt output (clear CONTROL[INTEN]).
|
||||
///
|
||||
/// Preserves the current RESEN setting. Note that clearing INTEN also
|
||||
/// freezes the counter — call [`unmask_interrupt`] or [`enable`] to
|
||||
/// resume it.
|
||||
pub fn mask_interrupt(&mut self) {
|
||||
self.unlock();
|
||||
let ctrl = self.csr.r(CONTROL) & !0b01;
|
||||
self.csr.wo(CONTROL, ctrl);
|
||||
self.lock();
|
||||
}
|
||||
}
|
||||
|
|
@ -19,13 +19,18 @@ rkyv = { version = "0.8.8", default-features = false, features = [
|
|||
] }
|
||||
|
||||
[features]
|
||||
zh = []
|
||||
ja = []
|
||||
kr = []
|
||||
emoji = []
|
||||
|
||||
# selection of board settings for display resolution
|
||||
bao1x = []
|
||||
board-baosec = []
|
||||
board-baosor = []
|
||||
hosted-baosec = []
|
||||
hosted = []
|
||||
renode = []
|
||||
precursor = []
|
||||
board-baosec = ["emoji", "ja"]
|
||||
board-baosor = ["emoji", "ja", "zh", "kr"]
|
||||
hosted-baosec = ["emoji", "ja", "zh", "kr"]
|
||||
hosted = ["emoji", "ja", "zh", "kr"]
|
||||
renode = ["emoji", "ja", "zh", "kr"]
|
||||
precursor = ["emoji", "ja", "zh", "kr"]
|
||||
|
||||
default = []
|
||||
|
|
|
|||
|
|
@ -3,13 +3,17 @@
|
|||
//
|
||||
#![allow(dead_code)]
|
||||
pub mod bold;
|
||||
#[cfg(feature = "emoji")]
|
||||
pub mod emoji;
|
||||
#[cfg(feature = "ja")]
|
||||
pub mod ja;
|
||||
#[cfg(feature = "kr")]
|
||||
pub mod kr;
|
||||
pub mod mono;
|
||||
pub mod regular;
|
||||
pub mod small;
|
||||
pub mod tall;
|
||||
#[cfg(feature = "zh")]
|
||||
pub mod zh;
|
||||
|
||||
use crate::GlyphSprite;
|
||||
|
|
@ -184,6 +188,7 @@ pub fn tall_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "emoji")]
|
||||
pub fn emoji_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
||||
match emoji::CODEPOINTS.binary_search(&(ch as u32)) {
|
||||
Ok(n) => {
|
||||
|
|
@ -208,6 +213,7 @@ pub fn emoji_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "emoji")]
|
||||
pub fn emoji_large_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
||||
match emoji::CODEPOINTS.binary_search(&(ch as u32)) {
|
||||
Ok(n) => {
|
||||
|
|
@ -232,6 +238,7 @@ pub fn emoji_large_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "zh")]
|
||||
pub fn zh_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
||||
match zh::CODEPOINTS.binary_search(&(ch as u32)) {
|
||||
Ok(n) => {
|
||||
|
|
@ -256,6 +263,7 @@ pub fn zh_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "ja")]
|
||||
pub fn ja_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
||||
match ja::CODEPOINTS.binary_search(&(ch as u32)) {
|
||||
Ok(n) => {
|
||||
|
|
@ -280,6 +288,7 @@ pub fn ja_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "kr")]
|
||||
pub fn kr_glyph(ch: char) -> Result<GlyphSprite, usize> {
|
||||
match kr::CODEPOINTS.binary_search(&(ch as u32)) {
|
||||
Ok(n) => {
|
||||
|
|
|
|||
|
|
@ -61,3 +61,28 @@ pub fn glyph_height_hint(g: GlyphStyle) -> usize {
|
|||
GlyphStyle::Tall => 19,
|
||||
}
|
||||
}
|
||||
|
||||
/// Find glyph for char using latin regular, emoji, ja, zh, and kr font data
|
||||
pub fn style_glyph(locale: &'static str, ch: char, base_style: &GlyphStyle) -> GlyphSprite {
|
||||
match locale {
|
||||
#[cfg(feature = "zh")]
|
||||
"zh" => {
|
||||
style_wrapper!(zh_rules, base_style, ch)
|
||||
}
|
||||
#[cfg(feature = "ja")]
|
||||
"jp" => {
|
||||
style_wrapper!(jp_rules, base_style, ch)
|
||||
}
|
||||
#[cfg(feature = "kr")]
|
||||
"kr" => {
|
||||
style_wrapper!(kr_rules, base_style, ch)
|
||||
}
|
||||
"en-tts" => {
|
||||
style_wrapper!(en_audio_rules, base_style, ch)
|
||||
}
|
||||
// default to English rules
|
||||
_ => {
|
||||
style_wrapper!(english_rules, base_style, ch)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,78 +30,79 @@ macro_rules! style_wrapper {
|
|||
}
|
||||
|
||||
#[macro_export]
|
||||
#[cfg(feature = "zh")]
|
||||
macro_rules! zh_rules {
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {
|
||||
match zh_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $base_style($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $emoji_style($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match ja_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match kr_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $base_style(REPLACEMENT) {
|
||||
Ok(g) => g,
|
||||
_ => NULL_GLYPH_SPRITE,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {{
|
||||
// Always-present: zh itself, base, emoji
|
||||
#[allow(unused_mut)]
|
||||
let mut result =
|
||||
zh_glyph($ch).ok().or_else(|| $base_style($ch).ok()).or_else(|| $emoji_style($ch).ok());
|
||||
|
||||
#[cfg(feature = "ja")]
|
||||
if result.is_none() {
|
||||
result = ja_glyph($ch).ok();
|
||||
}
|
||||
};
|
||||
|
||||
#[cfg(feature = "kr")]
|
||||
if result.is_none() {
|
||||
result = kr_glyph($ch).ok();
|
||||
}
|
||||
|
||||
// Always-present: replacement and null sentinel
|
||||
result.or_else(|| $base_style(REPLACEMENT).ok()).unwrap_or(NULL_GLYPH_SPRITE)
|
||||
}};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
#[cfg(feature = "ja")]
|
||||
macro_rules! jp_rules {
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {
|
||||
match ja_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $base_style($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $emoji_style($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match zh_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match kr_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $base_style(REPLACEMENT) {
|
||||
Ok(g) => g,
|
||||
_ => NULL_GLYPH_SPRITE,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {{
|
||||
// Always-present: ja itself, base, emoji
|
||||
#[allow(unused_mut)]
|
||||
let mut result =
|
||||
ja_glyph($ch).ok().or_else(|| $base_style($ch).ok()).or_else(|| $emoji_style($ch).ok());
|
||||
|
||||
// Optional: zh fallback only if zh is in the build
|
||||
#[cfg(feature = "zh")]
|
||||
if result.is_none() {
|
||||
result = zh_glyph($ch).ok();
|
||||
}
|
||||
};
|
||||
|
||||
// Optional: kr fallback only if kr is in the build
|
||||
#[cfg(feature = "kr")]
|
||||
if result.is_none() {
|
||||
result = kr_glyph($ch).ok();
|
||||
}
|
||||
|
||||
// Always-present: replacement and null sentinel
|
||||
result.or_else(|| $base_style(REPLACEMENT).ok()).unwrap_or(NULL_GLYPH_SPRITE)
|
||||
}};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
#[cfg(feature = "kr")]
|
||||
macro_rules! kr_rules {
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {
|
||||
match kr_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $base_style($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $emoji_style($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match ja_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match zh_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $base_style(REPLACEMENT) {
|
||||
Ok(g) => g,
|
||||
_ => NULL_GLYPH_SPRITE,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {{
|
||||
// Always-present: kr itself, base, emoji
|
||||
#[allow(unused_mut)]
|
||||
let mut result =
|
||||
kr_glyph($ch).ok().or_else(|| $base_style($ch).ok()).or_else(|| $emoji_style($ch).ok());
|
||||
|
||||
// Optional: ja fallback only if ja is in the build
|
||||
#[cfg(feature = "ja")]
|
||||
if result.is_none() {
|
||||
result = ja_glyph($ch).ok();
|
||||
}
|
||||
};
|
||||
|
||||
// Optional: zh fallback only if zh is in the build
|
||||
#[cfg(feature = "zh")]
|
||||
if result.is_none() {
|
||||
result = zh_glyph($ch).ok();
|
||||
}
|
||||
|
||||
// Always-present: replacement and null sentinel
|
||||
result.or_else(|| $base_style(REPLACEMENT).ok()).unwrap_or(NULL_GLYPH_SPRITE)
|
||||
}};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
|
|
@ -150,27 +151,28 @@ macro_rules! english_rules {
|
|||
// Reflect reduced font space on small-memory footprint devices
|
||||
#[cfg(any(feature = "board-baosec", feature = "hosted-baosec"))]
|
||||
macro_rules! english_rules {
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {
|
||||
match $base_style($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $emoji_style($ch) {
|
||||
Ok(g) => g,
|
||||
// add more character sets to bao1x target by adding match clauses here
|
||||
_ => match zh_glyph($ch) {
|
||||
Ok(g) => g,
|
||||
_ => match $base_style(REPLACEMENT) {
|
||||
Ok(g) => g,
|
||||
_ => NULL_GLYPH_SPRITE,
|
||||
},
|
||||
},
|
||||
},
|
||||
($base_style:expr, $emoji_style:expr, $ch:ident) => {{
|
||||
// Always-present: base, emoji
|
||||
#[allow(unused_mut)]
|
||||
let mut result = $base_style($ch).ok().or_else(|| $emoji_style($ch).ok());
|
||||
|
||||
// Optional: zh fallback only if zh is in the build
|
||||
#[cfg(feature = "zh")]
|
||||
if result.is_none() {
|
||||
result = zh_glyph($ch).ok();
|
||||
}
|
||||
};
|
||||
|
||||
// Always-present: replacement and null sentinel
|
||||
result.or_else(|| $base_style(REPLACEMENT).ok()).unwrap_or(NULL_GLYPH_SPRITE)
|
||||
}};
|
||||
}
|
||||
|
||||
pub use en_audio_rules;
|
||||
pub use english_rules;
|
||||
#[cfg(feature = "ja")]
|
||||
pub use jp_rules;
|
||||
#[cfg(feature = "kr")]
|
||||
pub use kr_rules;
|
||||
pub use style_wrapper;
|
||||
#[cfg(feature = "zh")]
|
||||
pub use zh_rules;
|
||||
|
|
|
|||
|
|
@ -111,6 +111,9 @@ pub enum GfxOpcode {
|
|||
/// This call is specific and highly optimized to the display on Baosec
|
||||
BaosecBitmap,
|
||||
#[cfg(feature = "board-baosec")]
|
||||
/// This call is specific and highly optimized to the display on Baosec
|
||||
BaosecBitmapDiffuse,
|
||||
#[cfg(feature = "board-baosec")]
|
||||
Brightness,
|
||||
#[cfg(feature = "board-baosec")]
|
||||
FlipScreen,
|
||||
|
|
|
|||
|
|
@ -792,6 +792,29 @@ impl Gfx {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(feature = "board-baosec")]
|
||||
pub fn bitmap_diffusion(
|
||||
&self,
|
||||
bitmap: &[u32],
|
||||
top_left: Option<Point>,
|
||||
bounding_box: Option<Rectangle>,
|
||||
) -> Result<(), xous::Error> {
|
||||
let mut bmp = BaosecBitmap {
|
||||
bits: [0u32; 512],
|
||||
top_left: top_left.unwrap_or(Point::new(0, 0)),
|
||||
bounding_box: bounding_box.unwrap_or(Rectangle {
|
||||
tl: Point::new(0, 0),
|
||||
// br is *exclusive*
|
||||
br: Point::new(128, 128),
|
||||
style: DrawStyle { fill_color: None, stroke_color: None, stroke_width: 0 },
|
||||
}),
|
||||
};
|
||||
bmp.bits[..bitmap.len().min(512)].copy_from_slice(&bitmap[..bitmap.len().min(512)]);
|
||||
let mut buf = Buffer::into_buf(bmp).unwrap();
|
||||
buf.lend_mut(self.conn, GfxOpcode::BaosecBitmapDiffuse.to_u32().unwrap())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(feature = "board-baosec")]
|
||||
pub fn brightness(&self, level: u8) -> Result<(), xous::Error> {
|
||||
send_message(
|
||||
|
|
|
|||
|
|
@ -293,10 +293,7 @@ fn layout(modal: &mut Modal, top_text: Option<&str>, bot_text: Option<&str>, sty
|
|||
top_tv.invert = true;
|
||||
// specify a clip rect that's the biggest possible allowed. If we don't do this, the current
|
||||
// canvas bounds are used, and the operation will fail if the text has to get bigger.
|
||||
top_tv.clip_rect = Some(Rectangle::new(
|
||||
Point::new(0, 0),
|
||||
Point::new(current_bounds.x, LINES - 2 * modal.line_height),
|
||||
));
|
||||
top_tv.clip_rect = Some(Rectangle::new(Point::new(0, 0), current_bounds));
|
||||
write!(top_tv.text, "{}", top_str).unwrap();
|
||||
|
||||
log::trace!("posting top tv: {:?}", top_tv);
|
||||
|
|
@ -340,10 +337,7 @@ fn layout(modal: &mut Modal, top_text: Option<&str>, bot_text: Option<&str>, sty
|
|||
bot_tv.invert = true;
|
||||
// specify a clip rect that's the biggest possible allowed. If we don't do this, the current canvas
|
||||
// bounds are used, and the operation will fail if the text has to get bigger.
|
||||
bot_tv.clip_rect = Some(Rectangle::new(
|
||||
Point::new(0, 0),
|
||||
Point::new(current_bounds.x, LINES - 2 * modal.line_height),
|
||||
));
|
||||
bot_tv.clip_rect = Some(Rectangle::new(Point::new(0, 0), current_bounds));
|
||||
write!(bot_tv.text, "{}", bot_str).unwrap();
|
||||
|
||||
log::trace!("posting bot tv: {:?}", bot_tv);
|
||||
|
|
|
|||
|
|
@ -244,15 +244,15 @@ pub struct Typesetter {
|
|||
impl Typesetter {
|
||||
pub fn setup(s: &str, extent: &Point, base_style: &GlyphStyle, insertion_point: Option<usize>) -> Self {
|
||||
let bb = ClipRect::new(0, 0, extent.x, extent.y);
|
||||
let mut space = style_glyph(' ', base_style);
|
||||
let mut space = style_glyph(locales::LANG, ' ', base_style);
|
||||
space.kern = 0;
|
||||
let mut ellipsis = style_glyph('…', base_style);
|
||||
let mut ellipsis = style_glyph(locales::LANG, '…', base_style);
|
||||
ellipsis.kern = 0;
|
||||
|
||||
#[cfg(not(feature = "bao1x"))]
|
||||
let mut large_space = style_glyph(' ', &GlyphStyle::Cjk);
|
||||
let mut large_space = style_glyph(locales::LANG, ' ', &GlyphStyle::Cjk);
|
||||
#[cfg(feature = "bao1x")]
|
||||
let mut large_space = style_glyph(' ', &GlyphStyle::Tall);
|
||||
let mut large_space = style_glyph(locales::LANG, ' ', &GlyphStyle::Tall);
|
||||
|
||||
if cfg!(feature = "bao1x") {
|
||||
large_space.wide = glyph_to_height_hint(GlyphStyle::Tall) as u8;
|
||||
|
|
@ -396,8 +396,11 @@ impl Typesetter {
|
|||
// line for it.
|
||||
// 5. The evolving word fits a line but doesn't fit this line, and there is no more space at
|
||||
// all.
|
||||
let mut gs =
|
||||
if ch != '\t' { style_glyph(ch, &self.base_style) } else { self.large_space.clone() };
|
||||
let mut gs = if ch != '\t' {
|
||||
style_glyph(locales::LANG, ch, &self.base_style)
|
||||
} else {
|
||||
self.large_space.clone()
|
||||
};
|
||||
if self.is_insert_point() {
|
||||
gs.insert = true;
|
||||
}
|
||||
|
|
@ -637,25 +640,3 @@ fn tsw_debug(tsw: &TypesetWord) {
|
|||
}
|
||||
log::info!("{} @ {},{}+{}={}", &s, tsw.origin.x, tsw.origin.y, tsw.height, tsw.origin.y + tsw.height);
|
||||
}
|
||||
|
||||
/// Find glyph for char using latin regular, emoji, ja, zh, and kr font data
|
||||
pub fn style_glyph(ch: char, base_style: &GlyphStyle) -> GlyphSprite {
|
||||
match locales::LANG {
|
||||
"zh" => {
|
||||
style_wrapper!(zh_rules, base_style, ch)
|
||||
}
|
||||
"jp" => {
|
||||
style_wrapper!(jp_rules, base_style, ch)
|
||||
}
|
||||
"kr" => {
|
||||
style_wrapper!(kr_rules, base_style, ch)
|
||||
}
|
||||
"en-tts" => {
|
||||
style_wrapper!(en_audio_rules, base_style, ch)
|
||||
}
|
||||
// default to English rules
|
||||
_ => {
|
||||
style_wrapper!(english_rules, base_style, ch)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,12 +43,12 @@ pub const APP_UART_IFRAM_ADDR: usize = bao1x_hal::board::APP_UART_IFRAM_ADDR;
|
|||
pub const GUARD_MEMORY_BYTES: usize = 3 * crate::PAGE_SIZE;
|
||||
/// Amount of space for loader stack only, with swap
|
||||
#[cfg(all(feature = "swap", not(feature = "resume"), not(feature = "bao1x")))]
|
||||
pub const GUARD_MEMORY_BYTES: usize = 8 * crate::PAGE_SIZE;
|
||||
pub const GUARD_MEMORY_BYTES: usize = 9 * crate::PAGE_SIZE;
|
||||
#[cfg(all(feature = "swap", not(feature = "resume"), feature = "bao1x"))]
|
||||
pub const GUARD_MEMORY_BYTES: usize = 8 * crate::PAGE_SIZE;
|
||||
pub const GUARD_MEMORY_BYTES: usize = 9 * crate::PAGE_SIZE;
|
||||
/// Amount of space for loader stack plus clean suspend, with swap. +1 page cost for the loading bar graphics
|
||||
#[cfg(all(feature = "swap", feature = "resume"))]
|
||||
pub const GUARD_MEMORY_BYTES: usize = 9 * crate::PAGE_SIZE; // 1 extra page for clean suspend
|
||||
pub const GUARD_MEMORY_BYTES: usize = 10 * crate::PAGE_SIZE; // 1 extra page for clean suspend
|
||||
|
||||
#[cfg(feature = "swap")]
|
||||
pub const SWAPPER_PID: u8 = 2;
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ rkyv = { version = "0.8.8", default-features = false, features = [
|
|||
"alloc",
|
||||
] }
|
||||
modals = { path = "../modals", optional = true }
|
||||
susres = { package = "xous-api-susres", path = "../../api/xous-api-susres" }
|
||||
|
||||
# QR decoding
|
||||
libm = { version = "0.2.8" }
|
||||
|
|
@ -35,6 +36,11 @@ base64 = { version = "0.22.1", optional = true }
|
|||
|
||||
locales = { path = "../../locales" }
|
||||
|
||||
# diffusion dithering
|
||||
rand = { version = "0.8.5", features = ["getrandom"] }
|
||||
rand_core = "0.6.4"
|
||||
getrandom = "=0.2.12"
|
||||
|
||||
[features]
|
||||
no-gam = ["modals/no-gam"]
|
||||
gfx-testing = []
|
||||
|
|
|
|||
|
|
@ -26,65 +26,71 @@ fn char_offset(c: char) -> isize {
|
|||
fallback
|
||||
}
|
||||
|
||||
pub fn msg<'a>(fb: &mut dyn FrameBuffer, text: &'a str, ll_pos: Point, fg: ColorNative, bg: ColorNative) {
|
||||
let mut ll_pos = ll_pos.clone();
|
||||
// this routine is adapted from the embedded graphics crate https://docs.rs/embedded-graphics/0.7.1/embedded_graphics/
|
||||
pub fn msg<'a>(
|
||||
fb: &mut dyn FrameBuffer,
|
||||
text: &'a str,
|
||||
ll_pos: Point,
|
||||
fg: ColorNative,
|
||||
bg: ColorNative,
|
||||
upside_down: bool,
|
||||
screen_size: Point, // e.g. Point::new(SCREEN_WIDTH, SCREEN_HEIGHT); ignored when !upside_down
|
||||
) {
|
||||
let mut ll_pos = ll_pos; // no need for .clone() on Copy types
|
||||
let char_per_row = FONT_IMAGE_WIDTH / CHAR_WIDTH;
|
||||
let mut idx = 0;
|
||||
let mut idx: isize = 0;
|
||||
|
||||
for current_char in text.chars() {
|
||||
let mut char_walk_x = 0;
|
||||
let mut char_walk_y = 0;
|
||||
let cur_byte = current_char as u8;
|
||||
let is_cr = cur_byte == 0x0d;
|
||||
let is_lf = cur_byte == 0x0a;
|
||||
let is_visible = !is_cr && !is_lf;
|
||||
|
||||
// -- Per-character constants (hoisted out of the pixel loop) ----------
|
||||
let char_offset = char_offset(current_char);
|
||||
let row = char_offset / char_per_row;
|
||||
let char_x = (char_offset - (row * char_per_row)) * CHAR_WIDTH;
|
||||
let char_y = row * CHAR_HEIGHT;
|
||||
// Base bit index in the font bitmap for the top-left of this glyph
|
||||
let base_bitmap_idx = char_x + FONT_IMAGE_WIDTH * char_y;
|
||||
// Screen X of the left edge of this character
|
||||
let char_screen_x = ll_pos.x + CHAR_WIDTH * idx;
|
||||
|
||||
// -- Pixel walk -------------------------------------------------------
|
||||
let mut char_walk_x: isize = 0;
|
||||
let mut char_walk_y: isize = 0;
|
||||
loop {
|
||||
// Char _code_ offset from first char, most often a space
|
||||
// E.g. first char = ' ' (32), target char = '!' (33), offset = 33 - 32 = 1
|
||||
let char_offset = char_offset(current_char);
|
||||
let row = char_offset / char_per_row;
|
||||
if is_visible {
|
||||
let bitmap_bit_idx = base_bitmap_idx + char_walk_x + char_walk_y * FONT_IMAGE_WIDTH;
|
||||
let bitmap_byte = (bitmap_bit_idx / 8) as usize;
|
||||
let bitmap_bit = bitmap_bit_idx as u8 & 7 ^ 7;
|
||||
let color = if FONT_IMAGE[bitmap_byte] & (1 << bitmap_bit) != 0 { fg } else { bg };
|
||||
|
||||
// Top left corner of character, in pixels
|
||||
let char_x = (char_offset - (row * char_per_row)) * CHAR_WIDTH;
|
||||
let char_y = row * CHAR_HEIGHT;
|
||||
let px = char_screen_x + char_walk_x;
|
||||
let py = ll_pos.y + char_walk_y;
|
||||
|
||||
// Bit index
|
||||
// = X pixel offset for char
|
||||
// + Character row offset (row 0 = 0, row 1 = (192 * 8) = 1536)
|
||||
// + X offset for the pixel block that comprises this char
|
||||
// + Y offset for pixel block
|
||||
let bitmap_bit_index =
|
||||
char_x + (FONT_IMAGE_WIDTH * char_y) + char_walk_x + (char_walk_y * FONT_IMAGE_WIDTH);
|
||||
// For upside-down: mirror the screen position.
|
||||
let draw_point = if upside_down {
|
||||
Point::new(screen_size.x - 1 - px, screen_size.y - 1 - py)
|
||||
} else {
|
||||
Point::new(px, py)
|
||||
};
|
||||
|
||||
let bitmap_byte = bitmap_bit_index / 8;
|
||||
let bitmap_bit = 7 - (bitmap_bit_index % 8);
|
||||
|
||||
let color = if FONT_IMAGE[bitmap_byte as usize] & (1 << bitmap_bit) != 0 { fg } else { bg };
|
||||
|
||||
let x = ll_pos.x + CHAR_WIDTH * idx + char_walk_x;
|
||||
let y = ll_pos.y + char_walk_y;
|
||||
|
||||
// draw color at x, y
|
||||
if (current_char as u8 != 0xd) && (current_char as u8 != 0xa) {
|
||||
// don't draw CRLF specials
|
||||
fb.put_pixel(Point::new(x, y), color);
|
||||
fb.put_pixel(draw_point, color);
|
||||
}
|
||||
|
||||
char_walk_x += 1;
|
||||
|
||||
if char_walk_x >= CHAR_WIDTH {
|
||||
char_walk_x = 0;
|
||||
char_walk_y += 1;
|
||||
|
||||
// Done with this char, move on to the next one
|
||||
if char_walk_y >= CHAR_HEIGHT {
|
||||
if current_char as u8 == 0xd {
|
||||
// '\n'
|
||||
if is_cr {
|
||||
ll_pos.y += CHAR_HEIGHT;
|
||||
} else if current_char as u8 == 0xa {
|
||||
// '\r'
|
||||
} else if is_lf {
|
||||
ll_pos.x = LEFT_MARGIN;
|
||||
idx = 0;
|
||||
} else {
|
||||
idx += 1;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,14 +70,13 @@ use xous_ipc::Buffer;
|
|||
pub const IMAGE_WIDTH: usize = 256;
|
||||
pub const IMAGE_HEIGHT: usize = 240;
|
||||
|
||||
// Next steps for performance improvement:
|
||||
//
|
||||
// Improve qr::mapping -> point_from_hv_lines such that we're not just deriving the HV
|
||||
// lines from the the edges of the finder regions, we're also using the very edge of
|
||||
// the whole QR code itself to guide the line. This will improve the intersection point
|
||||
// so that we can accurately hit the "fourth corner". At the moment it's sort of a
|
||||
// luck of the draw if the interpolation hits exactly right, or if we're roughly a module
|
||||
// off from ideal, which causes the data around that point to be interpreted incorrectly.
|
||||
const MAX_RETRIES: u32 = 5;
|
||||
|
||||
#[derive(PartialEq, Eq, Clone, Copy)]
|
||||
enum DisplayOrientation {
|
||||
Normal,
|
||||
UpsideDown,
|
||||
}
|
||||
|
||||
#[cfg(feature = "b64-export")]
|
||||
#[allow(dead_code)]
|
||||
|
|
@ -227,10 +226,9 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
let hal = Hal::new();
|
||||
|
||||
let mut display = Oled128x128::new(main_thread_token, bao1x_api::PERCLK, &iox, &udma_global);
|
||||
// these unwrap because if we have a time-out at this stage, it's likely a hardware problem
|
||||
display.init().unwrap();
|
||||
retry_display_op(&udma_global, &mut display, |d| d.init()).unwrap();
|
||||
display.clear();
|
||||
display.draw().unwrap();
|
||||
retry_display_op(&udma_global, &mut display, |d| d.draw()).unwrap();
|
||||
|
||||
// ---- panic handler - set up early so we can see panics quickly
|
||||
// install the graphical panic handler. It won't catch really early panics, or panics in this crate,
|
||||
|
|
@ -412,6 +410,7 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
|
||||
// ---- main loop variables
|
||||
let screen_clip = Rectangle::new(Point::new(0, 0), display.screen_size());
|
||||
let screen_size = display.screen_size(); // make a copy so the borrow checker doesn't complain
|
||||
|
||||
// this will kick the hardware into the QR code scanning routine automatically. Eventually
|
||||
// this needs to be turned into a call that can invoke and abort the QR code scanning.
|
||||
|
|
@ -433,6 +432,8 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
let mut bw_thresh: u8 = 128;
|
||||
let mut qr_request: Option<xous::MessageEnvelope> = None;
|
||||
let mut kbd_listeners: Vec<(CID, usize)> = Vec::new();
|
||||
#[allow(unused_mut)]
|
||||
let mut orientation = DisplayOrientation::Normal;
|
||||
loop {
|
||||
if !is_panic.load(Ordering::Relaxed) {
|
||||
xous::reply_and_receive_next(sid, &mut msg_opt).unwrap();
|
||||
|
|
@ -505,31 +506,47 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
log::error!("test image failed to decode, this shouldn't happen!");
|
||||
}
|
||||
|
||||
// now start acquisition
|
||||
cam.capture_async();
|
||||
// turning off preemption makes camera acquisition smoother; the OS will naturally try
|
||||
// to schedule other tasks between camera frames after each
|
||||
// CamIrq interrupt
|
||||
hal.set_preemption(false);
|
||||
// fix orientation if it's upside down
|
||||
if orientation == DisplayOrientation::UpsideDown {
|
||||
display
|
||||
.flip_vertical(false)
|
||||
.unwrap_or_else(|_| display_timeout_handler(&udma_global, &mut display))
|
||||
}
|
||||
// now start acquisition
|
||||
cam.capture_async();
|
||||
}
|
||||
// if qr_request is already pending, ignore any new acquisition requests
|
||||
}
|
||||
GfxOpcode::KeyPress => {
|
||||
if let Some(scalar) = msg.body.scalar_message() {
|
||||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
// any key press will abort QR acquisition by taking the qr_request.
|
||||
if let Some(mut envelope) = qr_request.take() {
|
||||
let acquisition = QrAcquisition { content: None, meta: None };
|
||||
let mut response = unsafe {
|
||||
xous_ipc::Buffer::from_memory_message_mut(
|
||||
envelope.body.memory_message_mut().unwrap(),
|
||||
)
|
||||
};
|
||||
response.replace(acquisition).unwrap();
|
||||
display
|
||||
.pop()
|
||||
.unwrap_or_else(|_| display_timeout_handler(&udma_global, &mut display));
|
||||
hal.set_preemption(true);
|
||||
let k = char::from_u32(scalar.arg1 as u32).unwrap_or('\u{0000}');
|
||||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
// ignore accelerometer reports
|
||||
if !(k == '🔽' || k == '🔼') {
|
||||
// any key press will abort QR acquisition by taking the qr_request.
|
||||
if let Some(mut envelope) = qr_request.take() {
|
||||
let acquisition = QrAcquisition { content: None, meta: None };
|
||||
let mut response = unsafe {
|
||||
xous_ipc::Buffer::from_memory_message_mut(
|
||||
envelope.body.memory_message_mut().unwrap(),
|
||||
)
|
||||
};
|
||||
response.replace(acquisition).unwrap();
|
||||
if orientation == DisplayOrientation::UpsideDown {
|
||||
display.flip_vertical(true).unwrap_or_else(|_| {
|
||||
display_timeout_handler(&udma_global, &mut display)
|
||||
})
|
||||
}
|
||||
display
|
||||
.pop()
|
||||
.unwrap_or_else(|_| display_timeout_handler(&udma_global, &mut display));
|
||||
hal.set_preemption(true);
|
||||
}
|
||||
}
|
||||
// forward messages on to listeners iff we don't have an active modal
|
||||
if modal_queue.len() == 0 {
|
||||
|
|
@ -609,6 +626,8 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
Point::new(0, 0),
|
||||
Mono::White.into(),
|
||||
Mono::Black.into(),
|
||||
orientation == DisplayOrientation::UpsideDown,
|
||||
screen_size,
|
||||
);
|
||||
display
|
||||
.draw()
|
||||
|
|
@ -632,6 +651,8 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
Point::new(0, 0),
|
||||
Mono::White.into(),
|
||||
Mono::Black.into(),
|
||||
orientation == DisplayOrientation::UpsideDown,
|
||||
screen_size,
|
||||
);
|
||||
display.draw().unwrap_or_else(|_| {
|
||||
display_timeout_handler(&udma_global, &mut display)
|
||||
|
|
@ -663,6 +684,11 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
)
|
||||
};
|
||||
response.replace(acquisition).unwrap();
|
||||
if orientation == DisplayOrientation::UpsideDown {
|
||||
display.flip_vertical(true).unwrap_or_else(|_| {
|
||||
display_timeout_handler(&udma_global, &mut display)
|
||||
})
|
||||
}
|
||||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
hal.set_preemption(true);
|
||||
continue;
|
||||
|
|
@ -675,6 +701,8 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
Point::new(0, 0),
|
||||
Mono::White.into(),
|
||||
Mono::Black.into(),
|
||||
orientation == DisplayOrientation::UpsideDown,
|
||||
screen_size,
|
||||
);
|
||||
gfx::msg(
|
||||
&mut display,
|
||||
|
|
@ -682,6 +710,8 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
Point::new(0, 64),
|
||||
Mono::White.into(),
|
||||
Mono::Black.into(),
|
||||
orientation == DisplayOrientation::UpsideDown,
|
||||
screen_size,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -693,6 +723,8 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
Point::new(0, 0),
|
||||
Mono::White.into(),
|
||||
Mono::Black.into(),
|
||||
orientation == DisplayOrientation::UpsideDown,
|
||||
screen_size,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -704,6 +736,8 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
Point::new(0, 0),
|
||||
Mono::White.into(),
|
||||
Mono::Black.into(),
|
||||
orientation == DisplayOrientation::UpsideDown,
|
||||
screen_size,
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -899,6 +933,15 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
display.render_bitmap(bitmap);
|
||||
}
|
||||
#[cfg(feature = "board-baosec")]
|
||||
GfxOpcode::BaosecBitmapDiffuse => {
|
||||
use rand::Rng;
|
||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||
let bitmap = buffer.to_original::<BaosecBitmap, _>().unwrap();
|
||||
display
|
||||
.render_bitmap_diffuse(&bitmap, 10, rand::thread_rng().gen::<u64>())
|
||||
.unwrap_or_else(|_| display_timeout_handler(&udma_global, &mut display));
|
||||
}
|
||||
#[cfg(feature = "board-baosec")]
|
||||
GfxOpcode::Brightness => {
|
||||
if let Some(scalar) = msg.body.scalar_message_mut() {
|
||||
let brightness = scalar.arg1.min(255) as u8;
|
||||
|
|
@ -910,12 +953,25 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
#[cfg(feature = "board-baosec")]
|
||||
GfxOpcode::FlipScreen => {
|
||||
if let Some(scalar) = msg.body.scalar_message_mut() {
|
||||
display
|
||||
.flip_vertical(scalar.arg1 != 0)
|
||||
.unwrap_or_else(|_| display_timeout_handler(&udma_global, &mut display))
|
||||
log::debug!("gfx flip");
|
||||
if scalar.arg1 != 0 {
|
||||
orientation = DisplayOrientation::UpsideDown;
|
||||
} else {
|
||||
orientation = DisplayOrientation::Normal;
|
||||
}
|
||||
if qr_request.is_none() {
|
||||
display
|
||||
.flip_vertical(scalar.arg1 != 0)
|
||||
.unwrap_or_else(|_| display_timeout_handler(&udma_global, &mut display));
|
||||
display
|
||||
.redraw()
|
||||
.unwrap_or_else(|_| display_timeout_handler(&udma_global, &mut display));
|
||||
}
|
||||
}
|
||||
}
|
||||
GfxOpcode::Quit => break,
|
||||
GfxOpcode::Quit => {
|
||||
log::info!("refusing to quit, this operation is not supported on this platform!");
|
||||
}
|
||||
_ => {
|
||||
// This is perfectly normal because not all opcodes are handled by all platforms.
|
||||
log::debug!("Invalid or unhandled opcode: {:?}", opcode);
|
||||
|
|
@ -926,13 +982,9 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
tt.sleep_ms(10_000).unwrap();
|
||||
}
|
||||
}
|
||||
log::trace!("main loop exit, destroying servers");
|
||||
xns.unregister_server(sid).unwrap();
|
||||
xous::destroy_server(sid).unwrap();
|
||||
log::trace!("quitting");
|
||||
xous::terminate_process(0)
|
||||
}
|
||||
|
||||
#[allow(unused_variables)]
|
||||
fn display_timeout_handler(udma_global: &UdmaGlobal, display: &mut Oled128x128) {
|
||||
log::info!("resetting display spim block");
|
||||
#[cfg(feature = "board-baosec")]
|
||||
|
|
@ -941,3 +993,35 @@ fn display_timeout_handler(udma_global: &UdmaGlobal, display: &mut Oled128x128)
|
|||
display.reinit_spi();
|
||||
}
|
||||
}
|
||||
|
||||
/// This is actually "infalliable" in the sense that if we can't initialize the
|
||||
/// display, we diverge and reboot.
|
||||
fn retry_display_op<F, R, E>(udma: &UdmaGlobal, display: &mut Oled128x128, mut op: F) -> Result<R, E>
|
||||
where
|
||||
F: FnMut(&mut Oled128x128) -> Result<R, E>,
|
||||
E: core::fmt::Debug,
|
||||
{
|
||||
let mut attempts = 0;
|
||||
loop {
|
||||
match op(display) {
|
||||
Ok(val) => return Ok(val),
|
||||
Err(e) => {
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
attempts += 1;
|
||||
if attempts >= MAX_RETRIES {
|
||||
log::warn!("Display seems stuck, rebooting whole chip.");
|
||||
let xns = xous_names::XousNames::new().unwrap();
|
||||
let susres = susres::Susres::new_without_hook(&xns).unwrap();
|
||||
susres.reboot(true).ok();
|
||||
}
|
||||
log::warn!(
|
||||
"Display op failed (attempt {}/{}), resetting SPI block... {:?}",
|
||||
attempts,
|
||||
MAX_RETRIES,
|
||||
e
|
||||
);
|
||||
display_timeout_handler(udma, display);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -134,6 +134,11 @@ impl<'a> Oled128x128 {
|
|||
unimplemented!("devboot feature does not exist on this platform");
|
||||
}
|
||||
|
||||
pub fn flip_vertical(&mut self, _flip: bool) -> Result<(), xous::Error> {
|
||||
log::warn!("flipping not implemented");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn stash(&mut self) { self.stash.copy_from_slice(&self.buffer); }
|
||||
|
||||
pub fn pop(&mut self) -> Result<(), xous::Error> {
|
||||
|
|
|
|||
|
|
@ -134,8 +134,4 @@ fn main() {
|
|||
}
|
||||
}
|
||||
}
|
||||
xns.unregister_server(sid).unwrap();
|
||||
xous::destroy_server(sid).unwrap();
|
||||
log::trace!("quitting");
|
||||
xous::terminate_process(0)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,6 +15,9 @@ fn bio_service(clk_freq: u32) {
|
|||
|
||||
let mut resource_tracker = ResourceTracker::new();
|
||||
|
||||
#[cfg(feature = "oem-baosec-lite")]
|
||||
let led_conn = xns.request_connection_blocking("_oem_led_").unwrap();
|
||||
|
||||
let mut bio_ss = bio_hw::BioSharedState::new(clk_freq);
|
||||
let mut msg_opt = None;
|
||||
loop {
|
||||
|
|
@ -125,6 +128,14 @@ fn bio_service(clk_freq: u32) {
|
|||
}
|
||||
}
|
||||
|
||||
BioOp::PrepFreqChange => {
|
||||
if let Some(_scalar) = msg_opt.as_mut().unwrap().body.scalar_message_mut() {
|
||||
// pause rendering while the clock transitions, avoiding 'bright glitches'
|
||||
#[cfg(feature = "oem-baosec-lite")]
|
||||
xous::send_message(led_conn, xous::Message::new_blocking_scalar(128, 0, 0, 0, 0)).ok();
|
||||
}
|
||||
}
|
||||
|
||||
BioOp::GetBioFreq => {
|
||||
if let Some(scalar) = msg_opt.as_mut().unwrap().body.scalar_message_mut() {
|
||||
scalar.arg1 = bio_ss.get_bio_freq() as usize;
|
||||
|
|
|
|||
|
|
@ -489,7 +489,7 @@ fn keyboard_service() {
|
|||
),
|
||||
)
|
||||
.unwrap_or_else(|_| {
|
||||
log::info!("Input overflow, dropping keys!");
|
||||
log::info!("Input overflow to {}, dropping keys!", conn);
|
||||
xous::Result::Ok
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -210,6 +210,7 @@ fn susres_service() {
|
|||
// - The update_bio_freq routine is being "too clever" and compensating for the fd
|
||||
// setting. But it seems like the routine just takes the putative fclk setting as
|
||||
// the argument to update_bio_freq(), I don't see any compensation happening...
|
||||
bio.prep_freq_change();
|
||||
if fclk_fd_backup == 0xff {
|
||||
bio.update_bio_freq(48_000_000);
|
||||
} else {
|
||||
|
|
@ -222,6 +223,7 @@ fn susres_service() {
|
|||
|
||||
// clk_mgr.set_fclk_fd(fclk_fd_backup); // restore the FD before restoring potentially
|
||||
// fast PLL setting
|
||||
bio.prep_freq_change();
|
||||
clk_mgr.restore_wfi();
|
||||
bio.update_bio_freq(clk_mgr.fclk);
|
||||
|
||||
|
|
@ -377,7 +379,14 @@ fn susres_service() {
|
|||
}),
|
||||
Some(Opcode::Quit) => break,
|
||||
Some(Opcode::PlatformSpecific) => {
|
||||
msg_blocking_scalar_unpack!(msg, op, _arg2, _arg3, _arg4, {
|
||||
if let xous::Message::BlockingScalar(xous::ScalarMessage {
|
||||
id: _id,
|
||||
arg1: op,
|
||||
arg2: _arg2,
|
||||
arg3: _arg3,
|
||||
arg4: _arg4,
|
||||
}) = msg.body
|
||||
{
|
||||
let platform_op = FromPrimitive::from_usize(op);
|
||||
match platform_op {
|
||||
Some(ClockOp::GetVco) => {
|
||||
|
|
@ -401,15 +410,26 @@ fn susres_service() {
|
|||
Some(ClockOp::GetPer) => {
|
||||
xous::return_scalar(msg.sender, clk_mgr.perclk as usize).unwrap()
|
||||
}
|
||||
_ => panic!("Incorrect PlatformOp"),
|
||||
}
|
||||
}
|
||||
if let xous::Message::Scalar(xous::ScalarMessage {
|
||||
id: _id,
|
||||
arg1: op,
|
||||
arg2: _arg2,
|
||||
arg3: _arg3,
|
||||
arg4: _arg4,
|
||||
}) = msg.body
|
||||
{
|
||||
let platform_op = FromPrimitive::from_usize(op);
|
||||
match platform_op {
|
||||
Some(ClockOp::DeepSleep) => {
|
||||
log::info!("entering deep sleep");
|
||||
clk_mgr.deep_sleep();
|
||||
xous::return_scalar(msg.sender, 1).ok();
|
||||
// system is shut down after this point, no code runs
|
||||
}
|
||||
_ => panic!("Incorrect PlatformOp"),
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
None => {
|
||||
log::error!("couldn't convert opcode");
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ fn wrapped_main() -> ! {
|
|||
Some("Placeholder"),
|
||||
None,
|
||||
DEFAULT_STYLE,
|
||||
8,
|
||||
4,
|
||||
);
|
||||
#[cfg(any(feature = "hosted-baosec", feature = "bao1x"))]
|
||||
let mut renderer_modal = Modal::new(
|
||||
|
|
@ -148,7 +148,7 @@ fn wrapped_main() -> ! {
|
|||
Some("Placeholder"),
|
||||
None,
|
||||
DEFAULT_STYLE,
|
||||
8,
|
||||
4,
|
||||
);
|
||||
#[cfg(any(feature = "hosted-baosec", feature = "bao1x"))]
|
||||
{
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
pub(crate) const SERVER_NAME_USB_DEVICE: &'static str = "_Xous USB device driver_";
|
||||
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub(crate) enum Opcode {
|
||||
pub enum Opcode {
|
||||
/// Returns the link status
|
||||
LinkStatus = 0,
|
||||
/// Send a keyboard code
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ pub struct Bao1xUsb<'a> {
|
|||
>,
|
||||
>,
|
||||
// storage for hid_packets to expatriate from the interrupt handler
|
||||
pub hid_packet: Option<[u8; 64]>,
|
||||
pub hid_packet: VecDeque<[u8; 64]>,
|
||||
pub serial_port: SerialPort<'a, CorigineWrapper, [u8; 1024], [u8; 1024]>,
|
||||
// holds one HS packet - must be statically allocated in IRQ handler. Valid length is
|
||||
// passed as part of the interrupt recovery message.
|
||||
|
|
@ -117,7 +117,7 @@ impl<'a> Bao1xUsb<'a> {
|
|||
fido_tx_queue: RefCell::new(VecDeque::new()),
|
||||
kbd_tx_queue: RefCell::new(VecDeque::new()),
|
||||
irq_req: None,
|
||||
hid_packet: None,
|
||||
hid_packet: VecDeque::with_capacity(4),
|
||||
serial_port,
|
||||
serial_rx: [0u8; SERIAL_MAX_PACKET_SIZE],
|
||||
double_lock: AtomicBool::new(false),
|
||||
|
|
@ -162,7 +162,7 @@ impl<'a> Bao1xUsb<'a> {
|
|||
|
||||
/// Process an unplug event - only valid on baosec, because dabao doesn't have a battery and unplugging
|
||||
/// it would power it down.
|
||||
#[cfg(all(feature = "board-baosec", not(feature = "oem-baosec-lite")))]
|
||||
#[cfg(all(feature = "board-baosec"))]
|
||||
pub fn unplug(&mut self) {
|
||||
// disable all interrupts so we can safely go through initialization routines
|
||||
self.irq_csr.wo(utra::irqarray1::EV_ENABLE, 0);
|
||||
|
|
@ -299,7 +299,7 @@ pub(crate) fn composite_handler(_irq_no: usize, arg: *mut usize) {
|
|||
match class.device::<RawFido<'_, _>, _>().read_report() {
|
||||
Ok(u2f_report) => {
|
||||
// crate::println!("got report {:x?}", u2f_report);
|
||||
usb.hid_packet = Some(u2f_report.packet);
|
||||
usb.hid_packet.push_back(u2f_report.packet);
|
||||
xous::try_send_message(
|
||||
usb.conn,
|
||||
Message::new_scalar(Opcode::IrqFidoRx.to_usize().unwrap(), 0, 0, 0, 0),
|
||||
|
|
|
|||
|
|
@ -364,6 +364,8 @@ impl UsbHid {
|
|||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
pub fn cid(&self) -> xous::CID { self.conn }
|
||||
}
|
||||
|
||||
use core::sync::atomic::{AtomicU32, Ordering};
|
||||
|
|
|
|||
|
|
@ -309,6 +309,16 @@ pub(crate) fn main_hw() -> ! {
|
|||
// log::warn!("Received an interrupt but no actual event reported");
|
||||
}
|
||||
},
|
||||
#[cfg(all(feature = "board-baosec", feature = "oem-baosec-lite"))]
|
||||
Opcode::PmicIrq => {
|
||||
use bao1x_hal::axp2101::VbusIrq;
|
||||
if let Some(scalar) = msg.body.scalar_message_mut() {
|
||||
let vbus_irq = VbusIrq::from(scalar.arg1);
|
||||
if vbus_irq == VbusIrq::Remove {
|
||||
cu.unplug();
|
||||
}
|
||||
}
|
||||
}
|
||||
Opcode::U2fRxDeferred => {
|
||||
// notify the event listener, if any
|
||||
if observer_conn.is_some() && observer_op.is_some() {
|
||||
|
|
@ -404,7 +414,7 @@ pub(crate) fn main_hw() -> ! {
|
|||
}
|
||||
}
|
||||
Opcode::IrqFidoRx => {
|
||||
if let Some(raw_report) = cu.hid_packet.take() {
|
||||
if let Some(raw_report) = cu.hid_packet.pop_front() {
|
||||
let u2f_report = HIDReport(raw_report);
|
||||
if let Some(mut listener) = fido_listener.take() {
|
||||
let mut response = unsafe {
|
||||
|
|
@ -432,6 +442,11 @@ pub(crate) fn main_hw() -> ! {
|
|||
let mut buffer =
|
||||
unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||
let mut u2f_ipc = buffer.to_original::<U2fMsgIpc, _>().unwrap();
|
||||
if cu.device.state() != usb_device::device::UsbDeviceState::Configured {
|
||||
u2f_ipc.code = U2fCode::Hangup;
|
||||
buffer.replace(u2f_ipc).unwrap();
|
||||
continue;
|
||||
}
|
||||
if fido_listener_pid == msg.sender.pid() {
|
||||
let mut u2f_msg = RawFidoReport::default();
|
||||
assert_eq!(u2f_ipc.code, U2fCode::Tx, "Expected U2fCode::Tx in wrapper");
|
||||
|
|
@ -450,6 +465,10 @@ pub(crate) fn main_hw() -> ! {
|
|||
}
|
||||
Opcode::SendKeyCode => {
|
||||
if let Some(scalar) = msg.body.scalar_message_mut() {
|
||||
if cu.device.state() != usb_device::device::UsbDeviceState::Configured {
|
||||
continue;
|
||||
}
|
||||
|
||||
let code0 = scalar.arg1;
|
||||
let code1 = scalar.arg2;
|
||||
let code2 = scalar.arg3;
|
||||
|
|
@ -493,6 +512,12 @@ pub(crate) fn main_hw() -> ! {
|
|||
unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||
let mut usb_send = buffer.to_original::<api::UsbString, _>().unwrap();
|
||||
let mut sent = 0;
|
||||
if cu.device.state() != usb_device::device::UsbDeviceState::Configured {
|
||||
log::warn!("Aborting send, no USB configured");
|
||||
usb_send.sent = Some(0);
|
||||
buffer.replace(usb_send).unwrap();
|
||||
continue;
|
||||
}
|
||||
|
||||
// check keymap on every call because we may need to toggle this for e.g. plugging
|
||||
// into a new host with a different map
|
||||
|
|
@ -696,6 +721,9 @@ pub(crate) fn main_hw() -> ! {
|
|||
serial_listener.take();
|
||||
}
|
||||
Opcode::SerialFlush => msg_scalar_unpack!(msg, _, _, _, _, {
|
||||
if cu.device.state() != usb_device::device::UsbDeviceState::Configured {
|
||||
continue;
|
||||
}
|
||||
// this will hardware flush any pending items in usb_serial driver
|
||||
cu.serial_port.flush().ok();
|
||||
// this tries to return any data that's pending within the main loop's buffers
|
||||
|
|
@ -738,6 +766,9 @@ pub(crate) fn main_hw() -> ! {
|
|||
}
|
||||
}),
|
||||
Opcode::SerialSendData => {
|
||||
if cu.device.state() != usb_device::device::UsbDeviceState::Configured {
|
||||
continue;
|
||||
}
|
||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||
let data = buffer.to_original::<UsbSerialBinary, _>().unwrap();
|
||||
let mut total_sent = 0;
|
||||
|
|
@ -791,7 +822,7 @@ pub(crate) fn main_hw() -> ! {
|
|||
break;
|
||||
}
|
||||
_ => {
|
||||
unimplemented!(
|
||||
log::warn!(
|
||||
"Opcode {:?} not implemented for this version of the USB stack: {:?}",
|
||||
opcode,
|
||||
msg
|
||||
|
|
|
|||
Loading…
Reference in a new issue