Struct EventDevice 

pub struct EventDevice {
    name: String,
    queue: Mutex<VecDeque<InputEvent>>,
    waker: Waker,
    nonblocking: Mutex<bool>,
}

Event device for input handling

This device provides a character device interface for reading input events. Events are buffered in a ring buffer and can be read by user space through standard read operations on the device file (e.g., /dev/input0).

Fields

name: String

Device name (e.g., “input0”)

queue: Mutex<VecDeque<InputEvent>>

Event queue (ring buffer)

waker: Waker

Waker for blocking reads

nonblocking: Mutex<bool>

Non-blocking mode flag

Implementations

impl EventDevice

pub fn new(device_type: &str) -> Self

Create a new event device

Arguments

• device_type - Device type (“keyboard”, “mouse”, “tablet”, or “input”)

Examples

let event_dev = Arc::new(EventDevice::new("keyboard"));
DeviceManager::get_manager().register_device(event_dev);

pub fn get_name(&self) -> &str

Get the device name

Returns

The device name (e.g., “keyboard0”, “mouse0”)

pub fn push_event(&self, type_: u16, code: u16, value: i32)

Push an input event into the queue

This method should be called from interrupt handlers or device drivers when a new input event occurs. If the queue is full, the oldest event is dropped to make room for the new one.

Arguments

• type_ - Event type (EV_KEY, EV_REL, etc.)
• code - Event code (KEY_A, REL_X, etc.)
• value - Event value (1/0 for keys, movement delta, etc.)

Examples

// In a mouse driver interrupt handler
event_dev.push_event(EV_REL, REL_X, mouse_dx);
event_dev.push_event(EV_REL, REL_Y, mouse_dy);
event_dev.push_event(EV_SYN, SYN_REPORT, 0);

fn has_events(&self) -> bool

Check if there are events available to read

Trait Implementations

impl CharDevice for EventDevice

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

Read a single byte from the device

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

Read multiple bytes from the device

fn read_at( &self, _offset: u64, buffer: &mut [u8], ) -> Result<usize, &'static str>

Read data from a specific position in 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 write(&self, buffer: &[u8]) -> Result<usize, &'static str>

Write multiple bytes to the device

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

Write data to a specific position in the device

fn can_seek(&self) -> bool

Check if this device supports seek operations

impl ControlOps for EventDevice

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 EventDevice

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 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_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 MemoryMappingOps for EventDevice

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 EventDevice

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

Return current readiness for the given interest set.

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 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.