1use core::ffi::c_int as int;
2use core::ffi::c_ulong as ulong;
3use core::ptr::null_mut;
4
5use linux_io::fd::ioctl::{
6 ioctl_no_arg, ioctl_write, ioctl_writeread, IoDevice, IoctlReqNoArgs, IoctlReqWrite,
7 IoctlReqWriteRead,
8};
9
10pub struct DrmCardDevice;
11
12impl IoDevice for DrmCardDevice {}
13
14const DRM_IOCTL_BASE: ulong = 100;
15
16#[allow(non_snake_case)]
17const fn _IO(nr: ulong) -> ulong {
18 linux_io::fd::ioctl::_IO(DRM_IOCTL_BASE, nr)
19}
20
21#[allow(non_snake_case)]
22const fn _IOW<T>(nr: ulong) -> ulong {
23 linux_io::fd::ioctl::_IOW(DRM_IOCTL_BASE, nr, core::mem::size_of::<T>() as _)
24}
25
26#[allow(non_snake_case)]
27const fn _IOR<T>(nr: ulong) -> ulong {
28 linux_io::fd::ioctl::_IOR(DRM_IOCTL_BASE, nr, core::mem::size_of::<T>() as _)
29}
30
31#[allow(non_snake_case)]
32const fn _IOWR<T>(nr: ulong) -> ulong {
33 linux_io::fd::ioctl::_IOWR(DRM_IOCTL_BASE, nr, core::mem::size_of::<T>() as _)
34}
35
36#[allow(non_camel_case_types)]
38#[derive(Copy, Clone, Debug)]
39#[repr(transparent)]
40pub struct fixedu16_16(u32);
41
42impl fixedu16_16 {
43 #[inline(always)]
44 pub fn from_u16(v: u16) -> Self {
45 Self((v as u32) << 16)
46 }
47
48 #[inline(always)]
49 pub fn from_u16_frac(w: u16, f: u16) -> Self {
50 Self(((w as u32) << 16) | (f as u32))
51 }
52
53 #[inline(always)]
54 pub fn as_raw_u32(self) -> u32 {
55 self.0
56 }
57}
58
59impl From<u16> for fixedu16_16 {
60 #[inline(always)]
61 fn from(value: u16) -> Self {
62 Self::from_u16(value)
63 }
64}
65
66impl From<u8> for fixedu16_16 {
67 #[inline(always)]
68 fn from(value: u8) -> Self {
69 Self::from_u16(value as u16)
70 }
71}
72
73macro_rules! impl_zeroed {
74 ($t:ty) => {
75 impl $t {
76 #[inline(always)]
77 pub const fn zeroed() -> Self {
78 unsafe { ::core::mem::zeroed() }
81 }
82 }
83
84 impl ::core::default::Default for $t {
86 #[inline(always)]
87 fn default() -> Self {
88 Self::zeroed()
89 }
90 }
91 };
92}
93
94#[repr(C)]
95#[derive(Clone, Copy, Debug)]
96pub struct DrmVersion {
97 pub version_major: int,
98 pub version_minor: int,
99 pub version_patchlevel: int,
100 name_len: usize,
101 name: *mut i8,
102 date_len: usize,
103 date: *mut i8,
104 desc_len: usize,
105 desc: *mut i8,
106}
107
108impl_zeroed!(DrmVersion);
109
110impl DrmVersion {
111 #[inline(always)]
112 pub unsafe fn set_name_ptr(&mut self, ptr: *mut i8, len: usize) {
113 self.name = ptr;
114 self.name_len = len;
115 }
116
117 #[inline(always)]
118 pub fn clear_name_ptr(&mut self) {
119 self.name = null_mut();
120 self.name_len = 0;
121 }
122
123 #[inline(always)]
124 pub fn name_len(&self) -> usize {
125 self.name_len
126 }
127
128 #[inline(always)]
129 pub unsafe fn set_date_ptr(&mut self, ptr: *mut i8, len: usize) {
130 self.date = ptr;
131 self.date_len = len;
132 }
133
134 #[inline(always)]
135 pub fn clear_date_ptr(&mut self) {
136 self.date = null_mut();
137 self.date_len = 0;
138 }
139
140 #[inline(always)]
141 pub fn date_len(&self) -> usize {
142 self.date_len
143 }
144
145 #[inline(always)]
146 pub unsafe fn set_desc_ptr(&mut self, ptr: *mut i8, len: usize) {
147 self.desc = ptr;
148 self.desc_len = len;
149 }
150
151 #[inline(always)]
152 pub fn clear_desc_ptr(&mut self) {
153 self.desc = null_mut();
154 self.desc_len = 0;
155 }
156
157 #[inline(always)]
158 pub fn desc_len(&self) -> usize {
159 self.desc_len
160 }
161}
162
163pub const DRM_IOCTL_VERSION: IoctlReqWriteRead<DrmCardDevice, DrmVersion, int> =
164 unsafe { ioctl_writeread(_IOWR::<DrmVersion>(0x00)) };
165
166#[repr(C)]
167#[derive(Clone, Copy, Debug)]
168pub struct DrmSetVersion {
169 pub drm_di_major: int,
170 pub drm_di_minor: int,
171 pub drm_dd_major: int,
172 pub drm_dd_minor: int,
173}
174
175impl_zeroed!(DrmSetVersion);
176
177pub const DRM_IOCTL_SET_VERSION: IoctlReqWriteRead<DrmCardDevice, DrmSetVersion, int> =
178 unsafe { ioctl_writeread(_IOWR::<DrmSetVersion>(0x07)) };
179
180pub const DRM_IOCTL_SET_MASTER: IoctlReqNoArgs<DrmCardDevice, int> =
181 unsafe { ioctl_no_arg(_IO(0x1e)) };
182
183pub const DRM_IOCTL_DROP_MASTER: IoctlReqNoArgs<DrmCardDevice, int> =
184 unsafe { ioctl_no_arg(_IO(0x1f)) };
185
186#[repr(C)]
187#[derive(Clone, Copy, Debug)]
188pub struct DrmGetCap {
189 pub capability: DrmCap,
190 pub value: u64,
191}
192
193impl_zeroed!(DrmGetCap);
194
195#[derive(Copy, Clone, Debug, PartialEq, Eq)]
196#[repr(transparent)]
197pub struct DrmCap(pub u64);
198
199pub const DRM_IOCTL_GET_CAP: IoctlReqWriteRead<DrmCardDevice, DrmGetCap, int> =
200 unsafe { ioctl_writeread(_IOWR::<DrmGetCap>(0x0c)) };
201
202pub const DRM_CAP_DUMB_BUFFER: DrmCap = DrmCap(0x1);
204pub const DRM_CAP_VBLANK_HIGH_CRTC: DrmCap = DrmCap(0x2);
207pub const DRM_CAP_DUMB_PREFERRED_DEPTH: DrmCap = DrmCap(0x3);
217pub const DRM_CAP_DUMB_PREFER_SHADOW: DrmCap = DrmCap(0x4);
225pub const DRM_CAP_PRIME: DrmCap = DrmCap(0x5);
233pub const DRM_PRIME_CAP_IMPORT: DrmCap = DrmCap(0x1);
236pub const DRM_PRIME_CAP_EXPORT: DrmCap = DrmCap(0x2);
239pub const DRM_CAP_TIMESTAMP_MONOTONIC: DrmCap = DrmCap(0x6);
246pub const DRM_CAP_ASYNC_PAGE_FLIP: DrmCap = DrmCap(0x7);
249pub const DRM_CAP_CURSOR_WIDTH: DrmCap = DrmCap(0x8);
251pub const DRM_CAP_CURSOR_HEIGHT: DrmCap = DrmCap(0x9);
253pub const DRM_CAP_ADDFB2_MODIFIERS: DrmCap = DrmCap(0x10);
255pub const DRM_CAP_PAGE_FLIP_TARGET: DrmCap = DrmCap(0x11);
256pub const DRM_CAP_CRTC_IN_VBLANK_EVENT: DrmCap = DrmCap(0x12);
263pub const DRM_CAP_SYNCOBJ: DrmCap = DrmCap(0x13);
265pub const DRM_CAP_SYNCOBJ_TIMELINE: DrmCap = DrmCap(0x14);
267pub const DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP: DrmCap = DrmCap(0x15);
269
270#[repr(C)]
271#[derive(Clone, Copy, Debug)]
272pub struct DrmSetClientCap {
273 pub capability: DrmClientCap,
274 pub value: u64,
275}
276
277impl_zeroed!(DrmSetClientCap);
278
279#[derive(Copy, Clone, Debug, PartialEq, Eq)]
280#[repr(transparent)]
281pub struct DrmClientCap(pub u64);
282
283pub const DRM_IOCTL_SET_CLIENT_CAP: IoctlReqWrite<DrmCardDevice, DrmSetClientCap, int> =
284 unsafe { ioctl_write(_IOW::<DrmSetClientCap>(0x0d)) };
285
286pub const DRM_CLIENT_CAP_STEREO_3D: DrmClientCap = DrmClientCap(1);
290
291pub const DRM_CLIENT_CAP_UNIVERSAL_PLANES: DrmClientCap = DrmClientCap(2);
294
295pub const DRM_CLIENT_CAP_ATOMIC: DrmClientCap = DrmClientCap(3);
297
298pub const DRM_CLIENT_CAP_ASPECT_RATIO: DrmClientCap = DrmClientCap(4);
300
301pub const DRM_CLIENT_CAP_WRITEBACK_CONNECTORS: DrmClientCap = DrmClientCap(5);
305
306pub const DRM_CLIENT_CAP_CURSOR_PLANE_HOTSPOT: DrmClientCap = DrmClientCap(6);
326
327#[repr(C)]
328#[derive(Debug)]
329pub struct DrmModeCardRes {
330 fb_id_ptr: u64,
331 crtc_id_ptr: u64,
332 connector_id_ptr: u64,
333 encoder_id_ptr: u64,
334 count_fbs: u32,
335 count_crtcs: u32,
336 count_connectors: u32,
337 count_encoders: u32,
338 pub min_width: u32,
339 pub max_width: u32,
340 pub min_height: u32,
341 pub max_height: u32,
342}
343
344impl_zeroed!(DrmModeCardRes);
345
346impl DrmModeCardRes {
347 #[inline(always)]
348 pub unsafe fn set_fb_id_ptr(&mut self, ptr: *mut u32, len: u32) {
349 self.fb_id_ptr = ptr as u64;
350 self.count_fbs = len;
351 }
352
353 #[inline(always)]
354 pub fn clear_fb_id_ptr(&mut self) {
355 self.fb_id_ptr = 0;
356 self.count_fbs = 0;
357 }
358
359 #[inline(always)]
360 pub fn count_fbs(&mut self) -> u32 {
361 self.count_fbs
362 }
363
364 #[inline(always)]
365 pub unsafe fn set_crtc_id_ptr(&mut self, ptr: *mut u32, len: u32) {
366 self.crtc_id_ptr = ptr as u64;
367 self.count_crtcs = len;
368 }
369
370 #[inline(always)]
371 pub fn clear_crtc_id_ptr(&mut self) {
372 self.crtc_id_ptr = 0;
373 self.count_crtcs = 0;
374 }
375
376 #[inline(always)]
377 pub fn count_crtcs(&mut self) -> u32 {
378 self.count_crtcs
379 }
380
381 #[inline(always)]
382 pub unsafe fn set_connector_id_ptr(&mut self, ptr: *mut u32, len: u32) {
383 self.connector_id_ptr = ptr as u64;
384 self.count_connectors = len;
385 }
386
387 #[inline(always)]
388 pub fn clear_connector_id_ptr(&mut self) {
389 self.connector_id_ptr = 0;
390 self.count_connectors = 0;
391 }
392
393 #[inline(always)]
394 pub fn count_connectors(&mut self) -> u32 {
395 self.count_connectors
396 }
397
398 #[inline(always)]
399 pub unsafe fn set_encoder_id_ptr(&mut self, ptr: *mut u32, len: u32) {
400 self.encoder_id_ptr = ptr as u64;
401 self.count_encoders = len;
402 }
403
404 #[inline(always)]
405 pub fn clear_encoder_id_ptr(&mut self) {
406 self.encoder_id_ptr = 0;
407 self.count_encoders = 0;
408 }
409
410 #[inline(always)]
411 pub fn count_encoders(&mut self) -> u32 {
412 self.count_encoders
413 }
414}
415
416pub const DRM_IOCTL_MODE_GETRESOURCES: IoctlReqWriteRead<DrmCardDevice, DrmModeCardRes, int> =
417 unsafe { ioctl_writeread(_IOWR::<DrmModeCardRes>(0xa0)) };
418
419#[repr(C)]
420#[derive(Debug)]
421pub struct DrmModeInfo {
422 pub clock: u32,
423 pub hdisplay: u16,
424 pub hsync_start: u16,
425 pub hsync_end: u16,
426 pub htotal: u16,
427 pub hskew: u16,
428 pub vdisplay: u16,
429 pub vsync_start: u16,
430 pub vsync_end: u16,
431 pub vtotal: u16,
432 pub vscan: u16,
433 pub vrefresh: u32,
434 pub flags: u32,
435 pub typ: u32,
436 pub name: [core::ffi::c_char; 32],
437}
438
439pub const DRM_MODE_TYPE_PREFERRED: u32 = 1 << 3;
440pub const DRM_MODE_TYPE_USERDEF: u32 = 1 << 5;
441pub const DRM_MODE_TYPE_DRIVER: u32 = 1 << 6;
442
443#[repr(C)]
444#[derive(Debug)]
445pub struct DrmModeGetConnector {
446 encoders_ptr: u64,
447 modes_ptr: u64,
448 props_ptr: u64,
449 prop_values_ptr: u64,
450 count_modes: u32,
451 count_props: u32,
452 count_encoders: u32,
453 pub encoder_id: u32,
454 pub connector_id: u32,
455 pub connector_type: u32,
456 pub connector_type_id: u32,
457 pub connection: u32,
458 pub mm_width: u32,
459 pub mm_height: u32,
460 pub subpixel: u32,
461 #[doc(hidden)]
462 pub _pad: u32,
463}
464
465impl_zeroed!(DrmModeGetConnector);
466
467impl DrmModeGetConnector {
468 #[inline(always)]
469 pub unsafe fn set_encoders_ptr(&mut self, ptr: *mut u32, len: u32) {
470 self.encoders_ptr = ptr as u64;
471 self.count_encoders = len;
472 }
473
474 #[inline(always)]
475 pub fn clear_encoders_ptr(&mut self) {
476 self.encoders_ptr = 0;
477 self.count_encoders = 0;
478 }
479
480 #[inline(always)]
481 pub fn count_encoders(&self) -> u32 {
482 self.count_encoders
483 }
484
485 #[inline(always)]
486 pub unsafe fn set_modes_ptr(&mut self, ptr: *mut DrmModeInfo, len: u32) {
487 self.modes_ptr = ptr as u64;
488 self.count_modes = len;
489 }
490
491 #[inline(always)]
492 pub fn clear_modes_ptr(&mut self) {
493 self.modes_ptr = 0;
494 self.count_modes = 0;
495 }
496
497 #[inline(always)]
498 pub fn count_modes(&self) -> u32 {
499 self.count_modes
500 }
501
502 #[inline(always)]
503 pub unsafe fn set_props_ptrs(&mut self, ids_ptr: *mut u32, vals_ptr: *mut u64, len: u32) {
504 self.props_ptr = ids_ptr as u64;
505 self.prop_values_ptr = vals_ptr as u64;
506 self.count_props = len;
507 }
508
509 #[inline(always)]
510 pub fn clear_props_ptrs(&mut self) {
511 self.props_ptr = 0;
512 self.prop_values_ptr = 0;
513 self.count_props = 0;
514 }
515
516 #[inline(always)]
517 pub fn count_props(&self) -> u32 {
518 self.count_props
519 }
520}
521
522pub const DRM_IOCTL_MODE_GETCONNECTOR: IoctlReqWriteRead<DrmCardDevice, DrmModeGetConnector, int> =
523 unsafe { ioctl_writeread(_IOWR::<DrmModeGetConnector>(0xa7)) };
524
525#[repr(C)]
526#[derive(Debug)]
527pub struct DrmModeGetEncoder {
528 pub encoder_id: u32,
529 pub encoder_type: u32,
530 pub crtc_id: u32,
531 pub possible_crtcs: u32,
532 pub possible_clones: u32,
533}
534
535impl_zeroed!(DrmModeGetEncoder);
536
537pub const DRM_IOCTL_MODE_GETENCODER: IoctlReqWriteRead<DrmCardDevice, DrmModeGetEncoder, int> =
538 unsafe { ioctl_writeread(_IOWR::<DrmModeGetEncoder>(0xa6)) };
539
540#[repr(C)]
541#[derive(Debug)]
542pub struct DrmModeCrtc {
543 set_connectors_ptr: u64,
544 count_connectors: u32,
545 pub crtc_id: u32,
546 pub fb_id: u32,
547 pub x: u32,
548 pub y: u32,
549 pub gamma_size: u32,
550 pub mode_valid: u32,
551 pub mode: DrmModeInfo,
552}
553
554impl_zeroed!(DrmModeCrtc);
555
556impl DrmModeCrtc {
557 pub unsafe fn set_set_connectors_ptr(&mut self, ptr: *const u32, len: u32) {
558 self.set_connectors_ptr = ptr as u64;
559 self.count_connectors = len;
560 }
561
562 pub fn clear_set_connectors_ptr(&mut self) {
563 self.set_connectors_ptr = 0;
564 self.count_connectors = 0;
565 }
566}
567
568pub const DRM_IOCTL_MODE_GETCRTC: IoctlReqWriteRead<DrmCardDevice, DrmModeCrtc, int> =
569 unsafe { ioctl_writeread(_IOWR::<DrmModeCrtc>(0xa1)) };
570
571pub const DRM_IOCTL_MODE_SETCRTC: IoctlReqWriteRead<DrmCardDevice, DrmModeCrtc, int> =
572 unsafe { ioctl_writeread(_IOWR::<DrmModeCrtc>(0xa2)) };
573
574#[repr(C)]
575#[derive(Debug)]
576pub struct DrmModeCreateDumb {
577 pub height: u32,
578 pub width: u32,
579 pub bpp: u32,
580 pub flags: u32,
581 pub handle: u32,
582 pub pitch: u32,
583 pub size: u64,
584}
585
586impl_zeroed!(DrmModeCreateDumb);
587
588pub const DRM_IOCTL_MODE_CREATE_DUMB: IoctlReqWriteRead<DrmCardDevice, DrmModeCreateDumb, int> =
589 unsafe { ioctl_writeread(_IOWR::<DrmModeCreateDumb>(0xb2)) };
590
591#[repr(C)]
592#[derive(Debug)]
593pub struct DrmModeMapDumb {
594 pub handle: u32,
595 pub pad: u32,
596 pub offset: u64,
597}
598
599impl_zeroed!(DrmModeMapDumb);
600
601pub const DRM_IOCTL_MODE_MAP_DUMB: IoctlReqWriteRead<DrmCardDevice, DrmModeMapDumb, int> =
602 unsafe { ioctl_writeread(_IOWR::<DrmModeMapDumb>(0xb3)) };
603
604#[repr(C)]
605#[derive(Debug)]
606pub struct DrmModeDestroyDumb {
607 pub handle: u32,
608}
609
610impl_zeroed!(DrmModeDestroyDumb);
611
612pub const DRM_IOCTL_MODE_DESTROY_DUMB: IoctlReqWriteRead<DrmCardDevice, DrmModeDestroyDumb, int> =
613 unsafe { ioctl_writeread(_IOWR::<DrmModeDestroyDumb>(0xb4)) };
614
615#[repr(C)]
616#[derive(Debug)]
617pub struct DrmModeFbCmd {
618 pub fb_id: u32,
619 pub width: u32,
620 pub height: u32,
621 pub pitch: u32,
622 pub bpp: u32,
623 pub depth: u32,
624 pub handle: u32,
625}
626
627impl_zeroed!(DrmModeFbCmd);
628
629pub const DRM_IOCTL_MODE_GETFB: IoctlReqWriteRead<DrmCardDevice, DrmModeFbCmd, int> =
630 unsafe { ioctl_writeread(_IOWR::<DrmModeFbCmd>(0xad)) };
631
632pub const DRM_IOCTL_MODE_ADDFB: IoctlReqWriteRead<DrmCardDevice, DrmModeFbCmd, int> =
633 unsafe { ioctl_writeread(_IOWR::<DrmModeFbCmd>(0xae)) };
634
635pub const DRM_IOCTL_MODE_RMFB: IoctlReqWriteRead<DrmCardDevice, linux_unsafe::uint, int> =
636 unsafe { ioctl_writeread(_IOWR::<linux_unsafe::uint>(0xaf)) };
637
638#[repr(C)]
639#[derive(Debug)]
640pub struct DrmModeFbDirtyCmd {
641 pub fb_id: u32,
642 pub flags: u32,
643 pub color: u32,
644 num_clips: u32,
645 clips_ptr: u64,
646}
647
648impl_zeroed!(DrmModeFbDirtyCmd);
649
650impl DrmModeFbDirtyCmd {
651 #[inline(always)]
652 pub unsafe fn set_clips_ptr(&mut self, ptr: *const DrmClipRect, len: u32) {
653 self.clips_ptr = ptr as u64;
654 self.num_clips = len;
655 }
656
657 #[inline(always)]
658 pub fn clear_clips_ptr(&mut self) {
659 self.clips_ptr = 0;
660 self.num_clips = 0;
661 }
662}
663
664pub const DRM_IOCTL_MODE_DIRTYFB: IoctlReqWriteRead<DrmCardDevice, DrmModeFbDirtyCmd, int> =
691 unsafe { ioctl_writeread(_IOWR::<DrmModeFbDirtyCmd>(0xb1)) };
692
693pub const DRM_MODE_FB_DIRTY_ANNOTATE_COPY: u32 = 0x01;
694pub const DRM_MODE_FB_DIRTY_ANNOTATE_FILL: u32 = 0x02;
695pub const DRM_MODE_FB_DIRTY_FLAGS: u32 = 0x03;
696pub const DRM_MODE_FB_DIRTY_MAX_CLIPS: u32 = 256;
697
698pub struct DrmClipRect {
699 pub x1: linux_unsafe::ushort,
700 pub y1: linux_unsafe::ushort,
701 pub x2: linux_unsafe::ushort,
702 pub y2: linux_unsafe::ushort,
703}
704
705#[repr(C)]
706#[derive(Debug)]
707pub struct DrmModeCrtcPageFlip {
708 pub crtc_id: u32,
709 pub fb_id: u32,
710 pub flags: u32,
711 pub reserved: u32,
713 pub user_data: u64,
714}
715
716impl_zeroed!(DrmModeCrtcPageFlip);
717
718pub const DRM_IOCTL_MODE_PAGE_FLIP: IoctlReqWriteRead<DrmCardDevice, DrmModeCrtcPageFlip, int> =
740 unsafe { ioctl_writeread(_IOWR::<DrmModeCrtcPageFlip>(0xb0)) };
741
742pub const DRM_MODE_PAGE_FLIP_EVENT: u32 = 0x01;
746pub const DRM_MODE_PAGE_FLIP_ASYNC: u32 = 0x02;
759pub const DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE: u32 = 0x4;
760pub const DRM_MODE_PAGE_FLIP_TARGET_RELATIVE: u32 = 0x8;
761pub const DRM_MODE_PAGE_FLIP_TARGET: u32 =
762 DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE | DRM_MODE_PAGE_FLIP_TARGET_RELATIVE;
763pub const DRM_MODE_PAGE_FLIP_FLAGS: u32 =
765 DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_PAGE_FLIP_ASYNC | DRM_MODE_PAGE_FLIP_TARGET;
766
767pub const DRM_MODE_CURSOR_BO: u32 = 0x01;
768pub const DRM_MODE_CURSOR_MOVE: u32 = 0x02;
769pub const DRM_MODE_CURSOR_FLAGS: u32 = 0x03;
770
771#[repr(C)]
772#[derive(Debug)]
773pub struct DrmModeAtomic {
774 pub flags: u32,
775 count_objs: u32,
776 objs_ptr: u64,
777 count_props_ptr: u64,
778 props_ptr: u64,
779 prop_values_ptr: u64,
780 pub reserved: u64,
781 pub user_data: u64,
782}
783
784pub struct DrmModeAtomicPtrs {
785 pub objs_ptr: *const u32,
786 pub count_props_ptr: *const u32,
787 pub count_objs: u32,
788
789 pub props_ptr: *const u32,
790 pub prop_values_ptr: *const u64,
791}
792
793impl_zeroed!(DrmModeAtomic);
794
795impl DrmModeAtomic {
796 #[inline(always)]
797 pub unsafe fn set_ptrs(&mut self, ptrs: DrmModeAtomicPtrs) {
798 self.objs_ptr = ptrs.objs_ptr as u64;
799 self.count_props_ptr = ptrs.count_props_ptr as u64;
800 self.count_objs = ptrs.count_objs;
801 self.props_ptr = ptrs.props_ptr as u64;
802 self.prop_values_ptr = ptrs.prop_values_ptr as u64;
803 }
804
805 #[inline(always)]
806 pub unsafe fn clear_ptrs(&mut self) {
807 self.objs_ptr = 0;
808 self.count_props_ptr = 0;
809 self.count_objs = 0;
810 self.props_ptr = 0;
811 self.prop_values_ptr = 0;
812 }
813}
814
815pub const DRM_IOCTL_MODE_ATOMIC: IoctlReqWriteRead<DrmCardDevice, DrmModeAtomic, int> =
816 unsafe { ioctl_writeread(_IOWR::<DrmModeAtomic>(0xbc)) };
817
818pub const DRM_MODE_ATOMIC_TEST_ONLY: u32 = 0x0100;
821
822pub const DRM_MODE_ATOMIC_NONBLOCK: u32 = 0x0200;
827
828pub const DRM_MODE_ATOMIC_ALLOW_MODESET: u32 = 0x0400;
844
845pub const DRM_MODE_ATOMIC_FLAGS: u32 = DRM_MODE_PAGE_FLIP_EVENT
848 | DRM_MODE_PAGE_FLIP_ASYNC
849 | DRM_MODE_ATOMIC_TEST_ONLY
850 | DRM_MODE_ATOMIC_NONBLOCK
851 | DRM_MODE_ATOMIC_ALLOW_MODESET;
852
853#[repr(C)]
854#[derive(Debug)]
855pub struct DrmModeObjGetProperties {
856 props_ptr: u64,
857 prop_values_ptr: u64,
858 count_props: u32,
859 pub obj_id: u32,
860 pub obj_type: u32,
861}
862
863impl_zeroed!(DrmModeObjGetProperties);
864
865impl DrmModeObjGetProperties {
866 pub unsafe fn set_prop_ptrs(&mut self, ids_ptr: *mut u32, values_ptr: *mut u64, len: u32) {
867 self.props_ptr = ids_ptr as u64;
868 self.prop_values_ptr = values_ptr as u64;
869 self.count_props = len;
870 }
871
872 pub fn clear_prop_attrs(&mut self) {
873 self.props_ptr = 0;
874 self.prop_values_ptr = 0;
875 self.count_props = 0;
876 }
877
878 pub fn count_props(&self) -> u32 {
879 self.count_props
880 }
881}
882
883pub const DRM_IOCTL_MODE_OBJ_GETPROPERTIES: IoctlReqWriteRead<
884 DrmCardDevice,
885 DrmModeObjGetProperties,
886 int,
887> = unsafe { ioctl_writeread(_IOWR::<DrmModeObjGetProperties>(0xb9)) };
888
889#[repr(C)]
890#[derive(Debug)]
891pub struct DrmModeObjSetProperty {
892 pub value: u64,
893 pub prop_id: u32,
894 pub obj_id: u32,
895 pub obj_type: u32,
896}
897
898impl_zeroed!(DrmModeObjSetProperty);
899
900pub const DRM_IOCTL_MODE_OBJ_SETPROPERTY: IoctlReqWriteRead<
901 DrmCardDevice,
902 DrmModeObjSetProperty,
903 int,
904> = unsafe { ioctl_writeread(_IOWR::<DrmModeObjSetProperty>(0xba)) };
905
906pub const DRM_MODE_OBJECT_CRTC: u32 = 0xcccccccc;
907pub const DRM_MODE_OBJECT_CONNECTOR: u32 = 0xc0c0c0c0;
908pub const DRM_MODE_OBJECT_ENCODER: u32 = 0xe0e0e0e0;
909pub const DRM_MODE_OBJECT_MODE: u32 = 0xdededede;
910pub const DRM_MODE_OBJECT_PROPERTY: u32 = 0xb0b0b0b0;
911pub const DRM_MODE_OBJECT_FB: u32 = 0xfbfbfbfb;
912pub const DRM_MODE_OBJECT_BLOB: u32 = 0xbbbbbbbb;
913pub const DRM_MODE_OBJECT_PLANE: u32 = 0xeeeeeeee;
914pub const DRM_MODE_OBJECT_ANY: u32 = 0;
915
916#[repr(C)]
917#[derive(Debug)]
918pub struct DrmModeGetPlaneRes {
919 plane_id_ptr: u64,
920 count_planes: u32,
921}
922
923impl_zeroed!(DrmModeGetPlaneRes);
924
925impl DrmModeGetPlaneRes {
926 #[inline(always)]
927 pub unsafe fn set_plane_id_ptr(&mut self, ptr: *mut u32, len: u32) {
928 self.plane_id_ptr = ptr as u64;
929 self.count_planes = len;
930 }
931
932 #[inline(always)]
933 pub fn clear_plane_id_ptr(&mut self) {
934 self.plane_id_ptr = 0;
935 self.count_planes = 0;
936 }
937
938 #[inline(always)]
939 pub fn count_planes(&self) -> u32 {
940 self.count_planes
941 }
942}
943
944pub const DRM_IOCTL_MODE_GETPLANERESOURCES: IoctlReqWriteRead<
945 DrmCardDevice,
946 DrmModeGetPlaneRes,
947 int,
948> = unsafe { ioctl_writeread(_IOWR::<DrmModeGetPlaneRes>(0xb5)) };
949
950#[repr(C)]
951#[derive(Debug)]
952pub struct DrmModeGetPlane {
953 pub plane_id: u32,
954 pub crtc_id: u32,
955 pub fb_id: u32,
956 pub possible_crtcs: u32,
957 pub gamma_size: u32,
958 count_format_types: u32,
959 format_type_ptr: u64,
960}
961
962impl_zeroed!(DrmModeGetPlane);
963
964impl DrmModeGetPlane {
965 #[inline(always)]
966 pub unsafe fn set_format_type_ptr(&mut self, ptr: *mut u32, len: u32) {
967 self.format_type_ptr = ptr as u64;
968 self.count_format_types = len;
969 }
970
971 #[inline(always)]
972 pub fn clear_format_type_ptr(&mut self) {
973 self.format_type_ptr = 0;
974 self.count_format_types = 0;
975 }
976
977 #[inline(always)]
978 pub fn count_format_types(&self) -> u32 {
979 self.count_format_types
980 }
981}
982
983pub const DRM_IOCTL_MODE_GETPLANE: IoctlReqWriteRead<DrmCardDevice, DrmModeGetPlane, int> =
984 unsafe { ioctl_writeread(_IOWR::<DrmModeGetPlane>(0xb6)) };
985
986#[repr(C)]
987#[derive(Debug)]
988pub struct DrmModeSetPlane {
989 pub plane_id: u32,
990 pub crtc_id: u32,
991 pub fb_id: u32, pub flags: u32, pub crtc_x: i32,
995 pub crtc_y: i32,
996 pub crtc_w: u32,
997 pub crtc_h: u32,
998
999 pub src_x: fixedu16_16,
1000 pub src_y: fixedu16_16,
1001 pub src_h: fixedu16_16,
1002 pub src_w: fixedu16_16,
1003}
1004
1005impl_zeroed!(DrmModeSetPlane);
1006
1007pub const DRM_IOCTL_MODE_SETPLANE: IoctlReqWriteRead<DrmCardDevice, DrmModeSetPlane, int> =
1008 unsafe { ioctl_writeread(_IOWR::<DrmModeSetPlane>(0xb7)) };
1009
1010pub const DRM_MODE_PRESENT_TOP_FIELD: u32 = 1 << 0;
1011pub const DRM_MODE_PRESENT_BOTTOM_FIELD: u32 = 1 << 1;
1012
1013#[repr(C)]
1014#[derive(Debug, Clone)]
1015pub struct DrmModeGetProperty {
1016 values_ptr: u64,
1017 enum_blob_ptr: u64,
1018 pub prop_id: u32,
1019 pub flags: u32,
1020 pub name: [u8; DRM_PROP_NAME_LEN],
1021 count_values: u32,
1022 count_enum_blobs: u32,
1023}
1024
1025impl_zeroed!(DrmModeGetProperty);
1026
1027impl DrmModeGetProperty {
1028 #[inline(always)]
1036 pub unsafe fn set_values_ptr(&mut self, ptr: *mut u64, len: u32) {
1037 self.values_ptr = ptr as u64;
1038 self.count_values = len;
1039 }
1040
1041 #[inline(always)]
1042 pub fn clear_values_ptr(&mut self) {
1043 self.values_ptr = 0;
1044 self.count_values = 0;
1045 }
1046
1047 #[inline(always)]
1048 pub fn count_values(&self) -> u32 {
1049 self.count_values
1050 }
1051
1052 #[inline(always)]
1060 pub unsafe fn set_enum_blob_ptr(&mut self, ptr: *mut DrmModePropertyEnum, len: u32) {
1061 self.enum_blob_ptr = ptr as u64;
1062 self.count_enum_blobs = len;
1063 }
1064
1065 #[inline(always)]
1066 pub fn clear_enum_blob_ptr(&mut self) {
1067 self.enum_blob_ptr = 0;
1068 self.count_enum_blobs = 0;
1069 }
1070
1071 #[inline(always)]
1072 pub fn count_enum_blobs(&self) -> u32 {
1073 self.count_enum_blobs
1074 }
1075}
1076
1077#[repr(C)]
1078#[derive(Debug, Clone)]
1079pub struct DrmModePropertyEnum {
1080 pub value: u64,
1081 pub name: [u8; DRM_PROP_NAME_LEN],
1082}
1083
1084impl_zeroed!(DrmModePropertyEnum);
1085
1086pub const DRM_IOCTL_MODE_GETPROPERTY: IoctlReqWriteRead<DrmCardDevice, DrmModeGetProperty, int> =
1116 unsafe { ioctl_writeread(_IOWR::<DrmModeGetProperty>(0xaa)) };
1117
1118pub const DRM_PROP_NAME_LEN: usize = 32;
1119
1120pub const DRM_MODE_PROP_PENDING: u32 = 1 << 0;
1121pub const DRM_MODE_PROP_RANGE: u32 = 1 << 1;
1122pub const DRM_MODE_PROP_IMMUTABLE: u32 = 1 << 2;
1123pub const DRM_MODE_PROP_ENUM: u32 = 1 << 3;
1124pub const DRM_MODE_PROP_BLOB: u32 = 1 << 4;
1125pub const DRM_MODE_PROP_BITMASK: u32 = 1 << 5;
1126pub const DRM_MODE_PROP_LEGACY_TYPE: u32 =
1127 DRM_MODE_PROP_RANGE | DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BLOB | DRM_MODE_PROP_BITMASK;
1128pub const DRM_MODE_PROP_EXTENDED_TYPE: u32 = 0x0000ffc0;
1129pub const DRM_MODE_PROP_OBJECT: u32 = DRM_MODE_PROP_TYPE(1);
1130pub const DRM_MODE_PROP_SIGNED_RANGE: u32 = DRM_MODE_PROP_TYPE(2);
1131
1132#[allow(non_snake_case)]
1133#[inline(always)]
1134pub const fn DRM_MODE_PROP_TYPE(n: u32) -> u32 {
1135 n << 6
1136}
1137
1138#[repr(C)]
1139#[derive(Debug)]
1140pub struct DrmModeCreateBlob {
1141 data: u64,
1142 length: u32,
1143 pub blob_id: u32,
1144}
1145
1146impl_zeroed!(DrmModeCreateBlob);
1147
1148impl DrmModeCreateBlob {
1149 pub unsafe fn set_data(&mut self, ptr: *const u8, len: u32) {
1157 self.data = ptr as u64;
1158 self.length = len;
1159 }
1160
1161 pub fn clear_data(&mut self) {
1162 self.data = 0;
1163 self.length = 0;
1164 }
1165}
1166
1167pub const DRM_IOCTL_MODE_CREATEPROPBLOB: IoctlReqWriteRead<DrmCardDevice, DrmModeCreateBlob, int> =
1168 unsafe { ioctl_writeread(_IOWR::<DrmModeCreateBlob>(0xbd)) };
1169
1170#[repr(C)]
1171#[derive(Debug)]
1172pub struct DrmModeDestroyBlob {
1173 pub blob_id: u32,
1174}
1175
1176impl_zeroed!(DrmModeDestroyBlob);
1177
1178pub const DRM_IOCTL_MODE_DESTROYPROPBLOB: IoctlReqWriteRead<
1179 DrmCardDevice,
1180 DrmModeDestroyBlob,
1181 int,
1182> = unsafe { ioctl_writeread(_IOWR::<DrmModeDestroyBlob>(0xbe)) };