r8125d: rewrite event loop against the real EventQueue/NetworkScheme API

local/recipes/drivers/redbear-r8125d/source/src/main.rs

@@ -106,51 +106,49 @@ mod redox_main {
             std::process::exit(1);
         }
 
-        let inner = scheme.inner();
-        let mut running = true;
-        while running {
-            let event_count = match event_queue.run() {
-                Ok(count) => count,
-                Err(err) => {
-                    log::error!("redbear-r8125d: event queue run failed: {err}");
-                    break;
-                }
-            };
+        if let Err(err) = libredox::call::setrens(0, 0) {
+            log::error!("redbear-r8125d: failed to enter null namespace: {err}");
+            std::process::exit(1);
+        }
 
-            if event_count == 0 {
-                log::warn!("redbear-r8125d: event count is zero, timeout");
-                continue;
+        if let Err(err) = scheme.tick() {
+            log::error!("redbear-r8125d: initial scheme tick failed: {err}");
+            std::process::exit(1);
+        }
+
+        for event in event_queue.map(|e| match e {
+            Ok(ev) => ev,
+            Err(err) => {
+                log::error!("redbear-r8125d: failed to get next event: {err}");
+                std::process::exit(1);
             }
-
-            let inner = &mut *inner;
-
-            // Handle scheme events before IRQ so pending reads don't starve.
-            if event_queue
-                .event_handle(Source::Scheme)
-                .map_or(false, |_| scheme.event_count() > 0)
-            {
-                match scheme.handle_events() {
-                    Ok(still_running) => running = still_running,
-                    Err(err) => {
-                        log::error!("redbear-r8125d: scheme handle_events failed: {err}");
-                        running = false;
+        }) {
+            match event.user_data {
+                Source::Irq => {
+                    let mut irq = [0; 8];
+                    if let Err(err) = irq_file.irq_handle().read(&mut irq) {
+                        log::error!("redbear-r8125d: IRQ read failed: {err}");
+                        break;
+                    }
+                    let ours = unsafe { scheme.adapter_mut().irq_handler() };
+                    // The kernel masks the IRQ line on delivery and only
+                    // re-arms it on write-back; ack unconditionally or a
+                    // foreign interrupt on a shared line leaves it masked.
+                    if let Err(err) = irq_file.irq_handle().write(&mut irq) {
+                        log::error!("redbear-r8125d: IRQ write-back failed: {err}");
+                        break;
+                    }
+                    if ours && let Err(err) = scheme.tick() {
+                        log::error!("redbear-r8125d: scheme tick after IRQ failed: {err}");
+                        break;
                     }
                 }
-            }
-
-            if event_queue
-                .event_handle(Source::Irq)
-                .map_or(false, |_| {
-                    irq_file
-                        .irq_handle()
-                        .read(&mut [0u8; 8])
-                        .unwrap_or(0) > 0
-                })
-            {
-                unsafe {
-                    inner.irq_handler();
+                Source::Scheme => {
+                    if let Err(err) = scheme.tick() {
+                        log::error!("redbear-r8125d: scheme tick failed: {err}");
+                        break;
+                    }
                 }
-                scheme.signal_read();
             }
         }