jolt: Update to latest zephyr-lang-rust

Feedback on zephyr-lang-rust has resulted in numerous API changes.  The
good news is that I only have a small number of commits on top of
zephyr-lang-rust to support this keyboard firmware, and all currently
live in: zephyrproject-rtos/zephyr-lang-rust#22

Author: d3zd3z

jolt/src/inter.rs

@@ -4,7 +4,7 @@ use core::mem::replace;
 
 use bbq_keyboard::{Side, serialize::{Decoder, Packet, EventVec, PacketBuffer}, InterState, Event, KeyEvent};
 
-use zephyr::driver::uart::Uart;
+use zephyr::device::uart::Uart;
 use zephyr::sync::channel::Sender;
 use log::{warn, info};
 
@@ -111,7 +111,7 @@ impl InterHandler {
         // TODO: Buffer this better.
         while let Some(ch) = self.xmit_buffer.pop_front() {
             let buf = [ch];
-            match self.uart.fifo_fill(&buf) {
+            match unsafe { self.uart.fifo_fill(&buf) } {
                 Ok(1) => (),
                 Ok(_) => (), // TODO: warn?
                 Err(_) => (),
@@ -141,7 +141,7 @@ impl InterHandler {
     /// TODO: Buffer this better.
     fn uart_read(&mut self) -> zephyr::Result<Option<u8>> {
         let mut buf = [0u8];
-        match self.uart.fifo_read(&mut buf) {
+        match unsafe { self.uart.fifo_read(&mut buf) } {
             Ok(1) => Ok(Some(buf[0])),
             Ok(0) => Ok(None),
             Ok(_) => unreachable!(),

jolt/src/leds.rs

@@ -5,8 +5,7 @@
 
 use crate::devices::leds::LedRgb;
 use zephyr::kobj_define;
-use zephyr::object::KobjInit;
-use zephyr::driver::led_strip::LedStrip;
+use zephyr::device::led_strip::LedStrip;
 use zephyr::sync::{Arc, Condvar, Mutex};
 
 const OFF: LedRgb = LedRgb::new(0, 0, 0);
@@ -247,10 +246,8 @@ struct LedState {
 impl LedManager {
     pub fn new(leds: LedStrip) -> Self {
 
-        LED_MUTEX_STATIC.init();
-        LED_CONDVAR_STATIC.init();
-        let sys_mutex = LED_MUTEX_STATIC.get();
-        let sys_condvar = LED_CONDVAR_STATIC.get();
+        let sys_mutex = LED_MUTEX_STATIC.init_once(()).unwrap();
+        let sys_condvar = LED_CONDVAR_STATIC.init_once(()).unwrap();
 
         let condvar = Condvar::new_from(sys_condvar);
         let info = LedInfo {
@@ -259,11 +256,11 @@ impl LedManager {
         let info = Arc::new((Mutex::new_from(info, sys_mutex), condvar));
 
         let info2 = info.clone();
-        let thread = LED_THREAD.spawn(LED_STACK.token(), -1, move || {
+        let mut thread = LED_THREAD.init_once(LED_STACK.init_once(()).unwrap()).unwrap();
+        thread.set_priority(-1);
+        thread.spawn(move || {
             led_thread(leds, info2);
         });
-        // TODO: set priority.
-        thread.start();
 
         LedManager {
             states: [
@@ -439,7 +436,7 @@ fn led_thread(mut driver: LedStrip, info: Arc<InfoPair>) -> ! {
     loop {
         let info = get_info(&*info);
         let leds = info.each_ref().map(|l| l.0);
-        driver.update(&leds[0..limit]).unwrap();
+        unsafe { driver.update(&leds[0..limit]).unwrap(); }
 
         // Also update the LEDs.  For now, just check for 1, but count really should be a multiple
         // of 3.

jolt/src/lib.rs

@@ -18,8 +18,7 @@ use log::info;
 
 use matrix::Matrix;
 use zephyr::{kobj_define, printkln};
-use zephyr::driver::uart::LineControl;
-use zephyr::object::KobjInit;
+use zephyr::device::uart::LineControl;
 use zephyr::sync::channel::{
     self,
     Sender,
@@ -63,22 +62,21 @@ extern "C" fn rust_main() {
     zephyr::set_logger();
 
     // Initialize the main event queue.
-    EVENT_QUEUE_STATIC.init();
-    let equeue = EVENT_QUEUE_STATIC.get();
+    let equeue = EVENT_QUEUE_STATIC.init_once(()).unwrap();
     let (equeue_send, equeue_recv) = channel::unbounded_from::<Event>(equeue);
 
     // This is the steno queue.
-    STENO_QUEUE_STATIC.init();
-    let stenoq = STENO_QUEUE_STATIC.get();
+    let stenoq = STENO_QUEUE_STATIC.init_once(()).unwrap();
     let (stenoq_send, stenoq_recv) = channel::unbounded_from::<Stroke>(stenoq);
 
     // Spawn the steno thread.
     // TODO: This needs to be lower priority.
     let sc = equeue_send.clone();
-    let thread = STENO_THREAD.spawn(STENO_STACK.token(), 5, move || {
+    let mut thread = STENO_THREAD.init_once(STENO_STACK.init_once(()).unwrap()).unwrap();
+    thread.set_priority(5);
+    thread.spawn(move || {
         steno_thread(stenoq_recv, sc);
     });
-    thread.start();
 
     unsafe {
         // Store a sender for the USB callback.
@@ -110,20 +108,20 @@ extern "C" fn rust_main() {
     let cols = zephyr::devicetree::aliases::matrix::get_cols();
 
     // Build a Vec for these.
-    let rows: Vec<_> = rows.into_iter().collect();
-    let cols: Vec<_> = cols.into_iter().collect();
+    let rows: Vec<_> = rows.into_iter().map(|p| p.unwrap()).collect();
+    let cols: Vec<_> = cols.into_iter().map(|p| p.unwrap()).collect();
 
     let matrix = Matrix::new(rows, cols, side);
     let mut scanner = Scanner::new(matrix, equeue_send.clone(), &info);
 
     let mut layout = LayoutManager::new();
 
-    let leds = zephyr::devicetree::aliases::led_strip::get_instance();
+    let leds = zephyr::devicetree::aliases::led_strip::get_instance().unwrap();
     let mut leds = LedManager::new(leds);
 
     let mut inter = get_inter(side, equeue_send.clone());
 
-    let mut acm = zephyr::devicetree::labels::acm_uart_0::get_instance();
+    let mut acm = zephyr::devicetree::labels::acm_uart_0::get_instance().unwrap();
     let mut acm_active;
 
     let mut eq_send = SendWrap(equeue_send.clone());
@@ -140,7 +138,7 @@ extern "C" fn rust_main() {
 
     loop {
         // Update the state of the Gemini indicator.
-        if let Ok(1) =  acm.line_ctrl_get(LineControl::DTR) {
+        if let Ok(1) =  unsafe { acm.line_ctrl_get(LineControl::DTR) } {
             leds.set_base(2, &leds::GEMINI_INDICATOR);
             acm_active = true;
         } else {
@@ -154,6 +152,7 @@ extern "C" fn rust_main() {
         match ev {
             Event::Tick => is_tick = true,
             Event::Matrix(key) => {
+                // info!("Matrix: {:?}", key);
                 match state {
                     InterState::Primary | InterState::Idle => {
                         layout.handle_event(key, &mut eq_send);
@@ -189,7 +188,7 @@ extern "C" fn rust_main() {
                         // TODO: Do the tx enable tx disable stuff.
                         let packet = stroke.to_gemini();
                         // Deal with errors and such.
-                        match acm.fifo_fill(&packet) {
+                        match unsafe { acm.fifo_fill(&packet) } {
                             Ok(_) => (),
                             Err(_) => (),
                         }
@@ -304,7 +303,7 @@ extern "C" fn rust_main() {
 /// Conditionally return the inter-board code.
 #[cfg(CONFIG_JOLT_INTER)]
 fn get_inter(side: Side, equeue_send: Sender<Event>) -> Option<InterHandler> {
-    let uart = zephyr::devicetree::chosen::inter_board_uart::get_instance();
+    let uart = zephyr::devicetree::chosen::inter_board_uart::get_instance().unwrap();
     Some(InterHandler::new(side, uart, equeue_send))
 }
 
@@ -458,7 +457,9 @@ extern "C" fn rust_heartbeat() {
     });
     // Send it, if there was one there to send.
     if let Some(boxed) = boxed {
-        send.send_boxed(boxed).unwrap();
+        unsafe {
+            send.send_boxed(boxed).unwrap();
+        }
     }
 }
 

jolt/src/matrix.rs

@@ -7,7 +7,7 @@ extern crate alloc;
 use alloc::vec::Vec;
 
 use zephyr::sys::busy_wait;
-use zephyr::sys::gpio::GpioPin;
+use zephyr::device::gpio::{GpioPin, GpioToken};
 use zephyr::raw::{
     GPIO_OUTPUT_INACTIVE,
     GPIO_INPUT,
@@ -17,6 +17,7 @@ use zephyr::raw::{
 use bbq_keyboard::Side;
 
 pub struct Matrix {
+    token: GpioToken,
     rows: Vec<GpioPin>,
     cols: Vec<GpioPin>,
     state: Vec<Debouncer>,
@@ -26,8 +27,9 @@ pub struct Matrix {
 impl Matrix {
     pub fn new(rows: Vec<GpioPin>, cols: Vec<GpioPin>, side: Side) -> Matrix {
         let state = (0 .. rows.len() * cols.len()).map(|_| Debouncer::new()).collect();
-        let mut result = Matrix { rows, cols, state, side };
-        Self::pin_setup(&mut result.cols, &mut result.rows);
+        let token = unsafe { GpioToken::get_instance().unwrap() };
+        let mut result = Matrix { token, rows, cols, state, side };
+        Self::pin_setup(&mut result.token, &mut result.cols, &mut result.rows);
         result
     }
 
@@ -38,11 +40,11 @@ impl Matrix {
         let bias = if self.side.is_left() { 0 } else { self.state.len() };
         let mut states = self.state.iter_mut().enumerate();
         for col in &mut self.cols {
-            col.set(true);
-            busy_wait(5);
-            for row in &self.rows {
+            unsafe { col.set(&mut self.token, true); }
+            unsafe { busy_wait(5); }
+            for row in &mut self.rows {
                 let (code, state) = states.next().unwrap();
-                match state.react(row.get()) {
+                match state.react(unsafe { row.get(&mut self.token) }) {
                     KeyAction::Press => {
                         act((code + bias) as u8, true);
                     }
@@ -52,21 +54,25 @@ impl Matrix {
                     _ => (),
                 }
             }
-            col.set(false);
+            unsafe { col.set(&mut self.token, false); }
             // busy_wait(5);
         }
     }
 
     /// Setup the gpios to drive from 'push' and read from 'pull'.
-    fn pin_setup(push: &mut [GpioPin], pull: &mut [GpioPin]) {
+    fn pin_setup(token: &mut GpioToken, push: &mut [GpioPin], pull: &mut [GpioPin]) {
         // The 'push' values are the outputs.
         for col in push {
-            col.configure(GPIO_OUTPUT_INACTIVE);
+            unsafe {
+                col.configure(token, GPIO_OUTPUT_INACTIVE);
+            }
         }
 
         // And 'pull' are the inputs.
         for row in pull {
-            row.configure(GPIO_INPUT | GPIO_PULL_DOWN);
+            unsafe {
+                row.configure(token, GPIO_INPUT | GPIO_PULL_DOWN);
+            }
         }
     }
 }