Struct Uart

pub struct Uart {
    base: usize,
    interrupt_id: RwLock<Option<InterruptId>>,
    rx_buffer: Mutex<VecDeque<u8>>,
    event_emitter: Mutex<DeviceEventEmitter>,
}

Fields

base: usize

interrupt_id: RwLock<Option<InterruptId>>

rx_buffer: Mutex<VecDeque<u8>>

event_emitter: Mutex<DeviceEventEmitter>

Implementations

impl Uart

pub fn new(base: usize) -> Self

pub fn init(&self)

pub fn enable_interrupts( &self, interrupt_id: InterruptId, ) -> Result<(), &'static str>

Enable UART interrupts

fn reg_write(&self, offset: usize, value: u8)

fn reg_read(&self, offset: usize) -> u8

fn write_byte_internal(&self, c: u8)

fn read_byte_internal(&self) -> u8

fn can_read(&self) -> bool

fn can_write(&self) -> bool

Trait Implementations

impl CharDevice for Uart

fn read_byte(&self) -> Option<u8>

Read a single byte from the device

fn write_byte(&self, byte: u8) -> Result<(), &'static str>

Write a single byte to the device

fn can_read(&self) -> bool

Check if the device is ready for reading

fn can_write(&self) -> bool

Check if the device is ready for writing

fn read(&self, buffer: &mut [u8]) -> usize

Read multiple bytes from the device

fn write(&self, buffer: &[u8]) -> Result<usize, &'static str>

Write multiple bytes to the device

impl Device for Uart

fn device_type(&self) -> DeviceType

fn name(&self) -> &'static str

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_char_device(&self) -> Option<&dyn CharDevice>

Cast to CharDevice if this device is a character device

fn as_block_device(&self) -> Option<&dyn BlockDevice>

Cast to BlockDevice if this device is a block device

impl EventCapableDevice for Uart

fn register_event_listener(&self, listener: Weak<dyn DeviceEventListener>)

fn unregister_event_listener(&self, _listener_id: &str)

fn emit_event(&self, event: &dyn DeviceEvent)

impl InterruptCapableDevice for Uart

fn handle_interrupt(&self) -> InterruptResult<()>

fn interrupt_id(&self) -> Option<InterruptId>

impl Serial for Uart

fn put(&self, c: char) -> Result

Writes a character to the UART. (blocking)

This function will block until the UART is ready to accept the character.

Arguments

• c - The character to write to the UART

Returns

A fmt::Result indicating success or failure.

fn get(&self) -> Option<char>

Reads a character from the UART. (non-blocking)

Returns Some(char) if a character is available, or None if not. If interrupts are enabled, reads from the interrupt buffer. Otherwise, falls back to polling mode.

fn as_any_mut(&mut self) -> &mut dyn Any

Get a mutable reference to Any for downcasting

impl Write for Uart

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a [char] into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the [write!] macro with implementors of this trait.