bjorn3
7b8ebe9dca
This is the actual size of the Orbital desktop. Previously resizing a virtio-gpu window after Orbital started but before logging in would cause the launcher to be out of view.
928 lines
35 KiB
Rust
928 lines
35 KiB
Rust
#![feature(slice_as_array)]
|
|
|
|
use std::collections::{BTreeMap, HashMap};
|
|
use std::ffi::c_char;
|
|
use std::fmt::Debug;
|
|
use std::fs::File;
|
|
use std::io::{self, Write};
|
|
use std::mem;
|
|
use std::mem::transmute;
|
|
use std::os::fd::BorrowedFd;
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use drm_sys::{
|
|
drm_mode_modeinfo, drm_mode_property_enum, DRM_MODE_CURSOR_BO, DRM_MODE_CURSOR_MOVE,
|
|
DRM_MODE_DPMS_OFF, DRM_MODE_DPMS_ON, DRM_MODE_DPMS_STANDBY, DRM_MODE_DPMS_SUSPEND,
|
|
DRM_MODE_PROP_ATOMIC, DRM_MODE_PROP_BITMASK, DRM_MODE_PROP_BLOB, DRM_MODE_PROP_ENUM,
|
|
DRM_MODE_PROP_IMMUTABLE, DRM_MODE_PROP_OBJECT, DRM_MODE_PROP_RANGE, DRM_MODE_PROP_SIGNED_RANGE,
|
|
DRM_PROP_NAME_LEN,
|
|
};
|
|
use graphics_ipc::v2::Damage;
|
|
use inputd::{DisplayHandle, VtEventKind};
|
|
use libredox::Fd;
|
|
use redox_scheme::scheme::{register_scheme_inner, SchemeState, SchemeSync};
|
|
use redox_scheme::{CallerCtx, OpenResult, RequestKind, SignalBehavior, Socket};
|
|
use syscall::schemev2::NewFdFlags;
|
|
use syscall::{Error, MapFlags, Result, EACCES, EAGAIN, EBADF, EINVAL, ENOENT, EOPNOTSUPP};
|
|
|
|
use crate::kms::connector::KmsConnector;
|
|
use crate::kms::objects::{KmsCrtc, KmsObjectId, KmsObjects};
|
|
use crate::kms::properties::KmsPropertyKind;
|
|
|
|
pub mod kms;
|
|
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct StandardProperties {
|
|
pub edid: KmsObjectId,
|
|
pub dpms: KmsObjectId,
|
|
}
|
|
|
|
pub trait GraphicsAdapter: Sized + Debug {
|
|
type Connector: Debug;
|
|
type Crtc: Debug;
|
|
|
|
type Buffer: Buffer;
|
|
|
|
fn name(&self) -> &'static [u8];
|
|
fn desc(&self) -> &'static [u8];
|
|
|
|
fn init(&mut self, objects: &mut KmsObjects<Self>, standard_properties: &StandardProperties);
|
|
|
|
fn get_cap(&self, cap: u32) -> Result<u64>;
|
|
fn set_client_cap(&self, cap: u32, value: u64) -> Result<()>;
|
|
|
|
fn probe_connector(
|
|
&mut self,
|
|
objects: &mut KmsObjects<Self>,
|
|
standard_properties: &StandardProperties,
|
|
id: KmsObjectId,
|
|
);
|
|
|
|
/// The maximum amount of displays that could be attached.
|
|
///
|
|
/// This must be constant for the lifetime of the graphics adapter.
|
|
fn display_count(&self) -> usize;
|
|
fn display_size(&self, display_id: usize) -> (u32, u32);
|
|
|
|
fn create_dumb_buffer(&mut self, width: u32, height: u32) -> Self::Buffer;
|
|
fn map_dumb_buffer(&mut self, framebuffer: &Self::Buffer) -> *mut u8;
|
|
|
|
fn set_crtc(
|
|
&mut self,
|
|
objects: &KmsObjects<Self>,
|
|
crtc: &Mutex<KmsCrtc<Self::Crtc>>,
|
|
connectors: &[KmsObjectId],
|
|
mode: Option<drm_mode_modeinfo>,
|
|
framebuffer: Option<&Self::Buffer>,
|
|
damage: Damage,
|
|
);
|
|
|
|
fn hw_cursor_size(&self) -> Option<(u32, u32)>;
|
|
fn handle_cursor(&mut self, cursor: &CursorPlane<Self::Buffer>, dirty_fb: bool);
|
|
}
|
|
|
|
pub trait Buffer: Debug {
|
|
fn width(&self) -> u32;
|
|
fn height(&self) -> u32;
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct CursorPlane<C: Buffer> {
|
|
pub x: i32,
|
|
pub y: i32,
|
|
pub hot_x: i32,
|
|
pub hot_y: i32,
|
|
pub buffer: Option<Arc<C>>,
|
|
}
|
|
|
|
pub struct GraphicsScheme<T: GraphicsAdapter> {
|
|
inner: GraphicsSchemeInner<T>,
|
|
inputd_handle: DisplayHandle,
|
|
state: SchemeState,
|
|
}
|
|
|
|
impl<T: GraphicsAdapter> GraphicsScheme<T> {
|
|
pub fn new(mut adapter: T, scheme_name: String, early: bool) -> Self {
|
|
assert!(scheme_name.starts_with("display"));
|
|
let socket = Socket::nonblock().expect("failed to create graphics scheme");
|
|
|
|
let disable_graphical_debug = Some(
|
|
File::open("/scheme/debug/disable-graphical-debug")
|
|
.expect("vesad: Failed to open /scheme/debug/disable-graphical-debug"),
|
|
);
|
|
|
|
let mut objects = KmsObjects::new();
|
|
|
|
let edid = objects.add_property("EDID", true, false, KmsPropertyKind::Blob);
|
|
let dpms = objects.add_property(
|
|
"DPMS",
|
|
false,
|
|
false,
|
|
KmsPropertyKind::Enum(vec![
|
|
("On", DRM_MODE_DPMS_ON.into()),
|
|
("Standby", DRM_MODE_DPMS_STANDBY.into()),
|
|
("Suspend", DRM_MODE_DPMS_SUSPEND.into()),
|
|
("Off", DRM_MODE_DPMS_OFF.into()),
|
|
]),
|
|
);
|
|
let standard_properties = StandardProperties { edid, dpms };
|
|
|
|
adapter.init(&mut objects, &standard_properties);
|
|
for connector_id in objects.connector_ids().to_vec() {
|
|
adapter.probe_connector(&mut objects, &standard_properties, connector_id)
|
|
}
|
|
|
|
let mut inner = GraphicsSchemeInner {
|
|
adapter,
|
|
scheme_name,
|
|
disable_graphical_debug,
|
|
socket,
|
|
objects,
|
|
standard_properties,
|
|
next_id: 0,
|
|
handles: BTreeMap::new(),
|
|
active_vt: 0,
|
|
vts: HashMap::new(),
|
|
};
|
|
|
|
let cap_id = inner.scheme_root().expect("failed to get this scheme root");
|
|
register_scheme_inner(&inner.socket, &inner.scheme_name, cap_id)
|
|
.expect("failed to register graphics scheme root");
|
|
|
|
let display_handle = if early {
|
|
DisplayHandle::new_early(&inner.scheme_name).unwrap()
|
|
} else {
|
|
DisplayHandle::new(&inner.scheme_name).unwrap()
|
|
};
|
|
|
|
Self {
|
|
inner,
|
|
inputd_handle: display_handle,
|
|
state: SchemeState::new(),
|
|
}
|
|
}
|
|
|
|
pub fn event_handle(&self) -> &Fd {
|
|
self.inner.socket.inner()
|
|
}
|
|
|
|
pub fn inputd_event_handle(&self) -> BorrowedFd<'_> {
|
|
self.inputd_handle.inner()
|
|
}
|
|
|
|
pub fn adapter(&self) -> &T {
|
|
&self.inner.adapter
|
|
}
|
|
|
|
pub fn adapter_mut(&mut self) -> &mut T {
|
|
&mut self.inner.adapter
|
|
}
|
|
|
|
pub fn kms_objects(&self) -> &KmsObjects<T> {
|
|
&self.inner.objects
|
|
}
|
|
|
|
pub fn kms_objects_mut(&mut self) -> &mut KmsObjects<T> {
|
|
&mut self.inner.objects
|
|
}
|
|
|
|
pub fn adapter_and_kms_objects_mut(&mut self) -> (&mut T, &mut KmsObjects<T>) {
|
|
(&mut self.inner.adapter, &mut self.inner.objects)
|
|
}
|
|
|
|
pub fn standard_properties(&self) -> StandardProperties {
|
|
self.inner.standard_properties
|
|
}
|
|
|
|
pub fn handle_vt_events(&mut self) {
|
|
while let Some(vt_event) = self
|
|
.inputd_handle
|
|
.read_vt_event()
|
|
.expect("driver-graphics: failed to read display handle")
|
|
{
|
|
match vt_event.kind {
|
|
VtEventKind::Activate => {
|
|
log::info!("activate {}", vt_event.vt);
|
|
|
|
// Disable the kernel graphical debug writing once switching vt's for the
|
|
// first time. This way the kernel graphical debug remains enabled if the
|
|
// userspace logging infrastructure doesn't start up because for example a
|
|
// kernel panic happened prior to it starting up or logd crashed.
|
|
if let Some(mut disable_graphical_debug) =
|
|
self.inner.disable_graphical_debug.take()
|
|
{
|
|
let _ = disable_graphical_debug.write(&[1]);
|
|
}
|
|
|
|
self.inner.active_vt = vt_event.vt;
|
|
|
|
let vt_state = GraphicsSchemeInner::get_or_create_vt(
|
|
&mut self.inner.adapter,
|
|
&mut self.inner.vts,
|
|
vt_event.vt,
|
|
);
|
|
|
|
for (display_id, fb) in vt_state.display_fbs.iter().enumerate() {
|
|
let crtc = self.inner.objects.crtcs().nth(display_id).unwrap();
|
|
|
|
let mode = fb.as_ref().map(|fb| {
|
|
KmsConnector::<()>::modeinfo_for_size(fb.width(), fb.height())
|
|
});
|
|
|
|
self.inner.adapter.set_crtc(
|
|
&self.inner.objects,
|
|
crtc,
|
|
&[self.inner.objects.connector_ids()[display_id]],
|
|
mode,
|
|
fb.as_deref(),
|
|
Damage {
|
|
x: 0,
|
|
y: 0,
|
|
width: fb.as_deref().map_or(0, |fb| fb.width()),
|
|
height: fb.as_deref().map_or(0, |fb| fb.height()),
|
|
},
|
|
);
|
|
}
|
|
|
|
if self.inner.adapter.hw_cursor_size().is_some() {
|
|
self.inner
|
|
.adapter
|
|
.handle_cursor(&vt_state.cursor_plane, true);
|
|
}
|
|
}
|
|
|
|
VtEventKind::Resize => {
|
|
log::warn!("driver-graphics: resize is not implemented yet")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn notify_displays_changed(&mut self) {
|
|
// FIXME notify clients
|
|
}
|
|
|
|
/// Process new scheme requests.
|
|
///
|
|
/// This needs to be called each time there is a new event on the scheme
|
|
/// file.
|
|
pub fn tick(&mut self) -> io::Result<()> {
|
|
loop {
|
|
let request = match self.inner.socket.next_request(SignalBehavior::Restart) {
|
|
Ok(Some(request)) => request,
|
|
Ok(None) => {
|
|
// Scheme likely got unmounted
|
|
std::process::exit(0);
|
|
}
|
|
Err(err) if err.errno == EAGAIN => break,
|
|
Err(err) => panic!("driver-graphics: failed to read display scheme: {err}"),
|
|
};
|
|
|
|
match request.kind() {
|
|
RequestKind::Call(call) => {
|
|
let response = call.handle_sync(&mut self.inner, &mut self.state);
|
|
self.inner
|
|
.socket
|
|
.write_response(response, SignalBehavior::Restart)
|
|
.expect("driver-graphics: failed to write response");
|
|
}
|
|
RequestKind::OnClose { id } => {
|
|
self.inner.on_close(id);
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
struct GraphicsSchemeInner<T: GraphicsAdapter> {
|
|
adapter: T,
|
|
|
|
scheme_name: String,
|
|
disable_graphical_debug: Option<File>,
|
|
socket: Socket,
|
|
objects: KmsObjects<T>,
|
|
standard_properties: StandardProperties,
|
|
next_id: usize,
|
|
handles: BTreeMap<usize, Handle<T>>,
|
|
|
|
active_vt: usize,
|
|
vts: HashMap<usize, VtState<T>>,
|
|
}
|
|
|
|
struct VtState<T: GraphicsAdapter> {
|
|
display_fbs: Vec<Option<Arc<T::Buffer>>>,
|
|
cursor_plane: CursorPlane<T::Buffer>,
|
|
}
|
|
|
|
enum Handle<T: GraphicsAdapter> {
|
|
// This only exists for compatibility with orbclient.
|
|
V1Screen {
|
|
vt: usize,
|
|
screen: usize,
|
|
},
|
|
V2 {
|
|
vt: usize,
|
|
next_id: u32,
|
|
buffers: HashMap<u32, Arc<T::Buffer>>,
|
|
},
|
|
SchemeRoot,
|
|
}
|
|
|
|
impl<T: GraphicsAdapter> GraphicsSchemeInner<T> {
|
|
fn get_or_create_vt<'a>(
|
|
adapter: &mut T,
|
|
vts: &'a mut HashMap<usize, VtState<T>>,
|
|
vt: usize,
|
|
) -> &'a mut VtState<T> {
|
|
vts.entry(vt).or_insert_with(|| VtState {
|
|
display_fbs: vec![None; adapter.display_count()],
|
|
cursor_plane: CursorPlane {
|
|
x: 0,
|
|
y: 0,
|
|
hot_x: 0,
|
|
hot_y: 0,
|
|
buffer: None,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
const MAP_FAKE_OFFSET_MULTIPLIER: usize = 0x10_000_000;
|
|
|
|
impl<T: GraphicsAdapter> SchemeSync for GraphicsSchemeInner<T> {
|
|
fn scheme_root(&mut self) -> Result<usize> {
|
|
let id = self.next_id;
|
|
self.next_id += 1;
|
|
self.handles.insert(id, Handle::SchemeRoot);
|
|
Ok(id)
|
|
}
|
|
fn openat(
|
|
&mut self,
|
|
dirfd: usize,
|
|
path: &str,
|
|
_flags: usize,
|
|
_fcntl_flags: u32,
|
|
_ctx: &CallerCtx,
|
|
) -> Result<OpenResult> {
|
|
if !matches!(
|
|
self.handles.get(&dirfd).ok_or(Error::new(EBADF))?,
|
|
Handle::SchemeRoot
|
|
) {
|
|
return Err(Error::new(EACCES));
|
|
}
|
|
if path.is_empty() {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
|
|
let handle = if path.starts_with("v") {
|
|
if !path.starts_with("v2/") {
|
|
return Err(Error::new(ENOENT));
|
|
}
|
|
let vt = path["v2/".len()..]
|
|
.parse::<usize>()
|
|
.map_err(|_| Error::new(EINVAL))?;
|
|
|
|
// Ensure the VT exists such that the rest of the methods can freely access it.
|
|
Self::get_or_create_vt(&mut self.adapter, &mut self.vts, vt);
|
|
|
|
Handle::V2 {
|
|
vt,
|
|
next_id: 0,
|
|
buffers: HashMap::new(),
|
|
}
|
|
} else {
|
|
let mut parts = path.split('/');
|
|
let mut screen = parts.next().unwrap_or("").split('.');
|
|
|
|
let vt = screen.next().unwrap_or("").parse::<usize>().unwrap();
|
|
let id = screen.next().unwrap_or("").parse::<usize>().unwrap_or(0);
|
|
|
|
if id >= self.adapter.display_count() {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
|
|
if !self.vts.contains_key(&vt) {
|
|
return Err(Error::new(ENOENT));
|
|
}
|
|
|
|
Handle::V1Screen { vt, screen: id }
|
|
};
|
|
self.next_id += 1;
|
|
self.handles.insert(self.next_id, handle);
|
|
Ok(OpenResult::ThisScheme {
|
|
number: self.next_id,
|
|
flags: NewFdFlags::empty(),
|
|
})
|
|
}
|
|
|
|
fn fpath(&mut self, id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> syscall::Result<usize> {
|
|
let path = match self.handles.get(&id).ok_or(Error::new(EBADF))? {
|
|
Handle::V1Screen { vt, screen } => {
|
|
let crtc_id = self.objects.crtc_ids()[*screen];
|
|
let crtc = self.objects.get_crtc(crtc_id).unwrap().lock().unwrap();
|
|
let (width, height) = crtc
|
|
.mode
|
|
.map_or((640, 480), |mode| (mode.hdisplay, mode.vdisplay));
|
|
format!("{}:{vt}.{screen}/{width}/{height}", self.scheme_name)
|
|
}
|
|
Handle::V2 {
|
|
vt,
|
|
next_id: _,
|
|
buffers: _,
|
|
} => format!("/scheme/{}/v2/{vt}", self.scheme_name),
|
|
Handle::SchemeRoot => return Err(Error::new(EOPNOTSUPP)),
|
|
};
|
|
buf[..path.len()].copy_from_slice(path.as_bytes());
|
|
Ok(path.len())
|
|
}
|
|
|
|
fn call(
|
|
&mut self,
|
|
id: usize,
|
|
payload: &mut [u8],
|
|
metadata: &[u64],
|
|
_ctx: &CallerCtx,
|
|
) -> Result<usize> {
|
|
use graphics_ipc::v2::ipc;
|
|
|
|
const DRM_FORMAT_ARGB8888: u32 = 0x34325241; // 'AR24' fourcc code, for ARGB8888
|
|
|
|
fn id_index(id: u32) -> u32 {
|
|
id & 0xFF
|
|
}
|
|
|
|
fn fb_id(i: u32) -> u32 {
|
|
id_index(i) | (1 << 11)
|
|
}
|
|
|
|
fn fb_handle_id(i: u32) -> u32 {
|
|
id_index(i) | (1 << 12)
|
|
}
|
|
|
|
fn plane_id(i: u32) -> u32 {
|
|
id_index(i) | (1 << 13)
|
|
}
|
|
|
|
match self.handles.get_mut(&id).ok_or(Error::new(EBADF))? {
|
|
Handle::V1Screen { .. } | Handle::SchemeRoot => return Err(Error::new(EOPNOTSUPP)),
|
|
Handle::V2 {
|
|
vt,
|
|
next_id,
|
|
buffers,
|
|
} => match metadata[0] {
|
|
ipc::VERSION => ipc::DrmVersion::with(payload, |mut data| {
|
|
data.set_version_major(1);
|
|
data.set_version_minor(4);
|
|
data.set_version_patchlevel(0);
|
|
|
|
data.set_name(unsafe { mem::transmute(self.adapter.name()) });
|
|
data.set_date(unsafe { mem::transmute(&b"0"[..]) });
|
|
data.set_desc(unsafe { mem::transmute(self.adapter.desc()) });
|
|
|
|
Ok(0)
|
|
}),
|
|
ipc::GET_CAP => ipc::DrmGetCap::with(payload, |mut data| {
|
|
data.set_value(
|
|
self.adapter.get_cap(
|
|
data.capability()
|
|
.try_into()
|
|
.map_err(|_| syscall::Error::new(EINVAL))?,
|
|
)?,
|
|
);
|
|
Ok(0)
|
|
}),
|
|
ipc::SET_CLIENT_CAP => ipc::DrmSetClientCap::with(payload, |data| {
|
|
self.adapter.set_client_cap(
|
|
data.capability()
|
|
.try_into()
|
|
.map_err(|_| syscall::Error::new(EINVAL))?,
|
|
data.value(),
|
|
)?;
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_CARD_RES => ipc::DrmModeCardRes::with(payload, |mut data| {
|
|
let count = self.adapter.display_count();
|
|
let conn_ids = self
|
|
.objects
|
|
.connector_ids()
|
|
.iter()
|
|
.map(|id| id.0)
|
|
.collect::<Vec<_>>();
|
|
let crtc_ids = self
|
|
.objects
|
|
.crtc_ids()
|
|
.iter()
|
|
.map(|id| id.0)
|
|
.collect::<Vec<_>>();
|
|
let enc_ids = self
|
|
.objects
|
|
.encoder_ids()
|
|
.iter()
|
|
.map(|id| id.0)
|
|
.collect::<Vec<_>>();
|
|
let mut fb_ids = Vec::with_capacity(count);
|
|
for i in 0..(count as u32) {
|
|
fb_ids.push(fb_id(i));
|
|
}
|
|
data.set_fb_id_ptr(&fb_ids);
|
|
data.set_crtc_id_ptr(&crtc_ids);
|
|
data.set_connector_id_ptr(&conn_ids);
|
|
data.set_encoder_id_ptr(&enc_ids);
|
|
data.set_min_width(0);
|
|
data.set_max_width(16384);
|
|
data.set_min_height(0);
|
|
data.set_max_height(16384);
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_CRTC => ipc::DrmModeCrtc::with(payload, |mut data| {
|
|
let crtc = self
|
|
.objects
|
|
.get_crtc(KmsObjectId(data.crtc_id()))?
|
|
.lock()
|
|
.unwrap();
|
|
// Don't touch set_connectors, that is only used by MODE_SET_CRTC
|
|
data.set_fb_id(crtc.fb_id.0);
|
|
// FIXME fill x and y with the data from the primary plane
|
|
data.set_x(0);
|
|
data.set_y(0);
|
|
data.set_gamma_size(crtc.gamma_size);
|
|
if let Some(mode) = crtc.mode {
|
|
data.set_mode_valid(1);
|
|
data.set_mode(mode);
|
|
} else {
|
|
data.set_mode_valid(0);
|
|
data.set_mode(Default::default());
|
|
}
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_CURSOR => ipc::DrmModeCursor::with(payload, |data| {
|
|
let vt_state = self.vts.get_mut(vt).unwrap();
|
|
|
|
let cursor_plane = &mut vt_state.cursor_plane;
|
|
|
|
let update_buffer = data.flags() & DRM_MODE_CURSOR_BO != 0;
|
|
if update_buffer {
|
|
cursor_plane.buffer = if data.handle() == 0 {
|
|
None
|
|
} else if let Some(buffer) = buffers.get(&data.handle()) {
|
|
Some(buffer.clone())
|
|
} else {
|
|
return Err(Error::new(EINVAL));
|
|
};
|
|
}
|
|
|
|
if data.flags() & DRM_MODE_CURSOR_MOVE != 0 {
|
|
cursor_plane.x = data.x();
|
|
cursor_plane.y = data.y();
|
|
}
|
|
|
|
self.adapter.handle_cursor(cursor_plane, update_buffer);
|
|
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_ENCODER => ipc::DrmModeGetEncoder::with(payload, |mut data| {
|
|
let encoder = self.objects.get_encoder(KmsObjectId(data.encoder_id()))?;
|
|
data.set_crtc_id(encoder.crtc_id.0);
|
|
data.set_possible_crtcs(encoder.possible_crtcs);
|
|
data.set_possible_clones(encoder.possible_clones);
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_CONNECTOR => ipc::DrmModeGetConnector::with(payload, |mut data| {
|
|
if data.count_modes() == 0 {
|
|
self.adapter.probe_connector(
|
|
&mut self.objects,
|
|
&self.standard_properties,
|
|
KmsObjectId(data.connector_id()),
|
|
);
|
|
}
|
|
let connector = self
|
|
.objects
|
|
.get_connector(KmsObjectId(data.connector_id()))?
|
|
.lock()
|
|
.unwrap();
|
|
data.set_encoders_ptr(&[connector.encoder_id.0]);
|
|
data.set_modes_ptr(&connector.modes);
|
|
let props = self
|
|
.objects
|
|
.get_object_properties(KmsObjectId(data.connector_id()))?
|
|
.lock()
|
|
.unwrap();
|
|
data.set_props_ptr(&props.iter().map(|&(id, _)| id.0).collect::<Vec<_>>());
|
|
data.set_prop_values_ptr(
|
|
&props.iter().map(|&(_, value)| value).collect::<Vec<_>>(),
|
|
);
|
|
data.set_connector_type(data.connector_type());
|
|
data.set_connector_type_id(data.connector_type_id());
|
|
data.set_connection(connector.connection as u32);
|
|
data.set_mm_width(connector.mm_width);
|
|
data.set_mm_height(connector.mm_width);
|
|
data.set_subpixel(connector.subpixel as u32);
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_PROPERTY => ipc::DrmModeGetProperty::with(payload, |mut data| {
|
|
let property = self.objects.get_property(KmsObjectId(data.prop_id()))?;
|
|
data.set_name(property.name);
|
|
let mut flags = 0;
|
|
if property.immutable {
|
|
flags |= DRM_MODE_PROP_IMMUTABLE;
|
|
}
|
|
if property.atomic {
|
|
flags |= DRM_MODE_PROP_ATOMIC;
|
|
}
|
|
match &property.kind {
|
|
&KmsPropertyKind::Range(start, end) => {
|
|
data.set_flags(flags | DRM_MODE_PROP_RANGE);
|
|
data.set_values_ptr(&[start, end]);
|
|
data.set_enum_blob_ptr(&[]);
|
|
}
|
|
KmsPropertyKind::Enum(variants) => {
|
|
data.set_flags(flags | DRM_MODE_PROP_ENUM);
|
|
data.set_values_ptr(
|
|
&variants.iter().map(|&(_, value)| value).collect::<Vec<_>>(),
|
|
);
|
|
data.set_enum_blob_ptr(
|
|
&variants
|
|
.iter()
|
|
.map(|&(name, value)| {
|
|
let mut name_bytes = [0; DRM_PROP_NAME_LEN as usize];
|
|
for (to, &from) in
|
|
name_bytes.iter_mut().zip(name.as_bytes())
|
|
{
|
|
*to = from as c_char;
|
|
}
|
|
drm_mode_property_enum {
|
|
name: name_bytes,
|
|
value,
|
|
}
|
|
})
|
|
.collect::<Vec<_>>(),
|
|
);
|
|
}
|
|
KmsPropertyKind::Blob => {
|
|
data.set_flags(flags | DRM_MODE_PROP_BLOB);
|
|
data.set_values_ptr(&[]);
|
|
data.set_enum_blob_ptr(&[]);
|
|
}
|
|
KmsPropertyKind::Bitmask(bitmask_flags) => {
|
|
data.set_flags(flags | DRM_MODE_PROP_BITMASK);
|
|
data.set_values_ptr(
|
|
&bitmask_flags
|
|
.iter()
|
|
.map(|&(_, value)| value)
|
|
.collect::<Vec<_>>(),
|
|
);
|
|
data.set_enum_blob_ptr(
|
|
&bitmask_flags
|
|
.iter()
|
|
.map(|&(name, value)| {
|
|
let mut name_bytes = [0; DRM_PROP_NAME_LEN as usize];
|
|
for (to, &from) in
|
|
name_bytes.iter_mut().zip(name.as_bytes())
|
|
{
|
|
*to = from as c_char;
|
|
}
|
|
drm_mode_property_enum {
|
|
name: name_bytes,
|
|
value,
|
|
}
|
|
})
|
|
.collect::<Vec<_>>(),
|
|
);
|
|
}
|
|
KmsPropertyKind::Object => {
|
|
data.set_flags(flags | DRM_MODE_PROP_OBJECT);
|
|
data.set_values_ptr(&[]);
|
|
data.set_enum_blob_ptr(&[]);
|
|
}
|
|
&KmsPropertyKind::SignedRange(start, end) => {
|
|
data.set_flags(flags | DRM_MODE_PROP_SIGNED_RANGE);
|
|
data.set_values_ptr(&[start as u64, end as u64]);
|
|
data.set_enum_blob_ptr(&[]);
|
|
}
|
|
}
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_PROP_BLOB => ipc::DrmModeGetBlob::with(payload, |mut data| {
|
|
let blob = self.objects.get_blob(KmsObjectId(data.blob_id()))?;
|
|
data.set_data(&blob);
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_FB => ipc::DrmModeFbCmd::with(payload, |mut data| {
|
|
let i = id_index(data.fb_id());
|
|
let (width, height) = self.adapter.display_size(i as usize);
|
|
data.set_width(width);
|
|
data.set_height(height);
|
|
data.set_pitch(width * 4); //TODO: stride
|
|
data.set_bpp(32);
|
|
data.set_depth(24);
|
|
data.set_handle(fb_handle_id(i));
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_ADD_FB => ipc::DrmModeFbCmd::with(payload, |mut data| {
|
|
data.set_fb_id(fb_handle_id(data.handle()));
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_CREATE_DUMB => ipc::DrmModeCreateDumb::with(payload, |mut data| {
|
|
if data.bpp() != 32 {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
|
|
let fb = self.adapter.create_dumb_buffer(data.width(), data.height());
|
|
|
|
*next_id += 1;
|
|
buffers.insert(*next_id, Arc::new(fb));
|
|
data.set_handle(*next_id as u32);
|
|
data.set_pitch(data.width() * 4);
|
|
data.set_size(u64::from(data.width()) * u64::from(data.height()) * 4);
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_MAP_DUMB => ipc::DrmModeMapDumb::with(payload, |mut data| {
|
|
if data.offset() != 0 {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
|
|
let buffer_id = data.handle();
|
|
|
|
if !buffers.contains_key(&buffer_id) {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
|
|
// FIXME use a better scheme for creating map offsets
|
|
assert!(
|
|
((buffers[&buffer_id].width() * buffers[&buffer_id].height() * 4) as usize)
|
|
< MAP_FAKE_OFFSET_MULTIPLIER
|
|
);
|
|
|
|
data.set_offset((buffer_id as usize * MAP_FAKE_OFFSET_MULTIPLIER) as u64);
|
|
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_DESTROY_DUMB => ipc::DrmModeDestroyDumb::with(payload, |data| {
|
|
if buffers.remove(&data.handle()).is_none() {
|
|
return Err(Error::new(ENOENT));
|
|
}
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_PLANE_RES => ipc::DrmModeGetPlaneRes::with(payload, |mut data| {
|
|
let count = self.adapter.display_count();
|
|
let mut ids = Vec::with_capacity(count);
|
|
for i in 0..(count as u32) {
|
|
ids.push(plane_id(i));
|
|
}
|
|
data.set_plane_id_ptr(&ids);
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_PLANE => ipc::DrmModeGetPlane::with(payload, |mut data| {
|
|
let i = id_index(data.plane_id());
|
|
data.set_crtc_id(self.objects.crtc_ids()[i as usize].0);
|
|
data.set_fb_id(fb_id(i));
|
|
data.set_possible_crtcs(1 << i);
|
|
data.set_format_type_ptr(&[DRM_FORMAT_ARGB8888]);
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_OBJ_GET_PROPERTIES => {
|
|
ipc::DrmModeObjGetProperties::with(payload, |mut data| {
|
|
// FIXME remove once all drm objects are materialized in self.objects
|
|
if data.obj_id() >= 1 << 11 {
|
|
data.set_props_ptr(&[]);
|
|
data.set_prop_values_ptr(&[]);
|
|
return Ok(0);
|
|
}
|
|
|
|
let props = self
|
|
.objects
|
|
.get_object_properties(KmsObjectId(data.obj_id()))?
|
|
.lock()
|
|
.unwrap();
|
|
data.set_props_ptr(&props.iter().map(|&(id, _)| id.0).collect::<Vec<_>>());
|
|
data.set_prop_values_ptr(
|
|
&props.iter().map(|&(_, value)| value).collect::<Vec<_>>(),
|
|
);
|
|
data.set_obj_type(self.objects.object_type(KmsObjectId(data.obj_id()))?);
|
|
Ok(0)
|
|
})
|
|
}
|
|
ipc::MODE_CURSOR2 => ipc::DrmModeCursor2::with(payload, |data| {
|
|
let vt_state = self.vts.get_mut(vt).unwrap();
|
|
|
|
let cursor_plane = &mut vt_state.cursor_plane;
|
|
|
|
let update_buffer = data.flags() & DRM_MODE_CURSOR_BO != 0;
|
|
if update_buffer {
|
|
cursor_plane.buffer = if data.handle() == 0 {
|
|
None
|
|
} else if let Some(buffer) = buffers.get(&data.handle()) {
|
|
Some(buffer.clone())
|
|
} else {
|
|
return Err(Error::new(EINVAL));
|
|
};
|
|
cursor_plane.hot_x = data.hot_x();
|
|
cursor_plane.hot_y = data.hot_y();
|
|
}
|
|
|
|
if data.flags() & DRM_MODE_CURSOR_MOVE != 0 {
|
|
cursor_plane.x = data.x();
|
|
cursor_plane.y = data.y();
|
|
}
|
|
|
|
self.adapter.handle_cursor(cursor_plane, update_buffer);
|
|
|
|
Ok(0)
|
|
}),
|
|
ipc::MODE_GET_FB2 => ipc::DrmModeFbCmd2::with(payload, |mut data| {
|
|
let i = id_index(data.fb_id());
|
|
let (width, height) = self.adapter.display_size(i as usize);
|
|
data.set_width(width);
|
|
data.set_height(height);
|
|
data.set_pixel_format(DRM_FORMAT_ARGB8888);
|
|
data.set_handles([fb_handle_id(i), 0, 0, 0]);
|
|
data.set_pitches([width * 4, 0, 0, 0]);
|
|
data.set_offsets([0; 4]);
|
|
data.set_modifier([0; 4]);
|
|
Ok(0)
|
|
}),
|
|
ipc::UPDATE_PLANE => {
|
|
if payload.len() < size_of::<ipc::UpdatePlane>() {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
let payload = unsafe {
|
|
transmute::<&mut [u8; size_of::<ipc::UpdatePlane>()], &mut ipc::UpdatePlane>(
|
|
payload.as_mut_array().unwrap(),
|
|
)
|
|
};
|
|
|
|
let display_id = payload.display_id;
|
|
let Some(crtc) = self.objects.crtcs().nth(display_id) else {
|
|
return Err(Error::new(EINVAL));
|
|
};
|
|
|
|
let framebuffer = if payload.fb_id == 0 {
|
|
None
|
|
} else if let Some(framebuffer) = buffers.get(&id_index(payload.fb_id)) {
|
|
Some(framebuffer)
|
|
} else {
|
|
return Err(Error::new(EINVAL));
|
|
};
|
|
|
|
self.vts.get_mut(vt).unwrap().display_fbs[display_id] =
|
|
framebuffer.map(Arc::clone);
|
|
|
|
if *vt == self.active_vt {
|
|
let mode = framebuffer.as_ref().map(|fb| {
|
|
KmsConnector::<()>::modeinfo_for_size(fb.width(), fb.height())
|
|
});
|
|
|
|
self.adapter.set_crtc(
|
|
&self.objects,
|
|
crtc,
|
|
&[self.objects.connector_ids()[display_id]],
|
|
mode,
|
|
framebuffer.map(|fb| &**fb),
|
|
payload.damage,
|
|
);
|
|
}
|
|
|
|
Ok(size_of::<ipc::UpdatePlane>())
|
|
}
|
|
_ => return Err(Error::new(EINVAL)),
|
|
},
|
|
}
|
|
}
|
|
|
|
fn mmap_prep(
|
|
&mut self,
|
|
id: usize,
|
|
offset: u64,
|
|
_size: usize,
|
|
_flags: MapFlags,
|
|
_ctx: &CallerCtx,
|
|
) -> syscall::Result<usize> {
|
|
// log::trace!("KSMSG MMAP {} {:?} {} {}", id, _flags, _offset, _size);
|
|
let (framebuffer, offset) = match self.handles.get(&id).ok_or(Error::new(EINVAL))? {
|
|
Handle::V2 {
|
|
vt: _,
|
|
next_id: _,
|
|
buffers,
|
|
} => (
|
|
buffers
|
|
.get(&((offset as usize / MAP_FAKE_OFFSET_MULTIPLIER) as u32))
|
|
.ok_or(Error::new(EINVAL))
|
|
.unwrap(),
|
|
offset & (MAP_FAKE_OFFSET_MULTIPLIER as u64 - 1),
|
|
),
|
|
Handle::V1Screen { .. } | Handle::SchemeRoot => return Err(Error::new(EOPNOTSUPP)),
|
|
};
|
|
let ptr = T::map_dumb_buffer(&mut self.adapter, framebuffer);
|
|
Ok(unsafe { ptr.add(offset as usize) } as usize)
|
|
}
|
|
}
|
|
|
|
impl<T: GraphicsAdapter> GraphicsSchemeInner<T> {
|
|
fn on_close(&mut self, id: usize) {
|
|
self.handles.remove(&id);
|
|
}
|
|
}
|