Merge ch9

os/src/drivers/chardev/ns16550a.rs

@@ -131,7 +131,7 @@ pub struct NS16550a<const BASE_ADDR: usize> {
 
 impl<const BASE_ADDR: usize> NS16550a<BASE_ADDR> {
     pub fn new() -> Self {
-        let mut inner = NS16550aInner {
+        let inner = NS16550aInner {
             ns16550a: NS16550aRaw::new(BASE_ADDR),
             read_buffer: VecDeque::new(),
         };
@@ -141,14 +141,20 @@ impl<const BASE_ADDR: usize> NS16550a<BASE_ADDR> {
             condvar: Condvar::new(),
         }
     }
+
+    pub fn read_buffer_is_empty(&self) -> bool {
+        self.inner
+            .exclusive_session(|inner| inner.read_buffer.is_empty())
+    }
 }
 
 impl<const BASE_ADDR: usize> CharDevice for NS16550a<BASE_ADDR> {
-    fn init(&self){
+    fn init(&self) {
         let mut inner = self.inner.exclusive_access();
         inner.ns16550a.init();
         drop(inner);
-    }    
+    }
+
     fn read(&self) -> u8 {
         loop {
             let mut inner = self.inner.exclusive_access();

os/src/drivers/input/mod.rs

@@ -1,20 +1,28 @@
 use crate::drivers::bus::virtio::VirtioHal;
-use crate::{
-    gui::{move_rect, reset},
-    sync::UPIntrFreeCell,
-};
+use crate::sync::{Condvar, UPIntrFreeCell};
+use crate::task::schedule;
+use alloc::collections::VecDeque;
 use alloc::sync::Arc;
 use core::any::Any;
 use virtio_drivers::{VirtIOHeader, VirtIOInput};
-use virtio_input_decoder::{Decoder, Key, KeyType};
 
 const VIRTIO5: usize = 0x10005000;
 const VIRTIO6: usize = 0x10006000;
 
-struct VirtIOInputWrapper(UPIntrFreeCell<VirtIOInput<'static, VirtioHal>>);
+struct VirtIOInputInner {
+    virtio_input: VirtIOInput<'static, VirtioHal>,
+    events: VecDeque<u64>,
+}
+
+struct VirtIOInputWrapper {
+    inner: UPIntrFreeCell<VirtIOInputInner>,
+    condvar: Condvar,
+}
 
 pub trait InputDevice: Send + Sync + Any {
+    fn read_event(&self) -> u64;
     fn handle_irq(&self);
+    fn is_empty(&self) -> bool;
 }
 
 lazy_static::lazy_static!(
@@ -24,52 +32,52 @@ lazy_static::lazy_static!(
 
 impl VirtIOInputWrapper {
     pub fn new(addr: usize) -> Self {
-        Self(unsafe {
-            UPIntrFreeCell::new(
-                VirtIOInput::<VirtioHal>::new(&mut *(addr as *mut VirtIOHeader)).unwrap(),
-            )
-        })
+        let inner = VirtIOInputInner {
+            virtio_input: unsafe {
+                VirtIOInput::<VirtioHal>::new(&mut *(addr as *mut VirtIOHeader)).unwrap()
+            },
+            events: VecDeque::new(),
+        };
+        Self {
+            inner: unsafe { UPIntrFreeCell::new(inner) },
+            condvar: Condvar::new(),
+        }
     }
 }
 
 impl InputDevice for VirtIOInputWrapper {
-    fn handle_irq(&self) {
-        let mut input = self.0.exclusive_access();
-        input.ack_interrupt();
-        while let Some(event) = input.pop_pending_event() {
-            let dtype = match Decoder::decode(
-                event.event_type as usize,
-                event.code as usize,
-                event.value as usize,
-            ) {
-                Ok(dtype) => dtype,
-                Err(_) => break,
-            };
-            match dtype {
-                virtio_input_decoder::DecodeType::Key(key, r#type) => {
-                    if r#type == KeyType::Press {
-                        match key {
-                            Key::C | Key::MouseLeft => {
-                                reset();
-                            }
-                            Key::W => {
-                                move_rect(0, -10);
-                            }
-                            Key::S => {
-                                move_rect(0, 10);
-                            }
-                            Key::A => {
-                                move_rect(-10, 0);
-                            }
-                            Key::D => {
-                                move_rect(10, 0);
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-                _ => {}
+    fn is_empty(&self) -> bool {
+        self.inner.exclusive_access().events.is_empty()
+    }
+
+    fn read_event(&self) -> u64 {
+        loop {
+            let mut inner = self.inner.exclusive_access();
+            if let Some(event) = inner.events.pop_front() {
+                return event;
+            } else {
+                let task_cx_ptr = self.condvar.wait_no_sched();
+                drop(inner);
+                schedule(task_cx_ptr);
             }
         }
     }
+
+    fn handle_irq(&self) {
+        let mut count = 0;
+        let mut result = 0;
+        self.inner.exclusive_session(|inner| {
+            inner.virtio_input.ack_interrupt();
+            while let Some(event) = inner.virtio_input.pop_pending_event() {
+                count += 1;
+                result = (event.event_type as u64) << 48
+                    | (event.code as u64) << 32
+                    | (event.value) as u64;
+                inner.events.push_back(result);
+            }
+        });
+        if count > 0 {
+            self.condvar.signal();
+        };
+    }
 }