bjorn3
560 lines
13 KiB
Rust
560 lines
13 KiB
Rust
//! `virtio-gpu` is a virtio based graphics adapter. It can operate in 2D mode and in 3D mode.
|
|
//!
|
|
//! XXX: 3D mode will offload rendering ops to the host gpu and therefore requires a GPU with 3D support
|
|
//! on the host machine.
|
|
|
|
// Notes for the future:
|
|
//
|
|
// `virtio-gpu` 2D acceleration is just blitting. 3D acceleration has 2 kinds:
|
|
// - virgl - OpenGL
|
|
// - venus - Vulkan
|
|
//
|
|
// The Venus driver requires support for the following from the `virtio-gpu` kernel driver:
|
|
// - VIRTGPU_PARAM_3D_FEATURES
|
|
// - VIRTGPU_PARAM_CAPSET_QUERY_FIX
|
|
// - VIRTGPU_PARAM_RESOURCE_BLOB
|
|
// - VIRTGPU_PARAM_HOST_VISIBLE
|
|
// - VIRTGPU_PARAM_CROSS_DEVICE
|
|
// - VIRTGPU_PARAM_CONTEXT_INIT
|
|
//
|
|
// cc https://docs.mesa3d.org/drivers/venus.html
|
|
// cc https://docs.mesa3d.org/drivers/virgl.html
|
|
|
|
use std::os::fd::AsRawFd;
|
|
use std::sync::atomic::{AtomicU32, Ordering};
|
|
|
|
use event::{user_data, EventQueue};
|
|
use pcid_interface::PciFunctionHandle;
|
|
|
|
use virtio_core::utils::VolatileCell;
|
|
use virtio_core::MSIX_PRIMARY_VECTOR;
|
|
|
|
mod scheme;
|
|
|
|
const VIRTIO_GPU_EVENT_DISPLAY: u32 = 1 << 0;
|
|
const VIRTIO_GPU_MAX_SCANOUTS: usize = 16;
|
|
|
|
#[repr(C)]
|
|
pub struct GpuConfig {
|
|
/// Signals pending events to the driver.
|
|
pub events_read: VolatileCell<u32>, // read-only
|
|
/// Clears pending events in the device (write-to-clear).
|
|
pub events_clear: VolatileCell<u32>, // write-only
|
|
|
|
pub num_scanouts: VolatileCell<u32>,
|
|
pub num_capsets: VolatileCell<u32>,
|
|
}
|
|
|
|
impl GpuConfig {
|
|
#[inline]
|
|
pub fn num_scanouts(&self) -> u32 {
|
|
self.num_scanouts.get()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq)]
|
|
#[repr(u32)]
|
|
pub enum CommandTy {
|
|
Undefined = 0,
|
|
|
|
// 2D commands
|
|
GetDisplayInfo = 0x0100,
|
|
ResourceCreate2d,
|
|
ResourceUnref,
|
|
SetScanout,
|
|
ResourceFlush,
|
|
TransferToHost2d,
|
|
ResourceAttachBacking,
|
|
ResourceDetachBacking,
|
|
GetCapsetInfo,
|
|
GetCapset,
|
|
GetEdid,
|
|
ResourceAssignUuid,
|
|
ResourceCreateBlob,
|
|
SetScanoutBlob,
|
|
|
|
// 3D commands
|
|
CtxCreate = 0x0200,
|
|
CtxDestroy,
|
|
CtxAttachResource,
|
|
CtxDetachResource,
|
|
ResourceCreate3d,
|
|
TransferToHost3d,
|
|
TransferFromHost3d,
|
|
Submit3d,
|
|
ResourceMapBlob,
|
|
ResourceUnmapBlob,
|
|
|
|
// cursor commands
|
|
UpdateCursor = 0x0300,
|
|
MoveCursor,
|
|
|
|
// success responses
|
|
RespOkNodata = 0x1100,
|
|
RespOkDisplayInfo,
|
|
RespOkCapsetInfo,
|
|
RespOkCapset,
|
|
RespOkEdid,
|
|
RespOkResourceUuid,
|
|
RespOkMapInfo,
|
|
|
|
// error responses
|
|
RespErrUnspec = 0x1200,
|
|
RespErrOutOfMemory,
|
|
RespErrInvalidScanoutId,
|
|
RespErrInvalidResourceId,
|
|
RespErrInvalidContextId,
|
|
RespErrInvalidParameter,
|
|
}
|
|
|
|
static_assertions::const_assert_eq!(core::mem::size_of::<CommandTy>(), 4);
|
|
|
|
const VIRTIO_GPU_FLAG_FENCE: u32 = 1 << 0;
|
|
//const VIRTIO_GPU_FLAG_INFO_RING_IDX: u32 = 1 << 1;
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct ControlHeader {
|
|
pub ty: CommandTy,
|
|
pub flags: u32,
|
|
pub fence_id: u64,
|
|
pub ctx_id: u32,
|
|
pub ring_index: u8,
|
|
padding: [u8; 3],
|
|
}
|
|
|
|
impl ControlHeader {
|
|
pub fn with_ty(ty: CommandTy) -> Self {
|
|
Self {
|
|
ty,
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for ControlHeader {
|
|
fn default() -> Self {
|
|
Self {
|
|
ty: CommandTy::Undefined,
|
|
flags: 0,
|
|
fence_id: 0,
|
|
ctx_id: 0,
|
|
ring_index: 0,
|
|
padding: [0; 3],
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone)]
|
|
#[repr(C)]
|
|
pub struct GpuRect {
|
|
pub x: u32,
|
|
pub y: u32,
|
|
pub width: u32,
|
|
pub height: u32,
|
|
}
|
|
|
|
impl GpuRect {
|
|
pub fn new(x: u32, y: u32, width: u32, height: u32) -> Self {
|
|
Self {
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct DisplayInfo {
|
|
rect: GpuRect,
|
|
pub enabled: u32,
|
|
pub flags: u32,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct GetDisplayInfo {
|
|
pub header: ControlHeader,
|
|
pub display_info: [DisplayInfo; VIRTIO_GPU_MAX_SCANOUTS],
|
|
}
|
|
|
|
impl Default for GetDisplayInfo {
|
|
fn default() -> Self {
|
|
Self {
|
|
header: ControlHeader {
|
|
ty: CommandTy::GetDisplayInfo,
|
|
..Default::default()
|
|
},
|
|
|
|
display_info: unsafe { core::mem::zeroed() },
|
|
}
|
|
}
|
|
}
|
|
|
|
static RESOURCE_ALLOC: AtomicU32 = AtomicU32::new(1); // XXX: 0 is reserved for whatever that takes `resource_id`.
|
|
|
|
#[derive(PartialEq, Eq, Debug, Copy, Clone)]
|
|
#[repr(C)]
|
|
pub struct ResourceId(u32);
|
|
|
|
impl ResourceId {
|
|
fn alloc() -> Self {
|
|
ResourceId(RESOURCE_ALLOC.fetch_add(1, Ordering::SeqCst))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone)]
|
|
#[repr(u32)]
|
|
pub enum ResourceFormat {
|
|
Unknown = 0,
|
|
|
|
Bgrx = 2,
|
|
Xrgb = 4,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct ResourceCreate2d {
|
|
pub header: ControlHeader,
|
|
resource_id: ResourceId,
|
|
format: ResourceFormat,
|
|
width: u32,
|
|
height: u32,
|
|
}
|
|
|
|
impl ResourceCreate2d {
|
|
fn new(resource_id: ResourceId, format: ResourceFormat, width: u32, height: u32) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::ResourceCreate2d),
|
|
resource_id,
|
|
format,
|
|
width,
|
|
height,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct MemEntry {
|
|
pub address: u64,
|
|
pub length: u32,
|
|
pub padding: u32,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct AttachBacking {
|
|
pub header: ControlHeader,
|
|
pub resource_id: ResourceId,
|
|
pub num_entries: u32,
|
|
}
|
|
|
|
impl AttachBacking {
|
|
pub fn new(resource_id: ResourceId, num_entries: u32) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::ResourceAttachBacking),
|
|
resource_id,
|
|
num_entries,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct DetachBacking {
|
|
pub header: ControlHeader,
|
|
pub resource_id: ResourceId,
|
|
pub padding: u32,
|
|
}
|
|
|
|
impl DetachBacking {
|
|
pub fn new(resource_id: ResourceId) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::ResourceDetachBacking),
|
|
resource_id,
|
|
padding: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct ResourceFlush {
|
|
pub header: ControlHeader,
|
|
pub rect: GpuRect,
|
|
pub resource_id: ResourceId,
|
|
pub padding: u32,
|
|
}
|
|
|
|
impl ResourceFlush {
|
|
pub fn new(resource_id: ResourceId, rect: GpuRect) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::ResourceFlush),
|
|
rect,
|
|
resource_id,
|
|
padding: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct ResourceUnref {
|
|
pub header: ControlHeader,
|
|
pub resource_id: ResourceId,
|
|
pub padding: u32,
|
|
}
|
|
|
|
impl ResourceUnref {
|
|
pub fn new(resource_id: ResourceId) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::ResourceUnref),
|
|
resource_id,
|
|
padding: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Debug)]
|
|
pub struct SetScanout {
|
|
pub header: ControlHeader,
|
|
pub rect: GpuRect,
|
|
pub scanout_id: u32,
|
|
pub resource_id: ResourceId,
|
|
}
|
|
|
|
impl SetScanout {
|
|
pub fn new(scanout_id: u32, resource_id: ResourceId, rect: GpuRect) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::SetScanout),
|
|
|
|
rect,
|
|
scanout_id,
|
|
resource_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct XferToHost2d {
|
|
pub header: ControlHeader,
|
|
pub rect: GpuRect,
|
|
pub offset: u64,
|
|
pub resource_id: ResourceId,
|
|
pub padding: u32,
|
|
}
|
|
|
|
impl XferToHost2d {
|
|
pub fn new(resource_id: ResourceId, rect: GpuRect, offset: u64) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::TransferToHost2d),
|
|
rect,
|
|
offset,
|
|
resource_id,
|
|
padding: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct CursorPos {
|
|
pub scanout_id: u32,
|
|
pub x: i32,
|
|
pub y: i32,
|
|
_padding: u32,
|
|
}
|
|
|
|
impl CursorPos {
|
|
pub fn new(scanout_id: u32, x: i32, y: i32) -> Self {
|
|
Self {
|
|
scanout_id,
|
|
x,
|
|
y,
|
|
_padding: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
/* VIRTIO_GPU_CMD_UPDATE_CURSOR, VIRTIO_GPU_CMD_MOVE_CURSOR */
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
pub struct UpdateCursor {
|
|
pub header: ControlHeader,
|
|
pub pos: CursorPos,
|
|
pub resource_id: ResourceId,
|
|
pub hot_x: i32,
|
|
pub hot_y: i32,
|
|
_padding: u32,
|
|
}
|
|
|
|
impl UpdateCursor {
|
|
pub fn update_cursor(x: i32, y: i32, hot_x: i32, hot_y: i32, resource_id: ResourceId) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::UpdateCursor),
|
|
pos: CursorPos::new(0, x, y),
|
|
resource_id,
|
|
hot_x,
|
|
hot_y,
|
|
_padding: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct MoveCursor {
|
|
pub header: ControlHeader,
|
|
pub pos: CursorPos,
|
|
pub resource_id: ResourceId,
|
|
pub hot_x: i32,
|
|
pub hot_y: i32,
|
|
_padding: u32,
|
|
}
|
|
|
|
impl MoveCursor {
|
|
pub fn move_cursor(x: i32, y: i32) -> Self {
|
|
Self {
|
|
header: ControlHeader::with_ty(CommandTy::MoveCursor),
|
|
pos: CursorPos::new(0, x, y),
|
|
resource_id: ResourceId(0),
|
|
hot_x: 0,
|
|
hot_y: 0,
|
|
_padding: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
static DEVICE: spin::Once<virtio_core::Device> = spin::Once::new();
|
|
|
|
fn main() {
|
|
pcid_interface::pci_daemon(daemon_runner);
|
|
}
|
|
|
|
fn daemon_runner(daemon: daemon::Daemon, pcid_handle: PciFunctionHandle) -> ! {
|
|
deamon(daemon, pcid_handle).unwrap();
|
|
unreachable!();
|
|
}
|
|
|
|
fn deamon(deamon: daemon::Daemon, mut pcid_handle: PciFunctionHandle) -> anyhow::Result<()> {
|
|
common::setup_logging(
|
|
"graphics",
|
|
"pci",
|
|
"virtio-gpud",
|
|
common::output_level(),
|
|
common::file_level(),
|
|
);
|
|
|
|
// Double check that we have the right device.
|
|
//
|
|
// 0x1050 - virtio-gpu
|
|
let pci_config = pcid_handle.config();
|
|
|
|
assert_eq!(pci_config.func.full_device_id.device_id, 0x1050);
|
|
log::info!("virtio-gpu: initiating startup sequence :^)");
|
|
|
|
let device = DEVICE.try_call_once(|| virtio_core::probe_device(&mut pcid_handle))?;
|
|
let config = unsafe { &mut *(device.device_space as *mut GpuConfig) };
|
|
|
|
// Negotiate features.
|
|
device.transport.finalize_features();
|
|
|
|
// Queue for sending control commands.
|
|
let control_queue = device
|
|
.transport
|
|
.setup_queue(MSIX_PRIMARY_VECTOR, &device.irq_handle)?;
|
|
|
|
// Queue for sending cursor updates.
|
|
let cursor_queue = device
|
|
.transport
|
|
.setup_queue(MSIX_PRIMARY_VECTOR, &device.irq_handle)?;
|
|
|
|
device.transport.setup_config_notify(MSIX_PRIMARY_VECTOR);
|
|
|
|
device.transport.run_device();
|
|
deamon.ready();
|
|
|
|
let (mut scheme, mut inputd_handle) = futures::executor::block_on(scheme::GpuScheme::new(
|
|
config,
|
|
control_queue.clone(),
|
|
cursor_queue.clone(),
|
|
device.transport.clone(),
|
|
))?;
|
|
|
|
user_data! {
|
|
enum Source {
|
|
Input,
|
|
Scheme,
|
|
Interrupt,
|
|
}
|
|
}
|
|
|
|
let event_queue: EventQueue<Source> =
|
|
EventQueue::new().expect("virtio-gpud: failed to create event queue");
|
|
event_queue
|
|
.subscribe(
|
|
inputd_handle.inner().as_raw_fd() as usize,
|
|
Source::Input,
|
|
event::EventFlags::READ,
|
|
)
|
|
.unwrap();
|
|
event_queue
|
|
.subscribe(
|
|
scheme.event_handle().raw(),
|
|
Source::Scheme,
|
|
event::EventFlags::READ,
|
|
)
|
|
.unwrap();
|
|
event_queue
|
|
.subscribe(
|
|
device.irq_handle.as_raw_fd() as usize,
|
|
Source::Interrupt,
|
|
event::EventFlags::READ,
|
|
)
|
|
.unwrap();
|
|
|
|
let all = [Source::Input, Source::Scheme, Source::Interrupt];
|
|
for event in all
|
|
.into_iter()
|
|
.chain(event_queue.map(|e| e.expect("virtio-gpud: failed to get next event").user_data))
|
|
{
|
|
match event {
|
|
Source::Input => {
|
|
while let Some(vt_event) = inputd_handle
|
|
.read_vt_event()
|
|
.expect("virtio-gpud: failed to read display handle")
|
|
{
|
|
scheme.handle_vt_event(vt_event);
|
|
}
|
|
}
|
|
Source::Scheme => {
|
|
scheme
|
|
.tick()
|
|
.expect("virtio-gpud: failed to process scheme events");
|
|
}
|
|
Source::Interrupt => loop {
|
|
let before_gen = device.transport.config_generation();
|
|
|
|
let events = config.events_read.get();
|
|
|
|
if events & VIRTIO_GPU_EVENT_DISPLAY != 0 {
|
|
futures::executor::block_on(scheme.adapter_mut().update_displays(config))
|
|
.unwrap();
|
|
scheme.notify_displays_changed();
|
|
config.events_clear.set(VIRTIO_GPU_EVENT_DISPLAY);
|
|
}
|
|
|
|
let after_gen = device.transport.config_generation();
|
|
if before_gen == after_gen {
|
|
break;
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
std::process::exit(0);
|
|
}
|