zephyr: device: Add uart

Add a simplistic uart wrapper, and drivers around it.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

dt-rust.yaml

@@ -77,6 +77,26 @@
           - type: reg
       device: "crate::device::flash::FlashPartition"
 
+# Uart devices.  This just has to be a list of devices that implement this interface.
+- name: uart
+  rules:
+  - type: compatible
+    value:
+      names:
+      - "arm,pl011"
+      # The nordic driver needs to be separate because they have a separate Kconfig for each uart
+      # block.
+      # - "nordic,nrf-uarte"
+      - "zephyr,cdc-acm-uart"
+      level: 0
+  actions:
+  - type: instance
+    value:
+      raw:
+        type: myself
+      device: "crate::device::uart::Uart"
+      kconfig: CONFIG_SERIAL
+
 # Generate a pseudo node that matches all of the labels across the tree with their nodes.
 - name: labels
   rules:

zephyr-build/src/devicetree/augment.rs

@@ -28,6 +28,12 @@ pub trait Augment {
     /// The default implementation checks if this node matches and calls a generator if it does, or
     /// does nothing if not.
     fn augment(&self, node: &Node, tree: &DeviceTree) -> TokenStream {
+        // If there is a status field present, and it is not set to "okay", don't augment this node.
+        if let Some(status) = node.get_single_string("status") {
+            if status != "okay" {
+                return TokenStream::new();
+            }
+        }
         if self.is_compatible(node) {
             self.generate(node, tree)
         } else {
@@ -135,6 +141,9 @@ pub enum Action {
         /// The name of the full path (within the zephyr-sys crate) for the wrapper node for this
         /// device.
         device: String,
+        /// A Kconfig option to allow the instances to only be present when said driver is compiled
+        /// in.
+        kconfig: Option<String>,
     },
     /// Generate all of the labels as its own node.
     Labels,
@@ -143,8 +152,8 @@ pub enum Action {
 impl Action {
     fn generate(&self, _name: &Ident, node: &Node, tree: &DeviceTree) -> TokenStream {
         match self {
-            Action::Instance { raw, device } => {
-                raw.generate(node, device)
+            Action::Instance { raw, device, kconfig } => {
+                raw.generate(node, device, kconfig.as_deref())
             }
             Action::Labels => {
                 let nodes = tree.labels.iter().map(|(k, v)| {
@@ -188,19 +197,31 @@ pub enum RawInfo {
 }
 
 impl RawInfo {
-    fn generate(&self, node: &Node, device: &str) -> TokenStream {
+    fn generate(&self, node: &Node, device: &str, kconfig: Option<&str>) -> TokenStream {
         let device_id = str_to_path(device);
+        let kconfig = if let Some(name) = kconfig {
+            let name = format_ident!("{}", name);
+            quote! {
+                #[cfg(#name)]
+            }
+        } else {
+            quote! {}
+        };
+
         match self {
             RawInfo::Myself => {
                 let ord = node.ord;
                 let rawdev = format_ident!("__device_dts_ord_{}", ord);
                 quote! {
                     /// Get the raw `const struct device *` of the device tree generated node.
+                    #kconfig
                     pub unsafe fn get_instance_raw() -> *const crate::raw::device {
                         &crate::raw::#rawdev
                     }
 
+                    #kconfig
                     static UNIQUE: crate::device::Unique = crate::device::Unique::new();
+                    #kconfig
                     pub fn get_instance() -> Option<#device_id> {
                         unsafe {
                             let device = get_instance_raw();
@@ -226,7 +247,9 @@ impl RawInfo {
                 let target_route = target.route_to_rust();
 
                 quote! {
+                    #kconfig
                     static UNIQUE: crate::device::Unique = crate::device::Unique::new();
+                    #kconfig
                     pub fn get_instance() -> Option<#device_id> {
                         unsafe {
                             let device = #target_route :: get_instance_raw();
@@ -245,7 +268,9 @@ impl RawInfo {
                 }
 
                 quote! {
+                    #kconfig
                     static UNIQUE: crate::device::Unique = crate::device::Unique::new();
+                    #kconfig
                     pub fn get_instance() -> Option<#device_id> {
                         unsafe {
                             let device = #path :: get_instance_raw();

zephyr-sys/build.rs

@@ -71,15 +71,19 @@ fn main() -> Result<()> {
         .allowlist_function("k_.*")
         .allowlist_function("gpio_.*")
         .allowlist_function("flash_.*")
+        .allowlist_function("usb_.*")
         .allowlist_item("GPIO_.*")
+        .allowlist_item("USB_.*")
         .allowlist_item("FLASH_.*")
         .allowlist_item("Z_.*")
         .allowlist_item("ZR_.*")
         .allowlist_item("K_.*")
+        .allowlist_item("uart_line_ctrl")
         // Each DT node has a device entry that is a static.
         .allowlist_item("__device_dts_ord.*")
         .allowlist_function("device_.*")
         .allowlist_function("sys_.*")
+        .allowlist_function("uart_.*")
         .allowlist_item("E.*")
         .allowlist_item("K_.*")
         .allowlist_item("ZR_.*")

zephyr-sys/wrapper.h

@@ -40,6 +40,7 @@ extern int errno;
 #include <zephyr/kernel/thread_stack.h>
 #include <zephyr/drivers/gpio.h>
 #include <zephyr/drivers/flash.h>
+#include <zephyr/drivers/uart.h>
 
 /*
  * bindgen will only output #defined constants that resolve to simple numbers.  These are some

zephyr/src/device.rs

@@ -9,6 +9,7 @@ use crate::sync::atomic::{AtomicUsize, Ordering};
 
 pub mod gpio;
 pub mod flash;
+pub mod uart;
 
 // Allow dead code, because it isn't required for a given build to have any devices.
 /// Device uniqueness.

zephyr/src/device/uart.rs

@@ -0,0 +1,94 @@
+//! Simple (and unsafe) wrappers around USB devices.
+
+use crate::raw;
+use crate::error::{Error, Result, to_result_void, to_result};
+
+use core::ffi::{c_uchar, c_int};
+
+use super::Unique;
+
+/// A wrapper around a UART device on Zephyr.
+pub struct Uart {
+    /// The underlying device itself.
+    #[allow(dead_code)]
+    pub(crate) device: *const raw::device,
+}
+
+/// Uart control values.
+///
+/// This mirrors these definitions from C, but as an enum.
+#[repr(u32)]
+pub enum LineControl {
+    /// Baud rate
+    BaudRate = raw::uart_line_ctrl_UART_LINE_CTRL_BAUD_RATE,
+    /// Request To Send (RTS)
+    RTS = raw::uart_line_ctrl_UART_LINE_CTRL_RTS,
+    /// Data Terminal Ready (DTR)
+    DTR = raw::uart_line_ctrl_UART_LINE_CTRL_DTR,
+    /// Data Carrier Detect (DCD)
+    DCD = raw::uart_line_ctrl_UART_LINE_CTRL_DCD,
+    /// Data Set Ready (DSR)
+    DSR = raw::uart_line_ctrl_UART_LINE_CTRL_DSR,
+}
+
+impl Uart {
+    // Note that the `poll_in` and `poll_out` are terrible.
+
+    /// Constructor, used by the devicetree generated code.
+    #[allow(dead_code)]
+    pub(crate) unsafe fn new(unique: &Unique, device: *const raw::device) -> Option<Uart> {
+        if !unique.once() {
+            return None;
+        }
+
+        Some(Uart { device })
+    }
+
+    /// Attempt to read a character from the UART fifo.
+    ///
+    /// Will return Ok(Some(ch)) if there is a character available, `Ok(None)` if no character
+    /// is available, or `Err(e)` if there was an error.
+    pub unsafe fn poll_in(&mut self) -> Result<Option<u8>> {
+        let mut ch: c_uchar = 0;
+
+        match to_result_void(unsafe { raw::uart_poll_in(self.device, &mut ch) }) {
+            Ok(()) => Ok(Some(ch as u8)),
+            Err(Error(1)) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+
+    /// Attempt to write to the outgoing FIFO.
+    ///
+    /// This writes to the outgoing UART fifo.  This will block if the outgoing fifo is full.
+    pub unsafe fn poll_out(&mut self, out_char: u8) {
+        unsafe { raw::uart_poll_out(self.device, out_char as c_uchar) }
+    }
+
+    /// Fill FIFO with data.
+    ///
+    /// This is unspecified what happens if this is not called from IRQ context.
+    /// Returns Ok(n) for the number of bytes sent.
+    pub unsafe fn fifo_fill(&mut self, data: &[u8]) -> Result<usize> {
+        to_result(unsafe {
+            raw::uart_fifo_fill(self.device, data.as_ptr(), data.len() as c_int)
+        }).map(|count| count as usize)
+    }
+
+    /// Drain FIFO.
+    ///
+    /// This is unspecified as to what happens if not called from IRQ context.
+    pub unsafe fn fifo_read(&mut self, data: &mut [u8]) -> Result<usize> {
+        to_result(unsafe {
+            raw::uart_fifo_read(self.device, data.as_mut_ptr(), data.len() as c_int)
+        }).map(|count| count as usize)
+    }
+
+    /// Read one of the UART line control values.
+    pub unsafe fn line_ctrl_get(&self, item: LineControl) -> Result<u32> {
+        let mut result: u32 = 0;
+        to_result_void(unsafe {
+            raw::uart_line_ctrl_get(self.device, item as u32, &mut result)
+        }).map(|()| result)
+    }
+}