Implement serial Read/Write traits

Author: Nathan Jones

rust/zephyr-sys/wrapper.h

@@ -7,6 +7,7 @@
 #include <misc/mempool.h>
 #include <device.h>
 #include <uart.h>
+#include <drivers/console/uart_pipe.h>
 
 // Create a constant we can use from Rust in all cases
 #ifdef CONFIG_USERSPACE

rust/zephyr/src/uart.rs

@@ -1,6 +1,10 @@
 use super::NegErr;
 use crate::device::Device;
 
+use std::cmp;
+use std::io;
+use std::io::{Read, Write, Error, ErrorKind};
+
 pub trait UartSyscalls {
     fn uart_poll_out(device: &Device, out_char: char);
 
@@ -13,6 +17,91 @@ pub trait UartSyscalls {
     fn uart_configure(device: &Device, config: &UartConfig) -> Result<(), u32>;
 }
 
+type UartCallback = unsafe extern "C" fn(*mut u8, *mut usize) -> *mut u8;
+
+fn uart_pipe_register(buf: &mut [u8], cb: UartCallback) {
+    unsafe {
+        zephyr_sys::raw::uart_pipe_register(buf.as_mut_ptr(), buf.len(), Some(cb))
+    };
+}
+
+pub struct UartDevice;
+
+const SERIAL_BUF_SIZE: usize = 4096;
+static mut SERIAL_BUF: [u8; SERIAL_BUF_SIZE] = [0; SERIAL_BUF_SIZE];
+static mut SERIAL_WRITE_INDEX: usize = 0;
+static mut SERIAL_READ_INDEX: usize = 0;
+
+/// Returns the amount of space that can be written into the serial buffer including wrapping.
+unsafe fn serial_buf_space() -> usize {
+    (SERIAL_READ_INDEX - SERIAL_WRITE_INDEX - 1) & (SERIAL_BUF_SIZE - 1)
+}
+
+/// Returns the amount of data available for reading in the serial buffer without wrapping.
+unsafe fn serial_buf_count_to_end() -> usize {
+    let end = SERIAL_BUF_SIZE - SERIAL_READ_INDEX;
+    let n = (SERIAL_WRITE_INDEX + end) & (SERIAL_BUF_SIZE - 1);
+    if n < end { n } else { end }
+}
+
+#[no_mangle]
+unsafe extern "C" fn rust_uart_cb(buf: *mut u8, off: *mut usize) -> *mut u8 {
+    let array = std::slice::from_raw_parts(buf, *off);
+    let space = serial_buf_space();
+    let idx = SERIAL_WRITE_INDEX;
+    if space < *off {
+        // XXX: do we need to handle this?
+        panic!("serial overflow")
+    }
+    if idx + *off < SERIAL_BUF_SIZE {
+        // easy case, copy in one chunk
+        SERIAL_BUF[idx..idx+*off].copy_from_slice(&array);
+    } else {
+        // wrap, copy in two chunks
+        let len = SERIAL_BUF_SIZE - idx;
+        SERIAL_BUF[idx..SERIAL_BUF_SIZE].copy_from_slice(&array[..len]);
+        SERIAL_BUF[0..*off-len].copy_from_slice(&array[len..]);
+    }
+    SERIAL_WRITE_INDEX = (SERIAL_WRITE_INDEX + *off) & (SERIAL_BUF_SIZE - 1);
+    *off = 0;
+    return buf;
+}
+
+impl Read for UartDevice {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        unsafe {
+            let avail = serial_buf_count_to_end();
+            let idx = SERIAL_READ_INDEX;
+            let amt = cmp::min(buf.len(), avail);
+            if amt == 0 {
+                return Err(Error::new(ErrorKind::WouldBlock, "would block"));
+            }
+            buf[..amt].copy_from_slice(&SERIAL_BUF[idx..idx+amt]);
+            SERIAL_READ_INDEX = (SERIAL_READ_INDEX + amt) & (SERIAL_BUF_SIZE - 1);
+            return Ok(amt);
+        }
+    }
+}
+
+impl Write for UartDevice {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        unsafe {
+            zephyr_sys::raw::uart_pipe_send(
+                buf.as_ptr(),
+                buf.len() as i32
+            )
+        };
+
+        // uart_pipe_send returns an int but it is always 0.
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+
 macro_rules! trait_impl {
     ($context:ident, $context_struct:path) => {
         impl UartSyscalls for $context_struct {

samples/rust-app-serial/CMakeLists.txt

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.13.1)
+get_filename_component(ZEPHYR_RUST ${CMAKE_CURRENT_SOURCE_DIR}/../.. ABSOLUTE)
+list(APPEND ZEPHYR_MODULES ${ZEPHYR_RUST})
+include($ENV{ZEPHYR_BASE}/cmake/app/boilerplate.cmake NO_POLICY_SCOPE)
+project(hello_world)
+target_sources(app PRIVATE ./src/main.c)

samples/rust-app-serial/Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "app"
+version = "0.1.0"
+authors = ["Tyler Hall <tylerwhall@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+cstr = "0.1.7"

samples/rust-app-serial/Cargo.toml

@@ -0,0 +1,26 @@
+Build
+=====
+
+.. code-block:: console
+
+    mkdir -p build-x86 && cd build-x86
+    cmake -GNinja -DBOARD=qemu_x86 ..
+    ninja
+
+Run
+===
+
+.. code-block:: console
+    sh ../run.sh
+
+A `run.sh` script has been provided which adds the following line to the qemu
+command:
+
+.. code-block:: console
+    -serial tcp:localhost:4444,server,nowait
+
+You can then connect to localhost:4444 using nc to simulate the other end of
+the serial connection.
+
+Of course, you can change the -serial argument to any other option that qemu
+supports.

samples/rust-app-serial/README.rst

@@ -0,0 +1,9 @@
+CONFIG_MAIN_STACK_SIZE=2048
+CONFIG_NATIVE_UART_0_ON_OWN_PTY=y
+CONFIG_RUST_ALLOC_POOL=y
+CONFIG_RUST=y
+CONFIG_SERIAL=y
+CONFIG_UART_NATIVE_POSIX=y
+CONFIG_UART_PIPE_ON_DEV_NAME="UART_1"
+CONFIG_UART_PIPE=y
+CONFIG_USERSPACE=y

samples/rust-app-serial/prj.conf

@@ -0,0 +1,5 @@
+$ZEPHYR_SDK_INSTALL_DIR/sysroots/x86_64-pokysdk-linux/usr/bin/qemu-system-i386 \
+-m 12 -cpu qemu32,+nx,+pae -device isa-debug-exit,iobase=0xf4,iosize=0x04 \
+-no-reboot -nographic -no-acpi -net none -pidfile qemu.pid -serial mon:stdio \
+-serial tcp:localhost:4444,server,nowait \
+-kernel ./zephyr/zephyr.elf

samples/rust-app-serial/run.sh

@@ -0,0 +1,24 @@
+extern crate zephyr;
+
+use std::io::{Read, Write};
+use std::time::Duration;
+
+#[no_mangle]
+pub extern "C" fn rust_main() {
+    let mut serial = zephyr::uart::UartDevice {};
+
+    loop {
+        let x = "hello\n";
+        let mut buf = [0u8; 32];
+        let res = serial.write(x.as_bytes());
+        println!("write: result {:?}", res);
+        match serial.read(&mut buf) {
+            Ok(n) => {
+                let mystr = std::str::from_utf8(&buf).unwrap();
+                println!("read: n={} mystr={}", n, mystr);
+            },
+            Err(rc) => println!("read: err rc={}", rc),
+        }
+        std::thread::sleep(Duration::from_millis(1000));
+    }
+}

samples/rust-app-serial/src/lib.rs

@@ -0,0 +1,12 @@
+#include <zephyr.h>
+#include <drivers/console/uart_pipe.h>
+
+extern void rust_main(void);
+extern u8_t *rust_uart_cb(u8_t *buf, size_t *off);
+
+void main(void)
+{
+	u8_t buf[256];
+	uart_pipe_register(buf, sizeof(buf), rust_uart_cb);
+	rust_main();
+}