9 files changed, 76 insertions, 44 deletions

diff --git a/cyw43/CHANGELOG.md b/cyw43/CHANGELOG.md
index 1045fd30b..4f0dc896b 100644
--- a/cyw43/CHANGELOG.md
+++ b/cyw43/CHANGELOG.md
@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- Reset WPA security before creating secure AP
+
+## 0.6.0 - 2025-11-27
+
 - Updated documentation for Control::join() #4678
 - Bump bt-hci to 0.6.0.
 - Add error handling to HCI transport implementation.
diff --git a/cyw43/Cargo.toml b/cyw43/Cargo.toml
index c59c15a71..6d7647697 100644
--- a/cyw43/Cargo.toml
+++ b/cyw43/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "cyw43"
-version = "0.5.0"
-edition = "2021"
+version = "0.6.0"
+edition = "2024"
 description = "Rust driver for the CYW43439 WiFi chip, used in the Raspberry Pi Pico W."
 keywords = ["embedded", "cyw43", "embassy-net", "embedded-hal-async", "wifi"]
 categories = ["embedded", "hardware-support", "no-std", "network-programming", "asynchronous"]
diff --git a/cyw43/src/bluetooth.rs b/cyw43/src/bluetooth.rs
index d176c4b09..332b7048d 100644
--- a/cyw43/src/bluetooth.rs
+++ b/cyw43/src/bluetooth.rs
@@ -15,7 +15,7 @@ use crate::bus::Bus;
 pub use crate::bus::SpiBusCyw43;
 use crate::consts::*;
 use crate::util::round_up;
