feature: removed refCell, use an arrat of Cell<CmdEntry>

Author: domnudragota

chips/x86_q35/src/cmd_fifo.rs

@@ -11,73 +11,87 @@
 // By requiring `T: FifoItem` with a `const EMPTY`, we can do `[T::EMPTY; N]`
 // and safely build the FIFO at compile time
 
+use core::cell::Cell;
+
 pub(crate) trait FifoItem: Copy {
     /// Const zero/empty value used to initialize the backing array.
     const EMPTY: Self;
 }
 
-pub(crate) struct Fifo<T: FifoItem, const N: usize> {
-    buf: [T; N],
-    head: usize,
-    tail: usize,
-    len: usize,
+pub struct Fifo<T: Copy + FifoItem, const N: usize> {
+    buf: [Cell<T>; N],
+    head: Cell<usize>,
+    tail: Cell<usize>,
+    len: Cell<usize>,
 }
 
-impl<T: FifoItem, const N: usize> Fifo<T, N> {
+impl<T: Copy + FifoItem, const N: usize> Fifo<T, N> {
     pub(crate) const fn new() -> Self {
         Self {
-            buf: [T::EMPTY; N],
-            head: 0,
-            tail: 0,
-            len: 0,
+            buf: [const { Cell::new(T::EMPTY) }; N],
+            head: Cell::new(0),
+            tail: Cell::new(0),
+            len: Cell::new(0),
         }
     }
 
     #[inline]
     pub(crate) fn is_empty(&self) -> bool {
-        self.len == 0
+        self.len.get() == 0
     }
+
     #[inline]
     pub(crate) fn is_full(&self) -> bool {
-        self.len == N
+        self.len.get() == N
     }
+
+    /// Push at head; returns Err(item) if full
     #[inline]
-    pub(crate) fn push(&mut self, item: T) -> Result<(), ()> {
+    pub(crate) fn push(&self, item: T) -> Result<(), T> {
         if self.is_full() {
-            return Err(());
+            return Err(item);
         }
-        self.buf[self.head] = item;
-        self.head = (self.head + 1) % N;
-        self.len += 1;
+        let h = self.head.get();
+        self.buf[h].set(item);
+        self.head.set((h + 1) % N);
+        self.len.set(self.len.get() + 1);
         Ok(())
     }
 
+    /// Copy the current head entry (None if empty).
     #[inline]
-    pub(crate) fn peek(&self) -> Option<&T> {
+    pub(crate) fn peek_copy(&self) -> Option<T> {
         if self.is_empty() {
             None
         } else {
-            Some(&self.buf[self.tail])
+            Some(self.buf[self.tail.get()].get())
         }
     }
 
+    /// Read-modify-write the current head entry; returns closure result.
     #[inline]
-    pub(crate) fn peek_mut(&mut self) -> Option<&mut T> {
+    pub(crate) fn peek_update<R>(&self, f: impl FnOnce(&mut T) -> R) -> Option<R> {
         if self.is_empty() {
             None
         } else {
-            Some(&mut self.buf[self.tail])
+            let t = self.tail.get();
+            let mut v = self.buf[t].get();
+            let r = f(&mut v);
+            self.buf[t].set(v);
+            Some(r)
         }
     }
 
+    /// Pop from tail; returns a copy of the removed item.
     #[inline]
-    pub(crate) fn pop(&mut self) -> Option<T> {
+    pub(crate) fn pop(&self) -> Option<T> {
         if self.is_empty() {
             return None;
         }
-        let item = self.buf[self.tail];
-        self.tail = (self.tail + 1) % N;
-        self.len -= 1;
+        let t = self.tail.get();
+        let item = self.buf[t].get();
+        self.tail.set((t + 1) % N);
+        self.len.set(self.len.get() - 1);
         Some(item)
     }
 }

chips/x86_q35/src/keyboard.rs

@@ -16,7 +16,7 @@
 use crate::cmd_fifo::Fifo as CmdFifo;
 use crate::ps2::Ps2Client;
 use crate::ps2::Ps2Controller;
-use core::cell::{Cell, RefCell};
+use core::cell::Cell;
 use kernel::utilities::cells::OptionalCell;
 
 /// Set-2 scancode constants used for decoding
@@ -131,8 +131,8 @@ pub struct Keyboard<'a> {
     shift_r: Cell<bool>,
     caps: Cell<bool>,
 
-    // command engine queue (ring FIFO)
-    cmd_q: RefCell<CmdFifo<CmdEntry, CMDQ_LEN>>,
+    // command engine queue (ring FIFO) - interior mutable via Cells inside
+    cmd_q: CmdFifo<CmdEntry, CMDQ_LEN>,
 
     in_flight: Cell<bool>,      // waiting for ACK/RESEND to the last sent byte
     retries_left: Cell<u8>,     // remaining entries for the current byte
@@ -158,7 +158,7 @@ impl<'a> Keyboard<'a> {
             shift_r: Cell::new(false),
             caps: Cell::new(false),
 
-            cmd_q: RefCell::new(CmdFifo::new()),
+            cmd_q: CmdFifo::new(),
 
             in_flight: Cell::new(false),
             retries_left: Cell::new(0),
@@ -305,12 +305,10 @@ impl<'a> Keyboard<'a> {
         let Some(entry) = CmdEntry::try_from_bytes(seq) else {
             return false;
         };
-        let mut q = self.cmd_q.borrow_mut();
-        if q.is_full() {
+        if self.cmd_q.is_full() {
             return false;
         }
-        let _ = q.push(entry);
-        drop(q);
+        let _ = self.cmd_q.push(entry);
         self.drive_tx();
         true
     }
@@ -322,20 +320,17 @@ impl<'a> Keyboard<'a> {
         }
 
         // Peek current command
-        let (byte_opt, done_opt) = {
-            let q = self.cmd_q.borrow();
-            match q.peek() {
-                None => (None, None), // empty
-                Some(e) if e.is_done() => (None, Some(true)),
-                Some(e) => (Some(e.bytes[e.idx as usize]), Some(false)),
-            }
+        let (byte_opt, done_opt) = match self.cmd_q.peek_copy() {
+            None => (None, None),
+            Some(e) if e.is_done() => (None, Some(true)),
+            Some(e) => (Some(e.bytes[e.idx as usize]), Some(false)),
         };
 
         match done_opt {
             None => return, // queue empty
             Some(true) => {
                 // finished entry => pop and try next
-                self.cmd_q.borrow_mut().pop();
+                self.cmd_q.pop();
                 self.drive_tx();
                 return;
             }
@@ -361,20 +356,17 @@ impl<'a> Keyboard<'a> {
     }
 
     fn advance_idx_after_ack(&self) {
-        let mut finished = false;
-        {
-            let mut q = self.cmd_q.borrow_mut();
-            if let Some(e) = q.peek_mut() {
+        let finished = self
+            .cmd_q
+            .peek_update(|e| {
                 if !e.is_done() {
                     e.idx = e.idx.saturating_add(1);
                 }
-                if e.is_done() {
-                    finished = true;
-                }
-            }
-            if finished {
-                q.pop();
-            }
+                e.is_done()
+            })
+            .unwrap_or(false);
+        if finished {
+            self.cmd_q.pop();
         }
         // New byte will get a fresh retry budget on first send
         self.retries_left.set(0);
@@ -468,7 +460,7 @@ impl Ps2Client for Keyboard<'_> {
                         // Give up on this command
                         self.cmd_drops.set(self.cmd_drops.get().wrapping_add(1));
                         self.in_flight.set(false);
-                        self.cmd_q.borrow_mut().pop();
+                        self.cmd_q.pop();
                         self.retries_left.set(0); // clear for the next new byte
                         self.drive_tx();
                     }