mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
commit
53dccf0df2
7 changed files with 150 additions and 28 deletions
|
|
@ -461,8 +461,8 @@ pub fn kpc_sr0_to_key(raw_event: u32) -> [KeyPress; 4] {
|
|||
0 => KeyPress::Down,
|
||||
1 => KeyPress::Select,
|
||||
2 => KeyPress::Up,
|
||||
4 => KeyPress::Right,
|
||||
5 => KeyPress::Left,
|
||||
4 => KeyPress::Left,
|
||||
5 => KeyPress::Right,
|
||||
6 => KeyPress::Center,
|
||||
#[cfg(feature = "accel-kbd")]
|
||||
9 => KeyPress::Accel,
|
||||
|
|
@ -489,8 +489,8 @@ pub fn kpc_sr1_to_key(raw_event: u32) -> KeyPress {
|
|||
0x10 => KeyPress::Down,
|
||||
0x11 => KeyPress::Select,
|
||||
0x12 => KeyPress::Up,
|
||||
0x14 => KeyPress::Right,
|
||||
0x15 => KeyPress::Left,
|
||||
0x14 => KeyPress::Left,
|
||||
0x15 => KeyPress::Right,
|
||||
0x16 => KeyPress::Center,
|
||||
#[cfg(feature = "accel-kbd")]
|
||||
0x19 => KeyPress::Accel,
|
||||
|
|
|
|||
|
|
@ -2,6 +2,8 @@ use bao1x_api::find_pll_params;
|
|||
#[cfg(all(feature = "std", feature = "board-baosec"))]
|
||||
use bao1x_api::{IoxHal, IoxPort};
|
||||
use bitbybit::bitfield;
|
||||
#[cfg(not(feature = "std"))]
|
||||
use num_traits::float::FloatCore;
|
||||
use utralib::*;
|
||||
|
||||
#[cfg(all(feature = "board-baosec", not(feature = "oem-baosec-lite")))]
|
||||
|
|
@ -270,6 +272,31 @@ pub fn divide_by_fd(fd: u32, in_freq_hz: u32) -> u32 {
|
|||
out_freq_khz * 1_000
|
||||
}
|
||||
|
||||
/// Returns the floating point number to multiply the VCO frequency by to get the
|
||||
/// resulting frequency. i.e. if the FCO is at 700 MHz, the net frequency is
|
||||
/// equal to `(700_000_000f32 * fd_to_ratio()) as u32`
|
||||
pub fn fd_to_ratio(fd: u32) -> f32 { (fd as f32 + 1.0) / (FD_MAX as f32) }
|
||||
|
||||
/// when `round_freq_up` is `true`, the resulting divider will result in a frequency that is
|
||||
/// rounded up from the target ratio, if it can't be perfectly achieved.
|
||||
///
|
||||
/// Otherwise, the result will round to the next lowest frequency that can be achieved.
|
||||
///
|
||||
/// Note that any divide ratio > 1.0 will result in a divide ration of 1.0: this is a
|
||||
/// *divide* ratio, not a multiplier. It can only strictly result in frequency that are lower
|
||||
/// than the input.
|
||||
///
|
||||
/// This will never return a result that causes the clock to stop. So any divisors smaller
|
||||
/// than 1/128 will result in a divisor of 1/128.
|
||||
pub fn divide_ratio_to_fd(ratio: f32, round_freq_up: bool) -> u8 {
|
||||
let target_div = ((FD_MAX as f32 * ratio) - 1.0).max(1.0);
|
||||
if round_freq_up {
|
||||
(target_div.floor() as u32).min(255) as u8
|
||||
} else {
|
||||
(target_div.ceil() as u32).min(255) as u8
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
pub struct ClockManagerImpl {
|
||||
pub vco_freq: u32,
|
||||
|
|
@ -414,6 +441,56 @@ impl ClockManagerImpl {
|
|||
self.perclk = divide_by_fd(perclk_fd, pll0_freq) / 2;
|
||||
}
|
||||
|
||||
pub fn fclk_fd(&self) -> u8 { (self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0) & 0xFF) as u8 }
|
||||
|
||||
pub fn aclk_fd(&self) -> u8 { (self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1) & 0xFF) as u8 }
|
||||
|
||||
pub fn hclk_fd(&self) -> u8 { (self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2) & 0xFF) as u8 }
|
||||
|
||||
pub fn iclk_fd(&self) -> u8 { (self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3) & 0xFF) as u8 }
|
||||
|
||||
pub fn pclk_fd(&self) -> u8 { (self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4) & 0xFF) as u8 }
|
||||
|
||||
pub fn set_fclk_fd(&mut self, fd: u8) {
|
||||
self.sysctrl.wo(
|
||||
utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0,
|
||||
self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0) & !0xFF | fd as u32,
|
||||
);
|
||||
self.sysctrl.wo(utra::sysctrl::SFR_CGUSET, 0x32);
|
||||
}
|
||||
|
||||
pub fn set_aclk_fd(&mut self, fd: u8) {
|
||||
self.sysctrl.wo(
|
||||
utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1,
|
||||
self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1) & !0xFF | fd as u32,
|
||||
);
|
||||
self.sysctrl.wo(utra::sysctrl::SFR_CGUSET, 0x32);
|
||||
}
|
||||
|
||||
pub fn set_hclk_fd(&mut self, fd: u8) {
|
||||
self.sysctrl.wo(
|
||||
utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2,
|
||||
self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2) & !0xFF | fd as u32,
|
||||
);
|
||||
self.sysctrl.wo(utra::sysctrl::SFR_CGUSET, 0x32);
|
||||
}
|
||||
|
||||
pub fn set_iclk_fd(&mut self, fd: u8) {
|
||||
self.sysctrl.wo(
|
||||
utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3,
|
||||
self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3) & !0xFF | fd as u32,
|
||||
);
|
||||
self.sysctrl.wo(utra::sysctrl::SFR_CGUSET, 0x32);
|
||||
}
|
||||
|
||||
pub fn set_pclk_fd(&mut self, fd: u8) {
|
||||
self.sysctrl.wo(
|
||||
utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4,
|
||||
self.sysctrl.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4) & !0xFF | fd as u32,
|
||||
);
|
||||
self.sysctrl.wo(utra::sysctrl::SFR_CGUSET, 0x32);
|
||||
}
|
||||
|
||||
/// Safety: this pulls out the hardware base for the susres block. The receiver of this
|
||||
/// address must manually manage all concurrency issues that could happen with respect to
|
||||
/// using the susres block.
|
||||
|
|
|
|||
|
|
@ -239,7 +239,10 @@ impl Gc2145 {
|
|||
}
|
||||
|
||||
/// TODO: figure out how to length-bound this to...the frame slice size? line size? idk...
|
||||
pub fn rx_buf<T: UdmaWidths>(&self) -> &[T] { &self.ifram.as_ref().unwrap().as_slice() }
|
||||
/// The offset on the slice is a "cheater" parameter which is empirically calibrated based on
|
||||
/// observed data. I don't know the underlying cause of it, but I suspect it probably has to
|
||||
/// do with data in the pipeline that's not flushed, so the first three elements are "stale"
|
||||
pub fn rx_buf<T: UdmaWidths>(&self) -> &[T] { &self.ifram.as_ref().unwrap().as_slice()[3..] }
|
||||
|
||||
/// TODO: figure out how to length-bound this to...the frame slice size? line size? idk...
|
||||
pub unsafe fn rx_buf_phys<T: UdmaWidths>(&self) -> &[T] { &self.ifram.as_ref().unwrap().as_phys_slice() }
|
||||
|
|
|
|||
|
|
@ -424,28 +424,23 @@ pub fn render_qr<T: FrameBuffer>(
|
|||
let total_width = qr_render.width as isize + QUIET_MODULES * 2;
|
||||
let module_width = (window_width / total_width).max(1) as isize;
|
||||
let left_edge = if module_width * total_width < window_width {
|
||||
(window_width - (module_width * total_width)) as isize / 2
|
||||
(window_width - module_width * total_width) as isize / 2
|
||||
} else {
|
||||
0
|
||||
};
|
||||
|
||||
const USE_TOP_LEFT: bool = false;
|
||||
let tl = if USE_TOP_LEFT { qr_render.top_left } else { Point::new(0, 0) };
|
||||
let tl = qr_render.top_left;
|
||||
|
||||
// draw a white background over the rendering area
|
||||
let r = Rectangle::new_with_style(
|
||||
Point::from((left_edge, tl.y)),
|
||||
screen_clip.unwrap_or(screensize).br,
|
||||
DrawStyle::new(PixelColor::Light, PixelColor::Light, 1),
|
||||
);
|
||||
let mut r = screensize.clone();
|
||||
r.style = DrawStyle::new(PixelColor::Light, PixelColor::Light, 1);
|
||||
op::rectangle(display, r, screen_clip.into(), false);
|
||||
|
||||
// now raster in the modules
|
||||
// TODO: on dense codes, the dark colors are over-sized by a pixel. Figure this out.
|
||||
// TODO: on smaller than optimal codes, align the QR code into the center of the screen.
|
||||
let mut line_top_left =
|
||||
Point::new(left_edge + module_width * QUIET_MODULES, tl.y + module_width * QUIET_MODULES);
|
||||
let dark = DrawStyle::new(PixelColor::Dark, PixelColor::Dark, 0);
|
||||
Point::new(left_edge + tl.x + module_width * QUIET_MODULES, tl.y + module_width * QUIET_MODULES);
|
||||
let dark = DrawStyle { fill_color: Some(PixelColor::Dark), stroke_color: None, stroke_width: 0 };
|
||||
// log::info!("left edge: {} module width: {}", left_edge, module_width);
|
||||
for line in qr_render.modules.chunks(qr_render.width) {
|
||||
for (i, &module) in line.iter().enumerate() {
|
||||
if module {
|
||||
|
|
|
|||
|
|
@ -444,7 +444,10 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
GfxOpcode::AcquireQr => {
|
||||
if qr_request.is_none() {
|
||||
display.stash(); // save a copy of the UI
|
||||
// reset camera UDMA block
|
||||
udma_global.reset(PeriphId::Cam);
|
||||
|
||||
// display.stash(); // save a copy of the UI
|
||||
// this will defer response until later
|
||||
qr_request = msg_opt.take();
|
||||
|
||||
|
|
@ -589,6 +592,7 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
None,
|
||||
None,
|
||||
);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -624,10 +628,18 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
Mono::White.into(),
|
||||
Mono::Black.into(),
|
||||
);
|
||||
display.draw().unwrap_or_else(|_| {
|
||||
display_timeout_handler(&udma_global, &mut display)
|
||||
});
|
||||
// this take will cause the QR response to be routed to the sender since
|
||||
// the Message `Drop`s. It will also cause the sampling of the camera to
|
||||
// stop on the next frame.
|
||||
if let Some(mut envelope) = qr_request.take() {
|
||||
/*
|
||||
display.pop().unwrap_or_else(|_| {
|
||||
display_timeout_handler(&udma_global, &mut display)
|
||||
})
|
||||
*/
|
||||
let metadata = format!("{:?}", meta);
|
||||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
if content.starts_with("test://") {
|
||||
|
|
@ -646,11 +658,9 @@ pub fn wrapped_main(main_thread_token: MainThreadToken) -> ! {
|
|||
)
|
||||
};
|
||||
response.replace(acquisition).unwrap();
|
||||
display.pop().unwrap_or_else(|_| {
|
||||
display_timeout_handler(&udma_global, &mut display)
|
||||
});
|
||||
#[cfg(not(feature = "hosted-baosec"))]
|
||||
hal.set_preemption(true);
|
||||
continue;
|
||||
} else {
|
||||
log::info!("meta: {:?}", meta);
|
||||
log::info!("************ {} ***********", content);
|
||||
|
|
|
|||
|
|
@ -52,6 +52,7 @@ pub fn handler(_irq_no: usize, arg: *mut usize) {
|
|||
}
|
||||
|
||||
#[cfg(feature = "board-baosec")]
|
||||
#[derive(Debug)]
|
||||
struct KeypressTimestamp {
|
||||
pub kp: KeyPress,
|
||||
pub next_repeat_time: u64,
|
||||
|
|
@ -64,7 +65,7 @@ struct KeyTracker {
|
|||
}
|
||||
#[cfg(feature = "board-baosec")]
|
||||
impl KeyTracker {
|
||||
pub fn new() -> Self { KeyTracker { rate_ms: KEYUP_DELAY_MS as usize, delay_ms: 500, keys: Vec::new() } }
|
||||
pub fn new() -> Self { KeyTracker { rate_ms: KEYUP_DELAY_MS as usize, delay_ms: 1000, keys: Vec::new() } }
|
||||
|
||||
pub fn register_key_down(&mut self, key: KeyPress, ts: u64) {
|
||||
if let Some(entry) = self.keys.iter_mut().find(|e| e.kp == key) {
|
||||
|
|
@ -90,8 +91,10 @@ impl KeyTracker {
|
|||
for key in keys {
|
||||
// search for key not in keys vector; create a new entry with next repeat equal
|
||||
// to now, so it gets emitted immediately
|
||||
if !self.keys.iter().any(|e| e.kp == *key) {
|
||||
self.keys.push(KeypressTimestamp { kp: *key, next_repeat_time: now });
|
||||
if *key != KeyPress::Invalid && *key != KeyPress::None {
|
||||
if !self.keys.iter().any(|e| e.kp == *key) {
|
||||
self.keys.push(KeypressTimestamp { kp: *key, next_repeat_time: now });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -460,6 +463,7 @@ fn keyboard_service() {
|
|||
let mut kc: Vec<char> = Vec::new();
|
||||
let now = tt.elapsed_ms();
|
||||
if now - last_key_event > KEYUP_DELAY_MS {
|
||||
log::debug!("clearing key tracker");
|
||||
key_tracker.clear_keys();
|
||||
}
|
||||
last_key_event = now;
|
||||
|
|
@ -468,9 +472,9 @@ fn keyboard_service() {
|
|||
if kpc_aoint.kpc.r(utra::dkpc::SFR_SR1) != 0 {
|
||||
let sr1 = unsafe { kpc_aoint.kpc.base().add(8).read_volatile() };
|
||||
let key_down = bao1x_hal::board::kpc_sr1_to_key(sr1);
|
||||
log::info!("{:?}", key_down);
|
||||
key_tracker.register_key_down(key_down, now);
|
||||
if key_down != KeyPress::Invalid {
|
||||
log::debug!("{:?}", key_down);
|
||||
if key_down != KeyPress::Invalid && key_down != KeyPress::None {
|
||||
key_tracker.register_key_down(key_down, now);
|
||||
kc.push(map_keypress(key_down))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -180,15 +180,48 @@ fn susres_service() {
|
|||
|
||||
use bao1x_api::bio::BioApi;
|
||||
let mut bio = bao1x_hal::bio::Bio::new();
|
||||
|
||||
// hard-coded to the value of the external crystal - this is a hardware
|
||||
// reference value that should never change; eg, USB doesn't work if this
|
||||
// isn't 48 MHz.
|
||||
bio.update_bio_freq(48_000_000);
|
||||
let fclk_fd_backup = clk_mgr.fclk_fd();
|
||||
|
||||
// TODO: this is a hack to get past some issue with clock rate changes
|
||||
//
|
||||
// In theory:
|
||||
// - the set_clk_fd(0xff) call should reset the fclk divider to 1:1
|
||||
// - this would mean the bio_freq is getting 48MHz
|
||||
// In practice:
|
||||
// - the fd seems "stuck" at /2 for fd settings from 0xff-0x3f
|
||||
// - so the pulse width outputs on BIO is the same for 0xff, 0x7f, 0x3f
|
||||
// - if I reduce reduce fd setting to 0x1f, then, I can see the clock rate is 1/8th
|
||||
// What has been tried:
|
||||
// - Forcing the clocks to a fixed 0xFF setting regardless of input - I can see that
|
||||
// BIO clocks, after wfi, are incorrect in this case. Which means that set_fclk_fd
|
||||
// is "getting through"
|
||||
// - Adding wait states, etc. around the CGUSET call does not seem to change the
|
||||
// situation
|
||||
//
|
||||
// The compromise for now is to detect the "fast_bio" setting at init by heuristically
|
||||
// looking at the fd_backup field, and then specifying an offset frequency to the
|
||||
// update_bio_freq that results in the correct waveform.
|
||||
//
|
||||
// Possible cause:
|
||||
// - 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...
|
||||
if fclk_fd_backup == 0xff {
|
||||
bio.update_bio_freq(48_000_000);
|
||||
} else {
|
||||
bio.update_bio_freq(24_000_000);
|
||||
}
|
||||
clk_mgr.set_fclk_fd(0xff); // set divider to 1:1 ratio
|
||||
clk_mgr.wfi();
|
||||
|
||||
// ~~~ time passes, but we're on carbonite so we don't notice ~~~
|
||||
|
||||
clk_mgr.restore_wfi();
|
||||
clk_mgr.set_fclk_fd(fclk_fd_backup); // restore the FD before restoring potentially fast PLL setting
|
||||
bio.update_bio_freq(clk_mgr.fclk);
|
||||
|
||||
// when wfi() returns, it means we've resumed
|
||||
|
|
|
|||
Loading…
Reference in a new issue