skb_queue_purge(&sdata->skb_queue);
 
        /* trigger a scan to find another IBSS network to join */
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 
        sdata_unlock(sdata);
 }
        spin_lock(&ifibss->incomplete_lock);
        list_add(&sta->list, &ifibss->incomplete_stations);
        spin_unlock(&ifibss->incomplete_lock);
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
 }
 
 static void ieee80211_ibss_sta_expire(struct ieee80211_sub_if_data *sdata)
        struct ieee80211_sub_if_data *sdata =
                from_timer(sdata, t, u.ibss.timer);
 
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 }
 
 void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata)
        sdata->deflink.needed_rx_chains = local->rx_chains;
        sdata->control_port_over_nl80211 = params->control_port_over_nl80211;
 
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
 
        return 0;
 }
 
        /* used to reconfigure hardware SM PS */
        struct work_struct recalc_smps;
 
-       struct work_struct work;
+       struct wiphy_work work;
        struct sk_buff_head skb_queue;
        struct sk_buff_head status_queue;
 
 
  * by either the RTNL, the iflist_mtx or RCU.
  */
 
-static void ieee80211_iface_work(struct work_struct *work);
+static void ieee80211_iface_work(struct wiphy *wiphy, struct wiphy_work *work);
 
 bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
 {
                RCU_INIT_POINTER(local->p2p_sdata, NULL);
                fallthrough;
        default:
-               cancel_work_sync(&sdata->work);
+               wiphy_work_cancel(sdata->local->hw.wiphy, &sdata->work);
                /*
                 * When we get here, the interface is marked down.
                 * Free the remaining keys, if there are any
 
        skb_queue_head_init(&sdata->skb_queue);
        skb_queue_head_init(&sdata->status_queue);
-       INIT_WORK(&sdata->work, ieee80211_iface_work);
+       wiphy_work_init(&sdata->work, ieee80211_iface_work);
 
        return 0;
 }
        }
 }
 
-static void ieee80211_iface_work(struct work_struct *work)
+static void ieee80211_iface_work(struct wiphy *wiphy, struct wiphy_work *work)
 {
        struct ieee80211_sub_if_data *sdata =
                container_of(work, struct ieee80211_sub_if_data, work);
 
        skb_queue_head_init(&sdata->skb_queue);
        skb_queue_head_init(&sdata->status_queue);
-       INIT_WORK(&sdata->work, ieee80211_iface_work);
+       wiphy_work_init(&sdata->work, ieee80211_iface_work);
        INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
        INIT_WORK(&sdata->activate_links_work, ieee80211_activate_links_work);
 
 
 
        set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
 
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
 }
 
 /**
        struct ieee80211_sub_if_data *sdata =
                from_timer(sdata, t, u.mesh.mesh_path_timer);
 
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 }
 
 static void ieee80211_mesh_path_root_timer(struct timer_list *t)
 
        set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
 
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 }
 
 void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh)
        for_each_set_bit(bit, &bits, sizeof(changed) * BITS_PER_BYTE)
                set_bit(bit, &ifmsh->mbss_changed);
        set_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags);
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 }
 
 int ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
        ifmsh->sync_offset_clockdrift_max = 0;
        set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
        ieee80211_mesh_root_setup(ifmsh);
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
        sdata->vif.bss_conf.ht_operation_mode =
                                ifmsh->mshcfg.ht_opmode;
        sdata->vif.bss_conf.enable_beacon = true;
 
 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (c) 2008, 2009 open80211s Ltd.
- * Copyright (C) 2019, 2021-2022 Intel Corporation
+ * Copyright (C) 2019, 2021-2023 Intel Corporation
  * Author:     Luis Carlos Cobo <luisca@cozybit.com>
  */
 
        spin_unlock_bh(&ifmsh->mesh_preq_queue_lock);
 
        if (time_after(jiffies, ifmsh->last_preq + min_preq_int_jiff(sdata)))
-               ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+               wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 
        else if (time_before(jiffies, ifmsh->last_preq)) {
                /* avoid long wait if did not send preqs for a long time
                 * and jiffies wrapped around
                 */
                ifmsh->last_preq = jiffies - min_preq_int_jiff(sdata) - 1;
-               ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+               wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
        } else
                mod_timer(&ifmsh->mesh_path_timer, ifmsh->last_preq +
                                                min_preq_int_jiff(sdata));
 
                sdata->u.mgd.probe_send_count = 0;
        else
                sdata->u.mgd.nullfunc_failed = true;
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 }
 
 static void ieee80211_mlme_send_probe_req(struct ieee80211_sub_if_data *sdata,
        struct ieee80211_sub_if_data *sdata =
                from_timer(sdata, t, u.mgd.timer);
 
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
 }
 
 void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
        sdata->u.mgd.status_acked = acked;
        sdata->u.mgd.status_received = true;
 
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
 }
 
 void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
 
        spin_lock(&ifocb->incomplete_lock);
        list_add(&sta->list, &ifocb->incomplete_stations);
        spin_unlock(&ifocb->incomplete_lock);
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
 }
 
 static struct sta_info *ieee80211_ocb_finish_sta(struct sta_info *sta)
 
        set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);
 
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
 }
 
 void ieee80211_ocb_setup_sdata(struct ieee80211_sub_if_data *sdata)
        ifocb->joined = true;
 
        set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);
-       ieee80211_queue_work(&local->hw, &sdata->work);
+       wiphy_work_queue(local->hw.wiphy, &sdata->work);
 
        netif_carrier_on(sdata->dev);
        return 0;
 
        }
 
        skb_queue_tail(&sdata->skb_queue, skb);
-       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
        if (sta)
                sta->deflink.rx_stats.packets++;
 }
 
         */
        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
                if (ieee80211_sdata_running(sdata))
-                       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+                       wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work);
        }
 
        if (was_scanning)
 
  * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
  * Copyright 2008-2010 Johannes Berg <johannes@sipsolutions.net>
  * Copyright 2013-2014  Intel Mobile Communications GmbH
- * Copyright 2021-2022  Intel Corporation
+ * Copyright 2021-2023  Intel Corporation
  */
 
 #include <linux/export.h>
                                        if (qskb) {
                                                skb_queue_tail(&sdata->status_queue,
                                                               qskb);
-                                               ieee80211_queue_work(&local->hw,
-                                                                    &sdata->work);
+                                               wiphy_work_queue(local->hw.wiphy,
+                                                                &sdata->work);
                                        }
                                }
                        } else {
 
 
                /* Requeue all works */
                list_for_each_entry(sdata, &local->interfaces, list)
-                       ieee80211_queue_work(&local->hw, &sdata->work);
+                       wiphy_work_queue(local->hw.wiphy, &sdata->work);
        }
 
        ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,