Implement Wait, Signal, and Reset opcodes for event synchronization

Author: IsaacWoods

src/aml/mod.rs

@@ -464,6 +464,91 @@ where
                         context.contribute_arg(Argument::Object(result));
                         context.retire_op(op);
                     }
+                    Opcode::Reset => {
+                        let [Argument::Object(sync_object)] = &op.arguments[..] else {
+                            panic!();
+                        };
+                        let sync_object = sync_object.clone().unwrap_reference();
+
+                        if let Object::Event(ref counter) = *sync_object {
+                            counter.store(0, Ordering::Release);
+                        } else {
+                            return Err(AmlError::InvalidOperationOnObject {
+                                op: Operation::ResetEvent,
+                                typ: sync_object.typ(),
+                            });
+                        }
+                    }
+                    Opcode::Signal => {
+                        let [Argument::Object(sync_object)] = &op.arguments[..] else {
+                            panic!();
+                        };
+                        let sync_object = sync_object.clone().unwrap_reference();
+
+                        if let Object::Event(ref counter) = *sync_object {
+                            counter.fetch_add(1, Ordering::AcqRel);
+                        } else {
+                            return Err(AmlError::InvalidOperationOnObject {
+                                op: Operation::SignalEvent,
+                                typ: sync_object.typ(),
+                            });
+                        }
+                    }
+                    Opcode::Wait => {
+                        let [Argument::Object(sync_object), Argument::Object(timeout)] = &op.arguments[..] else {
+                            panic!();
+                        };
+                        let sync_object = sync_object.clone().unwrap_reference();
+                        let timeout = u64::min(timeout.as_integer()?, 0xffff);
+
+                        if let Object::Event(ref counter) = *sync_object {
+                            /*
+                             * `Wait` returns a non-zero value if a timeout occurs and the event
+                             * was not signaled, and zero if it was. Timeout is specified in
+                             * milliseconds, should relinquish processor control (we use
+                             * `Handler::sleep` to do so) and a value of `0xffff` specifies that
+                             * the operation should wait indefinitely.
+                             */
+                            let mut remaining_sleep = timeout;
+                            let mut timed_out = true;
+
+                            'signaled: while remaining_sleep > 0 {
+                                loop {
+                                    /*
+                                     * Try to decrement the counter. If it's zero after a load, we
+                                     * haven't been signalled and should wait for a bit. If it's
+                                     * non-zero, we were signalled and should stop waiting.
+                                     */
+                                    let value = counter.load(Ordering::Acquire);
+                                    if value == 0 {
+                                        break;
+                                    }
+                                    if counter
+                                        .compare_exchange(value, value - 1, Ordering::AcqRel, Ordering::Acquire)
+                                        .is_ok()
+                                    {
+                                        timed_out = false;
+                                        break 'signaled;
+                                    }
+                                }
+
+                                let to_sleep = u64::min(timeout, 10);
+                                if timeout < 0xffff {
+                                    remaining_sleep -= to_sleep
+                                }
+                                self.handler.sleep(to_sleep);
+                            }
+
+                            context.contribute_arg(Argument::Object(
+                                Object::Integer(if timed_out { u64::MAX } else { 0 }).wrap(),
+                            ));
+                        } else {
+                            return Err(AmlError::InvalidOperationOnObject {
+                                op: Operation::WaitEvent,
+                                typ: sync_object.typ(),
+                            });
+                        }
+                    }
                     Opcode::FromBCD => self.do_from_bcd(&mut context, op)?,
                     Opcode::ToBCD => self.do_to_bcd(&mut context, op)?,
                     Opcode::Name => {
@@ -1158,9 +1243,9 @@ where
                 Opcode::Sleep => context.start_in_flight_op(OpInFlight::new(Opcode::Sleep, 1)),
                 Opcode::Acquire => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
                 Opcode::Release => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
-                Opcode::Signal => todo!(),
-                Opcode::Wait => todo!(),
-                Opcode::Reset => todo!(),
+                Opcode::Signal => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
+                Opcode::Wait => context.start_in_flight_op(OpInFlight::new(opcode, 2)),
+                Opcode::Reset => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
                 Opcode::Notify => todo!(),
                 Opcode::FromBCD | Opcode::ToBCD => context.start_in_flight_op(OpInFlight::new(opcode, 2)),
                 Opcode::Revision => {
@@ -3033,6 +3118,10 @@ pub enum Operation {
     LogicalOp,
     DecodePrt,
     ParseResource,
+
+    ResetEvent,
+    SignalEvent,
+    WaitEvent,
 }
 
 #[derive(Clone, PartialEq, Debug)]

src/aml/object.rs

@@ -1,7 +1,7 @@
 use crate::aml::{AmlError, Handle, Operation, op_region::OpRegion};
 use alloc::{borrow::Cow, string::String, sync::Arc, vec::Vec};
 use bit_field::BitField;
-use core::{cell::UnsafeCell, fmt, ops};
+use core::{cell::UnsafeCell, fmt, ops, sync::atomic::AtomicU64};
 
 type NativeMethod = dyn Fn(&[WrappedObject]) -> Result<WrappedObject, AmlError>;
 
@@ -11,7 +11,7 @@ pub enum Object {
     Buffer(Vec<u8>),
     BufferField { buffer: WrappedObject, offset: usize, length: usize },
     Device,
-    Event,
+    Event(Arc<AtomicU64>),
     FieldUnit(FieldUnit),
     Integer(u64),
     Method { code: Vec<u8>, flags: MethodFlags },
@@ -48,7 +48,7 @@ impl fmt::Display for Object {
                 write!(f, "BufferField {{ offset: {offset}, length: {length} }}")
             }
             Object::Device => write!(f, "Device"),
-            Object::Event => write!(f, "Event"),
+            Object::Event(counter) => write!(f, "Event({counter:?})"),
             // TODO: include fields
             Object::FieldUnit(_) => write!(f, "FieldUnit"),
             Object::Integer(value) => write!(f, "Integer({value})"),