iTWT (Individual Target Wake Time) support

esp-radio/src/wifi/event.rs

@@ -222,13 +222,95 @@ impl_wifi_event!(
     wifi_event_ap_wps_rg_pin_t
 );
 impl_wifi_event!(AccessPointWifiProtectedStatusRegistrarPushButtonConfigurationOverlap);
-impl_wifi_event!(IndividualTargetWakeTimeSetup);
-impl_wifi_event!(IndividualTargetWakeTimeTeardown);
-impl_wifi_event!(IndividualTargetWakeTimeProbe);
-impl_wifi_event!(IndividualTargetWakeTimeSuspend);
-impl_wifi_event!(TargetWakeTimeWakeup);
+impl_wifi_event!(IndividualTargetWakeTimeSetup, wifi_event_sta_itwt_setup_t);
+impl_wifi_event!(
+    IndividualTargetWakeTimeTeardown,
+    wifi_event_sta_itwt_teardown_t
+);
+impl_wifi_event!(IndividualTargetWakeTimeProbe, wifi_event_sta_itwt_probe_t);
+impl_wifi_event!(
+    IndividualTargetWakeTimeSuspend,
+    wifi_event_sta_itwt_suspend_t
+);
+impl_wifi_event!(TargetWakeTimeWakeup, wifi_event_sta_twt_wakeup_t);
 impl_wifi_event!(BroadcastTargetWakeTimeSetup);
 impl_wifi_event!(BroadcastTargetWakeTimeTeardown);
