drivers/usart/client/src/lib.rs

// Licensed under the Apache-2.0 license
// SPDX-License-Identifier: Apache-2.0

#![no_std]

use usart_api::{UsartError, UsartOp, UsartRequestHeader, UsartResponseHeader, MAX_PAYLOAD_SIZE};
use userspace::syscall;
use userspace::time::Instant;

const MAX_BUF_SIZE: usize = 512;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ClientError {
    IpcError(pw_status::Error),
    ServerError(UsartError),
    InvalidResponse,
    BufferTooSmall,
}

impl From<pw_status::Error> for ClientError {
    fn from(e: pw_status::Error) -> Self {
        Self::IpcError(e)
    }
}

pub struct UsartClient {
    handle: u32,
}

impl UsartClient {
    pub const fn new(handle: u32) -> Self {
        Self { handle }
    }

    pub fn configure(&self, baud_rate: u32) -> Result<(), ClientError> {
        let arg0 = (baud_rate & 0xffff) as u16;
        let arg1 = (baud_rate >> 16) as u16;
        self.call_no_payload(UsartOp::Configure, arg0, arg1)
    }

    pub fn write(&self, data: &[u8]) -> Result<usize, ClientError> {
        if data.len() > MAX_PAYLOAD_SIZE {
            return Err(ClientError::BufferTooSmall);
        }

        let mut req = [0u8; MAX_BUF_SIZE];
        let mut resp = [0u8; MAX_BUF_SIZE];

        let hdr = UsartRequestHeader::new(UsartOp::Write, 0, 0, data.len() as u16);
        req[..UsartRequestHeader::SIZE].copy_from_slice(zerocopy::IntoBytes::as_bytes(&hdr));
        req[UsartRequestHeader::SIZE..UsartRequestHeader::SIZE + data.len()].copy_from_slice(data);

        let resp_len = syscall::channel_transact(
            self.handle,
            &req[..UsartRequestHeader::SIZE + data.len()],
            &mut resp,
            Instant::MAX,
        )?;

        parse_no_payload_response(&resp[..resp_len])?;
        Ok(data.len())
    }

    pub fn read(&self, out: &mut [u8]) -> Result<usize, ClientError> {
        self.read_with_timeout(out, Instant::MAX)
    }

    pub fn read_with_timeout(
        &self,
        out: &mut [u8],
        deadline: Instant,
    ) -> Result<usize, ClientError> {
        if out.len() > MAX_PAYLOAD_SIZE {
            return Err(ClientError::BufferTooSmall);
        }

        let mut req = [0u8; MAX_BUF_SIZE];
        let mut resp = [0u8; MAX_BUF_SIZE];

        let hdr = UsartRequestHeader::new(UsartOp::Read, out.len() as u16, 0, 0);
        req[..UsartRequestHeader::SIZE].copy_from_slice(zerocopy::IntoBytes::as_bytes(&hdr));

        let resp_len = syscall::channel_transact(
            self.handle,
            &req[..UsartRequestHeader::SIZE],
            &mut resp,
            deadline,
        )?;

        parse_payload_response(&resp[..resp_len], out)
    }

    /// Non-blocking read.
    ///
    /// Sends a `TryRead` request to the server.  If bytes are available in the
    /// hardware FIFO right now the server responds immediately and this call
    /// returns `Ok(n)`.  If the FIFO is empty the server arms the RX interrupt
    /// and blocks the IPC transaction on the server side; this call returns
    /// once the interrupt fires and data has been copied into `out`.
    ///
    /// From the caller's perspective this function always returns with data
    /// (or an error); the "non-blocking" nature means the **server** is freed
    /// to handle other events while waiting rather than spinning in a hardware
    /// read loop.
    pub fn try_read(&self, out: &mut [u8]) -> Result<usize, ClientError> {
        self.try_read_with_timeout(out, Instant::MAX)
    }

    pub fn try_read_with_timeout(
        &self,
        out: &mut [u8],
        deadline: Instant,
    ) -> Result<usize, ClientError> {
        if out.len() > MAX_PAYLOAD_SIZE {
            return Err(ClientError::BufferTooSmall);
        }

        let mut req = [0u8; MAX_BUF_SIZE];
        let mut resp = [0u8; MAX_BUF_SIZE];

        let hdr = UsartRequestHeader::new(UsartOp::TryRead, out.len() as u16, 0, 0);
        req[..UsartRequestHeader::SIZE].copy_from_slice(zerocopy::IntoBytes::as_bytes(&hdr));

        let resp_len = syscall::channel_transact(
            self.handle,
            &req[..UsartRequestHeader::SIZE],
            &mut resp,
            deadline,
        )?;

        parse_payload_response(&resp[..resp_len], out)
    }

    fn call_no_payload(&self, op: UsartOp, arg0: u16, arg1: u16) -> Result<(), ClientError> {
        let mut req = [0u8; MAX_BUF_SIZE];
        let mut resp = [0u8; MAX_BUF_SIZE];

        let hdr = UsartRequestHeader::new(op, arg0, arg1, 0);
        req[..UsartRequestHeader::SIZE].copy_from_slice(zerocopy::IntoBytes::as_bytes(&hdr));

        let resp_len = syscall::channel_transact(
            self.handle,
            &req[..UsartRequestHeader::SIZE],
            &mut resp,
            Instant::MAX,
        )?;

        parse_no_payload_response(&resp[..resp_len])
    }
}

fn parse_no_payload_response(resp: &[u8]) -> Result<(), ClientError> {
    if resp.len() < UsartResponseHeader::SIZE {
        return Err(ClientError::InvalidResponse);
    }

    let hdr_bytes = &resp[..UsartResponseHeader::SIZE];
    let Some(hdr) = zerocopy::Ref::<_, UsartResponseHeader>::from_bytes(hdr_bytes).ok() else {
        return Err(ClientError::InvalidResponse);
    };

    if hdr.is_success() {
        Ok(())
    } else {
        Err(ClientError::ServerError(hdr.error_code()))
    }
}

fn parse_payload_response(resp: &[u8], out: &mut [u8]) -> Result<usize, ClientError> {
    if resp.len() < UsartResponseHeader::SIZE {
        return Err(ClientError::InvalidResponse);
    }

    let hdr_bytes = &resp[..UsartResponseHeader::SIZE];
    let Some(hdr) = zerocopy::Ref::<_, UsartResponseHeader>::from_bytes(hdr_bytes).ok() else {
        return Err(ClientError::InvalidResponse);
    };

    if !hdr.is_success() {
        return Err(ClientError::ServerError(hdr.error_code()));
    }

    let len = hdr.payload_length();
    if len > out.len() || resp.len() < UsartResponseHeader::SIZE + len {
        return Err(ClientError::InvalidResponse);
    }

    out[..len].copy_from_slice(&resp[UsartResponseHeader::SIZE..UsartResponseHeader::SIZE + len]);
    Ok(len)
}