drm: initial implementation DRM_IOCTL_VERSION

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

Author: Andy-Python-Programmer

src/Cargo.lock

@@ -35,6 +35,7 @@ stivale-boot = "0.2.6"
 intrusive-collections = "0.9.2"
 serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 lai = { git = "https://github.com/aero-os/lai-rs" }
+uapi = { path = "../uapi" }
 
 [dependencies.vte]
 git = "https://github.com/Andy-Python-Programmer/vte"

src/aero_kernel/Cargo.toml

@@ -1,13 +1,62 @@
+/*
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 use alloc::string::String;
 use alloc::sync::{Arc, Weak};
 
+use crate::fs;
 use crate::fs::devfs;
 use crate::fs::inode::INodeInterface;
 use crate::fs::FileSystem;
 
-trait DrmDevice: Send + Sync {}
+use crate::mem::paging::VirtAddr;
+
+use uapi::drm::*;
+
+trait DrmDevice: Send + Sync {
+    /// Returns a tuple containg the driver major, minor and patch level respectively.
+    fn driver_version(&self) -> (usize, usize, usize);
+    /// Returns a tuple contaning the driver name, desc and date respectively.
+    fn driver_info(&self) -> (&'static str, &'static str, &'static str);
+}
+
+fn copy_field(buffer: *mut u8, buffer_size: &mut usize, value: &[u8]) {
+    // do not overflow the user buffer.
+    let mut copy_len = value.len();
+
+    if *buffer_size > value.len() {
+        copy_len = *buffer_size;
+    }
+
+    // let userspace know exact length of driver value (which could be
+    // larger than the userspace-supplied buffer).
+    *buffer_size = value.len();
+
+    // finally, try filling in the user buffer.
+    if copy_len != 0 && !buffer.is_null() {
+        unsafe {
+            core::ptr::copy_nonoverlapping(value.as_ptr(), buffer, copy_len);
+        }
+    }
+}
 
 static DRM_CARD_ID: AtomicUsize = AtomicUsize::new(0);
 
@@ -34,7 +83,32 @@ impl Drm {
     }
 }
 
-impl INodeInterface for Drm {}
+impl INodeInterface for Drm {
+    // The DRM is accessed using IOCTLs on a device representing a graphics
+    // card.
+    fn ioctl(&self, command: usize, arg: usize) -> fs::Result<usize> {
+        match command {
+            DRM_IOCTL_VERSION => {
+                let struc = VirtAddr::new(arg as u64).read_mut::<DrmVersion>().unwrap();
+
+                let (major, minor, patch_level) = self.device.driver_version();
+                let (name, desc, date) = self.device.driver_info();
+
+                struc.version_major = major as _;
+                struc.version_minor = minor as _;
+                struc.version_patch_level = patch_level as _;
+
+                copy_field(struc.name, &mut struc.name_len, name.as_bytes());
+                copy_field(struc.desc, &mut struc.desc_len, desc.as_bytes());
+                copy_field(struc.date, &mut struc.date_len, date.as_bytes());
+
+                Ok(0)
+            }
+
+            _ => unimplemented!(),
+        }
+    }
+}
 
 impl devfs::Device for Drm {
     fn device_marker(&self) -> usize {
@@ -52,7 +126,15 @@ impl devfs::Device for Drm {
 
 struct RawFramebuffer {}
 
-impl DrmDevice for RawFramebuffer {}
+impl DrmDevice for RawFramebuffer {
+    fn driver_version(&self) -> (usize, usize, usize) {
+        (0, 0, 1)
+    }
+
+    fn driver_info(&self) -> (&'static str, &'static str, &'static str) {
+        ("rawfb_gpu", "rawfb gpu", "0")
+    }
+}
 
 fn init() {
     let dri = devfs::DEV_FILESYSTEM

src/aero_kernel/src/drivers/drm.rs

@@ -1,3 +1,22 @@
+/*
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
 use alloc::sync::Arc;
 
 use crate::acpi::aml;

src/aero_kernel/src/drivers/lai.rs

@@ -0,0 +1,7 @@
+[package]
+name = "uapi"
+version = "0.1.0"
+edition = "2021"
+authors = ["Anhad Singh <[email protected]>"]
+
+[dependencies]

src/uapi/Cargo.toml

@@ -0,0 +1,72 @@
+/*
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+use crate::ioctl;
+use core::ffi;
+
+pub const DRM_IOCTL_BASE: usize = 'd' as usize;
+
+// Functions to generate the IOCTl numbers:
+#[inline]
+pub const fn drm_io(nr: usize) -> usize {
+    ioctl::io(DRM_IOCTL_BASE, nr)
+}
+
+#[inline]
+pub const fn drm_ior<T>(nr: usize) -> usize {
+    ioctl::ior::<T>(DRM_IOCTL_BASE, nr)
+}
+
+#[inline]
+pub const fn drm_iow<T>(nr: usize) -> usize {
+    ioctl::iow::<T>(DRM_IOCTL_BASE, nr)
+}
+
+#[inline]
+pub const fn drm_iowr<T>(nr: usize) -> usize {
+    ioctl::iowr::<T>(DRM_IOCTL_BASE, nr)
+}
+
+// DRM structures:
+#[repr(C)]
+pub struct DrmVersion {
+    pub version_major: ffi::c_int,
+    pub version_minor: ffi::c_int,
+    pub version_patch_level: ffi::c_int,
+
+    pub name_len: usize,
+    pub name: *mut u8, // name of the driver
+
+    pub date_len: usize,
+    pub date: *mut u8, // buffer to hold date
+
+    pub desc_len: usize,
+    pub desc: *mut u8, // buffer to hold desc
+}
+
+// DRM IOCTL constants:
+pub const DRM_IOCTL_VERSION: usize = drm_iowr::<DrmVersion>(0x00);

src/uapi/src/drm.rs

@@ -0,0 +1,52 @@
+/*
+ * The generic ioctl numbering scheme doesn't really enforce
+ * a type field. De facto, however, the top 8 bits of the lower 16
+ * bits are indeed used as a type field, so we might just as well make
+ * this explicit here. Please be sure to use the decoding functions
+ * below from now on.
+ */
+pub const IOC_NRBITS: usize = 8;
+pub const IOC_TYPEBITS: usize = 8;
+pub const IOC_SIZEBITS: usize = 14;
+
+pub const IOC_NRSHIFT: usize = 0;
+pub const IOC_TYPESHIFT: usize = IOC_NRSHIFT + IOC_NRBITS;
+pub const IOC_SIZESHIFT: usize = IOC_TYPESHIFT + IOC_TYPEBITS;
+pub const IOC_DIRSHIFT: usize = IOC_SIZESHIFT + IOC_SIZEBITS;
+
+pub const IOC_NONE: usize = 0;
+pub const IOC_WRITE: usize = 1;
+pub const IOC_READ: usize = 2;
+
+pub const fn ioc(dir: usize, ty: usize, nr: usize, size: usize) -> usize {
+    ((dir) << IOC_DIRSHIFT)
+        | ((ty) << IOC_TYPESHIFT)
+        | ((nr) << IOC_NRSHIFT)
+        | ((size) << IOC_SIZESHIFT)
+}
+
+/*
+ * Used to create numbers.
+ *
+ * NOTE: `iow` means userland is writing and kernel is reading. `ior`
+ * means userland is reading and kernel is writing.
+ */
+#[inline]
+pub const fn io(typ: usize, nr: usize) -> usize {
+    ioc(IOC_NONE, typ, nr, 0)
+}
+
+#[inline]
+pub const fn ior<T>(typ: usize, nr: usize) -> usize {
+    ioc(IOC_READ, typ, nr, core::mem::size_of::<T>())
+}
+
+#[inline]
+pub const fn iow<T>(typ: usize, nr: usize) -> usize {
+    ioc(IOC_WRITE, typ, nr, core::mem::size_of::<T>())
+}
+
+#[inline]
+pub const fn iowr<T>(typ: usize, nr: usize) -> usize {
+    ioc(IOC_READ | IOC_WRITE, typ, nr, core::mem::size_of::<T>())
+}

src/uapi/src/ioctl.rs

@@ -0,0 +1,5 @@
+#![feature(core_ffi_c)]
+#![no_std]
+
+pub mod drm;
+pub mod ioctl;