ove/
uart.rs

1// Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
2//
3// SPDX-License-Identifier: GPL-3.0-or-later
4//
5// This file is part of oveRTOS.
6
7//! UART serial bus driver.
8//!
9//! Provides safe wrappers around the oveRTOS UART API with interrupt-driven
10//! RX buffering and thread-safe TX.
11
12use crate::bindings;
13use crate::error::{Error, Result};
14
15/// UART parity mode.
16#[repr(u32)]
17#[derive(Debug, Copy, Clone, PartialEq, Eq)]
18pub enum Parity {
19    None = 0,
20    Odd = 1,
21    Even = 2,
22}
23
24/// UART stop bits.
25#[repr(u32)]
26#[derive(Debug, Copy, Clone, PartialEq, Eq)]
27pub enum StopBits {
28    One = 0,
29    OnePointFive = 1,
30    Two = 2,
31}
32
33/// UART flow control.
34#[repr(u32)]
35#[derive(Debug, Copy, Clone, PartialEq, Eq)]
36pub enum FlowControl {
37    None = 0,
38    RtsCts = 1,
39}
40
41/// Write data to the UART. Returns the number of bytes written.
42pub fn write(
43    uart: bindings::ove_uart_t,
44    data: &[u8],
45    timeout_ms: u32,
46) -> Result<usize> {
47    let mut written: usize = 0;
48    let rc = unsafe {
49        bindings::ove_uart_write(
50            uart,
51            data.as_ptr().cast(),
52            data.len(),
53            timeout_ms,
54            &mut written,
55        )
56    };
57    Error::from_code(rc)?;
58    Ok(written)
59}
60
61/// Read data from the UART RX buffer. Returns the number of bytes read.
62pub fn read(
63    uart: bindings::ove_uart_t,
64    buf: &mut [u8],
65    timeout_ms: u32,
66) -> Result<usize> {
67    let mut read_count: usize = 0;
68    let rc = unsafe {
69        bindings::ove_uart_read(
70            uart,
71            buf.as_mut_ptr().cast(),
72            buf.len(),
73            timeout_ms,
74            &mut read_count,
75        )
76    };
77    Error::from_code(rc)?;
78    Ok(read_count)
79}
80
81/// Query the number of bytes available in the RX buffer.
82pub fn bytes_available(uart: bindings::ove_uart_t) -> usize {
83    unsafe { bindings::ove_uart_bytes_available(uart) }
84}
85
86/// Flush the TX hardware buffer.
87pub fn flush(uart: bindings::ove_uart_t) -> Result<()> {
88    let rc = unsafe { bindings::ove_uart_flush(uart) };
89    Error::from_code(rc)
90}