Add safe wrappers for the handful of raw drm_kms fields and helpers a
real KMS driver reaches for, so drivers need no raw escape hatch:
- drm::Device::hotplug_event() wraps drm_kms_helper_hotplug_event().
- RawCrtcState::mode() returns the state's programmed DisplayMode.
- DisplayMode gains hdisplay()/hsync_start()/hsync_end()/htotal()/
vdisplay()/vsync_start()/vsync_end()/vtotal()/clock()/vrefresh().
- RawPlaneState::crtc_w()/crtc_h() return the destination rectangle.
- ConnectorGuard::add_edid_modes() parses an EDID blob, updates the
connector and adds its modes (the safe counterpart to the existing
add_modes_noedid()).
Signed-off-by: Mike Lothian <[email protected]>
Assisted-by: Claude:claude-sonnet-5 [Claude-Code]
---
rust/kernel/drm/kms.rs | 12 ++++++
rust/kernel/drm/kms/connector.rs | 20 +++++++++
rust/kernel/drm/kms/crtc.rs | 13 +++++-
rust/kernel/drm/kms/modes.rs | 70 ++++++++++++++++++++++++++++++++
rust/kernel/drm/kms/plane.rs | 10 +++++
5 files changed, 123 insertions(+), 2 deletions(-)
diff --git a/rust/kernel/drm/kms.rs b/rust/kernel/drm/kms.rs
index 7c7e1d59c892..7207466094e7 100644
--- a/rust/kernel/drm/kms.rs
+++ b/rust/kernel/drm/kms.rs
@@ -114,6 +114,18 @@ fn deref(&self) -> &Self::Target {
}
}
+impl<T: KmsDriver, C: DeviceContext> Device<T, C> {
+ /// Send a hotplug uevent to userspace, prompting it to re-probe connector
state.
+ ///
+ /// A thin safe wrapper over `drm_kms_helper_hotplug_event()`, for drivers
that detect a
+ /// connection change out of band (for example a dock delivering an EDID
after bring-up).
+ pub fn hotplug_event(&self) {
+ // SAFETY: `self.as_raw()` is our live `drm_device`; a KMS driver has
the KMS helper
+ // state this call requires.
+ unsafe { bindings::drm_kms_helper_hotplug_event(self.as_raw()) };
+ }
+}
+
/// A trait which must be implemented by drivers that wish to support KMS
///
/// It should be implemented for the same type that implements [`Driver`].
Drivers which don't
diff --git a/rust/kernel/drm/kms/connector.rs b/rust/kernel/drm/kms/connector.rs
index 1c7c7b586340..591153de7ab4 100644
--- a/rust/kernel/drm/kms/connector.rs
+++ b/rust/kernel/drm/kms/connector.rs
@@ -574,6 +574,26 @@ pub fn set_preferred_mode(&self, (h_pref, w_pref): (u32,
u32)) {
// SAFETY: We hold the locks required to call this via our type
invariants.
unsafe { bindings::drm_set_preferred_mode(self.as_raw(), h_pref,
w_pref) }
}
+
+ /// Parse a raw EDID blob, update the connector's display information from
it, and add the
+ /// modes it advertises to the connector's mode list.
+ ///
+ /// Returns how many modes were added (0 if the blob is rejected).
+ pub fn add_edid_modes(&self, edid: &[u8]) -> i32 {
+ // SAFETY: `edid` is a valid byte buffer of `edid.len()` bytes;
`drm_edid_alloc` copies it.
+ let drm_edid = unsafe { bindings::drm_edid_alloc(edid.as_ptr().cast(),
edid.len()) };
+ if drm_edid.is_null() {
+ return 0;
+ }
+ // SAFETY: We hold the locks required via our type invariants;
`drm_edid` was just
+ // allocated above.
+ unsafe { bindings::drm_edid_connector_update(self.as_raw(), drm_edid)
};
+ // SAFETY: Same invariants; adds the EDID-derived modes and returns
the count.
+ let n = unsafe { bindings::drm_edid_connector_add_modes(self.as_raw())
};
+ // SAFETY: `drm_edid` was allocated by `drm_edid_alloc` above and is
no longer needed.
+ unsafe { bindings::drm_edid_free(drm_edid) };
+ n
+ }
}
/// A trait implemented by any type which can produce a reference to a
diff --git a/rust/kernel/drm/kms/crtc.rs b/rust/kernel/drm/kms/crtc.rs
index 9b43501bfb58..fbe113676e2f 100644
--- a/rust/kernel/drm/kms/crtc.rs
+++ b/rust/kernel/drm/kms/crtc.rs
@@ -5,8 +5,8 @@
//! C header: [`include/drm/drm_crtc.h`](srctree/include/drm/drm_crtc.h)
use super::{
- atomic::*, plane::*, vblank::*, KmsDriver, ModeObject, ModeObjectVtable,
StaticModeObject,
- NewKmsDevice, Probing, Sealed,
+ atomic::*, modes::DisplayMode, plane::*, vblank::*, KmsDriver, ModeObject,
ModeObjectVtable,
+ StaticModeObject, NewKmsDevice, Probing, Sealed,
};
use crate::{
alloc::KBox,
@@ -643,6 +643,7 @@ pub trait AsRawCrtcState: private::AsRawCrtcState {
pub(crate) mod private {
use super::*;
+ /// The raw-pointer half of [`AsRawCrtcState`](super::AsRawCrtcState).
#[allow(unreachable_pub)]
pub trait AsRawCrtcState {
/// Return a raw pointer to the DRM CRTC state
@@ -677,6 +678,14 @@ fn active(&self) -> bool {
// this access is serialized
unsafe { (*self.as_raw()).active }
}
+
+ /// Returns the display mode programmed into this CRTC state.
+ fn mode(&self) -> &DisplayMode {
+ // SAFETY: `mode` is embedded in `drm_crtc_state`, so it shares the
state's lifetime, and
+ // is only mutated from the atomic check context - invariant beyond
that point, so our
+ // interface can ensure this access is serialized.
+ unsafe { DisplayMode::as_ref(&(*self.as_raw()).mode) }
+ }
}
impl<T: AsRawCrtcState> RawCrtcState for T {}
diff --git a/rust/kernel/drm/kms/modes.rs b/rust/kernel/drm/kms/modes.rs
index 88ea27729212..16024855c32f 100644
--- a/rust/kernel/drm/kms/modes.rs
+++ b/rust/kernel/drm/kms/modes.rs
@@ -78,4 +78,74 @@ pub fn crtc_vtotal(&self) -> u16 {
// SAFETY: Reading these fields is safe via our type invariants
unsafe { (*self.as_raw()).crtc_vtotal }
}
+
+ /// Horizontal active pixels (`hdisplay`).
+ #[inline]
+ pub fn hdisplay(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).hdisplay }
+ }
+
+ /// Horizontal sync pulse start (`hsync_start`).
+ #[inline]
+ pub fn hsync_start(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).hsync_start }
+ }
+
+ /// Horizontal sync pulse end (`hsync_end`).
+ #[inline]
+ pub fn hsync_end(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).hsync_end }
+ }
+
+ /// Horizontal total pixels including blanking (`htotal`).
+ #[inline]
+ pub fn htotal(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).htotal }
+ }
+
+ /// Vertical active scanlines (`vdisplay`).
+ #[inline]
+ pub fn vdisplay(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).vdisplay }
+ }
+
+ /// Vertical sync pulse start (`vsync_start`).
+ #[inline]
+ pub fn vsync_start(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).vsync_start }
+ }
+
+ /// Vertical sync pulse end (`vsync_end`).
+ #[inline]
+ pub fn vsync_end(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).vsync_end }
+ }
+
+ /// Vertical total scanlines including blanking (`vtotal`).
+ #[inline]
+ pub fn vtotal(&self) -> u16 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).vtotal }
+ }
+
+ /// Pixel clock for this display mode in kHz (`clock`).
+ #[inline]
+ pub fn clock(&self) -> i32 {
+ // SAFETY: Reading these fields is safe via our type invariants
+ unsafe { (*self.as_raw()).clock }
+ }
+
+ /// The refresh rate of this mode in Hz, as computed by
`drm_mode_vrefresh()`.
+ #[inline]
+ pub fn vrefresh(&self) -> i32 {
+ // SAFETY: `drm_mode_vrefresh` only reads the mode, which is valid via
our invariants.
+ unsafe { bindings::drm_mode_vrefresh(self.as_raw()) }
+ }
}
diff --git a/rust/kernel/drm/kms/plane.rs b/rust/kernel/drm/kms/plane.rs
index 375f79bd3ceb..3863dfe1b84c 100644
--- a/rust/kernel/drm/kms/plane.rs
+++ b/rust/kernel/drm/kms/plane.rs
@@ -595,6 +595,16 @@ fn plane(&self) -> &Self::Plane {
unsafe { Self::Plane::from_raw(self.as_raw().plane) }
}
+ /// The width of this plane's destination rectangle within the CRTC, in
pixels (`crtc_w`).
+ fn crtc_w(&self) -> u32 {
+ self.as_raw().crtc_w
+ }
+
+ /// The height of this plane's destination rectangle within the CRTC, in
pixels (`crtc_h`).
+ fn crtc_h(&self) -> u32 {
+ self.as_raw().crtc_h
+ }
+
/// Return the current [`OpaqueCrtc`] assigned to this plane, if there is
one.
fn crtc<'a, 'b: 'a, D>(&'a self) -> Option<&'b OpaqueCrtc<D>>
where
--
2.55.0
