drm: initial implementation DRM_IOCTL_MODE_CREATE_DUMB

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/drivers/drm/mod.rs

@@ -68,7 +68,8 @@ trait ModeObject: Send + Sync + Downcastable {
 
 trait DrmDevice: Send + Sync {
     /// Returns weather the DRM device supports creating dumb buffers.
-    fn dumb_create(&self) -> bool;
+    fn can_dumb_create(&self) -> bool;
+    fn dumb_create(&self, width: u32, height: u32, bpp: u32) -> BufferObject;
 
     /// Returns tuple containing the minumum dimensions (`xmin`, `ymin`).
     fn min_dim(&self) -> (usize, usize);
@@ -81,6 +82,24 @@ trait DrmDevice: Send + Sync {
     fn driver_info(&self) -> (&'static str, &'static str, &'static str);
 }
 
+struct BufferObject {
+    width: u32,
+    height: u32,
+    size: usize,
+    mapping: usize,
+}
+
+impl BufferObject {
+    pub fn new(width: u32, height: u32, size: usize) -> Self {
+        Self {
+            width,
+            height,
+            size,
+            mapping: 0,
+        }
+    }
+}
+
 // ## Notes:
 //
 // Plane: Image source
@@ -287,6 +306,10 @@ struct Drm {
     device: Arc<dyn DrmDevice>,
 
     id_alloc: IdAllocator,
+    mapping_alloc: IdAllocator,
+    buffer_alloc: IdAllocator,
+
+    buffers: Mutex<HashMap<u32, BufferObject>>,
     mode_objs: Mutex<HashMap<u32, Arc<dyn ModeObject>>>,
 
     // All of the mode objects:
@@ -305,7 +328,11 @@ impl Drm {
             card_id: DRM_CARD_ID.fetch_add(1, Ordering::SeqCst),
             device,
 
+            buffer_alloc: IdAllocator::new(),
             id_alloc: IdAllocator::new(),
+            mapping_alloc: IdAllocator::new(),
+
+            buffers: Mutex::new(HashMap::new()),
             mode_objs: Mutex::new(HashMap::new()),
 
             crtcs: Mutex::new(alloc::vec![]),
@@ -344,6 +371,13 @@ impl Drm {
     fn find_object(&self, id: u32) -> Option<Arc<dyn ModeObject>> {
         self.mode_objs.lock().get(&id).map(|obj| obj.clone())
     }
+
+    fn create_handle(&self, buffer: BufferObject) -> u32 {
+        let handle = self.buffer_alloc.alloc() as u32;
+
+        self.buffers.lock().insert(handle, buffer);
+        handle
+    }
 }
 
 impl INodeInterface for Drm {
@@ -374,7 +408,7 @@ impl INodeInterface for Drm {
                 // NOTE: The user is responsible for zeroing out the structure.
                 match struc.capability {
                     DRM_CAP_DUMB_BUFFER => {
-                        if self.device.dumb_create() {
+                        if self.device.can_dumb_create() {
                             struc.value = 1;
                         }
                     }
@@ -505,6 +539,23 @@ impl INodeInterface for Drm {
                 Ok(0)
             }
 
+            DRM_IOCTL_MODE_CREATE_DUMB => {
+                let struc = VirtAddr::new(arg as u64)
+                    .read_mut::<DrmModeCreateDumb>()
+                    .unwrap();
+
+                let mut buffer = self
+                    .device
+                    .dumb_create(struc.width, struc.height, struc.bpp);
+
+                assert!(buffer.size < (1usize << 32));
+
+                buffer.mapping = self.mapping_alloc.alloc() << 32;
+                struc.handle = self.create_handle(buffer);
+
+                Ok(0)
+            }
+
             _ => {
                 // command[8..16] is the ASCII character supposedly unique to each driver.
                 if command.get_bits(8..16) == DRM_IOCTL_BASE {

src/aero_kernel/src/drivers/drm/rawfb.rs

@@ -21,17 +21,24 @@ use alloc::sync::Arc;
 
 use crate::fs::devfs;
 use crate::fs::FileSystem;
-use crate::rendy;
+
+use crate::mem::paging::*;
 
 use super::*;
+use crate::rendy;
 
 struct RawFramebuffer {}
 
 impl DrmDevice for RawFramebuffer {
-    fn dumb_create(&self) -> bool {
+    fn can_dumb_create(&self) -> bool {
         true
     }
 
+    fn dumb_create(&self, width: u32, height: u32, bpp: u32) -> BufferObject {
+        let size = align_up((width * height * bpp / 8) as _, Size4KiB::SIZE);
+        BufferObject::new(width, height, size as usize)
+    }
+
     fn driver_version(&self) -> (usize, usize, usize) {
         (0, 0, 1)
     }

src/uapi/src/drm.rs

@@ -198,9 +198,25 @@ pub struct DrmModeGetConnector {
     pub pad: u32, // padding; must be zero
 }
 
+#[repr(C)]
+pub struct DrmModeCreateDumb {
+    pub height: u32,
+    pub width: u32,
+    pub bpp: u32,
+    pub flags: u32,
+
+    // the following will be returned:
+    pub handle: u32,
+    pub pitch: u32,
+    pub size: u64,
+}
+
 // DRM IOCTL constants:
 pub const DRM_IOCTL_VERSION: usize = drm_iowr::<DrmVersion>(0x00);
 pub const DRM_IOCTL_GET_CAP: usize = drm_iowr::<DrmGetCap>(0x0c);
+
 pub const DRM_IOCTL_MODE_GETRESOURCES: usize = drm_iowr::<DrmModeCardRes>(0xa0);
 pub const DRM_IOCTL_GET_ENCODER: usize = drm_iowr::<DrmModeGetEncoder>(0xa6);
 pub const DRM_IOCTL_GET_CONNECTOR: usize = drm_iowr::<DrmModeGetConnector>(0xa7);
+
+pub const DRM_IOCTL_MODE_CREATE_DUMB: usize = drm_iowr::<DrmModeCreateDumb>(0xb2);