use core::ffi::c_int;
use bytemuck::{AnyBitPattern, NoUninit};
const IOC_READ: u32 = 2;
const IOC_WRITE: u32 = 1;
const fn ioc(dir: u32, ty: u8, nr: u8, size: u16) -> u32 {
(dir << 30) | ((size as u32) << 16) | ((ty as u32) << 8) | (nr as u32)
}
#[inline]
const fn iowr<T>(ty: u8, nr: u8) -> u32 {
ioc(
IOC_READ | IOC_WRITE,
ty,
nr,
core::mem::size_of::<T>() as u16,
)
}
#[inline]
const fn io(ty: u8, nr: u8) -> u32 {
ioc(0, ty, nr, 0)
}
#[cfg(feature = "rknpu")]
pub const DRM_COMMAND_BASE: u32 = 0x40;
#[cfg(feature = "rknpu")]
pub const DRM_COMMAND_END: u32 = 0xA0;
#[cfg(feature = "rknpu")]
#[inline]
pub const fn ioctl_nr(cmd: u32) -> u32 {
cmd & 0xff
}
#[cfg(feature = "rknpu")]
#[inline]
pub const fn io_size(cmd: u32) -> u32 {
(cmd >> 16) & ((1 << 14) - 1)
}
#[cfg(feature = "rknpu")]
#[inline]
pub fn is_driver_ioctl(nr: u32) -> bool {
(DRM_COMMAND_BASE..DRM_COMMAND_END).contains(&nr)
}
pub const DRM_TYPE: u8 = b'd';
pub const DRM_IOCTL_VERSION: u32 = iowr::<DrmVersion>(DRM_TYPE, 0x00);
pub const DRM_IOCTL_GET_UNIQUE: u32 = iowr::<DrmUnique>(DRM_TYPE, 0x01);
pub const DRM_IOCTL_SET_VERSION: u32 = iowr::<DrmSetVersion>(DRM_TYPE, 0x07);
pub const DRM_IOCTL_GET_CAP: u32 = iowr::<DrmGetCap>(DRM_TYPE, 0x0c);
pub const DRM_IOCTL_GEM_CLOSE: u32 = ioc(
IOC_WRITE,
DRM_TYPE,
0x09,
core::mem::size_of::<DrmGemClose>() as u16,
);
pub const DRM_IOCTL_SET_CLIENT_CAP: u32 = ioc(
IOC_WRITE,
DRM_TYPE,
0x0d,
core::mem::size_of::<DrmSetClientCap>() as u16,
);
pub const DRM_IOCTL_SET_MASTER: u32 = io(DRM_TYPE, 0x1e);
pub const DRM_IOCTL_DROP_MASTER: u32 = io(DRM_TYPE, 0x1f);
pub const DRM_IOCTL_GET_MAGIC: u32 = iowr::<DrmAuth>(DRM_TYPE, 0x02);
pub const DRM_IOCTL_AUTH_MAGIC: u32 = iowr::<DrmAuth>(DRM_TYPE, 0x03);
pub const DRM_IOCTL_MODE_DIRTYFB: u32 = iowr::<DrmModeDirtyFB>(DRM_TYPE, 0xB1);
pub const DRM_IOCTL_PRIME_HANDLE_TO_FD: u32 = iowr::<DrmPrimeHandle>(DRM_TYPE, 0x2d);
pub const DRM_IOCTL_PRIME_FD_TO_HANDLE: u32 = iowr::<DrmPrimeHandle>(DRM_TYPE, 0x2e);
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmAuth {
pub magic: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeDirtyFB {
pub fb_id: u32,
pub flags: u32,
pub color: u32,
pub num_clips: u32,
pub clips_ptr: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmPrimeHandle {
pub handle: u32,
pub flags: u32,
pub fd: i32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVersion {
pub version_major: c_int,
pub version_minor: c_int,
pub version_patchlevel: c_int,
pub _padding: u32,
pub name_len: usize,
pub name: u64,
pub date_len: usize,
pub date: u64,
pub desc_len: usize,
pub desc: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmUnique {
pub unique_len: usize,
pub unique: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmSetVersion {
pub drm_di_major: c_int,
pub drm_di_minor: c_int,
pub drm_dd_major: c_int,
pub drm_dd_minor: c_int,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmGetCap {
pub capability: u64,
pub value: u64,
}
pub const DRM_CAP_DUMB_BUFFER: u64 = 0x1;
pub const DRM_CAP_PRIME: u64 = 0x5;
pub const DRM_PRIME_CAP_IMPORT: u64 = 0x1;
pub const DRM_PRIME_CAP_EXPORT: u64 = 0x2;
pub const DRM_CAP_TIMESTAMP_MONOTONIC: u64 = 0x6;
pub const DRM_CAP_CRTC_IN_VBLANK_EVENT: u64 = 0x12;
pub const DRM_CAP_ADDFB2_MODIFIERS: u64 = 0x10;
pub const DRM_MODE_FB_MODIFIERS: u32 = 0x2;
pub const DRM_FORMAT_MOD_INVALID: u64 = 0x00ff_ffff_ffff_ffff;
pub const DRM_FORMAT_MOD_LINEAR: u64 = 0;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmSetClientCap {
pub capability: u64,
pub value: u64,
}
pub const DRM_IOCTL_MODE_GETRESOURCES: u32 = iowr::<DrmModeCardRes>(DRM_TYPE, 0xA0);
pub const DRM_IOCTL_MODE_GETCRTC: u32 = iowr::<DrmModeCrtc>(DRM_TYPE, 0xA1);
pub const DRM_IOCTL_MODE_SETCRTC: u32 = iowr::<DrmModeCrtc>(DRM_TYPE, 0xA2);
pub const DRM_IOCTL_MODE_GETENCODER: u32 = iowr::<DrmModeGetEncoder>(DRM_TYPE, 0xA6);
pub const DRM_IOCTL_MODE_GETCONNECTOR: u32 = iowr::<DrmModeGetConnector>(DRM_TYPE, 0xA7);
pub const DRM_IOCTL_MODE_GETPROPERTY: u32 = iowr::<DrmModeGetProperty>(DRM_TYPE, 0xAA);
pub const DRM_IOCTL_MODE_RMFB: u32 = iowr::<u32>(DRM_TYPE, 0xAF);
pub const DRM_IOCTL_MODE_PAGE_FLIP: u32 = iowr::<DrmModeCrtcPageFlip>(DRM_TYPE, 0xB0);
pub const DRM_IOCTL_MODE_CREATE_DUMB: u32 = iowr::<DrmModeCreateDumb>(DRM_TYPE, 0xB2);
pub const DRM_IOCTL_MODE_MAP_DUMB: u32 = iowr::<DrmModeMapDumb>(DRM_TYPE, 0xB3);
pub const DRM_IOCTL_MODE_DESTROY_DUMB: u32 = iowr::<DrmModeDestroyDumb>(DRM_TYPE, 0xB4);
pub const DRM_IOCTL_MODE_GETPLANERESOURCES: u32 = iowr::<DrmModeGetPlaneRes>(DRM_TYPE, 0xB5);
pub const DRM_IOCTL_MODE_GETPLANE: u32 = iowr::<DrmModeGetPlane>(DRM_TYPE, 0xB6);
pub const DRM_IOCTL_MODE_ADDFB2: u32 = iowr::<DrmModeFbCmd2>(DRM_TYPE, 0xB8);
pub const DRM_IOCTL_MODE_OBJ_GETPROPERTIES: u32 = iowr::<DrmModeObjGetProperties>(DRM_TYPE, 0xB9);
pub const DRM_IOCTL_MODE_ATOMIC: u32 = iowr::<DrmModeAtomic>(DRM_TYPE, 0xBC);
pub const DRM_IOCTL_MODE_CREATEPROPBLOB: u32 = iowr::<DrmModeCreateBlob>(DRM_TYPE, 0xBD);
pub const DRM_IOCTL_MODE_DESTROYPROPBLOB: u32 = iowr::<DrmModeDestroyBlob>(DRM_TYPE, 0xBE);
pub const DRM_IOCTL_MODE_GETPROPBLOB: u32 = iowr::<DrmModeGetBlob>(DRM_TYPE, 0xAC);
pub const DRM_IOCTL_WAIT_VBLANK: u32 = ioc(
IOC_READ | IOC_WRITE,
DRM_TYPE,
0x3A,
core::mem::size_of::<DrmWaitVblank>() as u16,
);
pub const DRM_MODE_NAME_LEN: usize = 32;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeCardRes {
pub fb_id_ptr: u64,
pub crtc_id_ptr: u64,
pub connector_id_ptr: u64,
pub encoder_id_ptr: u64,
pub count_fbs: u32,
pub count_crtcs: u32,
pub count_connectors: u32,
pub count_encoders: u32,
pub min_width: u32,
pub max_width: u32,
pub min_height: u32,
pub max_height: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeModeInfo {
pub clock: u32,
pub hdisplay: u16,
pub hsync_start: u16,
pub hsync_end: u16,
pub htotal: u16,
pub hskew: u16,
pub vdisplay: u16,
pub vsync_start: u16,
pub vsync_end: u16,
pub vtotal: u16,
pub vscan: u16,
pub vrefresh: u32,
pub flags: u32,
pub kind: u32,
pub name: [u8; DRM_MODE_NAME_LEN],
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeCrtc {
pub set_connectors_ptr: u64,
pub count_connectors: u32,
pub crtc_id: u32,
pub fb_id: u32,
pub x: u32,
pub y: u32,
pub gamma_size: u32,
pub mode_valid: u32,
pub mode: DrmModeModeInfo,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeGetEncoder {
pub encoder_id: u32,
pub encoder_type: u32,
pub crtc_id: u32,
pub possible_crtcs: u32,
pub possible_clones: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeGetConnector {
pub encoders_ptr: u64,
pub modes_ptr: u64,
pub props_ptr: u64,
pub prop_values_ptr: u64,
pub count_modes: u32,
pub count_props: u32,
pub count_encoders: u32,
pub encoder_id: u32,
pub connector_id: u32,
pub connector_type: u32,
pub connector_type_id: u32,
pub connection: u32,
pub mm_width: u32,
pub mm_height: u32,
pub subpixel: u32,
pub pad: u32,
}
pub const DRM_MODE_CONNECTED: u32 = 1;
pub const DRM_MODE_CONNECTOR_VIRTUAL: u32 = 15;
pub const DRM_MODE_ENCODER_VIRTUAL: u32 = 5;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeFbCmd2 {
pub fb_id: u32,
pub width: u32,
pub height: u32,
pub pixel_format: u32,
pub flags: u32,
pub handles: [u32; 4],
pub pitches: [u32; 4],
pub offsets: [u32; 4],
pub _padding: u32,
pub modifier: [u64; 4],
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeCreateDumb {
pub height: u32,
pub width: u32,
pub bpp: u32,
pub flags: u32,
pub handle: u32,
pub pitch: u32,
pub size: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeMapDumb {
pub handle: u32,
pub pad: u32,
pub offset: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeDestroyDumb {
pub handle: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern)]
pub struct DrmGemClose {
pub handle: u32,
pub pad: u32,
}
pub const DRM_FORMAT_XRGB8888: u32 =
(b'X' as u32) | ((b'R' as u32) << 8) | ((b'2' as u32) << 16) | ((b'4' as u32) << 24);
pub const DRM_FORMAT_ARGB8888: u32 =
(b'A' as u32) | ((b'R' as u32) << 8) | ((b'2' as u32) << 16) | ((b'4' as u32) << 24);
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeGetPlaneRes {
pub plane_id_ptr: u64,
pub count_planes: u32,
pub _padding: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeGetPlane {
pub plane_id: u32,
pub crtc_id: u32,
pub fb_id: u32,
pub possible_crtcs: u32,
pub gamma_size: u32,
pub count_format_types: u32,
pub format_type_ptr: u64,
}
pub const DRM_MODE_OBJECT_CRTC: u32 = 0xcccc_cccc;
pub const DRM_MODE_OBJECT_CONNECTOR: u32 = 0xc0c0_c0c0;
pub const DRM_MODE_OBJECT_PLANE: u32 = 0xeeee_eeee;
pub const DRM_MODE_OBJECT_FB: u32 = 0xfbfb_fbfb;
pub const DRM_PLANE_TYPE_PRIMARY: u64 = 1;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeObjGetProperties {
pub props_ptr: u64,
pub prop_values_ptr: u64,
pub count_props: u32,
pub obj_id: u32,
pub obj_type: u32,
pub _padding: u32,
}
pub const DRM_MODE_PROP_RANGE: u32 = 1 << 1;
pub const DRM_MODE_PROP_IMMUTABLE: u32 = 1 << 2;
pub const DRM_MODE_PROP_ENUM: u32 = 1 << 3;
pub const DRM_MODE_PROP_BLOB: u32 = 1 << 4;
pub const DRM_MODE_PROP_OBJECT: u32 = 1 << 6;
pub const DRM_MODE_PROP_SIGNED_RANGE: u32 = 1 << 7;
pub const DRM_MODE_PROP_ATOMIC: u32 = 0x8000_0000;
pub const DRM_PROP_NAME_LEN: usize = 32;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModePropertyEnum {
pub value: u64,
pub name: [u8; DRM_PROP_NAME_LEN],
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeGetProperty {
pub values_ptr: u64,
pub enum_blob_ptr: u64,
pub prop_id: u32,
pub flags: u32,
pub name: [u8; DRM_PROP_NAME_LEN],
pub count_values: u32,
pub count_enum_blobs: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeCrtcPageFlip {
pub crtc_id: u32,
pub fb_id: u32,
pub flags: u32,
pub reserved: u32,
pub user_data: u64,
}
pub const DRM_MODE_PAGE_FLIP_EVENT: u32 = 0x01;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmWaitVblank {
pub rep_type: u32,
pub sequence: u32,
pub tv_sec: i64,
pub tv_usec: i64,
}
pub const DRM_VBLANK_RELATIVE: u32 = 0x1;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmEvent {
pub event_type: u32,
pub length: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmEventVblank {
pub base: DrmEvent,
pub user_data: u64,
pub tv_sec: u32,
pub tv_usec: u32,
pub sequence: u32,
pub crtc_id: u32,
}
pub const DRM_EVENT_FLIP_COMPLETE: u32 = 0x02;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeAtomic {
pub flags: u32,
pub count_objs: u32,
pub objs_ptr: u64,
pub count_props_ptr: u64,
pub props_ptr: u64,
pub prop_values_ptr: u64,
pub reserved: u64,
pub user_data: u64,
}
pub const DRM_MODE_ATOMIC_TEST_ONLY: u32 = 0x0100;
pub const DRM_MODE_ATOMIC_NONBLOCK: u32 = 0x0200;
pub const DRM_MODE_ATOMIC_ALLOW_MODESET: u32 = 0x0400;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeCreateBlob {
pub data: u64,
pub length: u32,
pub blob_id: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeDestroyBlob {
pub blob_id: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmModeGetBlob {
pub blob_id: u32,
pub length: u32,
pub data: u64,
}
pub const DRM_IOCTL_VIRTGPU_MAP: u32 = iowr::<DrmVirtgpuMap>(DRM_TYPE, 0x41);
pub const DRM_IOCTL_VIRTGPU_EXECBUFFER: u32 = iowr::<DrmVirtgpuExecbuffer>(DRM_TYPE, 0x42);
pub const DRM_IOCTL_VIRTGPU_GETPARAM: u32 = iowr::<DrmVirtgpuGetparam>(DRM_TYPE, 0x43);
pub const DRM_IOCTL_VIRTGPU_RESOURCE_CREATE: u32 = iowr::<DrmVirtgpuResourceCreate>(DRM_TYPE, 0x44);
pub const DRM_IOCTL_VIRTGPU_RESOURCE_INFO: u32 = iowr::<DrmVirtgpuResourceInfo>(DRM_TYPE, 0x45);
pub const DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST: u32 =
iowr::<DrmVirtgpu3dTransferFromHost>(DRM_TYPE, 0x46);
pub const DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST: u32 =
iowr::<DrmVirtgpu3dTransferToHost>(DRM_TYPE, 0x47);
pub const DRM_IOCTL_VIRTGPU_WAIT: u32 = iowr::<DrmVirtgpu3dWait>(DRM_TYPE, 0x48);
pub const DRM_IOCTL_VIRTGPU_GET_CAPS: u32 = iowr::<DrmVirtgpuGetCaps>(DRM_TYPE, 0x49);
pub const DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB: u32 =
iowr::<DrmVirtgpuResourceCreateBlob>(DRM_TYPE, 0x4a);
pub const DRM_IOCTL_VIRTGPU_CONTEXT_INIT: u32 = iowr::<DrmVirtgpuContextInit>(DRM_TYPE, 0x4b);
pub const VIRTGPU_PARAM_3D_FEATURES: u64 = 1;
pub const VIRTGPU_PARAM_CAPSET_QUERY_FIX: u64 = 2;
pub const VIRTGPU_PARAM_RESOURCE_BLOB: u64 = 3;
pub const VIRTGPU_PARAM_HOST_VISIBLE: u64 = 4;
pub const VIRTGPU_PARAM_CROSS_DEVICE: u64 = 5;
pub const VIRTGPU_PARAM_CONTEXT_INIT: u64 = 6;
pub const VIRTGPU_PARAM_SUPPORTED_CAPSET_IDS: u64 = 7;
#[allow(dead_code)]
pub const VIRTGPU_PARAM_EXPLICIT_DEBUG_NAME: u64 = 8;
#[allow(dead_code)]
pub const VIRTGPU_PARAM_BLOB_ALIGNMENT: u64 = 9;
pub const VIRTGPU_EXECBUF_FENCE_FD_IN: u32 = 0x01;
pub const VIRTGPU_EXECBUF_FENCE_FD_OUT: u32 = 0x02;
#[allow(dead_code)]
pub const VIRTGPU_EXECBUF_RING_IDX: u32 = 0x04;
#[allow(dead_code)]
pub const VIRTGPU_EXECBUF_SYNCOBJ_RESET: u32 = 0x01;
#[allow(dead_code)]
pub const VIRTGPU_WAIT_NOWAIT: u32 = 1;
pub const VIRTGPU_CONTEXT_PARAM_CAPSET_ID: u64 = 0x0001;
pub const VIRTGPU_CONTEXT_PARAM_NUM_RINGS: u64 = 0x0002;
pub const VIRTGPU_CONTEXT_PARAM_POLL_RINGS_MASK: u64 = 0x0003;
#[allow(dead_code)]
pub const VIRTGPU_CONTEXT_PARAM_DEBUG_NAME: u64 = 0x0004;
pub const VIRTGPU_DRM_CAPSET_VIRGL: u32 = 1;
pub const VIRTGPU_DRM_CAPSET_VIRGL2: u32 = 2;
#[allow(dead_code)]
pub const VIRTGPU_DRM_CAPSET_GFXSTREAM_VULKAN: u32 = 3;
#[allow(dead_code)]
pub const VIRTGPU_DRM_CAPSET_VENUS: u32 = 4;
#[allow(dead_code)]
pub const VIRTGPU_DRM_CAPSET_CROSS_DOMAIN: u32 = 5;
#[allow(dead_code)]
pub const VIRTGPU_DRM_CAPSET_DRM: u32 = 6;
pub const VIRTGPU_BLOB_MEM_GUEST: u32 = 0x0001;
pub const VIRTGPU_BLOB_MEM_HOST3D: u32 = 0x0002;
pub const VIRTGPU_BLOB_MEM_HOST3D_GUEST: u32 = 0x0003;
#[allow(dead_code)]
pub const VIRTGPU_BLOB_FLAG_USE_MAPPABLE: u32 = 0x0001;
#[allow(dead_code)]
pub const VIRTGPU_BLOB_FLAG_USE_SHAREABLE: u32 = 0x0002;
#[allow(dead_code)]
pub const VIRTGPU_BLOB_FLAG_USE_CROSS_DEVICE: u32 = 0x0004;
#[allow(dead_code)]
pub const DRM_VIRTGPU_BLOB_FLAG_HINT_DEFER_MAPPING: u32 = 0x0001;
#[allow(dead_code)]
pub const VIRTGPU_EVENT_FENCE_SIGNALED: u32 = 0x90000000;
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuMap {
pub offset: u64,
pub handle: u32,
pub pad: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuExecbuffer {
pub flags: u32,
pub size: u32,
pub command: u64,
pub bo_handles: u64,
pub num_bo_handles: u32,
pub fence_fd: i32,
pub ring_idx: u32,
pub syncobj_stride: u32,
pub num_in_syncobjs: u32,
pub num_out_syncobjs: u32,
pub in_syncobjs: u64,
pub out_syncobjs: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuGetparam {
pub param: u64,
pub value: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuResourceCreate {
pub target: u32,
pub format: u32,
pub bind: u32,
pub width: u32,
pub height: u32,
pub depth: u32,
pub array_size: u32,
pub last_level: u32,
pub nr_samples: u32,
pub flags: u32,
pub bo_handle: u32,
pub res_handle: u32,
pub size: u32,
pub stride: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuResourceInfo {
pub bo_handle: u32,
pub res_handle: u32,
pub size: u32,
pub blob_mem: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpu3dBox {
pub x: u32,
pub y: u32,
pub z: u32,
pub w: u32,
pub h: u32,
pub d: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern)]
pub struct DrmVirtgpu3dTransferToHost {
pub bo_handle: u32,
pub box_: DrmVirtgpu3dBox,
pub level: u32,
pub offset: u32,
pub stride: u32,
pub layer_stride: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern)]
pub struct DrmVirtgpu3dTransferFromHost {
pub bo_handle: u32,
pub box_: DrmVirtgpu3dBox,
pub level: u32,
pub offset: u32,
pub stride: u32,
pub layer_stride: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpu3dWait {
pub handle: u32,
pub flags: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuGetCaps {
pub cap_set_id: u32,
pub cap_set_ver: u32,
pub addr: u64,
pub size: u32,
pub pad: u32,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuResourceCreateBlob {
pub blob_mem: u32,
pub blob_flags: u32,
pub bo_handle: u32,
pub res_handle: u32,
pub size: u64,
pub pad: u32,
pub cmd_size: u32,
pub cmd: u64,
pub blob_id: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern)]
pub struct DrmVirtgpuContextInit {
pub num_params: u32,
pub pad: u32,
pub ctx_set_params: u64,
}
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern)]
pub struct DrmVirtgpuContextSetParam {
pub param: u64,
pub value: u64,
}
#[allow(dead_code)]
#[repr(C)]
#[derive(Debug, Default, Clone, Copy, AnyBitPattern, NoUninit)]
pub struct DrmVirtgpuExecbufferSyncobj {
pub handle: u32,
pub flags: u32,
pub point: u64,
}
#[cfg(all(test, not(axtest), feature = "rknpu"))]
mod tests {
use super::*;
#[test]
fn ioctl_nr_recovers_command_number() {
assert_eq!(ioctl_nr(DRM_IOCTL_VERSION), 0x00);
assert_eq!(ioctl_nr(DRM_IOCTL_GET_UNIQUE), 0x01);
assert_eq!(ioctl_nr(DRM_IOCTL_PRIME_HANDLE_TO_FD), 0x2d);
assert_eq!(ioctl_nr(DRM_IOCTL_MODE_GETRESOURCES), 0xA0);
}
#[test]
fn ioctl_nr_masks_to_low_byte() {
assert_eq!(ioctl_nr(0xc010_6402), 0x02);
}
#[test]
fn io_size_recovers_struct_size() {
assert_eq!(
io_size(DRM_IOCTL_VERSION),
core::mem::size_of::<DrmVersion>() as u32
);
assert_eq!(
io_size(DRM_IOCTL_GET_UNIQUE),
core::mem::size_of::<DrmUnique>() as u32
);
assert_eq!(io_size(DRM_IOCTL_SET_MASTER), 0);
}
#[test]
fn is_driver_ioctl_covers_command_range() {
assert!(!is_driver_ioctl(DRM_COMMAND_BASE - 1));
assert!(is_driver_ioctl(DRM_COMMAND_BASE));
assert!(is_driver_ioctl(DRM_COMMAND_END - 1));
assert!(!is_driver_ioctl(DRM_COMMAND_END));
assert!(!is_driver_ioctl(ioctl_nr(DRM_IOCTL_VERSION)));
assert!(!is_driver_ioctl(ioctl_nr(DRM_IOCTL_MODE_GETRESOURCES)));
assert!(is_driver_ioctl(0x40));
assert!(is_driver_ioctl(0x45));
}
}