Struct VirtioInputDevice 

pub struct VirtioInputDevice {
    base_addr: usize,
    eventq: Mutex<VirtQueue<'static>>,
    statusq: Mutex<VirtQueue<'static>>,
    event_device: Arc<EventDevice>,
    initialized: Mutex<bool>,
    event_buffers: Mutex<Vec<Box<[u8]>>>,
    interrupt_id: Mutex<Option<u32>>,
}

VirtIO Input Device

Fields

base_addr: usize

eventq: Mutex<VirtQueue<'static>>

statusq: Mutex<VirtQueue<'static>>

event_device: Arc<EventDevice>

initialized: Mutex<bool>

event_buffers: Mutex<Vec<Box<[u8]>>>

interrupt_id: Mutex<Option<u32>>

Implementations

impl VirtioInputDevice

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

Read a u8 from configuration space

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

Write a u8 to configuration space

fn read_device_name(&self) -> Option<String>

Read device name from configuration

fn determine_device_type(name: &str) -> &'static str

Determine device type from name

pub fn new(base_addr: usize) -> Self

Create a new VirtIO Input device

Arguments

• base_addr - The base address of the device

Returns

A new instance of VirtioInputDevice

fn init(&mut self) -> Result<(), &'static str>

Initialize the VirtIO input device

fn setup_queues(&mut self) -> Result<(), &'static str>

Setup virtqueues

fn prefill_event_queue(&mut self) -> Result<(), &'static str>

Prefill event queue with receive buffers

pub fn handle_interrupt(&self)

Handle input events from the device

This should be called from the interrupt handler or periodically polled

pub fn poll_events(&self)

Poll for events (for testing without interrupt support)

This can be called periodically to check for events when interrupt handling is not yet implemented

fn process_events(&self)

Process events from the event queue

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

Enable interrupts for this device

pub fn get_event_device(&self) -> Arc<EventDevice>

Get the EventDevice for this input device

Trait Implementations

impl ControlOps for VirtioInputDevice

fn control(&self, command: u32, arg: usize) -> Result<i32, &'static str>

Perform a control operation

