Struct VirtioDeviceCommon

struct VirtioDeviceCommon {
    base_addr: usize,
}

Virtio Common Device

Only use this struct for checking the device info. It should not be used for actual device operations.

Fields

base_addr: usize

Implementations

impl VirtioDeviceCommon

pub fn new(base_addr: usize) -> Self

Create a new Virtio device

Arguments

• base_addr - The base address of the device

Returns

A new instance of VirtioDeviceCommon

Trait Implementations

impl VirtioDevice for VirtioDeviceCommon

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

Initialize the device

fn get_base_addr(&self) -> usize

fn get_virtqueue_count(&self) -> usize

fn get_virtqueue(&self, _queue_idx: usize) -> &VirtQueue<'_>

fn reset(&mut self)

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) -> bool

Negotiate device features

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

Get device features supported by this driver

fn setup_queue(&mut self, queue_idx: 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_device_info(&self) -> (u32, u32)

Get device and vendor IDs

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(&mut 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