1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::bindings;
use core::ptr::addr_of;

pub use bindings::{drmModePropertyPtr, drm_mode_property_enum};

#[derive(Debug, Clone)]
pub struct drmModeProperty(pub(crate) drmModePropertyPtr);

impl drmModeProperty {
    pub fn get(fd: i32, property_id: u32) -> Option<Self> {
        let prop_ptr = unsafe { bindings::drmModeGetProperty(
            fd,
            property_id,
        ) };

        if prop_ptr.is_null() {
            None
        } else {
            Some(Self(prop_ptr))
        }
    }

    pub fn name(&self) -> String {
        let c_name = unsafe { addr_of!((*self.0).name).read() };

        super::c_char_to_string(&c_name)
    }

    pub fn prop_id(&self) -> u32 {
        unsafe { addr_of!((*self.0).prop_id).read() }
    }

    pub fn flags(&self) -> u32 {
        unsafe { addr_of!((*self.0).flags).read() }
    }

    pub fn property_type(&self) -> drmModePropType {
        let flags = self.flags();
        let type_ = flags & (bindings::DRM_MODE_PROP_LEGACY_TYPE | bindings::DRM_MODE_PROP_EXTENDED_TYPE);

        drmModePropType::from(type_)
    }

    pub fn is_pending(&self) -> bool {
        let flags = self.flags();
        (flags & DRM_MODE_PROP_PENDING) != 0
    }

    pub fn is_immutable(&self) -> bool {
        let flags = self.flags();
        (flags & DRM_MODE_PROP_IMMUTABLE) != 0
    }

    pub fn values(&self) -> Vec<u64> {
        unsafe { std::slice::from_raw_parts(
            addr_of!((*self.0).values).read(),
            addr_of!((*self.0).count_values).read() as usize,
        ) }.to_vec()
    }

    pub fn blob_ids(&self) -> Vec<u32> {
        unsafe { std::slice::from_raw_parts(
            addr_of!((*self.0).blob_ids).read(),
            addr_of!((*self.0).count_blobs).read() as usize,
        ) }.to_vec()
    }

    pub fn enums(&self) -> Vec<drm_mode_property_enum> {
        unsafe { std::slice::from_raw_parts(
            addr_of!((*self.0).enums).read(),
            addr_of!((*self.0).count_enums).read() as usize,
        ) }.to_vec()
    }
}

impl Drop for drmModeProperty {
    fn drop(&mut self) {
	    unsafe { bindings::drmModeFreeProperty(self.0); }
    }
}

pub(crate) const DRM_MODE_PROP_OBJECT: u32 = 1 << 6;
pub(crate) const DRM_MODE_PROP_SIGNED_RANGE: u32 = 2 << 6;

use bindings::{
    DRM_MODE_PROP_PENDING,
    DRM_MODE_PROP_RANGE,
    DRM_MODE_PROP_IMMUTABLE,
    DRM_MODE_PROP_ENUM,
    DRM_MODE_PROP_BLOB,
    DRM_MODE_PROP_BITMASK,
    DRM_MODE_PROP_LEGACY_TYPE,
    DRM_MODE_PROP_EXTENDED_TYPE,
    DRM_MODE_PROP_ATOMIC,
};

#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd)]
#[repr(u32)]
pub enum drmModePropType {
    RANGE = DRM_MODE_PROP_RANGE,
    ENUM = DRM_MODE_PROP_ENUM,
    BLOB = DRM_MODE_PROP_BLOB,
    BITMASK = DRM_MODE_PROP_BITMASK,
    LEGACY_TYPE = DRM_MODE_PROP_LEGACY_TYPE,
    EXTENDED_TYPE = DRM_MODE_PROP_EXTENDED_TYPE,
    ATOMIC = DRM_MODE_PROP_ATOMIC,
    OBJECT = DRM_MODE_PROP_OBJECT,
    SIGNED_RANGE = DRM_MODE_PROP_SIGNED_RANGE,
    UNKNOWN,
}

impl From<u32> for drmModePropType {
    fn from(value: u32) -> Self {
        match value {
            DRM_MODE_PROP_RANGE => Self::RANGE,
            DRM_MODE_PROP_ENUM => Self::ENUM,
            DRM_MODE_PROP_BLOB => Self::BLOB,
            DRM_MODE_PROP_BITMASK => Self::BITMASK,
            DRM_MODE_PROP_LEGACY_TYPE => Self::LEGACY_TYPE,
            DRM_MODE_PROP_EXTENDED_TYPE => Self::EXTENDED_TYPE,
            DRM_MODE_PROP_ATOMIC => Self::ATOMIC,
            _ => Self::UNKNOWN,
        }
    }
}

#[cfg(feature = "std")]
use std::fmt;
#[cfg(feature = "std")]
impl fmt::Display for drmModePropType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl drm_mode_property_enum {
    pub fn name(&self) -> String {
        super::c_char_to_string(&self.name)
    }
}