-use crate::{util, CHIP};
+use crate::{CHIP, util};
 
 pub(crate) struct BtState {
     rx: [BtPacketBuf; 4],
diff --git a/cyw43/src/bus.rs b/cyw43/src/bus.rs
index 8a53484d5..aa2b66a40 100644
--- a/cyw43/src/bus.rs
+++ b/cyw43/src/bus.rs
@@ -340,11 +340,7 @@ where
         self.status = self.spi.cmd_read(cmd, &mut buf[..len]).await;
 
         // if we read from the backplane, the result is in the second word, after the response delay
-        if func == FUNC_BACKPLANE {
-            buf[1]
-        } else {
-            buf[0]
-        }
+        if func == FUNC_BACKPLANE { buf[1] } else { buf[0] }
     }
 
     async fn writen(&mut self, func: u32, addr: u32, val: u32, len: u32) {
diff --git a/cyw43/src/consts.rs b/cyw43/src/consts.rs
index c3f0dbfd8..e561d4794 100644
--- a/cyw43/src/consts.rs
+++ b/cyw43/src/consts.rs
@@ -177,9 +177,11 @@ pub(crate) enum Security {
 }
 
 #[allow(non_camel_case_types)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, num_enum::FromPrimitive)]
 #[repr(u8)]
 pub enum EStatus {
+    #[num_enum(default)]
+    Unknown = 0xFF,
     /// operation was successful
     SUCCESS = 0,
     /// operation failed
diff --git a/cyw43/src/control.rs b/cyw43/src/control.rs
index fd0d4d532..240c0e728 100644
--- a/cyw43/src/control.rs
+++ b/cyw43/src/control.rs
@@ -10,13 +10,18 @@ use crate::events::{Event, EventSubscriber, Events};
 use crate::fmt::Bytes;
 use crate::ioctl::{IoctlState, IoctlType};
 use crate::structs::*;
-use crate::{countries, events, PowerManagementMode};
+use crate::{PowerManagementMode, countries, events};
 
-/// Control errors.
+/// Join errors.
 #[derive(Debug)]
-pub struct Error {
-    /// Status code.
-    pub status: u32,
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum JoinError {
+    /// Network not found.
+    NetworkNotFound,
+    /// Failure to join network. Contains the status code from the SET_SSID event.
+    JoinFailure(u8),
+    /// Authentication failure for a secure network.
+    AuthenticationFailure,
 }
 
 /// Multicast errors.
@@ -296,7 +301,7 @@ impl<'a> Control<'a> {
     }
 
     /// Join a network with the provided SSID using the specified options.
-    pub async fn join(&mut self, ssid: &str, options: JoinOptions<'_>) -> Result<(), Error> {
+    pub async fn join(&mut self, ssid: &str, options: JoinOptions<'_>) -> Result<(), JoinError> {
         self.set_iovar_u32("ampdu_ba_wsize", 8).await;
 
         if options.auth == JoinAuth::Open {
@@ -367,40 +372,55 @@ impl<'a> Control<'a> {
         };
         i.ssid[..ssid.len()].copy_from_slice(ssid.as_bytes());
 
-        self.wait_for_join(i).await
+        let secure_network = options.auth != JoinAuth::Open;
+        self.wait_for_join(i, secure_network).await
     }
 
-    async fn wait_for_join(&mut self, i: SsidInfo) -> Result<(), Error> {
-        self.events.mask.enable(&[Event::SET_SSID, Event::AUTH]);
+    async fn wait_for_join(&mut self, i: SsidInfo, secure_network: bool) -> Result<(), JoinError> {
+        self.events.mask.enable(&[Event::SET_SSID, Event::AUTH, Event::PSK_SUP]);
         let mut subscriber = self.events.queue.subscriber().unwrap();
         // the actual join operation starts here
         // we make sure to enable events before so we don't miss any
 
         self.ioctl(IoctlType::Set, Ioctl::SetSsid, 0, &mut i.to_bytes()).await;
 
-        // to complete the join, we wait for a SET_SSID event
-        // we also save the AUTH status for the user, it may be interesting
-        let mut auth_status = 0;
-        let status = loop {
+        // To complete the join on an open network, we wait for a SET_SSID event with status SUCCESS
+        // For secured networks, we wait for a PSK_SUP event with status 6 "UNSOLICITED"
+        let result = loop {
             let msg = subscriber.next_message_pure().await;
-            if msg.header.event_type == Event::AUTH && msg.header.status != EStatus::SUCCESS {
-                auth_status = msg.header.status;
-            } else if msg.header.event_type == Event::SET_SSID {
-                // join operation ends with SET_SSID event
-                break msg.header.status;
-            }
+
+            let status = EStatus::from(msg.header.status as u8);
+            match (msg.header.event_type, status, secure_network) {
+                // Join operation ends with SET_SSID event for open networks
+                (Event::SET_SSID, EStatus::SUCCESS, false) => break Ok(()),
+                (Event::SET_SSID, EStatus::NO_NETWORKS, _) => break Err(JoinError::NetworkNotFound),
+                (Event::SET_SSID, status, _) if status != EStatus::SUCCESS => {
+                    break Err(JoinError::JoinFailure(status as u8));
+                }
+                // Ignore PSK_SUP "ABORT" which is sometimes sent before successful join
+                (Event::PSK_SUP, EStatus::ABORT, true) => {}
+                // Event PSK_SUP with status 6 "UNSOLICITED" indicates success for secure networks
+                (Event::PSK_SUP, EStatus::UNSOLICITED, true) => break Ok(()),
+                // Events indicating authentication failure, possibly due to incorrect password
+                (Event::PSK_SUP, _, true) | (Event::AUTH, EStatus::FAIL, true) => {
+                    break Err(JoinError::AuthenticationFailure);
+                }
+                _ => {}
+            };
         };
 
         self.events.mask.disable_all();
-        if status == EStatus::SUCCESS {
-            // successful join
-            self.state_ch.set_link_state(LinkState::Up);
-            debug!("JOINED");
-            Ok(())
-        } else {
-            warn!("JOIN failed with status={} auth={}", status, auth_status);
-            Err(Error { status })
-        }
+        match result {
+            Ok(()) => {
+                self.state_ch.set_link_state(LinkState::Up);
+                debug!("JOINED");
+            }
+            Err(JoinError::JoinFailure(status)) => debug!("JOIN failed: status={}", status),
+            Err(JoinError::NetworkNotFound) => debug!("JOIN failed: network not found"),
+            Err(JoinError::AuthenticationFailure) => debug!("JOIN failed: authentication failure"),
+        };
+
+        result
     }
 
     /// Set GPIO pin on WiFi chip.
@@ -436,6 +456,9 @@ impl<'a> Control<'a> {
         // Set wifi up again
         self.up().await;
 
+        // Disable authentication
+        self.ioctl_set_u32(Ioctl::SetAuth, 0, AUTH_OPEN).await;
+
         // Turn on AP mode
         self.ioctl_set_u32(Ioctl::SetAp, 0, 1).await;
 
@@ -470,8 +493,6 @@ impl<'a> Control<'a> {
             pfi.passphrase[..passphrase.as_bytes().len()].copy_from_slice(passphrase.as_bytes());
             self.ioctl(IoctlType::Set, Ioctl::SetWsecPmk, 0, &mut pfi.to_bytes())
                 .await;
-        } else {
-            self.ioctl_set_u32(Ioctl::SetAuth, 0, 0).await;
         }
 
         // Change mutlicast rate from 1 Mbps to 11 Mbps
@@ -547,6 +568,14 @@ impl<'a> Control<'a> {
         n
     }
 
+    /// Retrieve the latest RSSI value
+    pub async fn get_rssi(&mut self) -> i32 {
+        let mut rssi_buf = [0u8; 4];
+        let n = self.ioctl(IoctlType::Get, Ioctl::GetRssi, 0, &mut rssi_buf).await;
+        assert_eq!(n, 4);
+        i32::from_ne_bytes(rssi_buf)
+    }
+
     async fn set_iovar_u32x2(&mut self, name: &str, val1: u32, val2: u32) {
         let mut buf = [0; 8];
         buf[0..4].copy_from_slice(&val1.to_le_bytes());
diff --git a/cyw43/src/ioctl.rs b/cyw43/src/ioctl.rs
index 35135e296..deccc945d 100644
--- a/cyw43/src/ioctl.rs
+++ b/cyw43/src/ioctl.rs
@@ -1,5 +1,5 @@
 use core::cell::{Cell, RefCell};
-use core::future::{poll_fn, Future};
+use core::future::{Future, poll_fn};
 use core::task::{Poll, Waker};
 
 use embassy_sync::waitqueue::WakerRegistration;
diff --git a/cyw43/src/lib.rs b/cyw43/src/lib.rs
index 16b436e66..73d2830ca 100644
--- a/cyw43/src/lib.rs
+++ b/cyw43/src/lib.rs
@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 #![allow(async_fn_in_trait)]
+#![allow(unsafe_op_in_unsafe_fn)]
 #![deny(unused_must_use)]
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
@@ -30,7 +31,7 @@ use ioctl::IoctlState;
 use crate::bus::Bus;
 pub use crate::bus::SpiBusCyw43;
 pub use crate::control::{
-    AddMulticastAddressError, Control, Error as ControlError, JoinAuth, JoinOptions, ScanOptions, ScanType, Scanner,
+    AddMulticastAddressError, Control, JoinAuth, JoinError, JoinOptions, ScanOptions, ScanType, Scanner,
 };
 pub use crate::runner::Runner;
 pub use crate::structs::BssInfo;
diff --git a/cyw43/src/runner.rs b/cyw43/src/runner.rs
index 77910b281..7c38be24a 100644
--- a/cyw43/src/runner.rs
+++ b/cyw43/src/runner.rs
@@ -1,6 +1,6 @@
-use embassy_futures::select::{select4, Either4};
+use embassy_futures::select::{Either4, select4};
 use embassy_net_driver_channel as ch;
-use embassy_time::{block_for, Duration, Timer};
+use embassy_time::{Duration, Timer, block_for};
 use embedded_hal_1::digital::OutputPin;
 
 use crate::bus::Bus;
@@ -12,7 +12,7 @@ use crate::ioctl::{IoctlState, IoctlType, PendingIoctl};
 use crate::nvram::NVRAM;
 use crate::structs::*;
 use crate::util::slice8_mut;
-use crate::{events, Core, CHIP, MTU};
+use crate::{CHIP, Core, MTU, events};
 
 #[cfg(feature = "firmware-logs")]
 struct LogState {