Jackson Netherwood-Imig
704 lines
17 KiB
Zig
704 lines
17 KiB
Zig
const std = @import("std");
|
|
const IOCTL = std.os.linux.IOCTL;
|
|
|
|
pub const IoctlError = std.posix.UnexpectedError;
|
|
|
|
pub fn ioctl(fd: std.posix.fd_t, request: Request, arg: anytype) IoctlError!void {
|
|
const casted: usize = switch (@typeInfo(@TypeOf(arg))) {
|
|
.int => @intCast(arg),
|
|
.@"enum" => @intCast(@intFromEnum(arg)),
|
|
.pointer => @intFromPtr(arg),
|
|
else => @compileError("Unsupported type: " ++ @typeName(@TypeOf(arg))),
|
|
};
|
|
|
|
const rc = std.posix.system.ioctl(fd, @intCast(@intFromEnum(request)), casted);
|
|
|
|
return switch (std.posix.errno(rc)) {
|
|
.SUCCESS => {},
|
|
else => |err| std.posix.unexpectedErrno(err),
|
|
};
|
|
}
|
|
|
|
pub const Request = enum(u32) {
|
|
version = drm_iowr(0x00, Version),
|
|
get_unique = drm_iowr(0x01, Unique),
|
|
get_magic = drm_ior(0x02, Auth),
|
|
irq_busid = drm_iowr(0x03, IrqBusid),
|
|
get_map = drm_iowr(0x04, Map),
|
|
get_client = drm_iowr(0x05, Client),
|
|
get_stats = drm_ior(0x06, Stats),
|
|
set_version = drm_iowr(0x07, SetVersion),
|
|
// modeset_ctl = drm_iow(0x08, drm_modeset_ctl),
|
|
// gem_close = drm_iow(0x09, drm_gem_close),
|
|
// gem_flink = drm_iowr(0x0a, drm_gem_flink),
|
|
// gem_open = drm_iowr(0x0b, drm_gem_open),
|
|
get_cap = drm_iowr(0x0c, GetCap),
|
|
set_client_cap = drm_iow(0x0d, SetClientCap),
|
|
set_unique = drm_iow(0x10, Unique),
|
|
auth_magic = drm_iow(0x11, Auth),
|
|
// block = drm_iowr(0x12, drm_block),
|
|
// unblock = drm_iowr(0x13, drm_block),
|
|
// control = drm_iow(0x14, drm_control),
|
|
add_map = drm_iowr(0x15, Map),
|
|
// add_bufs = drm_iowr(0x16, drm_buf_desc),
|
|
// mark_bufs = drm_iow(0x17, drm_buf_desc),
|
|
// info_bufs = drm_iowr(0x18, drm_buf_info),
|
|
// map_bufs = drm_iowr(0x19, drm_buf_map),
|
|
// free_bufs = drm_iow(0x1a, drm_buf_free),
|
|
rm_map = drm_iow(0x1b, Map),
|
|
// set_sarea_ctx = drm_iow(0x1c, drm_ctx_priv_map),
|
|
// get_sarea_ctx = drm_iowr(0x1d, drm_ctx_priv_map),
|
|
set_master = drm_io(0x1e),
|
|
drop_master = drm_io(0x1f),
|
|
add_ctx = drm_iowr(0x20, Ctx),
|
|
rm_ctx = drm_iowr(0x21, Ctx),
|
|
mod_ctx = drm_iow(0x22, Ctx),
|
|
get_ctx = drm_iowr(0x23, Ctx),
|
|
switch_ctx = drm_iow(0x24, Ctx),
|
|
new_ctx = drm_iow(0x25, Ctx),
|
|
res_ctx = drm_iowr(0x26, CtxRes),
|
|
// add_draw = drm_iowr(0x27, drm_draw),
|
|
// rm_draw = drm_iowr(0x28, drm_draw),
|
|
// dma = drm_iowr(0x29, drm_dma),
|
|
// lock = drm_iow(0x2a, drm_lock),
|
|
// unlock = drm_iow(0x2b, drm_lock),
|
|
// finish = drm_iow(0x2c, drm_lock),
|
|
// prime_handle_to_fd = drm_iowr(0x2d, drm_prime_handle),
|
|
// prime_fd_to_handle = drm_iowr(0x2e, drm_prime_handle),
|
|
agp_acquire = drm_io(0x30),
|
|
agp_release = drm_io(0x31),
|
|
// agp_enable = drm_iow(0x32, drm_agp_mode),
|
|
// agp_info = drm_ior(0x33, drm_agp_info),
|
|
// agp_alloc = drm_iowr(0x34, drm_agp_buffer),
|
|
// agp_free = drm_iow(0x35, drm_agp_buffer),
|
|
// agp_bind = drm_iow(0x36, drm_agp_binding),
|
|
// agp_unbind = drm_iow(0x37, drm_agp_binding),
|
|
// sg_alloc = drm_iowr(0x38, drm_scatter_gather),
|
|
// sg_free = drm_iow(0x39, drm_scatter_gather),
|
|
// wait_vblank = drm_iowr(0x3a, drm_wait_vblank),
|
|
// crtc_get_sequence = drm_iowr(0x3b, drm_crtc_get_sequence),
|
|
// crtc_queue_sequence = drm_iowr(0x3c, drm_crtc_queue_sequence),
|
|
// update_draw = drm_iow(0x3f, drm_update_draw),
|
|
mode_getresources = drm_iowr(0xA0, mode.CardRes),
|
|
mode_getcrtc = drm_iowr(0xA1, mode.Crtc),
|
|
mode_setcrtc = drm_iowr(0xA2, mode.Crtc),
|
|
mode_cursor = drm_iowr(0xA3, mode.Cursor),
|
|
mode_getgamma = drm_iowr(0xA4, mode.CrtcLut),
|
|
mode_setgamma = drm_iowr(0xA5, mode.CrtcLut),
|
|
mode_getencoder = drm_iowr(0xA6, mode.GetEncoder),
|
|
mode_getconnector = drm_iowr(0xA7, mode.GetConnector),
|
|
mode_getproperty = drm_iowr(0xAA, mode.GetProperty),
|
|
mode_setproperty = drm_iowr(0xAB, mode.ConnectorSetProperty),
|
|
mode_getpropblob = drm_iowr(0xAC, mode.GetBlob),
|
|
mode_getfb = drm_iowr(0xAD, mode.FbCmd),
|
|
mode_addfb = drm_iowr(0xAE, mode.FbCmd),
|
|
mode_rmfb = drm_iowr(0xAF, c_uint),
|
|
mode_page_flip = drm_iowr(0xB0, mode.CrtcPageFlip),
|
|
mode_dirtyfb = drm_iowr(0xB1, mode.FbDirtyCmd),
|
|
mode_create_dumb = drm_iowr(0xB2, mode.CreateDumb),
|
|
mode_map_dumb = drm_iowr(0xB3, mode.MapDumb),
|
|
mode_destroy_dumb = drm_iowr(0xB4, mode.DestroyDumb),
|
|
mode_getplaneresources = drm_iowr(0xB5, mode.GetPlaneRes),
|
|
mode_getplane = drm_iowr(0xB6, mode.GetPlane),
|
|
mode_setplane = drm_iowr(0xB7, mode.SetPlane),
|
|
mode_addfb2 = drm_iowr(0xB8, mode.FbCmd2),
|
|
mode_obj_getproperties = drm_iowr(0xB9, mode.ObjGetProperties),
|
|
mode_obj_setproperty = drm_iowr(0xBA, mode.ObjSetProperty),
|
|
mode_cursor2 = drm_iowr(0xBB, mode.Cursor2),
|
|
mode_atomic = drm_iowr(0xBC, mode.Atomic),
|
|
mode_createpropblob = drm_iowr(0xBD, mode.CreateBlob),
|
|
mode_destroypropblob = drm_iowr(0xBE, mode.DestroyBlob),
|
|
// syncobj_create = drm_iowr(0xBF, drm_syncobj_create),
|
|
// syncobj_destroy = drm_iowr(0xC0, drm_syncobj_destroy),
|
|
// syncobj_handle_to_fd = drm_iowr(0xC1, drm_syncobj_handle),
|
|
// syncobj_fd_to_handle = drm_iowr(0xC2, drm_syncobj_handle),
|
|
// syncobj_wait = drm_iowr(0xC3, drm_syncobj_wait),
|
|
// syncobj_reset = drm_iowr(0xC4, drm_syncobj_array),
|
|
// syncobj_signal = drm_iowr(0xC5, drm_syncobj_array),
|
|
mode_create_lease = drm_iowr(0xC6, mode.CreateLease),
|
|
mode_list_lessees = drm_iowr(0xC7, mode.ListLessees),
|
|
mode_get_lease = drm_iowr(0xC8, mode.GetLease),
|
|
mode_revoke_lease = drm_iowr(0xC9, mode.RevokeLease),
|
|
// syncobj_timeline_wait = drm_iowr(0xCA, drm_syncobj_timeline_wait),
|
|
// syncobj_query = drm_iowr(0xCB, drm_syncobj_timeline_array),
|
|
// syncobj_transfer = drm_iowr(0xCC, drm_syncobj_transfer),
|
|
// syncobj_timeline_signal = drm_iowr(0xCD, drm_syncobj_timeline_array),
|
|
mode_getfb2 = drm_iowr(0xCE, mode.FbCmd2),
|
|
// syncobj_eventfd = drm_iowr(0xCF, drm_syncobj_eventfd),
|
|
mode_closefb = drm_iowr(0xD0, mode.CloseFb),
|
|
// set_client_name = drm_iowr(0xD1, drm_set_client_name),
|
|
// gem_change_handle = drm_iowr(0xD2, drm_gem_change_handle),
|
|
|
|
const io_type = 'd';
|
|
|
|
fn drm_io(nr: u8) u32 {
|
|
return IOCTL.IO(io_type, nr);
|
|
}
|
|
|
|
fn drm_ior(nr: u8, comptime T: type) u32 {
|
|
return IOCTL.IOR(io_type, nr, T);
|
|
}
|
|
|
|
fn drm_iow(nr: u8, comptime T: type) u32 {
|
|
return IOCTL.IOW(io_type, nr, T);
|
|
}
|
|
|
|
fn drm_iowr(nr: u8, comptime T: type) u32 {
|
|
return IOCTL.IOWR(io_type, nr, T);
|
|
}
|
|
};
|
|
|
|
pub const Magic = c_uint;
|
|
|
|
pub const Context = c_ulong;
|
|
|
|
pub const Version = extern struct {
|
|
version_major: c_int,
|
|
version_minor: c_int,
|
|
version_patch: c_int,
|
|
name_len: c_ulong,
|
|
name: [*:0]const u8,
|
|
date_len: c_ulong,
|
|
date: [*:0]const u8,
|
|
desc_len: c_ulong,
|
|
desc: [*:0]const u8,
|
|
};
|
|
|
|
pub const Unique = extern struct {
|
|
unique_len: c_ulong,
|
|
unique: [*:0]const u8,
|
|
};
|
|
|
|
pub const Auth = extern struct {
|
|
magic: Magic,
|
|
};
|
|
|
|
pub const IrqBusid = extern struct {
|
|
irq: c_int,
|
|
busnum: c_int,
|
|
devnum: c_int,
|
|
funcnum: c_int,
|
|
};
|
|
|
|
pub const Map = extern struct {
|
|
offset: c_ulong,
|
|
size: c_ulong,
|
|
type: MapType,
|
|
flags: MapFlags,
|
|
handle: *anyopaque,
|
|
mtrr: c_int,
|
|
};
|
|
|
|
pub const MapType = enum(c_int) {
|
|
frame_buffer = 0,
|
|
registers = 1,
|
|
shm = 2,
|
|
agp = 3,
|
|
scatter_gather = 4,
|
|
consistent = 5,
|
|
};
|
|
|
|
pub const MapFlags = packed struct(c_int) {
|
|
restricted: bool = false,
|
|
read_only: bool = false,
|
|
locked: bool = false,
|
|
kernel: bool = false,
|
|
write_combining: bool = false,
|
|
contains_lock: bool = false,
|
|
removable: bool = false,
|
|
driver: bool = false,
|
|
_: @Int(.signed, @bitSizeOf(c_int) - 8) = 0,
|
|
};
|
|
|
|
pub const Client = extern struct {
|
|
idx: c_int,
|
|
auth: c_int,
|
|
pid: c_ulong,
|
|
uid: c_ulong,
|
|
magic: Magic,
|
|
iocs: c_ulong,
|
|
};
|
|
|
|
pub const Stats = extern struct {
|
|
count: c_ulong,
|
|
data: [15]Stat,
|
|
};
|
|
|
|
pub const Stat = extern struct {
|
|
value: c_ulong,
|
|
type: StatType,
|
|
};
|
|
|
|
pub const StatType = enum(c_int) {
|
|
lock,
|
|
opens,
|
|
closes,
|
|
ioctls,
|
|
locks,
|
|
unlocks,
|
|
value,
|
|
byte,
|
|
count,
|
|
irq,
|
|
primary,
|
|
secondary,
|
|
dma,
|
|
special,
|
|
missed,
|
|
};
|
|
|
|
pub const SetVersion = extern struct {
|
|
di_major: c_int,
|
|
di_minor: c_int,
|
|
dd_major: c_int,
|
|
dd_minor: c_int,
|
|
};
|
|
|
|
pub const GetCap = extern struct {
|
|
capability: Capability,
|
|
value: u64,
|
|
};
|
|
|
|
pub const Capability = enum(u64) {
|
|
dumb_buffer = 0x1,
|
|
vblank_high_crtc = 0x2,
|
|
dumb_preferred_depth = 0x3,
|
|
dumb_buffer_shadow = 0x4,
|
|
prime = 0x5,
|
|
timestamp_monotonic = 0x6,
|
|
async_page_flip = 0x7,
|
|
cursor_width = 0x8,
|
|
cursor_height = 0x9,
|
|
addfbd_modifiers = 0x10,
|
|
page_flip_target = 0x11,
|
|
crtc_in_vblank_event = 0x12,
|
|
syncobj = 0x13,
|
|
syncobj_timeline = 0x14,
|
|
atomic_async_page_flip = 0x15,
|
|
};
|
|
|
|
pub const SetClientCap = extern struct {
|
|
capability: ClientCapability,
|
|
value: u64,
|
|
};
|
|
|
|
pub const ClientCapability = enum(u64) {
|
|
stereo_3d = 1,
|
|
universal_planes = 2,
|
|
atomic = 3,
|
|
aspect_ratio = 4,
|
|
writeback_connectors = 5,
|
|
cursor_plane_hotspot = 6,
|
|
};
|
|
|
|
pub const Ctx = extern struct {
|
|
handle: Context,
|
|
flags: CtxFlags,
|
|
};
|
|
|
|
pub const CtxFlags = packed struct(c_int) {
|
|
preserved: bool = false,
|
|
@"2d_only": bool = false,
|
|
_: @Int(.signed, @bitSizeOf(c_int) - 2) = 0,
|
|
};
|
|
|
|
pub const CtxRes = extern struct {
|
|
count: c_int,
|
|
contexts: [*]Ctx,
|
|
};
|
|
|
|
pub const Event = extern struct {
|
|
type: EventType,
|
|
length: u32,
|
|
};
|
|
|
|
pub const EventType = enum(u32) {
|
|
vblank = 0x01,
|
|
flip_complete = 0x02,
|
|
crtc_sequence = 0x03,
|
|
};
|
|
|
|
pub const EventVblank = extern struct {
|
|
base: Event,
|
|
user_data: u64,
|
|
tv_sec: u32,
|
|
tv_usec: u32,
|
|
sequence: u32,
|
|
crtc_id: u32,
|
|
};
|
|
|
|
pub const EventCrtcSequence = extern struct {
|
|
base: Event,
|
|
user_data: u64,
|
|
time_ns: i64,
|
|
sequence: u64,
|
|
};
|
|
|
|
pub const mode = struct {
|
|
pub const display_mode_len = 32;
|
|
pub const prop_name_len = 32;
|
|
|
|
pub const CardRes = extern struct {
|
|
fb_id_ptr: u64,
|
|
crtc_id_ptr: u64,
|
|
connector_id_ptr: u64,
|
|
encoder_id_ptr: u64,
|
|
count_fbs: u32,
|
|
count_crtcs: u32,
|
|
count_connectors: u32,
|
|
count_encoders: u32,
|
|
min_width: u32,
|
|
max_width: u32,
|
|
min_height: u32,
|
|
max_height: u32,
|
|
};
|
|
|
|
pub const Crtc = extern struct {
|
|
set_connectors_ptr: u64,
|
|
count_connectors: u32,
|
|
crtc_id: u32,
|
|
fb_id: u32,
|
|
x: u32,
|
|
y: u32,
|
|
gamma_size: u32,
|
|
mode_valid: u32,
|
|
mode: ModeInfo,
|
|
};
|
|
|
|
pub const CrtcLut = extern struct {
|
|
crtc_id: u32,
|
|
gamma_size: u32,
|
|
red: u64,
|
|
green: u64,
|
|
blue: u64,
|
|
};
|
|
|
|
pub const ModeInfo = extern struct {
|
|
clock: u32,
|
|
hdisplay: u16,
|
|
hsync_start: u16,
|
|
hsync_end: u16,
|
|
htotal: u16,
|
|
hskew: u16,
|
|
vdisplay: u16,
|
|
vsync_start: u16,
|
|
vsync_end: u16,
|
|
vtotal: u16,
|
|
vscan: u16,
|
|
vrefresh: u32,
|
|
flags: ModeFlags,
|
|
type: ModeType,
|
|
|
|
name: [display_mode_len]u8,
|
|
};
|
|
|
|
pub const ModeType = packed struct(u32) {
|
|
_deprecated0: u1 = 0,
|
|
_deprecated1: u1 = 0,
|
|
_deprecated2: u1 = 0,
|
|
preferred: bool = false,
|
|
_deprecated4: u1 = 0,
|
|
userdef: bool = false,
|
|
driver: bool = false,
|
|
_: u25 = 0,
|
|
};
|
|
|
|
pub const ModeFlags = packed struct(u32) {
|
|
phsync: bool = false,
|
|
nhsync: bool = false,
|
|
pvsync: bool = false,
|
|
nvsync: bool = false,
|
|
interlace: bool = false,
|
|
dblscan: bool = false,
|
|
csync: bool = false,
|
|
pcsync: bool = false,
|
|
ncsync: bool = false,
|
|
hskew: bool = false,
|
|
_deprecated10: u1 = 0,
|
|
_deprecated11: u1 = 0,
|
|
dblclk: bool = false,
|
|
clkdiv2: bool = false,
|
|
_: u18 = 0,
|
|
};
|
|
|
|
pub const Cursor = extern struct {
|
|
flags: u32,
|
|
crtc_id: u32,
|
|
x: i32,
|
|
y: i32,
|
|
width: u32,
|
|
height: u32,
|
|
handle: u32,
|
|
};
|
|
|
|
pub const GetEncoder = extern struct {
|
|
encoder_id: u32,
|
|
encoder_type: EncoderType,
|
|
crtc_id: u32,
|
|
possible_crtcs: u32,
|
|
possible_clones: u32,
|
|
};
|
|
|
|
pub const EncoderType = enum(u32) {
|
|
none = 0,
|
|
dac = 1,
|
|
tmds = 2,
|
|
lvds = 3,
|
|
tvdac = 4,
|
|
virtual = 5,
|
|
dsi = 6,
|
|
dpmst = 7,
|
|
dpi = 8,
|
|
};
|
|
|
|
pub const GetConnector = extern struct {
|
|
encoders_ptr: u64,
|
|
modes_ptr: u64,
|
|
props_ptr: u64,
|
|
prop_values_ptr: u64,
|
|
count_modes: u32,
|
|
count_props: u32,
|
|
count_encoders: u32,
|
|
encoder_id: u32,
|
|
connector_id: u32,
|
|
connector_type: ConnectorType,
|
|
connector_type_id: u32,
|
|
connection: u32,
|
|
mm_width: u32,
|
|
mm_height: u32,
|
|
subpixel: u32,
|
|
pad: u32,
|
|
};
|
|
|
|
pub const ConnectorType = enum(u32) {
|
|
unknown = 0,
|
|
vga = 1,
|
|
dvi_i = 2,
|
|
dvi_d = 3,
|
|
dvi_a = 4,
|
|
composite = 5,
|
|
svideo = 6,
|
|
lvds = 7,
|
|
component = 8,
|
|
din = 9,
|
|
display_port = 10,
|
|
hdmi_a = 11,
|
|
hdmi_b = 12,
|
|
tv = 13,
|
|
e_dp = 14,
|
|
virtual = 15,
|
|
dsi = 16,
|
|
dpi = 17,
|
|
writeback = 18,
|
|
spi = 19,
|
|
usb = 20,
|
|
};
|
|
|
|
pub const GetProperty = extern struct {
|
|
values_ptr: u64,
|
|
enum_blob_ptr: u64,
|
|
prop_id: u32,
|
|
flags: u32,
|
|
name: [prop_name_len]u8,
|
|
count_values: u32,
|
|
count_enum_blobs: u32,
|
|
};
|
|
|
|
pub const ConnectorSetProperty = extern struct {
|
|
value: u64,
|
|
prop_id: u32,
|
|
connector_id: u32,
|
|
};
|
|
|
|
pub const GetBlob = extern struct {
|
|
blob_id: u32,
|
|
length: u32,
|
|
data: u64,
|
|
};
|
|
|
|
pub const FbCmd = extern struct {
|
|
fb_id: u32,
|
|
width: u32,
|
|
height: u32,
|
|
pitch: u32,
|
|
bpp: u32,
|
|
depth: u32,
|
|
handle: u32,
|
|
};
|
|
|
|
pub const CrtcPageFlip = extern struct {
|
|
crtc_id: u32,
|
|
fb_id: u32,
|
|
flags: PageFlipFlags,
|
|
reserved: u32,
|
|
user_data: u64,
|
|
};
|
|
|
|
pub const PageFlipFlags = packed struct(u32) {
|
|
event: bool = false,
|
|
async: bool = false,
|
|
target_absolute: bool = false,
|
|
target_relative: bool = false,
|
|
_: u28 = 0,
|
|
};
|
|
|
|
pub const FbDirtyCmd = extern struct {
|
|
fb_id: u32,
|
|
flags: u32,
|
|
color: u32,
|
|
num_clips: u32,
|
|
clips_ptr: u64,
|
|
};
|
|
|
|
pub const CreateDumb = extern struct {
|
|
height: u32,
|
|
width: u32,
|
|
bpp: u32,
|
|
flags: u32,
|
|
handle: u32,
|
|
pitch: u32,
|
|
size: u64,
|
|
};
|
|
|
|
pub const MapDumb = extern struct {
|
|
handle: u32,
|
|
pad: u32,
|
|
offset: u64,
|
|
};
|
|
|
|
pub const DestroyDumb = extern struct {
|
|
handle: u32,
|
|
};
|
|
|
|
pub const GetPlaneRes = extern struct {
|
|
plane_id_ptr: u64,
|
|
count_planes: u32,
|
|
};
|
|
|
|
pub const GetPlane = extern struct {
|
|
plane_id: u32,
|
|
crtc_id: u32,
|
|
fb_id: u32,
|
|
possible_crtcs: u32,
|
|
gamma_size: u32,
|
|
count_format_types: u32,
|
|
format_type_ptr: u64,
|
|
};
|
|
|
|
pub const SetPlane = extern struct {
|
|
plane_id: u32,
|
|
crtc_id: u32,
|
|
fb_id: u32,
|
|
flags: u32,
|
|
crtc_x: i32,
|
|
crtc_y: i32,
|
|
crtc_w: u32,
|
|
crtc_h: u32,
|
|
src_x: u32,
|
|
src_y: u32,
|
|
src_h: u32,
|
|
src_w: u32,
|
|
};
|
|
|
|
pub const FbCmd2 = extern struct {
|
|
fb_id: u32,
|
|
width: u32,
|
|
height: u32,
|
|
pixel_format: u32,
|
|
flags: u32,
|
|
handles: [4]u32,
|
|
pitches: [4]u32,
|
|
offsets: [4]u32,
|
|
modifiers: [4]u64,
|
|
};
|
|
|
|
pub const ObjGetProperties = extern struct {
|
|
props_ptr: u64,
|
|
prop_values_ptr: u64,
|
|
count_props: u32,
|
|
obj_id: u32,
|
|
obj_type: ObjType,
|
|
};
|
|
|
|
pub const ObjType = enum(u32) {
|
|
crtc = 0xcccccccc,
|
|
connector = 0xc0c0c0c0,
|
|
encoder = 0xe0e0e0e0,
|
|
mode = 0xdededede,
|
|
property = 0xb0b0b0b0,
|
|
fb = 0xfbfbfbfb,
|
|
blob = 0xbbbbbbbb,
|
|
plane = 0xeeeeeeee,
|
|
any = 0,
|
|
};
|
|
|
|
pub const ObjSetProperty = extern struct {
|
|
value: u64,
|
|
prop_id: u32,
|
|
obj_id: u32,
|
|
obj_type: u32,
|
|
};
|
|
|
|
pub const Cursor2 = extern struct {
|
|
flags: u32,
|
|
crtc_id: u32,
|
|
x: i32,
|
|
y: i32,
|
|
width: u32,
|
|
height: u32,
|
|
handle: u32,
|
|
hot_x: i32,
|
|
hot_y: i32,
|
|
};
|
|
|
|
pub const Atomic = extern struct {
|
|
flags: u32,
|
|
count_objs: u32,
|
|
objs_ptr: u64,
|
|
count_props_ptr: u64,
|
|
props_ptr: u64,
|
|
prop_values_ptr: u64,
|
|
reserved: u64,
|
|
user_data: u64,
|
|
};
|
|
|
|
pub const CreateBlob = extern struct {
|
|
data: u64,
|
|
length: u32,
|
|
blob_id: u32,
|
|
};
|
|
|
|
pub const DestroyBlob = extern struct {
|
|
blob_id: u32,
|
|
};
|
|
|
|
pub const CreateLease = extern struct {
|
|
object_ids: u64,
|
|
object_count: u32,
|
|
flags: u32,
|
|
lessee_id: u32,
|
|
fd: u32,
|
|
};
|
|
|
|
pub const ListLessees = extern struct {
|
|
count_lessees: u32,
|
|
pad: u32,
|
|
lessees_ptr: u64,
|
|
};
|
|
|
|
pub const GetLease = extern struct {
|
|
count_objects: u32,
|
|
pad: u32,
|
|
objects_ptr: u64,
|
|
};
|
|
|
|
pub const RevokeLease = extern struct {
|
|
lessee_id: u32,
|
|
};
|
|
|
|
pub const CloseFb = extern struct {
|
|
fb_id: u32,
|
|
pad: u32,
|
|
};
|
|
};
|