summaryrefslogtreecommitdiff
path: root/src/control/mod.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/control/mod.rs')
-rw-r--r--src/control/mod.rs1567
1 files changed, 1567 insertions, 0 deletions
diff --git a/src/control/mod.rs b/src/control/mod.rs
new file mode 100644
index 0000000..2b6f946
--- /dev/null
+++ b/src/control/mod.rs
@@ -0,0 +1,1567 @@
+//! Modesetting operations that the DRM subsystem exposes.
+//!
+//! # Summary
+//!
+//! The DRM subsystem provides Kernel Modesetting (KMS) functionality by
+//! exposing the following resource types:
+//!
+//! * FrameBuffer - Specific to an individual process, these wrap around generic
+//! GPU buffers so that they can be attached to a Plane.
+//!
+//! * Planes - Dedicated memory objects which contain a buffer that can then be
+//! scanned out by a CRTC. There exist a few different types of planes depending
+//! on the use case.
+//!
+//! * CRTC - Scanout engines that read pixel data from a Plane and sends it to
+//! a Connector. Each CRTC has at least one Primary Plane.
+//!
+//! * Connector - Represents the physical output, such as a DisplayPort or
+//! VGA connector.
+//!
+//! * Encoder - Encodes pixel data from a CRTC into something a Connector can
+//! understand.
+//!
+//! Further details on each resource can be found in their respective modules.
+//!
+//! # Usage
+//!
+//! To begin using modesetting functionality, the [`Device`] trait
+//! must be implemented on top of the basic [`super::Device`] trait.
+
+use drm_ffi as ffi;
+use drm_fourcc::{DrmFourcc, DrmModifier, UnrecognizedFourcc};
+
+use bytemuck::allocation::TransparentWrapperAlloc;
+use rustix::io::Errno;
+
+pub mod atomic;
+pub mod connector;
+pub mod crtc;
+pub mod dumbbuffer;
+pub mod encoder;
+pub mod framebuffer;
+pub mod plane;
+pub mod syncobj;
+
+pub mod property;
+
+use self::dumbbuffer::*;
+use crate::buffer;
+
+use super::util::*;
+
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::error;
+use std::fmt;
+use std::io;
+use std::iter::Zip;
+use std::mem;
+use std::ops::RangeBounds;
+use std::os::unix::io::{AsFd, BorrowedFd, FromRawFd, OwnedFd, RawFd};
+use std::time::Duration;
+
+use core::num::NonZeroU32;
+
+/// Raw handle for a drm resource
+pub type RawResourceHandle = NonZeroU32;
+
+/// Id of a Lease
+pub type LeaseId = NonZeroU32;
+
+/// Handle for a drm resource
+pub trait ResourceHandle:
+ From<RawResourceHandle> + Into<RawResourceHandle> + Into<u32> + Copy + Sized
+{
+ /// Associated encoded object type
+ const FFI_TYPE: u32;
+}
+
+/// Convert from a raw drm object value to a typed Handle
+///
+/// Note: This does no verification on the validity of the original value
+pub fn from_u32<T: From<RawResourceHandle>>(raw: u32) -> Option<T> {
+ RawResourceHandle::new(raw).map(T::from)
+}
+
+/// Error from [`Device::get_planar_framebuffer`]
+#[derive(Debug)]
+pub enum GetPlanarFramebufferError {
+ /// IO error
+ Io(io::Error),
+ /// Unrecognized fourcc format
+ UnrecognizedFourcc(drm_fourcc::UnrecognizedFourcc),
+}
+
+impl fmt::Display for GetPlanarFramebufferError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ Self::Io(err) => write!(f, "{}", err),
+ Self::UnrecognizedFourcc(err) => write!(f, "{}", err),
+ }
+ }
+}
+
+impl error::Error for GetPlanarFramebufferError {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ match self {
+ Self::Io(err) => Some(err),
+ Self::UnrecognizedFourcc(err) => Some(err),
+ }
+ }
+}
+
+impl From<io::Error> for GetPlanarFramebufferError {
+ fn from(err: io::Error) -> Self {
+ Self::Io(err)
+ }
+}
+
+impl From<UnrecognizedFourcc> for GetPlanarFramebufferError {
+ fn from(err: UnrecognizedFourcc) -> Self {
+ Self::UnrecognizedFourcc(err)
+ }
+}
+
+/// This trait should be implemented by any object that acts as a DRM device and
+/// provides modesetting functionality.
+///
+/// Like the parent [`super::Device`] trait, this crate does not
+/// provide a concrete object for this trait.
+///
+/// # Example
+/// ```ignore
+/// use drm::control::Device as ControlDevice;
+///
+/// /// Assuming the [`Card`] wrapper already implements [`drm::Device`]
+/// impl ControlDevice for Card {}
+/// ```
+pub trait Device: super::Device {
+ /// Gets the set of resource handles that this device currently controls
+ fn resource_handles(&self) -> io::Result<ResourceHandles> {
+ let mut fbs = Vec::new();
+ let mut crtcs = Vec::new();
+ let mut connectors = Vec::new();
+ let mut encoders = Vec::new();
+
+ let ffi_res = ffi::mode::get_resources(
+ self.as_fd(),
+ Some(&mut fbs),
+ Some(&mut crtcs),
+ Some(&mut connectors),
+ Some(&mut encoders),
+ )?;
+
+ let res = unsafe {
+ ResourceHandles {
+ fbs: transmute_vec_from_u32(fbs),
+ crtcs: transmute_vec_from_u32(crtcs),
+ connectors: transmute_vec_from_u32(connectors),
+ encoders: transmute_vec_from_u32(encoders),
+ width: (ffi_res.min_width, ffi_res.max_width),
+ height: (ffi_res.min_height, ffi_res.max_height),
+ }
+ };
+
+ Ok(res)
+ }
+
+ /// Gets the set of plane handles that this device currently has
+ fn plane_handles(&self) -> io::Result<Vec<plane::Handle>> {
+ let mut planes = Vec::new();
+ let _ = ffi::mode::get_plane_resources(self.as_fd(), Some(&mut planes))?;
+ Ok(unsafe { transmute_vec_from_u32(planes) })
+ }
+
+ /// Returns information about a specific connector
+ ///
+ /// ## Force-probing
+ ///
+ /// If `force_probe` is set to `true` and the DRM client is the current DRM master,
+ /// the kernel will perform a forced probe on the connector to refresh the connector status, modes and EDID.
+ /// A forced-probe can be slow, might cause flickering and the ioctl will block.
+ ///
+ /// - User needs to force-probe connectors to ensure their metadata is up-to-date at startup and after receiving a hot-plug event.
+ /// - User may perform a forced-probe when the user explicitly requests it.
+ /// - User shouldn’t perform a forced-probe in other situations.
+ fn get_connector(
+ &self,
+ handle: connector::Handle,
+ force_probe: bool,
+ ) -> io::Result<connector::Info> {
+ // Maximum number of encoders is 3 due to kernel restrictions
+ let mut encoders = Vec::new();
+ let mut modes = Vec::new();
+
+ let ffi_info = ffi::mode::get_connector(
+ self.as_fd(),
+ handle.into(),
+ None,
+ None,
+ Some(&mut modes),
+ Some(&mut encoders),
+ force_probe,
+ )?;
+
+ let connector = connector::Info {
+ handle,
+ interface: connector::Interface::from(ffi_info.connector_type),
+ interface_id: ffi_info.connector_type_id,
+ connection: connector::State::from(ffi_info.connection),
+ size: match (ffi_info.mm_width, ffi_info.mm_height) {
+ (0, 0) => None,
+ (x, y) => Some((x, y)),
+ },
+ modes: Mode::wrap_vec(modes),
+ encoders: unsafe { transmute_vec_from_u32(encoders) },
+ curr_enc: unsafe { mem::transmute(ffi_info.encoder_id) },
+ subpixel: connector::SubPixel::from_raw(ffi_info.subpixel),
+ };
+
+ Ok(connector)
+ }
+
+ /// Returns information about a specific encoder
+ fn get_encoder(&self, handle: encoder::Handle) -> io::Result<encoder::Info> {
+ let info = ffi::mode::get_encoder(self.as_fd(), handle.into())?;
+
+ let enc = encoder::Info {
+ handle,
+ enc_type: encoder::Kind::from(info.encoder_type),
+ crtc: from_u32(info.crtc_id),
+ pos_crtcs: info.possible_crtcs,
+ pos_clones: info.possible_clones,
+ };
+
+ Ok(enc)
+ }
+
+ /// Returns information about a specific CRTC
+ fn get_crtc(&self, handle: crtc::Handle) -> io::Result<crtc::Info> {
+ let info = ffi::mode::get_crtc(self.as_fd(), handle.into())?;
+
+ let crtc = crtc::Info {
+ handle,
+ position: (info.x, info.y),
+ mode: match info.mode_valid {
+ 0 => None,
+ _ => Some(Mode::from(info.mode)),
+ },
+ fb: from_u32(info.fb_id),
+ gamma_length: info.gamma_size,
+ };
+
+ Ok(crtc)
+ }
+
+ /// Set CRTC state
+ fn set_crtc(
+ &self,
+ handle: crtc::Handle,
+ framebuffer: Option<framebuffer::Handle>,
+ pos: (u32, u32),
+ conns: &[connector::Handle],
+ mode: Option<Mode>,
+ ) -> io::Result<()> {
+ let _info = ffi::mode::set_crtc(
+ self.as_fd(),
+ handle.into(),
+ framebuffer.map(Into::into).unwrap_or(0),
+ pos.0,
+ pos.1,
+ unsafe { &*(conns as *const _ as *const [u32]) },
+ mode.map(|m| m.into()),
+ )?;
+
+ Ok(())
+ }
+
+ /// Returns information about a specific framebuffer
+ fn get_framebuffer(&self, handle: framebuffer::Handle) -> io::Result<framebuffer::Info> {
+ let info = ffi::mode::get_framebuffer(self.as_fd(), handle.into())?;
+
+ let fb = framebuffer::Info {
+ handle,
+ size: (info.width, info.height),
+ pitch: info.pitch,
+ bpp: info.bpp,
+ depth: info.depth,
+ buffer: from_u32(info.handle),
+ };
+
+ Ok(fb)
+ }
+
+ /// Returns information about a specific framebuffer (with modifiers)
+ fn get_planar_framebuffer(
+ &self,
+ handle: framebuffer::Handle,
+ ) -> Result<framebuffer::PlanarInfo, GetPlanarFramebufferError> {
+ let info = ffi::mode::get_framebuffer2(self.as_fd(), handle.into())?;
+
+ let pixel_format = DrmFourcc::try_from(info.pixel_format)?;
+
+ let flags = FbCmd2Flags::from_bits_truncate(info.flags);
+ let modifier = flags
+ .contains(FbCmd2Flags::MODIFIERS)
+ .then(|| DrmModifier::from(info.modifier[0]));
+
+ let fb = framebuffer::PlanarInfo {
+ handle,
+ size: (info.width, info.height),
+ pixel_format,
+ flags,
+ buffers: bytemuck::cast(info.handles),
+ pitches: info.pitches,
+ offsets: info.offsets,
+ modifier,
+ };
+
+ Ok(fb)
+ }
+
+ /// Add a new framebuffer
+ fn add_framebuffer<B>(
+ &self,
+ buffer: &B,
+ depth: u32,
+ bpp: u32,
+ ) -> io::Result<framebuffer::Handle>
+ where
+ B: buffer::Buffer + ?Sized,
+ {
+ let (w, h) = buffer.size();
+ let info = ffi::mode::add_fb(
+ self.as_fd(),
+ w,
+ h,
+ buffer.pitch(),
+ bpp,
+ depth,
+ buffer.handle().into(),
+ )?;
+
+ Ok(from_u32(info.fb_id).unwrap())
+ }
+
+ /// Add framebuffer (with modifiers)
+ fn add_planar_framebuffer<B>(
+ &self,
+ planar_buffer: &B,
+ flags: FbCmd2Flags,
+ ) -> io::Result<framebuffer::Handle>
+ where
+ B: buffer::PlanarBuffer + ?Sized,
+ {
+ let modifier = planar_buffer.modifier();
+ let has_modifier = flags.contains(FbCmd2Flags::MODIFIERS);
+ assert!((has_modifier && modifier.is_some()) || (!has_modifier && modifier.is_none()));
+ let modifier = if let Some(modifier) = modifier {
+ u64::from(modifier)
+ } else {
+ 0
+ };
+
+ let (w, h) = planar_buffer.size();
+ let opt_handles = planar_buffer.handles();
+
+ let handles = bytemuck::cast(opt_handles);
+ let mods = [
+ opt_handles[0].map_or(0, |_| modifier),
+ opt_handles[1].map_or(0, |_| modifier),
+ opt_handles[2].map_or(0, |_| modifier),
+ opt_handles[3].map_or(0, |_| modifier),
+ ];
+
+ let info = ffi::mode::add_fb2(
+ self.as_fd(),
+ w,
+ h,
+ planar_buffer.format() as u32,
+ &handles,
+ &planar_buffer.pitches(),
+ &planar_buffer.offsets(),
+ &mods,
+ flags.bits(),
+ )?;
+
+ Ok(from_u32(info.fb_id).unwrap())
+ }
+
+ /// Mark parts of a framebuffer dirty
+ fn dirty_framebuffer(&self, handle: framebuffer::Handle, clips: &[ClipRect]) -> io::Result<()> {
+ ffi::mode::dirty_fb(self.as_fd(), handle.into(), unsafe {
+ // SAFETY: ClipRect is repr(transparent) for drm_clip_rect
+ core::slice::from_raw_parts(clips.as_ptr() as *const ffi::drm_clip_rect, clips.len())
+ })?;
+ Ok(())
+ }
+
+ /// Destroy a framebuffer
+ fn destroy_framebuffer(&self, handle: framebuffer::Handle) -> io::Result<()> {
+ ffi::mode::rm_fb(self.as_fd(), handle.into())
+ }
+
+ /// Returns information about a specific plane
+ fn get_plane(&self, handle: plane::Handle) -> io::Result<plane::Info> {
+ let mut formats = Vec::new();
+
+ let info = ffi::mode::get_plane(self.as_fd(), handle.into(), Some(&mut formats))?;
+
+ let plane = plane::Info {
+ handle,
+ crtc: from_u32(info.crtc_id),
+ fb: from_u32(info.fb_id),
+ pos_crtcs: info.possible_crtcs,
+ formats: unsafe { transmute_vec_from_u32(formats) },
+ };
+
+ Ok(plane)
+ }
+
+ /// Set plane state.
+ ///
+ /// Providing no framebuffer clears the plane.
+ fn set_plane(
+ &self,
+ handle: plane::Handle,
+ crtc: crtc::Handle,
+ framebuffer: Option<framebuffer::Handle>,
+ flags: u32,
+ crtc_rect: (i32, i32, u32, u32),
+ src_rect: (u32, u32, u32, u32),
+ ) -> io::Result<()> {
+ let _info = ffi::mode::set_plane(
+ self.as_fd(),
+ handle.into(),
+ crtc.into(),
+ framebuffer.map(Into::into).unwrap_or(0),
+ flags,
+ crtc_rect.0,
+ crtc_rect.1,
+ crtc_rect.2,
+ crtc_rect.3,
+ src_rect.0,
+ src_rect.1,
+ src_rect.2,
+ src_rect.3,
+ )?;
+
+ Ok(())
+ }
+
+ /// Returns information about a specific property.
+ fn get_property(&self, handle: property::Handle) -> io::Result<property::Info> {
+ let mut values = Vec::new();
+ let mut enums = Vec::new();
+
+ let info = ffi::mode::get_property(
+ self.as_fd(),
+ handle.into(),
+ Some(&mut values),
+ Some(&mut enums),
+ )?;
+
+ let flags = ModePropFlags::from_bits_truncate(info.flags);
+
+ let val_type = {
+ use self::property::ValueType;
+
+ if flags.contains(ModePropFlags::RANGE) {
+ let min = values[0];
+ let max = values[1];
+
+ match (min, max) {
+ (0, 1) => ValueType::Boolean,
+ (min, max) => ValueType::UnsignedRange(min, max),
+ }
+ } else if flags.contains(ModePropFlags::SIGNED_RANGE) {
+ let min = values[0];
+ let max = values[1];
+
+ ValueType::SignedRange(min as i64, max as i64)
+ } else if flags.contains(ModePropFlags::ENUM) {
+ let enum_values = self::property::EnumValues {
+ values,
+ enums: property::EnumValue::wrap_vec(enums),
+ };
+
+ ValueType::Enum(enum_values)
+ } else if flags.contains(ModePropFlags::BLOB) {
+ ValueType::Blob
+ } else if flags.contains(ModePropFlags::BITMASK) {
+ ValueType::Bitmask
+ } else if flags.contains(ModePropFlags::OBJECT) {
+ match values[0] as u32 {
+ ffi::DRM_MODE_OBJECT_CRTC => ValueType::CRTC,
+ ffi::DRM_MODE_OBJECT_CONNECTOR => ValueType::Connector,
+ ffi::DRM_MODE_OBJECT_ENCODER => ValueType::Encoder,
+ ffi::DRM_MODE_OBJECT_FB => ValueType::Framebuffer,
+ ffi::DRM_MODE_OBJECT_PLANE => ValueType::Plane,
+ ffi::DRM_MODE_OBJECT_PROPERTY => ValueType::Property,
+ ffi::DRM_MODE_OBJECT_BLOB => ValueType::Blob,
+ ffi::DRM_MODE_OBJECT_ANY => ValueType::Object,
+ _ => ValueType::Unknown,
+ }
+ } else {
+ ValueType::Unknown
+ }
+ };
+
+ let property = property::Info {
+ handle,
+ val_type,
+ mutable: !flags.contains(ModePropFlags::IMMUTABLE),
+ atomic: flags.contains(ModePropFlags::ATOMIC),
+ info,
+ };
+
+ Ok(property)
+ }
+
+ /// Sets a property for a specific resource.
+ fn set_property<T: ResourceHandle>(
+ &self,
+ handle: T,
+ prop: property::Handle,
+ value: property::RawValue,
+ ) -> io::Result<()> {
+ ffi::mode::set_property(self.as_fd(), prop.into(), handle.into(), T::FFI_TYPE, value)?;
+
+ Ok(())
+ }
+
+ /// Create a property blob value from a given data blob
+ fn create_property_blob<T>(&self, data: &T) -> io::Result<property::Value<'static>> {
+ let data = unsafe {
+ std::slice::from_raw_parts_mut(data as *const _ as *mut u8, mem::size_of::<T>())
+ };
+ let blob = ffi::mode::create_property_blob(self.as_fd(), data)?;
+
+ Ok(property::Value::Blob(blob.blob_id.into()))
+ }
+
+ /// Get a property blob's data
+ fn get_property_blob(&self, blob: u64) -> io::Result<Vec<u8>> {
+ let mut data = Vec::new();
+ let _ = ffi::mode::get_property_blob(self.as_fd(), blob as u32, Some(&mut data))?;
+ Ok(data)
+ }
+
+ /// Destroy a given property blob value
+ fn destroy_property_blob(&self, blob: u64) -> io::Result<()> {
+ ffi::mode::destroy_property_blob(self.as_fd(), blob as u32)?;
+
+ Ok(())
+ }
+
+ /// Returns the set of [`Mode`]s that a particular connector supports.
+ fn get_modes(&self, handle: connector::Handle) -> io::Result<Vec<Mode>> {
+ let mut modes = Vec::new();
+
+ let _ffi_info = ffi::mode::get_connector(
+ self.as_fd(),
+ handle.into(),
+ None,
+ None,
+ Some(&mut modes),
+ None,
+ false,
+ )?;
+
+ Ok(Mode::wrap_vec(modes))
+ }
+
+ /// Gets a list of property handles and values for this resource.
+ fn get_properties<T: ResourceHandle>(&self, handle: T) -> io::Result<PropertyValueSet> {
+ let mut prop_ids = Vec::new();
+ let mut prop_vals = Vec::new();
+
+ ffi::mode::get_properties(
+ self.as_fd(),
+ handle.into(),
+ T::FFI_TYPE,
+ Some(&mut prop_ids),
+ Some(&mut prop_vals),
+ )?;
+
+ let prop_val_set = PropertyValueSet {
+ prop_ids: unsafe { transmute_vec_from_u32(prop_ids) },
+ prop_vals,
+ };
+
+ Ok(prop_val_set)
+ }
+
+ /// Receive the currently set gamma ramp of a crtc
+ fn get_gamma(
+ &self,
+ crtc: crtc::Handle,
+ red: &mut [u16],
+ green: &mut [u16],
+ blue: &mut [u16],
+ ) -> io::Result<()> {
+ let crtc_info = self.get_crtc(crtc)?;
+ if crtc_info.gamma_length as usize > red.len()
+ || crtc_info.gamma_length as usize > green.len()
+ || crtc_info.gamma_length as usize > blue.len()
+ {
+ return Err(Errno::INVAL.into());
+ }
+
+ ffi::mode::get_gamma(
+ self.as_fd(),
+ crtc.into(),
+ crtc_info.gamma_length as usize,
+ red,
+ green,
+ blue,
+ )?;
+
+ Ok(())
+ }
+
+ /// Set a gamma ramp for the given crtc
+ fn set_gamma(
+ &self,
+ crtc: crtc::Handle,
+ red: &[u16],
+ green: &[u16],
+ blue: &[u16],
+ ) -> io::Result<()> {
+ let crtc_info = self.get_crtc(crtc)?;
+ if crtc_info.gamma_length as usize > red.len()
+ || crtc_info.gamma_length as usize > green.len()
+ || crtc_info.gamma_length as usize > blue.len()
+ {
+ return Err(Errno::INVAL.into());
+ }
+
+ ffi::mode::set_gamma(
+ self.as_fd(),
+ crtc.into(),
+ crtc_info.gamma_length as usize,
+ red,
+ green,
+ blue,
+ )?;
+
+ Ok(())
+ }
+
+ /// Open a GEM buffer handle by name
+ fn open_buffer(&self, name: buffer::Name) -> io::Result<buffer::Handle> {
+ let info = drm_ffi::gem::open(self.as_fd(), name.into())?;
+ Ok(from_u32(info.handle).unwrap())
+ }
+
+ /// Close a GEM buffer handle
+ fn close_buffer(&self, handle: buffer::Handle) -> io::Result<()> {
+ let _info = drm_ffi::gem::close(self.as_fd(), handle.into())?;
+ Ok(())
+ }
+
+ /// Create a new dumb buffer with a given size and pixel format
+ fn create_dumb_buffer(
+ &self,
+ size: (u32, u32),
+ format: buffer::DrmFourcc,
+ bpp: u32,
+ ) -> io::Result<DumbBuffer> {
+ let info = drm_ffi::mode::dumbbuffer::create(self.as_fd(), size.0, size.1, bpp, 0)?;
+
+ let dumb = DumbBuffer {
+ size: (info.width, info.height),
+ length: info.size as usize,
+ format,
+ pitch: info.pitch,
+ handle: from_u32(info.handle).unwrap(),
+ };
+
+ Ok(dumb)
+ }
+ /// Map the buffer for access
+ fn map_dumb_buffer<'a>(&self, buffer: &'a mut DumbBuffer) -> io::Result<DumbMapping<'a>> {
+ let info = drm_ffi::mode::dumbbuffer::map(self.as_fd(), buffer.handle.into(), 0, 0)?;
+
+ let map = {
+ use rustix::mm;
+ let prot = mm::ProtFlags::READ | mm::ProtFlags::WRITE;
+ let flags = mm::MapFlags::SHARED;
+ let fd = self.as_fd();
+ let offset = info.offset as _;
+ unsafe { mm::mmap(std::ptr::null_mut(), buffer.length, prot, flags, fd, offset)? }
+ };
+
+ let mapping = DumbMapping {
+ _phantom: std::marker::PhantomData,
+ map: unsafe { std::slice::from_raw_parts_mut(map as *mut _, buffer.length) },
+ };
+
+ Ok(mapping)
+ }
+
+ /// Free the memory resources of a dumb buffer
+ fn destroy_dumb_buffer(&self, buffer: DumbBuffer) -> io::Result<()> {
+ let _info = drm_ffi::mode::dumbbuffer::destroy(self.as_fd(), buffer.handle.into())?;
+
+ Ok(())
+ }
+
+ /// Sets a hardware-cursor on the given crtc with the image of a given buffer
+ ///
+ /// A buffer argument of [`None`] will clear the cursor.
+ #[deprecated(note = "Usage of deprecated ioctl set_cursor: use a cursor plane instead")]
+ #[allow(deprecated)]
+ fn set_cursor<B>(&self, crtc: crtc::Handle, buffer: Option<&B>) -> io::Result<()>
+ where
+ B: buffer::Buffer + ?Sized,
+ {
+ let (id, w, h) = buffer
+ .map(|buf| {
+ let (w, h) = buf.size();
+ (buf.handle().into(), w, h)
+ })
+ .unwrap_or((0, 0, 0));
+ drm_ffi::mode::set_cursor(self.as_fd(), crtc.into(), id, w, h)?;
+
+ Ok(())
+ }
+
+ /// Sets a hardware-cursor on the given crtc with the image of a given buffer
+ /// and a hotspot marking the click point of the cursor.
+ ///
+ /// A buffer argument of [`None`] will clear the cursor.
+ #[deprecated(note = "Usage of deprecated ioctl set_cursor2: use a cursor plane instead")]
+ #[allow(deprecated)]
+ fn set_cursor2<B>(
+ &self,
+ crtc: crtc::Handle,
+ buffer: Option<&B>,
+ hotspot: (i32, i32),
+ ) -> io::Result<()>
+ where
+ B: buffer::Buffer + ?Sized,
+ {
+ let (id, w, h) = buffer
+ .map(|buf| {
+ let (w, h) = buf.size();
+ (buf.handle().into(), w, h)
+ })
+ .unwrap_or((0, 0, 0));
+ drm_ffi::mode::set_cursor2(self.as_fd(), crtc.into(), id, w, h, hotspot.0, hotspot.1)?;
+
+ Ok(())
+ }
+
+ /// Moves a set cursor on a given crtc
+ #[deprecated(note = "Usage of deprecated ioctl move_cursor: use a cursor plane instead")]
+ #[allow(deprecated)]
+ fn move_cursor(&self, crtc: crtc::Handle, pos: (i32, i32)) -> io::Result<()> {
+ drm_ffi::mode::move_cursor(self.as_fd(), crtc.into(), pos.0, pos.1)?;
+
+ Ok(())
+ }
+
+ /// Request an atomic commit with given flags and property-value pair for a list of objects.
+ fn atomic_commit(
+ &self,
+ flags: AtomicCommitFlags,
+ mut req: atomic::AtomicModeReq,
+ ) -> io::Result<()> {
+ drm_ffi::mode::atomic_commit(
+ self.as_fd(),
+ flags.bits(),
+ unsafe { &mut *(&mut *req.objects as *mut _ as *mut [u32]) },
+ &mut req.count_props_per_object,
+ unsafe { &mut *(&mut *req.props as *mut _ as *mut [u32]) },
+ &mut req.values,
+ )
+ }
+
+ /// Convert a prime file descriptor to a GEM buffer handle
+ fn prime_fd_to_buffer(&self, fd: BorrowedFd<'_>) -> io::Result<buffer::Handle> {
+ let info = ffi::gem::fd_to_handle(self.as_fd(), fd)?;
+ Ok(from_u32(info.handle).unwrap())
+ }
+
+ /// Convert a GEM buffer handle to a prime file descriptor
+ fn buffer_to_prime_fd(&self, handle: buffer::Handle, flags: u32) -> io::Result<OwnedFd> {
+ let info = ffi::gem::handle_to_fd(self.as_fd(), handle.into(), flags)?;
+ Ok(unsafe { OwnedFd::from_raw_fd(info.fd) })
+ }
+
+ /// Queue a page flip on the given crtc
+ fn page_flip(
+ &self,
+ handle: crtc::Handle,
+ framebuffer: framebuffer::Handle,
+ flags: PageFlipFlags,
+ target_sequence: Option<PageFlipTarget>,
+ ) -> io::Result<()> {
+ let mut flags = flags.bits();
+
+ let sequence = match target_sequence {
+ Some(PageFlipTarget::Absolute(n)) => {
+ flags |= ffi::drm_sys::DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE;
+ n
+ }
+ Some(PageFlipTarget::Relative(n)) => {
+ flags |= ffi::drm_sys::DRM_MODE_PAGE_FLIP_TARGET_RELATIVE;
+ n
+ }
+ None => 0,
+ };
+
+ ffi::mode::page_flip(
+ self.as_fd(),
+ handle.into(),
+ framebuffer.into(),
+ flags,
+ sequence,
+ )?;
+
+ Ok(())
+ }
+
+ /// Creates a syncobj.
+ fn create_syncobj(&self, signalled: bool) -> io::Result<syncobj::Handle> {
+ let info = ffi::syncobj::create(self.as_fd(), signalled)?;
+ Ok(from_u32(info.handle).unwrap())
+ }
+
+ /// Destroys a syncobj.
+ fn destroy_syncobj(&self, handle: syncobj::Handle) -> io::Result<()> {
+ ffi::syncobj::destroy(self.as_fd(), handle.into())?;
+ Ok(())
+ }
+
+ /// Exports a syncobj as an inter-process file descriptor or as a poll()-able sync file.
+ fn syncobj_to_fd(
+ &self,
+ handle: syncobj::Handle,
+ export_sync_file: bool,
+ ) -> io::Result<OwnedFd> {
+ let info = ffi::syncobj::handle_to_fd(self.as_fd(), handle.into(), export_sync_file)?;
+ Ok(unsafe { OwnedFd::from_raw_fd(info.fd) })
+ }
+
+ /// Imports a file descriptor exported by [`Self::syncobj_to_fd`] back into a process-local handle.
+ fn fd_to_syncobj(
+ &self,
+ fd: BorrowedFd<'_>,
+ import_sync_file: bool,
+ ) -> io::Result<syncobj::Handle> {
+ let info = ffi::syncobj::fd_to_handle(self.as_fd(), fd, import_sync_file)?;
+ Ok(from_u32(info.handle).unwrap())
+ }
+
+ /// Waits for one or more syncobjs to become signalled.
+ fn syncobj_wait(
+ &self,
+ handles: &[syncobj::Handle],
+ timeout_nsec: i64,
+ wait_all: bool,
+ wait_for_submit: bool,
+ ) -> io::Result<u32> {
+ let info = ffi::syncobj::wait(
+ self.as_fd(),
+ bytemuck::cast_slice(handles),
+ timeout_nsec,
+ wait_all,
+ wait_for_submit,
+ )?;
+ Ok(info.first_signaled)
+ }
+
+ /// Resets (un-signals) one or more syncobjs.
+ fn syncobj_reset(&self, handles: &[syncobj::Handle]) -> io::Result<()> {
+ ffi::syncobj::reset(self.as_fd(), bytemuck::cast_slice(handles))?;
+ Ok(())
+ }
+
+ /// Signals one or more syncobjs.
+ fn syncobj_signal(&self, handles: &[syncobj::Handle]) -> io::Result<()> {
+ ffi::syncobj::signal(self.as_fd(), bytemuck::cast_slice(handles))?;
+ Ok(())
+ }
+
+ /// Waits for one or more specific timeline syncobj points.
+ fn syncobj_timeline_wait(
+ &self,
+ handles: &[syncobj::Handle],
+ points: &[u64],
+ timeout_nsec: i64,
+ wait_all: bool,
+ wait_for_submit: bool,
+ wait_available: bool,
+ ) -> io::Result<u32> {
+ let info = ffi::syncobj::timeline_wait(
+ self.as_fd(),
+ bytemuck::cast_slice(handles),
+ points,
+ timeout_nsec,
+ wait_all,
+ wait_for_submit,
+ wait_available,
+ )?;
+ Ok(info.first_signaled)
+ }
+
+ /// Queries for state of one or more timeline syncobjs.
+ fn syncobj_timeline_query(
+ &self,
+ handles: &[syncobj::Handle],
+ points: &mut [u64],
+ last_submitted: bool,
+ ) -> io::Result<()> {
+ ffi::syncobj::query(
+ self.as_fd(),
+ bytemuck::cast_slice(handles),
+ points,
+ last_submitted,
+ )?;
+ Ok(())
+ }
+
+ /// Transfers one timeline syncobj point to another.
+ fn syncobj_timeline_transfer(
+ &self,
+ src_handle: syncobj::Handle,
+ dst_handle: syncobj::Handle,
+ src_point: u64,
+ dst_point: u64,
+ ) -> io::Result<()> {
+ ffi::syncobj::transfer(
+ self.as_fd(),
+ src_handle.into(),
+ dst_handle.into(),
+ src_point,
+ dst_point,
+ )?;
+ Ok(())
+ }
+
+ /// Signals one or more specific timeline syncobj points.
+ fn syncobj_timeline_signal(
+ &self,
+ handles: &[syncobj::Handle],
+ points: &[u64],
+ ) -> io::Result<()> {
+ ffi::syncobj::timeline_signal(self.as_fd(), bytemuck::cast_slice(handles), points)?;
+ Ok(())
+ }
+
+ /// Create a drm lease
+ fn create_lease(
+ &self,
+ objects: &[RawResourceHandle],
+ flags: u32,
+ ) -> io::Result<(LeaseId, OwnedFd)> {
+ let lease = ffi::mode::create_lease(self.as_fd(), bytemuck::cast_slice(objects), flags)?;
+ Ok((
+ unsafe { NonZeroU32::new_unchecked(lease.lessee_id) },
+ unsafe { OwnedFd::from_raw_fd(lease.fd as RawFd) },
+ ))
+ }
+
+ /// List active lessees
+ fn list_lessees(&self) -> io::Result<Vec<LeaseId>> {
+ let mut lessees = Vec::new();
+ ffi::mode::list_lessees(self.as_fd(), Some(&mut lessees))?;
+ Ok(unsafe { transmute_vec_from_u32(lessees) })
+ }
+
+ /// Revoke a previously issued drm lease
+ fn revoke_lease(&self, lessee_id: LeaseId) -> io::Result<()> {
+ ffi::mode::revoke_lease(self.as_fd(), lessee_id.get())
+ }
+
+ /// Receive pending events
+ fn receive_events(&self) -> io::Result<Events>
+ where
+ Self: Sized,
+ {
+ let mut event_buf: [u8; 1024] = [0; 1024];
+ let amount = rustix::io::read(self.as_fd(), &mut event_buf)?;
+
+ Ok(Events::with_event_buf(event_buf, amount))
+ }
+}
+
+/// List of leased resources
+pub struct LeaseResources {
+ /// leased crtcs
+ pub crtcs: Vec<crtc::Handle>,
+ /// leased connectors
+ pub connectors: Vec<connector::Handle>,
+ /// leased planes
+ pub planes: Vec<plane::Handle>,
+}
+
+/// Query lease resources
+pub fn get_lease<D: AsFd>(lease: D) -> io::Result<LeaseResources> {
+ let mut crtcs = Vec::new();
+ let mut connectors = Vec::new();
+ let mut planes = Vec::new();
+ let mut objects = Vec::new();
+
+ ffi::mode::get_lease(lease.as_fd(), Some(&mut objects))?;
+
+ let _ = ffi::mode::get_resources(
+ lease.as_fd(),
+ None,
+ Some(&mut crtcs),
+ Some(&mut connectors),
+ None,
+ )?;
+ let _ = ffi::mode::get_plane_resources(lease.as_fd(), Some(&mut planes))?;
+
+ unsafe {
+ Ok(LeaseResources {
+ crtcs: transmute_vec_from_u32::<crtc::Handle>(
+ crtcs
+ .into_iter()
+ .filter(|handle| objects.contains(handle))
+ .collect(),
+ ),
+ connectors: transmute_vec_from_u32::<connector::Handle>(
+ connectors
+ .into_iter()
+ .filter(|handle| objects.contains(handle))
+ .collect(),
+ ),
+ planes: transmute_vec_from_u32::<plane::Handle>(
+ planes
+ .into_iter()
+ .filter(|handle| objects.contains(handle))
+ .collect(),
+ ),
+ })
+ }
+}
+
+bitflags::bitflags! {
+ /// Flags to alter the behaviour of a page flip
+ ///
+ /// Limited to the values in [`ffi::drm_sys::DRM_MODE_PAGE_FLIP_FLAGS`],
+ /// minus [`ffi::drm_sys::DRM_MODE_PAGE_FLIP_TARGET`] bits which are
+ /// passed through [`PageFlipTarget`].
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+ pub struct PageFlipFlags : u32 {
+ /// Request a vblank event on page flip
+ const EVENT = ffi::drm_sys::DRM_MODE_PAGE_FLIP_EVENT;
+ /// Request page flip as soon as possible, not waiting for vblank
+ const ASYNC = ffi::drm_sys::DRM_MODE_PAGE_FLIP_ASYNC;
+ }
+}
+
+/// Target to alter the sequence of page flips
+///
+/// These represent the [`ffi::drm_sys::DRM_MODE_PAGE_FLIP_TARGET`] bits
+/// of [`PageFlipFlags`] wrapped in a regular `enum` due to their
+/// mutual-exclusiveness.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum PageFlipTarget {
+ /// Absolute Vblank Sequence
+ Absolute(u32),
+ /// Relative Vblank Sequence (to the current, when calling)
+ Relative(u32),
+}
+
+/// Iterator over [`Event`]s of a device. Create via [`Device::receive_events()`].
+pub struct Events {
+ event_buf: [u8; 1024],
+ amount: usize,
+ i: usize,
+}
+
+impl Events {
+ /// Create [`Event`]s iterator from buffer read using something other than
+ /// [`Device::receive_events()`].
+ pub fn with_event_buf(event_buf: [u8; 1024], amount: usize) -> Self {
+ Events {
+ event_buf,
+ amount,
+ i: 0,
+ }
+ }
+}
+
+/// An event from a device.
+pub enum Event {
+ /// A vblank happened
+ Vblank(VblankEvent),
+ /// A page flip happened
+ PageFlip(PageFlipEvent),
+ /// Unknown event, raw data provided
+ Unknown(Vec<u8>),
+}
+
+/// Vblank event
+pub struct VblankEvent {
+ /// sequence of the frame
+ pub frame: u32,
+ /// time at which the vblank occurred
+ pub time: Duration,
+ /// crtc that did throw the event
+ pub crtc: crtc::Handle,
+ /// user data that was passed to wait_vblank
+ pub user_data: usize,
+}
+
+/// Page Flip event
+pub struct PageFlipEvent {
+ /// sequence of the frame
+ pub frame: u32,
+ /// duration between events
+ pub duration: Duration,
+ /// crtc that did throw the event
+ pub crtc: crtc::Handle,
+}
+
+impl Iterator for Events {
+ type Item = Event;
+
+ fn next(&mut self) -> Option<Event> {
+ if self.amount > 0 && self.i < self.amount {
+ let event = unsafe { &*(self.event_buf.as_ptr().add(self.i) as *const ffi::drm_event) };
+ self.i += event.length as usize;
+ match event.type_ {
+ ffi::DRM_EVENT_VBLANK => {
+ let vblank_event =
+ unsafe { &*(event as *const _ as *const ffi::drm_event_vblank) };
+ Some(Event::Vblank(VblankEvent {
+ frame: vblank_event.sequence,
+ time: Duration::new(
+ vblank_event.tv_sec as u64,
+ vblank_event.tv_usec * 1000,
+ ),
+ #[allow(clippy::unnecessary_cast)]
+ crtc: from_u32(vblank_event.crtc_id as u32).unwrap(),
+ user_data: vblank_event.user_data as usize,
+ }))
+ }
+ ffi::DRM_EVENT_FLIP_COMPLETE => {
+ let vblank_event =
+ unsafe { &*(event as *const _ as *const ffi::drm_event_vblank) };
+ Some(Event::PageFlip(PageFlipEvent {
+ frame: vblank_event.sequence,
+ duration: Duration::new(
+ vblank_event.tv_sec as u64,
+ vblank_event.tv_usec * 1000,
+ ),
+ crtc: from_u32(if vblank_event.crtc_id != 0 {
+ vblank_event.crtc_id
+ } else {
+ vblank_event.user_data as u32
+ })
+ .unwrap(),
+ }))
+ }
+ _ => Some(Event::Unknown(
+ self.event_buf[self.i - (event.length as usize)..self.i].to_vec(),
+ )),
+ }
+ } else {
+ None
+ }
+ }
+}
+
+/// The set of [`ResourceHandles`] that a
+/// [`Device`] exposes. Excluding Plane resources.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct ResourceHandles {
+ /// Set of [`framebuffer::Handle`]
+ pub fbs: Vec<framebuffer::Handle>,
+ /// Set of [`crtc::Handle`]
+ pub crtcs: Vec<crtc::Handle>,
+ /// Set of [`connector::Handle`]
+ pub connectors: Vec<connector::Handle>,
+ /// Set of [`encoder::Handle`]
+ pub encoders: Vec<encoder::Handle>,
+ width: (u32, u32),
+ height: (u32, u32),
+}
+
+impl ResourceHandles {
+ /// Returns the set of [`connector::Handle`]
+ pub fn connectors(&self) -> &[connector::Handle] {
+ &self.connectors
+ }
+
+ /// Returns the set of [`encoder::Handle`]
+ pub fn encoders(&self) -> &[encoder::Handle] {
+ &self.encoders
+ }
+
+ /// Returns the set of [`crtc::Handle`]
+ pub fn crtcs(&self) -> &[crtc::Handle] {
+ &self.crtcs
+ }
+
+ /// Returns the set of [`framebuffer::Handle`]
+ pub fn framebuffers(&self) -> &[framebuffer::Handle] {
+ &self.fbs
+ }
+
+ /// Returns the supported minimum and maximum width for framebuffers
+ pub fn supported_fb_width(&self) -> impl RangeBounds<u32> {
+ self.width.0..=self.width.1
+ }
+
+ /// Returns the supported minimum and maximum height for framebuffers
+ pub fn supported_fb_height(&self) -> impl RangeBounds<u32> {
+ self.height.0..=self.height.1
+ }
+
+ /// Apply a filter the all crtcs of these resources, resulting in a list of crtcs allowed.
+ pub fn filter_crtcs(&self, filter: CrtcListFilter) -> Vec<crtc::Handle> {
+ self.crtcs
+ .iter()
+ .enumerate()
+ .filter(|&(n, _)| (1 << n) & filter.0 != 0)
+ .map(|(_, &e)| e)
+ .collect()
+ }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// A filter that can be used with a [`ResourceHandles`] to determine the set of
+/// Crtcs that can attach to a specific encoder.
+pub struct CrtcListFilter(u32);
+
+/// Resolution and timing information for a display mode.
+#[repr(transparent)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq, bytemuck::TransparentWrapper)]
+pub struct Mode {
+ // We're using the FFI struct because the DRM API expects it when giving it
+ // to a CRTC or creating a blob from it. Rather than rearranging the fields
+ // to convert to/from an abstracted type, just use the raw object.
+ mode: ffi::drm_mode_modeinfo,
+}
+
+impl Mode {
+ /// Returns the name of this mode.
+ pub fn name(&self) -> &std::ffi::CStr {
+ unsafe { std::ffi::CStr::from_ptr(&self.mode.name[0] as _) }
+ }
+
+ /// Returns the clock speed of this mode.
+ pub fn clock(&self) -> u32 {
+ self.mode.clock
+ }
+
+ /// Returns the size (resolution) of the mode.
+ pub fn size(&self) -> (u16, u16) {
+ (self.mode.hdisplay, self.mode.vdisplay)
+ }
+
+ /// Returns the horizontal sync start, end, and total.
+ pub fn hsync(&self) -> (u16, u16, u16) {
+ (self.mode.hsync_start, self.mode.hsync_end, self.mode.htotal)
+ }
+
+ /// Returns the vertical sync start, end, and total.
+ pub fn vsync(&self) -> (u16, u16, u16) {
+ (self.mode.vsync_start, self.mode.vsync_end, self.mode.vtotal)
+ }
+
+ /// Returns the horizontal skew of this mode.
+ pub fn hskew(&self) -> u16 {
+ self.mode.hskew
+ }
+
+ /// Returns the vertical scan of this mode.
+ pub fn vscan(&self) -> u16 {
+ self.mode.vscan
+ }
+
+ /// Returns the vertical refresh rate of this mode
+ pub fn vrefresh(&self) -> u32 {
+ self.mode.vrefresh
+ }
+
+ /// Returns the bitmask of this mode
+ pub fn mode_type(&self) -> ModeTypeFlags {
+ ModeTypeFlags::from_bits_truncate(self.mode.type_)
+ }
+
+ /// Returns the flags of this mode
+ pub fn flags(&self) -> ModeFlags {
+ ModeFlags::from_bits_truncate(self.mode.flags)
+ }
+}
+
+impl From<ffi::drm_mode_modeinfo> for Mode {
+ fn from(raw: ffi::drm_mode_modeinfo) -> Mode {
+ Mode { mode: raw }
+ }
+}
+
+impl From<Mode> for ffi::drm_mode_modeinfo {
+ fn from(mode: Mode) -> Self {
+ mode.mode
+ }
+}
+
+impl fmt::Debug for Mode {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_struct("Mode")
+ .field("name", &self.name())
+ .field("clock", &self.clock())
+ .field("size", &self.size())
+ .field("hsync", &self.hsync())
+ .field("vsync", &self.vsync())
+ .field("hskew", &self.hskew())
+ .field("vscan", &self.vscan())
+ .field("vrefresh", &self.vrefresh())
+ .field("mode_type", &self.mode_type())
+ .finish()
+ }
+}
+
+bitflags::bitflags! {
+ /// Display mode type flags
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+ pub struct ModeTypeFlags : u32 {
+ /// Builtin mode type
+ #[deprecated]
+ const BUILTIN = ffi::DRM_MODE_TYPE_BUILTIN;
+ /// CLOCK_C mode type
+ #[deprecated]
+ const CLOCK_C = ffi::DRM_MODE_TYPE_CLOCK_C;
+ /// CRTC_C mode type
+ #[deprecated]
+ const CRTC_C = ffi::DRM_MODE_TYPE_CRTC_C;
+ /// Preferred mode
+ const PREFERRED = ffi::DRM_MODE_TYPE_PREFERRED;
+ /// Default mode
+ #[deprecated]
+ const DEFAULT = ffi::DRM_MODE_TYPE_DEFAULT;
+ /// User defined mode type
+ const USERDEF = ffi::DRM_MODE_TYPE_USERDEF;
+ /// Mode created by driver
+ const DRIVER = ffi::DRM_MODE_TYPE_DRIVER;
+ /// Bitmask of all valid (non-deprecated) mode type flags
+ const ALL = ffi::DRM_MODE_TYPE_ALL;
+ }
+}
+
+bitflags::bitflags! {
+ /// Display mode flags
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+ pub struct ModeFlags: u32 {
+ /// PHSYNC flag
+ const PHSYNC = ffi::DRM_MODE_FLAG_PHSYNC;
+ /// NHSYNC flag
+ const NHSYNC = ffi::DRM_MODE_FLAG_NHSYNC;
+ /// PVSYNC flag
+ const PVSYNC = ffi::DRM_MODE_FLAG_PVSYNC;
+ /// NVSYNC flag
+ const NVSYNC = ffi::DRM_MODE_FLAG_NVSYNC;
+ /// Interlace flag
+ const INTERLACE = ffi::DRM_MODE_FLAG_INTERLACE;
+ /// DBLSCAN flag
+ const DBLSCAN = ffi::DRM_MODE_FLAG_DBLSCAN;
+ /// CSYNC flag
+ const CSYNC = ffi::DRM_MODE_FLAG_CSYNC;
+ /// PCSYNC flag
+ const PCSYNC = ffi::DRM_MODE_FLAG_PCSYNC;
+ /// NCSYNC flag
+ const NCSYNC = ffi::DRM_MODE_FLAG_NCSYNC;
+ /// HSKEW flag
+ const HSKEW = ffi::DRM_MODE_FLAG_HSKEW;
+ #[deprecated]
+ /// BCAST flag
+ const BCAST = ffi::DRM_MODE_FLAG_BCAST;
+ #[deprecated]
+ /// PIXMUX flag
+ const PIXMUX = ffi::DRM_MODE_FLAG_PIXMUX;
+ /// DBLCLK flag
+ const DBLCLK = ffi::DRM_MODE_FLAG_DBLCLK;
+ /// CLKDIV2 flag
+ const CLKDIV2 = ffi::DRM_MODE_FLAG_CLKDIV2;
+ /// Stereo 3D mode utilizing frame packing
+ const _3D_FRAME_PACKING = ffi::DRM_MODE_FLAG_3D_FRAME_PACKING;
+ /// Stereo 3D mode utilizing alternating fields
+ const _3D_FIELD_ALTERNATIVE = ffi::DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE;
+ /// Stereo 3D mode utilizing alternating lines
+ const _3D_LINE_ALTERNATIVE = ffi::DRM_MODE_FLAG_3D_LINE_ALTERNATIVE;
+ /// Stereo 3D mode utilizing side by side full size image
+ const _3D_SIDE_BY_SIDE_FULL = ffi::DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL;
+ /// Stereo 3D mode utilizing depth images
+ const _3D_L_DEPTH = ffi::DRM_MODE_FLAG_3D_L_DEPTH;
+ /// Stereo 3D mode utilizing depth images
+ const _3D_L_DEPTH_GFX_GFX_DEPTH = ffi::DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH;
+ /// Stereo 3D mode utilizing top and bottom images
+ const _3D_TOP_AND_BOTTOM = ffi::DRM_MODE_FLAG_3D_TOP_AND_BOTTOM;
+ /// Stereo 3D mode utilizing side by side half size image
+ const _3D_SIDE_BY_SIDE_HALF = ffi::DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF;
+ }
+}
+
+/// Type of a plane
+#[repr(u32)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum PlaneType {
+ /// Overlay plane
+ Overlay = ffi::DRM_PLANE_TYPE_OVERLAY,
+ /// Primary plane
+ Primary = ffi::DRM_PLANE_TYPE_PRIMARY,
+ /// Cursor plane
+ Cursor = ffi::DRM_PLANE_TYPE_CURSOR,
+}
+
+/// Wrapper around a set of property IDs and their raw values.
+#[derive(Debug, Clone)]
+pub struct PropertyValueSet {
+ prop_ids: Vec<property::Handle>,
+ prop_vals: Vec<property::RawValue>,
+}
+
+impl PropertyValueSet {
+ /// Returns a HashMap mapping property names to info
+ pub fn as_hashmap(&self, device: &impl Device) -> io::Result<HashMap<String, property::Info>> {
+ let mut map = HashMap::new();
+ for id in self.prop_ids.iter() {
+ let info = device.get_property(*id)?;
+ let name = info.name().to_str().unwrap().to_owned();
+ map.insert(name, info);
+ }
+ Ok(map)
+ }
+
+ /// Returns a pair representing a set of [`property::Handle`] and their raw values
+ pub fn as_props_and_values(&self) -> (&[property::Handle], &[property::RawValue]) {
+ (&self.prop_ids, &self.prop_vals)
+ }
+
+ /// Returns iterator over pairs representing a set of [`property::Handle`] and their raw values
+ pub fn iter(&self) -> impl Iterator<Item = (&property::Handle, &property::RawValue)> {
+ self.into_iter()
+ }
+}
+
+impl<'a> IntoIterator for &'a PropertyValueSet {
+ type Item = (&'a property::Handle, &'a property::RawValue);
+ type IntoIter =
+ Zip<std::slice::Iter<'a, property::Handle>, std::slice::Iter<'a, property::RawValue>>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.prop_ids.iter().zip(self.prop_vals.iter())
+ }
+}
+
+impl IntoIterator for PropertyValueSet {
+ type Item = (property::Handle, property::RawValue);
+ type IntoIter =
+ Zip<std::vec::IntoIter<property::Handle>, std::vec::IntoIter<property::RawValue>>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.prop_ids.into_iter().zip(self.prop_vals)
+ }
+}
+
+/// Describes a rectangular region of a buffer
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
+pub struct ClipRect(ffi::drm_sys::drm_clip_rect);
+
+impl ClipRect {
+ /// Create a new clipping rectangle.
+ pub fn new(x1: u16, y1: u16, x2: u16, y2: u16) -> Self {
+ Self(ffi::drm_sys::drm_clip_rect { x1, y1, x2, y2 })
+ }
+
+ /// Get the X coordinate of the top left corner of the rectangle.
+ pub fn x1(self) -> u16 {
+ self.0.x1
+ }
+
+ /// Get the Y coordinate of the top left corner of the rectangle.
+ pub fn y1(self) -> u16 {
+ self.0.y1
+ }
+
+ /// Get the X coordinate of the bottom right corner of the rectangle
+ pub fn x2(self) -> u16 {
+ self.0.x2
+ }
+
+ /// Get the Y coordinate of the bottom right corner of the rectangle.
+ pub fn y2(self) -> u16 {
+ self.0.y2
+ }
+}
+
+bitflags::bitflags! {
+ /// Commit flags for atomic mode setting
+ ///
+ /// Limited to the values in [`ffi::drm_sys::DRM_MODE_ATOMIC_FLAGS`].
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+ pub struct AtomicCommitFlags : u32 {
+ /// Generate a page flip event, when the changes are applied
+ const PAGE_FLIP_EVENT = ffi::drm_sys::DRM_MODE_PAGE_FLIP_EVENT;
+ /// Request page flip when the changes are applied, not waiting for vblank
+ const PAGE_FLIP_ASYNC = ffi::drm_sys::DRM_MODE_PAGE_FLIP_ASYNC;
+ /// Test only validity of the request, do not actually apply the requested changes
+ const TEST_ONLY = ffi::drm_sys::DRM_MODE_ATOMIC_TEST_ONLY;
+ /// Do not block on the request and return early
+ const NONBLOCK = ffi::drm_sys::DRM_MODE_ATOMIC_NONBLOCK;
+ /// Allow the changes to trigger a modeset, if necessary
+ ///
+ /// Changes requiring a modeset are rejected otherwise.
+ const ALLOW_MODESET = ffi::drm_sys::DRM_MODE_ATOMIC_ALLOW_MODESET;
+ }
+}
+
+bitflags::bitflags! {
+ /// Mode property flags
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+ pub struct ModePropFlags : u32 {
+ /// Do not use
+ #[deprecated]
+ const PENDING = ffi::DRM_MODE_PROP_PENDING;
+
+ /// Non-extended types: legacy bitmask, one bit per type:
+ const LEGACY_TYPE = ffi::DRM_MODE_PROP_LEGACY_TYPE;
+ /// An unsigned integer that has a min and max value
+ const RANGE = ffi::DRM_MODE_PROP_RANGE;
+ /// Set when this property is informational only and cannot be modified
+ const IMMUTABLE = ffi::DRM_MODE_PROP_IMMUTABLE;
+ /// Enumerated type with text strings
+ const ENUM = ffi::DRM_MODE_PROP_ENUM;
+ /// A chunk of binary data that must be acquired
+ const BLOB = ffi::DRM_MODE_PROP_BLOB;
+ /// Bitmask of enumerated types
+ const BITMASK = ffi::DRM_MODE_PROP_BITMASK;
+
+ /// Extended-types: rather than continue to consume a bit per type,
+ /// grab a chunk of the bits to use as integer type id.
+ const EXTENDED_TYPE = ffi::DRM_MODE_PROP_EXTENDED_TYPE;
+ /// A DRM object that can have a specific type
+ ///
+ /// See `ffi::DRM_MODE_OBJECT_*` for specific types.
+ const OBJECT = ffi::DRM_MODE_PROP_OBJECT;
+ /// A signed integer that has a min and max value
+ const SIGNED_RANGE = ffi::DRM_MODE_PROP_SIGNED_RANGE;
+ /// the [`Self::ATOMIC`] flag is used to hide properties from userspace that
+ /// is not aware of atomic properties. This is mostly to work around
+ /// older userspace (DDX drivers) that read/write each prop they find,
+ /// witout being aware that this could be triggering a lengthy modeset.
+ const ATOMIC = ffi::DRM_MODE_PROP_ATOMIC;
+ }
+}
+
+bitflags::bitflags! {
+ /// Planar framebuffer flags
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+ pub struct FbCmd2Flags : u32 {
+ /// For interlaced framebuffers
+ const INTERLACED = ffi::DRM_MODE_FB_INTERLACED;
+ /// Enables .modifier
+ const MODIFIERS = ffi::DRM_MODE_FB_MODIFIERS;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-23 14:39:25 +0000