config: tell the config about drm devices

src/tasks/backend.rs

@@ -1,4 +1,5 @@
 use {
+    super::drmdev,
     crate::{
         backend::BackendEvent,
         state::State,
@@ -23,6 +24,7 @@ impl BackendEventHandler {
         match event {
             BackendEvent::NewConnector(connector) => connector::handle(&self.state, &connector),
             BackendEvent::NewInputDevice(s) => input_device::handle(&self.state, s),
+            BackendEvent::NewDrmDevice(d) => drmdev::handle(&self.state, d),
         }
     }
 }

src/tasks/connector.rs

@@ -13,13 +13,24 @@ use {
 };
 
 pub fn handle(state: &Rc<State>, connector: &Rc<dyn Connector>) {
+    let mut drm_dev = None;
+    if let Some(dev_id) = connector.drm_dev() {
+        drm_dev = match state.drm_devs.get(&dev_id) {
+            Some(dev) => Some(dev),
+            _ => panic!("connector's drm device does not exist"),
+        };
+    }
     let id = connector.id();
     let data = Rc::new(ConnectorData {
         connector: connector.clone(),
         handler: Default::default(),
         connected: Cell::new(false),
         name: connector.kernel_id().to_string(),
+        drm_dev: drm_dev.clone(),
     });
+    if let Some(dev) = drm_dev {
+        dev.connectors.set(id, data.clone());
+    }
     let oh = ConnectorHandler {
         id,
         state: state.clone(),
@@ -150,5 +161,8 @@ impl ConnectorHandler {
         self.state.root.outputs.remove(&self.id);
         self.data.connected.set(false);
         self.state.outputs.remove(&self.id);
+        if let Some(dev) = &self.data.drm_dev {
+            dev.connectors.remove(&self.id);
+        }
     }
 }

src/tasks/drmdev.rs

@@ -0,0 +1,120 @@
+use {
+    crate::{
+        backend::{BackendDrmDevice, DrmDeviceId, DrmEvent},
+        state::{DrmDevData, State},
+        udev::{Udev, UdevDeviceType},
+        utils::{asyncevent::AsyncEvent, errorfmt::ErrorFmt},
+    },
+    jay_config::PciId,
+    std::{cell::Cell, rc::Rc},
+};
+
+pub fn handle(state: &Rc<State>, dev: Rc<dyn BackendDrmDevice>) {
+    let id = dev.id();
+    let mut syspath = None;
+    let mut vendor = None;
+    let mut model = None;
+    let mut pci_id = None;
+    'properties: {
+        let udev = match Udev::new() {
+            Ok(udev) => Rc::new(udev),
+            Err(e) => {
+                log::error!("Could not create a udev instance: {}", e);
+                break 'properties;
+            }
+        };
+        let odev = match udev.create_device_from_devnum(UdevDeviceType::Character, dev.dev_t()) {
+            Ok(dev) => dev,
+            Err(e) => {
+                log::error!("{}", ErrorFmt(e));
+                break 'properties;
+            }
+        };
+        let dev = match odev.parent() {
+            Ok(dev) => dev,
+            Err(e) => {
+                log::error!("{}", ErrorFmt(e));
+                break 'properties;
+            }
+        };
+        syspath = dev.syspath().map(|s| s.to_string_lossy().into_owned());
+        vendor = dev.vendor().map(|s| s.to_string_lossy().into_owned());
+        model = dev.model().map(|s| s.to_string_lossy().into_owned());
+        'get_pci_id: {
+            let id = match dev.pci_id() {
+                Some(id) => id,
+                _ => break 'get_pci_id,
+            };
+            let id = id.to_string_lossy();
+            let colon = match id.find(':') {
+                Some(pos) => pos,
+                _ => break 'get_pci_id,
+            };
+            let vendor = &id[..colon];
+            let model = &id[colon + 1..];
+            let vendor = match u32::from_str_radix(vendor, 16) {
+                Ok(v) => v,
+                _ => break 'get_pci_id,
+            };
+            let model = match u32::from_str_radix(model, 16) {
+                Ok(v) => v,
+                _ => break 'get_pci_id,
+            };
+            pci_id = Some(PciId { vendor, model });
+        }
+    }
+    let data = Rc::new(DrmDevData {
+        dev: dev.clone(),
+        handler: Cell::new(None),
+        connectors: Default::default(),
+        syspath,
+        vendor,
+        model,
+        pci_id,
+    });
+    let oh = DrvDevHandler {
+        id,
+        state: state.clone(),
+        data: data.clone(),
+    };
+    let future = state.eng.spawn(oh.handle());
+    data.handler.set(Some(future));
+    if state.drm_devs.set(id, data).is_some() {
+        panic!("Drm device id has been reused");
+    }
+}
+
+struct DrvDevHandler {
+    id: DrmDeviceId,
+    state: Rc<State>,
+    data: Rc<DrmDevData>,
+}
+
+impl DrvDevHandler {
+    async fn handle(self) {
+        let ae = Rc::new(AsyncEvent::default());
+        {
+            let ae = ae.clone();
+            self.data.dev.on_change(Rc::new(move || ae.trigger()));
+        }
+        if let Some(config) = self.state.config.get() {
+            config.new_drm_dev(self.id);
+        }
+        'outer: loop {
+            while let Some(event) = self.data.dev.event() {
+                match event {
+                    DrmEvent::Removed => break 'outer,
+                }
+            }
+            ae.triggered().await;
+        }
+        if !self.data.connectors.is_empty() {
+            panic!("DRM device removed before its connectors");
+        }
+        if let Some(config) = self.state.config.get() {
+            config.del_drm_dev(self.id);
+        }
+        self.data.handler.set(None);
+        self.state.drm_devs.remove(&self.id);
+    }
+}