2 * Off-channel operation helpers
4 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
5 * Copyright 2004, Instant802 Networks, Inc.
6 * Copyright 2005, Devicescape Software, Inc.
7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
15 #include <linux/export.h>
16 #include <net/mac80211.h>
17 #include "ieee80211_i.h"
18 #include "driver-ops.h"
21 * Tell our hardware to disable PS.
22 * Optionally inform AP that we will go to sleep so that it will buffer
23 * the frames while we are doing off-channel work. This is optional
24 * because we *may* be doing work on-operating channel, and want our
25 * hardware unconditionally awake, but still let the AP send us normal frames.
27 static void ieee80211_offchannel_ps_enable(struct ieee80211_sub_if_data *sdata)
29 struct ieee80211_local *local = sdata->local;
30 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
32 local->offchannel_ps_enabled = false;
34 /* FIXME: what to do when local->pspolling is true? */
36 del_timer_sync(&local->dynamic_ps_timer);
37 del_timer_sync(&ifmgd->bcn_mon_timer);
38 del_timer_sync(&ifmgd->conn_mon_timer);
40 cancel_work_sync(&local->dynamic_ps_enable_work);
42 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
43 local->offchannel_ps_enabled = true;
44 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
45 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
48 if (!local->offchannel_ps_enabled ||
49 !ieee80211_hw_check(&local->hw, PS_NULLFUNC_STACK))
51 * If power save was enabled, no need to send a nullfunc
52 * frame because AP knows that we are sleeping. But if the
53 * hardware is creating the nullfunc frame for power save
54 * status (ie. IEEE80211_HW_PS_NULLFUNC_STACK is not
55 * enabled) and power save was enabled, the firmware just
56 * sent a null frame with power save disabled. So we need
57 * to send a new nullfunc frame to inform the AP that we
60 ieee80211_send_nullfunc(local, sdata, true);
63 /* inform AP that we are awake again, unless power save is enabled */
64 static void ieee80211_offchannel_ps_disable(struct ieee80211_sub_if_data *sdata)
66 struct ieee80211_local *local = sdata->local;
69 ieee80211_send_nullfunc(local, sdata, false);
70 else if (local->offchannel_ps_enabled) {
72 * In !IEEE80211_HW_PS_NULLFUNC_STACK case the hardware
73 * will send a nullfunc frame with the powersave bit set
74 * even though the AP already knows that we are sleeping.
75 * This could be avoided by sending a null frame with power
76 * save bit disabled before enabling the power save, but
77 * this doesn't gain anything.
79 * When IEEE80211_HW_PS_NULLFUNC_STACK is enabled, no need
80 * to send a nullfunc frame because AP already knows that
81 * we are sleeping, let's just enable power save mode in
84 /* TODO: Only set hardware if CONF_PS changed?
85 * TODO: Should we set offchannel_ps_enabled to false?
87 local->hw.conf.flags |= IEEE80211_CONF_PS;
88 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
89 } else if (local->hw.conf.dynamic_ps_timeout > 0) {
91 * If IEEE80211_CONF_PS was not set and the dynamic_ps_timer
92 * had been running before leaving the operating channel,
93 * restart the timer now and send a nullfunc frame to inform
94 * the AP that we are awake.
96 ieee80211_send_nullfunc(local, sdata, false);
97 mod_timer(&local->dynamic_ps_timer, jiffies +
98 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
101 ieee80211_sta_reset_beacon_monitor(sdata);
102 ieee80211_sta_reset_conn_monitor(sdata);
105 void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local)
107 struct ieee80211_sub_if_data *sdata;
109 if (WARN_ON(local->use_chanctx))
113 * notify the AP about us leaving the channel and stop all
118 * Stop queues and transmit all frames queued by the driver
119 * before sending nullfunc to enable powersave at the AP.
121 ieee80211_stop_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
122 IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
124 ieee80211_flush_queues(local, NULL, false);
126 mutex_lock(&local->iflist_mtx);
127 list_for_each_entry(sdata, &local->interfaces, list) {
128 if (!ieee80211_sdata_running(sdata))
131 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
134 if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
135 set_bit(SDATA_STATE_OFFCHANNEL, &sdata->state);
137 /* Check to see if we should disable beaconing. */
138 if (sdata->vif.bss_conf.enable_beacon) {
139 set_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
141 sdata->vif.bss_conf.enable_beacon = false;
142 ieee80211_bss_info_change_notify(
143 sdata, BSS_CHANGED_BEACON_ENABLED);
146 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
147 sdata->u.mgd.associated)
148 ieee80211_offchannel_ps_enable(sdata);
150 mutex_unlock(&local->iflist_mtx);
153 void ieee80211_offchannel_return(struct ieee80211_local *local)
155 struct ieee80211_sub_if_data *sdata;
157 if (WARN_ON(local->use_chanctx))
160 mutex_lock(&local->iflist_mtx);
161 list_for_each_entry(sdata, &local->interfaces, list) {
162 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
165 if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
166 clear_bit(SDATA_STATE_OFFCHANNEL, &sdata->state);
168 if (!ieee80211_sdata_running(sdata))
171 /* Tell AP we're back */
172 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
173 sdata->u.mgd.associated)
174 ieee80211_offchannel_ps_disable(sdata);
176 if (test_and_clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
178 sdata->vif.bss_conf.enable_beacon = true;
179 ieee80211_bss_info_change_notify(
180 sdata, BSS_CHANGED_BEACON_ENABLED);
183 mutex_unlock(&local->iflist_mtx);
185 ieee80211_wake_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
186 IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
190 static void ieee80211_roc_notify_destroy(struct ieee80211_roc_work *roc)
192 /* was never transmitted */
194 cfg80211_mgmt_tx_status(&roc->sdata->wdev, roc->mgmt_tx_cookie,
195 roc->frame->data, roc->frame->len,
197 ieee80211_free_txskb(&roc->sdata->local->hw, roc->frame);
200 if (!roc->mgmt_tx_cookie)
201 cfg80211_remain_on_channel_expired(&roc->sdata->wdev,
202 roc->cookie, roc->chan,
205 list_del(&roc->list);
209 static unsigned long ieee80211_end_finished_rocs(struct ieee80211_local *local,
212 struct ieee80211_roc_work *roc, *tmp;
213 long remaining_dur_min = LONG_MAX;
215 lockdep_assert_held(&local->mtx);
217 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
223 remaining = roc->start_time +
224 msecs_to_jiffies(roc->duration) -
227 if (roc->abort || remaining <= 0)
228 ieee80211_roc_notify_destroy(roc);
230 remaining_dur_min = min(remaining_dur_min, remaining);
233 return remaining_dur_min;
236 static bool ieee80211_recalc_sw_work(struct ieee80211_local *local,
239 long dur = ieee80211_end_finished_rocs(local, now);
244 mod_delayed_work(local->workqueue, &local->roc_work, dur);
248 static void ieee80211_handle_roc_started(struct ieee80211_roc_work *roc,
249 unsigned long start_time)
251 struct ieee80211_local *local = roc->sdata->local;
253 if (WARN_ON(roc->notified))
256 roc->start_time = start_time;
258 roc->hw_begun = true;
260 if (roc->mgmt_tx_cookie) {
261 if (!WARN_ON(!roc->frame)) {
262 ieee80211_tx_skb_tid_band(roc->sdata, roc->frame, 7,
267 cfg80211_ready_on_channel(&roc->sdata->wdev, roc->cookie,
268 roc->chan, roc->req_duration,
272 roc->notified = true;
274 if (!local->ops->remain_on_channel)
275 ieee80211_recalc_sw_work(local, start_time);
278 static void ieee80211_hw_roc_start(struct work_struct *work)
280 struct ieee80211_local *local =
281 container_of(work, struct ieee80211_local, hw_roc_start);
282 struct ieee80211_roc_work *roc;
284 mutex_lock(&local->mtx);
286 list_for_each_entry(roc, &local->roc_list, list) {
290 ieee80211_handle_roc_started(roc, local->hw_roc_start_time);
293 mutex_unlock(&local->mtx);
296 void ieee80211_ready_on_channel(struct ieee80211_hw *hw)
298 struct ieee80211_local *local = hw_to_local(hw);
300 local->hw_roc_start_time = jiffies;
302 trace_api_ready_on_channel(local);
304 ieee80211_queue_work(hw, &local->hw_roc_start);
306 EXPORT_SYMBOL_GPL(ieee80211_ready_on_channel);
308 static void _ieee80211_start_next_roc(struct ieee80211_local *local)
310 struct ieee80211_roc_work *roc, *tmp;
311 enum ieee80211_roc_type type;
312 u32 min_dur, max_dur;
314 lockdep_assert_held(&local->mtx);
316 if (WARN_ON(list_empty(&local->roc_list)))
319 roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work,
322 if (WARN_ON(roc->started))
325 min_dur = roc->duration;
326 max_dur = roc->duration;
329 list_for_each_entry(tmp, &local->roc_list, list) {
332 if (tmp->sdata != roc->sdata || tmp->chan != roc->chan)
334 max_dur = max(tmp->duration, max_dur);
335 min_dur = min(tmp->duration, min_dur);
336 type = max(tmp->type, type);
339 if (local->ops->remain_on_channel) {
340 int ret = drv_remain_on_channel(local, roc->sdata, roc->chan,
344 wiphy_warn(local->hw.wiphy,
345 "failed to start next HW ROC (%d)\n", ret);
347 * queue the work struct again to avoid recursion
348 * when multiple failures occur
350 list_for_each_entry(tmp, &local->roc_list, list) {
351 if (tmp->sdata != roc->sdata ||
352 tmp->chan != roc->chan)
357 ieee80211_queue_work(&local->hw, &local->hw_roc_done);
361 /* we'll notify about the start once the HW calls back */
362 list_for_each_entry(tmp, &local->roc_list, list) {
363 if (tmp->sdata != roc->sdata || tmp->chan != roc->chan)
368 /* If actually operating on the desired channel (with at least
369 * 20 MHz channel width) don't stop all the operations but still
370 * treat it as though the ROC operation started properly, so
371 * other ROC operations won't interfere with this one.
373 roc->on_channel = roc->chan == local->_oper_chandef.chan &&
374 local->_oper_chandef.width != NL80211_CHAN_WIDTH_5 &&
375 local->_oper_chandef.width != NL80211_CHAN_WIDTH_10;
378 ieee80211_recalc_idle(local);
380 if (!roc->on_channel) {
381 ieee80211_offchannel_stop_vifs(local);
383 local->tmp_channel = roc->chan;
384 ieee80211_hw_config(local, 0);
387 ieee80211_queue_delayed_work(&local->hw, &local->roc_work,
388 msecs_to_jiffies(min_dur));
390 /* tell userspace or send frame(s) */
391 list_for_each_entry(tmp, &local->roc_list, list) {
392 if (tmp->sdata != roc->sdata || tmp->chan != roc->chan)
395 tmp->on_channel = roc->on_channel;
396 ieee80211_handle_roc_started(tmp, jiffies);
401 void ieee80211_start_next_roc(struct ieee80211_local *local)
403 struct ieee80211_roc_work *roc;
405 lockdep_assert_held(&local->mtx);
407 if (list_empty(&local->roc_list)) {
408 ieee80211_run_deferred_scan(local);
412 roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work,
415 if (WARN_ON_ONCE(roc->started))
418 if (local->ops->remain_on_channel) {
419 _ieee80211_start_next_roc(local);
422 ieee80211_queue_delayed_work(&local->hw, &local->roc_work,
423 round_jiffies_relative(HZ/2));
427 static void __ieee80211_roc_work(struct ieee80211_local *local)
429 struct ieee80211_roc_work *roc;
432 lockdep_assert_held(&local->mtx);
434 if (WARN_ON(local->ops->remain_on_channel))
437 roc = list_first_entry_or_null(&local->roc_list,
438 struct ieee80211_roc_work, list);
443 WARN_ON(local->use_chanctx);
444 _ieee80211_start_next_roc(local);
446 on_channel = roc->on_channel;
447 if (ieee80211_recalc_sw_work(local, jiffies))
450 /* careful - roc pointer became invalid during recalc */
453 ieee80211_flush_queues(local, NULL, false);
455 local->tmp_channel = NULL;
456 ieee80211_hw_config(local, 0);
458 ieee80211_offchannel_return(local);
461 ieee80211_recalc_idle(local);
462 ieee80211_start_next_roc(local);
466 static void ieee80211_roc_work(struct work_struct *work)
468 struct ieee80211_local *local =
469 container_of(work, struct ieee80211_local, roc_work.work);
471 mutex_lock(&local->mtx);
472 __ieee80211_roc_work(local);
473 mutex_unlock(&local->mtx);
476 static void ieee80211_hw_roc_done(struct work_struct *work)
478 struct ieee80211_local *local =
479 container_of(work, struct ieee80211_local, hw_roc_done);
481 mutex_lock(&local->mtx);
483 ieee80211_end_finished_rocs(local, jiffies);
485 /* if there's another roc, start it now */
486 ieee80211_start_next_roc(local);
488 mutex_unlock(&local->mtx);
491 void ieee80211_remain_on_channel_expired(struct ieee80211_hw *hw)
493 struct ieee80211_local *local = hw_to_local(hw);
495 trace_api_remain_on_channel_expired(local);
497 ieee80211_queue_work(hw, &local->hw_roc_done);
499 EXPORT_SYMBOL_GPL(ieee80211_remain_on_channel_expired);
502 ieee80211_coalesce_hw_started_roc(struct ieee80211_local *local,
503 struct ieee80211_roc_work *new_roc,
504 struct ieee80211_roc_work *cur_roc)
506 unsigned long now = jiffies;
507 unsigned long remaining;
509 if (WARN_ON(!cur_roc->started))
512 /* if it was scheduled in the hardware, but not started yet,
513 * we can only combine if the older one had a longer duration
515 if (!cur_roc->hw_begun && new_roc->duration > cur_roc->duration)
518 remaining = cur_roc->start_time +
519 msecs_to_jiffies(cur_roc->duration) -
522 /* if it doesn't fit entirely, schedule a new one */
523 if (new_roc->duration > jiffies_to_msecs(remaining))
526 /* add just after the current one so we combine their finish later */
527 list_add(&new_roc->list, &cur_roc->list);
529 /* if the existing one has already begun then let this one also
530 * begin, otherwise they'll both be marked properly by the work
531 * struct that runs once the driver notifies us of the beginning
533 if (cur_roc->hw_begun)
534 ieee80211_handle_roc_started(new_roc, now);
539 static int ieee80211_start_roc_work(struct ieee80211_local *local,
540 struct ieee80211_sub_if_data *sdata,
541 struct ieee80211_channel *channel,
542 unsigned int duration, u64 *cookie,
543 struct sk_buff *txskb,
544 enum ieee80211_roc_type type)
546 struct ieee80211_roc_work *roc, *tmp;
547 bool queued = false, combine_started = true;
550 lockdep_assert_held(&local->mtx);
552 if (local->use_chanctx && !local->ops->remain_on_channel)
555 roc = kzalloc(sizeof(*roc), GFP_KERNEL);
560 * If the duration is zero, then the driver
561 * wouldn't actually do anything. Set it to
564 * TODO: cancel the off-channel operation
565 * when we get the SKB's TX status and
566 * the wait time was zero before.
572 roc->duration = duration;
573 roc->req_duration = duration;
579 * cookie is either the roc cookie (for normal roc)
580 * or the SKB (for mgmt TX)
583 roc->cookie = ieee80211_mgmt_tx_cookie(local);
584 *cookie = roc->cookie;
586 roc->mgmt_tx_cookie = *cookie;
589 /* if there's no need to queue, handle it immediately */
590 if (list_empty(&local->roc_list) &&
591 !local->scanning && !ieee80211_is_radar_required(local)) {
592 /* if not HW assist, just queue & schedule work */
593 if (!local->ops->remain_on_channel) {
594 list_add_tail(&roc->list, &local->roc_list);
595 ieee80211_queue_delayed_work(&local->hw,
596 &local->roc_work, 0);
598 /* otherwise actually kick it off here
599 * (for error handling)
601 ret = drv_remain_on_channel(local, sdata, channel,
608 list_add_tail(&roc->list, &local->roc_list);
614 /* otherwise handle queueing */
616 list_for_each_entry(tmp, &local->roc_list, list) {
617 if (tmp->chan != channel || tmp->sdata != sdata)
621 * Extend this ROC if possible: If it hasn't started, add
622 * just after the new one to combine.
625 list_add(&roc->list, &tmp->list);
630 if (!combine_started)
633 if (!local->ops->remain_on_channel) {
634 /* If there's no hardware remain-on-channel, and
635 * doing so won't push us over the maximum r-o-c
636 * we allow, then we can just add the new one to
637 * the list and mark it as having started now.
638 * If it would push over the limit, don't try to
639 * combine with other started ones (that haven't
640 * been running as long) but potentially sort it
641 * with others that had the same fate.
643 unsigned long now = jiffies;
644 u32 elapsed = jiffies_to_msecs(now - tmp->start_time);
645 struct wiphy *wiphy = local->hw.wiphy;
646 u32 max_roc = wiphy->max_remain_on_channel_duration;
648 if (elapsed + roc->duration > max_roc) {
649 combine_started = false;
653 list_add(&roc->list, &tmp->list);
655 roc->on_channel = tmp->on_channel;
656 ieee80211_handle_roc_started(roc, now);
660 queued = ieee80211_coalesce_hw_started_roc(local, roc, tmp);
663 /* if it wasn't queued, perhaps it can be combined with
664 * another that also couldn't get combined previously,
665 * but no need to check for already started ones, since
668 combine_started = false;
672 list_add_tail(&roc->list, &local->roc_list);
677 int ieee80211_remain_on_channel(struct wiphy *wiphy, struct wireless_dev *wdev,
678 struct ieee80211_channel *chan,
679 unsigned int duration, u64 *cookie)
681 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
682 struct ieee80211_local *local = sdata->local;
685 mutex_lock(&local->mtx);
686 ret = ieee80211_start_roc_work(local, sdata, chan,
687 duration, cookie, NULL,
688 IEEE80211_ROC_TYPE_NORMAL);
689 mutex_unlock(&local->mtx);
694 static int ieee80211_cancel_roc(struct ieee80211_local *local,
695 u64 cookie, bool mgmt_tx)
697 struct ieee80211_roc_work *roc, *tmp, *found = NULL;
703 mutex_lock(&local->mtx);
704 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
705 if (!mgmt_tx && roc->cookie != cookie)
707 else if (mgmt_tx && roc->mgmt_tx_cookie != cookie)
715 mutex_unlock(&local->mtx);
719 if (!found->started) {
720 ieee80211_roc_notify_destroy(found);
724 if (local->ops->remain_on_channel) {
725 ret = drv_cancel_remain_on_channel(local);
726 if (WARN_ON_ONCE(ret)) {
727 mutex_unlock(&local->mtx);
732 * if multiple items were combined here then we really shouldn't
733 * cancel them all - we should wait for as much time as needed
734 * for the longest remaining one, and only then cancel ...
736 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
741 ieee80211_roc_notify_destroy(roc);
744 /* that really must not happen - it was started */
747 ieee80211_start_next_roc(local);
749 /* go through work struct to return to the operating channel */
751 mod_delayed_work(local->workqueue, &local->roc_work, 0);
755 mutex_unlock(&local->mtx);
760 int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
761 struct wireless_dev *wdev, u64 cookie)
763 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
764 struct ieee80211_local *local = sdata->local;
766 return ieee80211_cancel_roc(local, cookie, false);
769 int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
770 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
772 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
773 struct ieee80211_local *local = sdata->local;
775 struct sta_info *sta;
776 const struct ieee80211_mgmt *mgmt = (void *)params->buf;
777 bool need_offchan = false;
782 if (params->dont_wait_for_ack)
783 flags = IEEE80211_TX_CTL_NO_ACK;
785 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
786 IEEE80211_TX_CTL_REQ_TX_STATUS;
789 flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
791 switch (sdata->vif.type) {
792 case NL80211_IFTYPE_ADHOC:
793 if (!sdata->vif.bss_conf.ibss_joined)
796 #ifdef CONFIG_MAC80211_MESH
797 case NL80211_IFTYPE_MESH_POINT:
798 if (ieee80211_vif_is_mesh(&sdata->vif) &&
799 !sdata->u.mesh.mesh_id_len)
803 case NL80211_IFTYPE_AP:
804 case NL80211_IFTYPE_AP_VLAN:
805 case NL80211_IFTYPE_P2P_GO:
806 if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
807 !ieee80211_vif_is_mesh(&sdata->vif) &&
808 !rcu_access_pointer(sdata->bss->beacon))
810 if (!ieee80211_is_action(mgmt->frame_control) ||
811 mgmt->u.action.category == WLAN_CATEGORY_PUBLIC ||
812 mgmt->u.action.category == WLAN_CATEGORY_SELF_PROTECTED ||
813 mgmt->u.action.category == WLAN_CATEGORY_SPECTRUM_MGMT)
816 sta = sta_info_get(sdata, mgmt->da);
821 case NL80211_IFTYPE_STATION:
822 case NL80211_IFTYPE_P2P_CLIENT:
824 if (!sdata->u.mgd.associated ||
825 (params->offchan && params->wait &&
826 local->ops->remain_on_channel &&
827 memcmp(sdata->u.mgd.associated->bssid,
828 mgmt->bssid, ETH_ALEN)))
832 case NL80211_IFTYPE_P2P_DEVICE:
839 /* configurations requiring offchan cannot work if no channel has been
842 if (need_offchan && !params->chan)
845 mutex_lock(&local->mtx);
847 /* Check if the operating channel is the requested channel */
849 struct ieee80211_chanctx_conf *chanctx_conf;
852 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
855 need_offchan = params->chan &&
857 chanctx_conf->def.chan);
858 } else if (!params->chan) {
868 if (need_offchan && !params->offchan) {
873 skb = dev_alloc_skb(local->hw.extra_tx_headroom + params->len);
878 skb_reserve(skb, local->hw.extra_tx_headroom);
880 data = skb_put(skb, params->len);
881 memcpy(data, params->buf, params->len);
883 /* Update CSA counters */
884 if (sdata->vif.csa_active &&
885 (sdata->vif.type == NL80211_IFTYPE_AP ||
886 sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
887 sdata->vif.type == NL80211_IFTYPE_ADHOC) &&
888 params->n_csa_offsets) {
890 struct beacon_data *beacon = NULL;
894 if (sdata->vif.type == NL80211_IFTYPE_AP)
895 beacon = rcu_dereference(sdata->u.ap.beacon);
896 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
897 beacon = rcu_dereference(sdata->u.ibss.presp);
898 else if (ieee80211_vif_is_mesh(&sdata->vif))
899 beacon = rcu_dereference(sdata->u.mesh.beacon);
902 for (i = 0; i < params->n_csa_offsets; i++)
903 data[params->csa_offsets[i]] =
904 beacon->csa_current_counter;
909 IEEE80211_SKB_CB(skb)->flags = flags;
911 skb->dev = sdata->dev;
913 if (!params->dont_wait_for_ack) {
914 /* make a copy to preserve the frame contents
915 * in case of encryption.
917 ret = ieee80211_attach_ack_skb(local, skb, cookie, GFP_KERNEL);
923 /* Assign a dummy non-zero cookie, it's not sent to
924 * userspace in this case but we rely on its value
925 * internally in the need_offchan case to distinguish
926 * mgmt-tx from remain-on-channel.
928 *cookie = 0xffffffff;
932 ieee80211_tx_skb(sdata, skb);
937 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN |
938 IEEE80211_TX_INTFL_OFFCHAN_TX_OK;
939 if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
940 IEEE80211_SKB_CB(skb)->hw_queue =
941 local->hw.offchannel_tx_hw_queue;
943 /* This will handle all kinds of coalescing and immediate TX */
944 ret = ieee80211_start_roc_work(local, sdata, params->chan,
945 params->wait, cookie, skb,
946 IEEE80211_ROC_TYPE_MGMT_TX);
948 ieee80211_free_txskb(&local->hw, skb);
950 mutex_unlock(&local->mtx);
954 int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
955 struct wireless_dev *wdev, u64 cookie)
957 struct ieee80211_local *local = wiphy_priv(wiphy);
959 return ieee80211_cancel_roc(local, cookie, true);
962 void ieee80211_roc_setup(struct ieee80211_local *local)
964 INIT_WORK(&local->hw_roc_start, ieee80211_hw_roc_start);
965 INIT_WORK(&local->hw_roc_done, ieee80211_hw_roc_done);
966 INIT_DELAYED_WORK(&local->roc_work, ieee80211_roc_work);
967 INIT_LIST_HEAD(&local->roc_list);
970 void ieee80211_roc_purge(struct ieee80211_local *local,
971 struct ieee80211_sub_if_data *sdata)
973 struct ieee80211_roc_work *roc, *tmp;
974 bool work_to_do = false;
976 mutex_lock(&local->mtx);
977 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
978 if (sdata && roc->sdata != sdata)
982 if (local->ops->remain_on_channel) {
983 /* can race, so ignore return value */
984 drv_cancel_remain_on_channel(local);
985 ieee80211_roc_notify_destroy(roc);
991 ieee80211_roc_notify_destroy(roc);
995 __ieee80211_roc_work(local);
996 mutex_unlock(&local->mtx);