fn supported_control_commands(&self) -> Vec<(u32, &'static str)>

Get a list of supported control commands

impl Device for VirtioInputDevice

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 capabilities(&self) -> &'static [DeviceCapability]

Optional capabilities exposed by this device (default: none)

fn as_event_capable(&self) -> Option<&dyn EventCapableDevice>

Cast to EventCapableDevice if this device can emit events

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

fn as_graphics_device(&self) -> Option<&dyn GraphicsDevice>

Cast to GraphicsDevice if this device is a graphics device

fn as_network_device(&self) -> Option<&dyn NetworkDevice>

Cast to NetworkDevice if this device is a network device

fn into_block_device(self: Arc<Self>) -> Option<Arc<dyn BlockDevice>>

Cast Arc to Arc if this device is a block device This allows direct ownership of the block device for efficient I/O operations

fn into_char_device(self: Arc<Self>) -> Option<Arc<dyn CharDevice>>

Cast Arc to Arc if this device is a character device This allows direct ownership of the char device for efficient I/O operations

fn into_graphics_device(self: Arc<Self>) -> Option<Arc<dyn GraphicsDevice>>

Cast Arc to Arc if this device is a graphics device This allows direct ownership of the graphics device for efficient operations

fn into_network_device(self: Arc<Self>) -> Option<Arc<dyn NetworkDevice>>

Cast Arc to Arc if this device is a network device This allows direct ownership of the network device for efficient operations

impl InterruptCapableDevice for VirtioInputDevice

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

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

impl MemoryMappingOps for VirtioInputDevice

fn get_mapping_info( &self, _offset: usize, _length: usize, ) -> Result<(usize, usize, bool), &'static str>

Get mapping information for a region of the object

fn get_mapping_info_with( &self, offset: usize, length: usize, _is_shared: bool, ) -> Result<(usize, usize, bool), &'static str>

Get mapping information with sharing intent.

fn on_mapped(&self, vaddr: usize, paddr: usize, length: usize, offset: usize)

Notification that a mapping has been created

fn on_unmapped(&self, vaddr: usize, length: usize)

Notification that a mapping has been removed

fn supports_mmap(&self) -> bool

Check if memory mapping is supported

fn mmap_owner_name(&self) -> String

Diagnostic helper: return a short owner name for logging

fn resolve_fault( &self, access: &AccessKind, map: &VirtualMemoryMap, ) -> Result<ResolveFaultResult, ResolveFaultError>

impl Selectable for VirtioInputDevice

fn wait_until_ready( &self, _interest: ReadyInterest, _trapframe: &mut Trapframe, _timeout_ticks: Option<u64>, ) -> SelectWaitOutcome

Block the current task using the provided trapframe until the interest becomes ready or the optional timeout (in ticks) expires.

fn current_ready(&self, interest: ReadyInterest) -> ReadySet

Return current readiness for the given interest set.

fn set_nonblocking(&self, _enabled: bool)

Enable or disable non-blocking I/O semantics on this object.

fn is_nonblocking(&self) -> bool

Query whether non-blocking I/O semantics are enabled on this object.

impl VirtioDevice for VirtioInputDevice

fn get_base_addr(&self) -> usize

fn get_device_info(&self) -> (u32, u32)

Get device and vendor IDs

fn get_virtqueue_count(&self) -> usize

fn get_virtqueue_size(&self, queue_idx: usize) -> usize

fn get_queue_desc_addr(&self, queue_idx: usize) -> Option<u64>

Get the descriptor address for a virtqueue

fn get_queue_driver_addr(&self, queue_idx: usize) -> Option<u64>

Get the driver area address for a virtqueue

fn get_queue_device_addr(&self, queue_idx: usize) -> Option<u64>

Get the device area address for a virtqueue

fn debug_dump_mmio_state(&self, tag: &'static str)

fn debug_log_status_transition( &self, tag: &'static str, old: u32, new: u32, readback: u32, )

fn wait_for_status_zero( &self, tag: &'static str, max_iters: usize, ) -> Result<(), &'static str>

fn init(&mut self) -> Result<u32, &'static str>

Initialize the device

fn is_modern_device(&self) -> bool

fn supports_feature(&self, feature: u32) -> bool

fn reset(&mut self) -> Result<(), &'static str>

Reset the device by writing 0 to the Status register

fn acknowledge(&mut self)

Set ACKNOWLEDGE status bit

fn driver(&mut self)

Set DRIVER status bit

fn driver_ok(&mut self)

Set DRIVER_OK status bit

fn set_failed(&mut self)

Set FAILED status bit

fn negotiate_features(&mut self) -> Result<u32, &'static str>

Negotiate device features

fn get_supported_features(&self, device_features: u32) -> u32

Get device features supported by this driver

fn allow_ring_features(&self) -> bool

fn setup_queue(&mut self, queue_idx: usize, queue_size: usize) -> bool

Set up a virtqueue

fn read_config<T: Sized>(&self, offset: usize) -> T

Read device-specific configuration

fn write_config<T: Sized>(&self, offset: usize, value: T)

Write device-specific configuration

fn get_interrupt_status(&self) -> u32

Get interrupt status

fn process_interrupts(&mut self) -> u32

Process interrupts (polling method)

fn memory_barrier(&self)

Memory barrier for ensuring memory operations ordering

fn notify(&self, virtqueue_idx: usize)

Notify the device about new buffers in a specified virtqueue

fn read32_register(&self, register: Register) -> u32

Read a 32-bit value from a device register

fn write32_register(&self, register: Register, value: u32)

Write a 32-bit value to a device register

fn read64_register(&self, register: Register) -> u64

Read a 64-bit value from a device register

fn write64_register(&self, register: Register, value: u64)

Write a 64-bit value to a device register