+
+impl IndividualTargetWakeTimeSetup<'_> {
+    /// Get the setup status. 1 indicates success, other values indicate failure.
+    pub fn status(&self) -> i32 {
+        self.0.status
+    }
+
+    /// Get the setup failure reason code.
+    pub fn reason(&self) -> u8 {
+        self.0.reason
+    }
+
+    /// Get the TWT service period start time.
+    pub fn target_wake_time(&self) -> u64 {
+        self.0.target_wake_time
+    }
+
+    /// Get the negotiated iTWT setup configuration.
+    pub fn config(&self) -> crate::wifi::twt::ITwtSetupConfig {
+        crate::wifi::twt::ITwtSetupConfig::from_raw(&self.0.config)
+    }
+}
+
+impl IndividualTargetWakeTimeTeardown<'_> {
+    /// Get the flow ID that was torn down.
+    pub fn flow_id(&self) -> u8 {
+        self.0.flow_id
+    }
+
+    /// Get the teardown status.
+    pub fn status(&self) -> crate::wifi::twt::ITwtTeardownStatus {
+        crate::wifi::twt::ITwtTeardownStatus::from_raw(self.0.status)
+    }
+}
+
+impl IndividualTargetWakeTimeProbe<'_> {
+    /// Get the probe status.
+    pub fn status(&self) -> crate::wifi::twt::ITwtProbeStatus {
+        crate::wifi::twt::ITwtProbeStatus::from_raw(self.0.status)
+    }
+
+    /// Get the failure reason code.
+    pub fn reason(&self) -> u8 {
+        self.0.reason
+    }
+}
+
+impl IndividualTargetWakeTimeSuspend<'_> {
+    /// Get the suspend status. 0 (`ESP_OK`) indicates success.
+    pub fn status(&self) -> i32 {
+        self.0.status
+    }
+
+    /// Get the bitmap of suspended flow IDs.
+    pub fn flow_id_bitmap(&self) -> u8 {
+        self.0.flow_id_bitmap
+    }
+
+    /// Get the actual suspend time for each flow ID, in milliseconds.
+    pub fn actual_suspend_time_ms(&self) -> [u32; 8] {
+        self.0.actual_suspend_time_ms
+    }
+}
+
+impl TargetWakeTimeWakeup<'_> {
+    /// Get the TWT type (individual or broadcast).
+    pub fn twt_type(&self) -> crate::wifi::twt::TwtType {
+        crate::wifi::twt::TwtType::from_raw(self.0.twt_type)
+    }
+
+    /// Get the flow ID.
+    pub fn flow_id(&self) -> u8 {
+        self.0.flow_id
+    }
+}
+
 impl_wifi_event!(NeighborAwarenessNetworkingStarted);
 impl_wifi_event!(NeighborAwarenessNetworkingStopped);
 impl_wifi_event!(
@@ -1017,19 +1099,50 @@ pub enum EventInfo {
     AccessPointWifiProtectedStatusRegistrarPushButtonConfigurationOverlap,
 
     /// Individual Target-Wake-Time setup.
-    IndividualTargetWakeTimeSetup,
+    IndividualTargetWakeTimeSetup {
+        /// The negotiated iTWT setup configuration.
+        config: crate::wifi::twt::ITwtSetupConfig,
+        /// Setup status. 1 indicates success, other values indicate failure.
+        status: i32,
+        /// Setup failure reason code.
+        reason: u8,
+        /// TWT service period start time.
+        target_wake_time: u64,
+    },
 
     /// Individual Target-Wake-Time teardown.
-    IndividualTargetWakeTimeTeardown,
+    IndividualTargetWakeTimeTeardown {
+        /// Flow ID that was torn down.
+        flow_id: crate::wifi::twt::FlowId,
+        /// Teardown status.
+        status: crate::wifi::twt::ITwtTeardownStatus,
+    },
 
     /// Individual Target-Wake-Time probe.
-    IndividualTargetWakeTimeProbe,
+    IndividualTargetWakeTimeProbe {
+        /// Probe status.
+        status: crate::wifi::twt::ITwtProbeStatus,
+        /// Failure reason code.
+        reason: u8,
+    },
 
     /// Individual Target-Wake-Time suspended.
-    IndividualTargetWakeTimeSuspend,
+    IndividualTargetWakeTimeSuspend {
+        /// Suspend status. 0 (`ESP_OK`) indicates success.
+        status: i32,
+        /// The set of suspended flow IDs.
+        suspended_flows: EnumSet<crate::wifi::twt::FlowId>,
+        /// Actual suspend time for each flow ID, in milliseconds.
+        actual_suspend_time_ms: [u32; 8],
+    },
 
-    /// Target-Wake-Wakeup event.
-    TargetWakeTimeWakeup,
+    /// Target-Wake-Time wakeup event.
+    TargetWakeTimeWakeup {
+        /// TWT type (individual or broadcast).
+        twt_type: crate::wifi::twt::TwtType,
+        /// Flow ID.
+        flow_id: crate::wifi::twt::FlowId,
+    },
 
     /// Broadcast-Target-Wake-Time setup.
     BroadcastTargetWakeTimeSetup,
@@ -1247,19 +1360,46 @@ impl EventInfo {
                 Some(EventInfo::AccessPointWifiProtectedStatusRegistrarPushButtonConfigurationOverlap)
             }
             WifiEvent::IndividualTargetWakeTimeSetup => {
-                Some(EventInfo::IndividualTargetWakeTimeSetup)
+                let ev =
+                    unsafe { IndividualTargetWakeTimeSetup::from_raw_event_data(payload) };
+                Some(EventInfo::IndividualTargetWakeTimeSetup {
+                    config: ev.config(),
+                    status: ev.status(),
+                    reason: ev.reason(),
+                    target_wake_time: ev.target_wake_time(),
+                })
             }
-             WifiEvent::IndividualTargetWakeTimeTeardown => {
-                Some(EventInfo::IndividualTargetWakeTimeTeardown)
+            WifiEvent::IndividualTargetWakeTimeTeardown => {
+                let ev =
+                    unsafe { IndividualTargetWakeTimeTeardown::from_raw_event_data(payload) };
+                Some(EventInfo::IndividualTargetWakeTimeTeardown {
+                    flow_id: crate::wifi::twt::FlowId::from_raw(ev.flow_id()),
+                    status: ev.status(),
+                })
             }
             WifiEvent::IndividualTargetWakeTimeProbe => {
-                Some(EventInfo::IndividualTargetWakeTimeProbe)
+                let ev =
+                    unsafe { IndividualTargetWakeTimeProbe::from_raw_event_data(payload) };
+                Some(EventInfo::IndividualTargetWakeTimeProbe {
+                    status: ev.status(),
+                    reason: ev.reason(),
+                })
             }
             WifiEvent::IndividualTargetWakeTimeSuspend => {
-                Some(EventInfo::IndividualTargetWakeTimeSuspend)
+                let ev =
+                    unsafe { IndividualTargetWakeTimeSuspend::from_raw_event_data(payload) };
+                Some(EventInfo::IndividualTargetWakeTimeSuspend {
+                    status: ev.status(),
+                    suspended_flows: EnumSet::from_repr(ev.flow_id_bitmap()),
+                    actual_suspend_time_ms: ev.actual_suspend_time_ms(),
+                })
             }
             WifiEvent::TargetWakeTimeWakeup => {
-                Some(EventInfo::TargetWakeTimeWakeup)
+                let ev = unsafe { TargetWakeTimeWakeup::from_raw_event_data(payload) };
+                Some(EventInfo::TargetWakeTimeWakeup {
+                    twt_type: ev.twt_type(),
+                    flow_id: crate::wifi::twt::FlowId::from_raw(ev.flow_id()),
+                })
             }
             WifiEvent::BroadcastTargetWakeTimeSetup => {
                 Some(EventInfo::BroadcastTargetWakeTimeSetup)