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 /* In case of HW ROC, it is possible that the HW finished the
228 * ROC session before the actual requested time. In such a case
229 * end the ROC session (disregarding the remaining time).
231 if (roc
->abort
|| roc
->hw_begun
|| remaining
<= 0)
232 ieee80211_roc_notify_destroy(roc
);
234 remaining_dur_min
= min(remaining_dur_min
, remaining
);
237 return remaining_dur_min
;
240 static bool ieee80211_recalc_sw_work(struct ieee80211_local
*local
,
243 long dur
= ieee80211_end_finished_rocs(local
, now
);
248 mod_delayed_work(local
->workqueue
, &local
->roc_work
, dur
);
252 static void ieee80211_handle_roc_started(struct ieee80211_roc_work
*roc
,
253 unsigned long start_time
)
255 struct ieee80211_local
*local
= roc
->sdata
->local
;
257 if (WARN_ON(roc
->notified
))
260 roc
->start_time
= start_time
;
262 roc
->hw_begun
= true;
264 if (roc
->mgmt_tx_cookie
) {
265 if (!WARN_ON(!roc
->frame
)) {
266 ieee80211_tx_skb_tid_band(roc
->sdata
, roc
->frame
, 7,
271 cfg80211_ready_on_channel(&roc
->sdata
->wdev
, roc
->cookie
,
272 roc
->chan
, roc
->req_duration
,
276 roc
->notified
= true;
278 if (!local
->ops
->remain_on_channel
)
279 ieee80211_recalc_sw_work(local
, start_time
);
282 static void ieee80211_hw_roc_start(struct work_struct
*work
)
284 struct ieee80211_local
*local
=
285 container_of(work
, struct ieee80211_local
, hw_roc_start
);
286 struct ieee80211_roc_work
*roc
;
288 mutex_lock(&local
->mtx
);
290 list_for_each_entry(roc
, &local
->roc_list
, list
) {
294 ieee80211_handle_roc_started(roc
, local
->hw_roc_start_time
);
297 mutex_unlock(&local
->mtx
);
300 void ieee80211_ready_on_channel(struct ieee80211_hw
*hw
)
302 struct ieee80211_local
*local
= hw_to_local(hw
);
304 local
->hw_roc_start_time
= jiffies
;
306 trace_api_ready_on_channel(local
);
308 ieee80211_queue_work(hw
, &local
->hw_roc_start
);
310 EXPORT_SYMBOL_GPL(ieee80211_ready_on_channel
);
312 static void _ieee80211_start_next_roc(struct ieee80211_local
*local
)
314 struct ieee80211_roc_work
*roc
, *tmp
;
315 enum ieee80211_roc_type type
;
316 u32 min_dur
, max_dur
;
318 lockdep_assert_held(&local
->mtx
);
320 if (WARN_ON(list_empty(&local
->roc_list
)))
323 roc
= list_first_entry(&local
->roc_list
, struct ieee80211_roc_work
,
326 if (WARN_ON(roc
->started
))
329 min_dur
= roc
->duration
;
330 max_dur
= roc
->duration
;
333 list_for_each_entry(tmp
, &local
->roc_list
, list
) {
336 if (tmp
->sdata
!= roc
->sdata
|| tmp
->chan
!= roc
->chan
)
338 max_dur
= max(tmp
->duration
, max_dur
);
339 min_dur
= min(tmp
->duration
, min_dur
);
340 type
= max(tmp
->type
, type
);
343 if (local
->ops
->remain_on_channel
) {
344 int ret
= drv_remain_on_channel(local
, roc
->sdata
, roc
->chan
,
348 wiphy_warn(local
->hw
.wiphy
,
349 "failed to start next HW ROC (%d)\n", ret
);
351 * queue the work struct again to avoid recursion
352 * when multiple failures occur
354 list_for_each_entry(tmp
, &local
->roc_list
, list
) {
355 if (tmp
->sdata
!= roc
->sdata
||
356 tmp
->chan
!= roc
->chan
)
361 ieee80211_queue_work(&local
->hw
, &local
->hw_roc_done
);
365 /* we'll notify about the start once the HW calls back */
366 list_for_each_entry(tmp
, &local
->roc_list
, list
) {
367 if (tmp
->sdata
!= roc
->sdata
|| tmp
->chan
!= roc
->chan
)
372 /* If actually operating on the desired channel (with at least
373 * 20 MHz channel width) don't stop all the operations but still
374 * treat it as though the ROC operation started properly, so
375 * other ROC operations won't interfere with this one.
377 roc
->on_channel
= roc
->chan
== local
->_oper_chandef
.chan
&&
378 local
->_oper_chandef
.width
!= NL80211_CHAN_WIDTH_5
&&
379 local
->_oper_chandef
.width
!= NL80211_CHAN_WIDTH_10
;
382 ieee80211_recalc_idle(local
);
384 if (!roc
->on_channel
) {
385 ieee80211_offchannel_stop_vifs(local
);
387 local
->tmp_channel
= roc
->chan
;
388 ieee80211_hw_config(local
, 0);
391 ieee80211_queue_delayed_work(&local
->hw
, &local
->roc_work
,
392 msecs_to_jiffies(min_dur
));
394 /* tell userspace or send frame(s) */
395 list_for_each_entry(tmp
, &local
->roc_list
, list
) {
396 if (tmp
->sdata
!= roc
->sdata
|| tmp
->chan
!= roc
->chan
)
399 tmp
->on_channel
= roc
->on_channel
;
400 ieee80211_handle_roc_started(tmp
, jiffies
);
405 void ieee80211_start_next_roc(struct ieee80211_local
*local
)
407 struct ieee80211_roc_work
*roc
;
409 lockdep_assert_held(&local
->mtx
);
411 if (list_empty(&local
->roc_list
)) {
412 ieee80211_run_deferred_scan(local
);
416 roc
= list_first_entry(&local
->roc_list
, struct ieee80211_roc_work
,
419 if (WARN_ON_ONCE(roc
->started
))
422 if (local
->ops
->remain_on_channel
) {
423 _ieee80211_start_next_roc(local
);
426 ieee80211_queue_delayed_work(&local
->hw
, &local
->roc_work
,
427 round_jiffies_relative(HZ
/2));
431 static void __ieee80211_roc_work(struct ieee80211_local
*local
)
433 struct ieee80211_roc_work
*roc
;
436 lockdep_assert_held(&local
->mtx
);
438 if (WARN_ON(local
->ops
->remain_on_channel
))
441 roc
= list_first_entry_or_null(&local
->roc_list
,
442 struct ieee80211_roc_work
, list
);
447 WARN_ON(local
->use_chanctx
);
448 _ieee80211_start_next_roc(local
);
450 on_channel
= roc
->on_channel
;
451 if (ieee80211_recalc_sw_work(local
, jiffies
))
454 /* careful - roc pointer became invalid during recalc */
457 ieee80211_flush_queues(local
, NULL
, false);
459 local
->tmp_channel
= NULL
;
460 ieee80211_hw_config(local
, 0);
462 ieee80211_offchannel_return(local
);
465 ieee80211_recalc_idle(local
);
466 ieee80211_start_next_roc(local
);
470 static void ieee80211_roc_work(struct work_struct
*work
)
472 struct ieee80211_local
*local
=
473 container_of(work
, struct ieee80211_local
, roc_work
.work
);
475 mutex_lock(&local
->mtx
);
476 __ieee80211_roc_work(local
);
477 mutex_unlock(&local
->mtx
);
480 static void ieee80211_hw_roc_done(struct work_struct
*work
)
482 struct ieee80211_local
*local
=
483 container_of(work
, struct ieee80211_local
, hw_roc_done
);
485 mutex_lock(&local
->mtx
);
487 ieee80211_end_finished_rocs(local
, jiffies
);
489 /* if there's another roc, start it now */
490 ieee80211_start_next_roc(local
);
492 mutex_unlock(&local
->mtx
);
495 void ieee80211_remain_on_channel_expired(struct ieee80211_hw
*hw
)
497 struct ieee80211_local
*local
= hw_to_local(hw
);
499 trace_api_remain_on_channel_expired(local
);
501 ieee80211_queue_work(hw
, &local
->hw_roc_done
);
503 EXPORT_SYMBOL_GPL(ieee80211_remain_on_channel_expired
);
506 ieee80211_coalesce_hw_started_roc(struct ieee80211_local
*local
,
507 struct ieee80211_roc_work
*new_roc
,
508 struct ieee80211_roc_work
*cur_roc
)
510 unsigned long now
= jiffies
;
511 unsigned long remaining
;
513 if (WARN_ON(!cur_roc
->started
))
516 /* if it was scheduled in the hardware, but not started yet,
517 * we can only combine if the older one had a longer duration
519 if (!cur_roc
->hw_begun
&& new_roc
->duration
> cur_roc
->duration
)
522 remaining
= cur_roc
->start_time
+
523 msecs_to_jiffies(cur_roc
->duration
) -
526 /* if it doesn't fit entirely, schedule a new one */
527 if (new_roc
->duration
> jiffies_to_msecs(remaining
))
530 /* add just after the current one so we combine their finish later */
531 list_add(&new_roc
->list
, &cur_roc
->list
);
533 /* if the existing one has already begun then let this one also
534 * begin, otherwise they'll both be marked properly by the work
535 * struct that runs once the driver notifies us of the beginning
537 if (cur_roc
->hw_begun
)
538 ieee80211_handle_roc_started(new_roc
, now
);
543 static int ieee80211_start_roc_work(struct ieee80211_local
*local
,
544 struct ieee80211_sub_if_data
*sdata
,
545 struct ieee80211_channel
*channel
,
546 unsigned int duration
, u64
*cookie
,
547 struct sk_buff
*txskb
,
548 enum ieee80211_roc_type type
)
550 struct ieee80211_roc_work
*roc
, *tmp
;
551 bool queued
= false, combine_started
= true;
554 lockdep_assert_held(&local
->mtx
);
556 if (local
->use_chanctx
&& !local
->ops
->remain_on_channel
)
559 roc
= kzalloc(sizeof(*roc
), GFP_KERNEL
);
564 * If the duration is zero, then the driver
565 * wouldn't actually do anything. Set it to
568 * TODO: cancel the off-channel operation
569 * when we get the SKB's TX status and
570 * the wait time was zero before.
576 roc
->duration
= duration
;
577 roc
->req_duration
= duration
;
583 * cookie is either the roc cookie (for normal roc)
584 * or the SKB (for mgmt TX)
587 roc
->cookie
= ieee80211_mgmt_tx_cookie(local
);
588 *cookie
= roc
->cookie
;
590 roc
->mgmt_tx_cookie
= *cookie
;
593 /* if there's no need to queue, handle it immediately */
594 if (list_empty(&local
->roc_list
) &&
595 !local
->scanning
&& !ieee80211_is_radar_required(local
)) {
596 /* if not HW assist, just queue & schedule work */
597 if (!local
->ops
->remain_on_channel
) {
598 list_add_tail(&roc
->list
, &local
->roc_list
);
599 ieee80211_queue_delayed_work(&local
->hw
,
600 &local
->roc_work
, 0);
602 /* otherwise actually kick it off here
603 * (for error handling)
605 ret
= drv_remain_on_channel(local
, sdata
, channel
,
612 list_add_tail(&roc
->list
, &local
->roc_list
);
618 /* otherwise handle queueing */
620 list_for_each_entry(tmp
, &local
->roc_list
, list
) {
621 if (tmp
->chan
!= channel
|| tmp
->sdata
!= sdata
)
625 * Extend this ROC if possible: If it hasn't started, add
626 * just after the new one to combine.
629 list_add(&roc
->list
, &tmp
->list
);
634 if (!combine_started
)
637 if (!local
->ops
->remain_on_channel
) {
638 /* If there's no hardware remain-on-channel, and
639 * doing so won't push us over the maximum r-o-c
640 * we allow, then we can just add the new one to
641 * the list and mark it as having started now.
642 * If it would push over the limit, don't try to
643 * combine with other started ones (that haven't
644 * been running as long) but potentially sort it
645 * with others that had the same fate.
647 unsigned long now
= jiffies
;
648 u32 elapsed
= jiffies_to_msecs(now
- tmp
->start_time
);
649 struct wiphy
*wiphy
= local
->hw
.wiphy
;
650 u32 max_roc
= wiphy
->max_remain_on_channel_duration
;
652 if (elapsed
+ roc
->duration
> max_roc
) {
653 combine_started
= false;
657 list_add(&roc
->list
, &tmp
->list
);
659 roc
->on_channel
= tmp
->on_channel
;
660 ieee80211_handle_roc_started(roc
, now
);
664 queued
= ieee80211_coalesce_hw_started_roc(local
, roc
, tmp
);
667 /* if it wasn't queued, perhaps it can be combined with
668 * another that also couldn't get combined previously,
669 * but no need to check for already started ones, since
672 combine_started
= false;
676 list_add_tail(&roc
->list
, &local
->roc_list
);
681 int ieee80211_remain_on_channel(struct wiphy
*wiphy
, struct wireless_dev
*wdev
,
682 struct ieee80211_channel
*chan
,
683 unsigned int duration
, u64
*cookie
)
685 struct ieee80211_sub_if_data
*sdata
= IEEE80211_WDEV_TO_SUB_IF(wdev
);
686 struct ieee80211_local
*local
= sdata
->local
;
689 mutex_lock(&local
->mtx
);
690 ret
= ieee80211_start_roc_work(local
, sdata
, chan
,
691 duration
, cookie
, NULL
,
692 IEEE80211_ROC_TYPE_NORMAL
);
693 mutex_unlock(&local
->mtx
);
698 static int ieee80211_cancel_roc(struct ieee80211_local
*local
,
699 u64 cookie
, bool mgmt_tx
)
701 struct ieee80211_roc_work
*roc
, *tmp
, *found
= NULL
;
707 mutex_lock(&local
->mtx
);
708 list_for_each_entry_safe(roc
, tmp
, &local
->roc_list
, list
) {
709 if (!mgmt_tx
&& roc
->cookie
!= cookie
)
711 else if (mgmt_tx
&& roc
->mgmt_tx_cookie
!= cookie
)
719 mutex_unlock(&local
->mtx
);
723 if (!found
->started
) {
724 ieee80211_roc_notify_destroy(found
);
728 if (local
->ops
->remain_on_channel
) {
729 ret
= drv_cancel_remain_on_channel(local
);
730 if (WARN_ON_ONCE(ret
)) {
731 mutex_unlock(&local
->mtx
);
736 * if multiple items were combined here then we really shouldn't
737 * cancel them all - we should wait for as much time as needed
738 * for the longest remaining one, and only then cancel ...
740 list_for_each_entry_safe(roc
, tmp
, &local
->roc_list
, list
) {
745 ieee80211_roc_notify_destroy(roc
);
748 /* that really must not happen - it was started */
751 ieee80211_start_next_roc(local
);
753 /* go through work struct to return to the operating channel */
755 mod_delayed_work(local
->workqueue
, &local
->roc_work
, 0);
759 mutex_unlock(&local
->mtx
);
764 int ieee80211_cancel_remain_on_channel(struct wiphy
*wiphy
,
765 struct wireless_dev
*wdev
, u64 cookie
)
767 struct ieee80211_sub_if_data
*sdata
= IEEE80211_WDEV_TO_SUB_IF(wdev
);
768 struct ieee80211_local
*local
= sdata
->local
;
770 return ieee80211_cancel_roc(local
, cookie
, false);
773 int ieee80211_mgmt_tx(struct wiphy
*wiphy
, struct wireless_dev
*wdev
,
774 struct cfg80211_mgmt_tx_params
*params
, u64
*cookie
)
776 struct ieee80211_sub_if_data
*sdata
= IEEE80211_WDEV_TO_SUB_IF(wdev
);
777 struct ieee80211_local
*local
= sdata
->local
;
779 struct sta_info
*sta
;
780 const struct ieee80211_mgmt
*mgmt
= (void *)params
->buf
;
781 bool need_offchan
= false;
786 if (params
->dont_wait_for_ack
)
787 flags
= IEEE80211_TX_CTL_NO_ACK
;
789 flags
= IEEE80211_TX_INTFL_NL80211_FRAME_TX
|
790 IEEE80211_TX_CTL_REQ_TX_STATUS
;
793 flags
|= IEEE80211_TX_CTL_NO_CCK_RATE
;
795 switch (sdata
->vif
.type
) {
796 case NL80211_IFTYPE_ADHOC
:
797 if (!sdata
->vif
.bss_conf
.ibss_joined
)
800 #ifdef CONFIG_MAC80211_MESH
801 case NL80211_IFTYPE_MESH_POINT
:
802 if (ieee80211_vif_is_mesh(&sdata
->vif
) &&
803 !sdata
->u
.mesh
.mesh_id_len
)
807 case NL80211_IFTYPE_AP
:
808 case NL80211_IFTYPE_AP_VLAN
:
809 case NL80211_IFTYPE_P2P_GO
:
810 if (sdata
->vif
.type
!= NL80211_IFTYPE_ADHOC
&&
811 !ieee80211_vif_is_mesh(&sdata
->vif
) &&
812 !rcu_access_pointer(sdata
->bss
->beacon
))
814 if (!ieee80211_is_action(mgmt
->frame_control
) ||
815 mgmt
->u
.action
.category
== WLAN_CATEGORY_PUBLIC
||
816 mgmt
->u
.action
.category
== WLAN_CATEGORY_SELF_PROTECTED
||
817 mgmt
->u
.action
.category
== WLAN_CATEGORY_SPECTRUM_MGMT
)
820 sta
= sta_info_get(sdata
, mgmt
->da
);
825 case NL80211_IFTYPE_STATION
:
826 case NL80211_IFTYPE_P2P_CLIENT
:
828 if (!sdata
->u
.mgd
.associated
||
829 (params
->offchan
&& params
->wait
&&
830 local
->ops
->remain_on_channel
&&
831 memcmp(sdata
->u
.mgd
.associated
->bssid
,
832 mgmt
->bssid
, ETH_ALEN
)))
836 case NL80211_IFTYPE_P2P_DEVICE
:
843 /* configurations requiring offchan cannot work if no channel has been
846 if (need_offchan
&& !params
->chan
)
849 mutex_lock(&local
->mtx
);
851 /* Check if the operating channel is the requested channel */
853 struct ieee80211_chanctx_conf
*chanctx_conf
;
856 chanctx_conf
= rcu_dereference(sdata
->vif
.chanctx_conf
);
859 need_offchan
= params
->chan
&&
861 chanctx_conf
->def
.chan
);
862 } else if (!params
->chan
) {
872 if (need_offchan
&& !params
->offchan
) {
877 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ params
->len
);
882 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
884 data
= skb_put(skb
, params
->len
);
885 memcpy(data
, params
->buf
, params
->len
);
887 /* Update CSA counters */
888 if (sdata
->vif
.csa_active
&&
889 (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
890 sdata
->vif
.type
== NL80211_IFTYPE_MESH_POINT
||
891 sdata
->vif
.type
== NL80211_IFTYPE_ADHOC
) &&
892 params
->n_csa_offsets
) {
894 struct beacon_data
*beacon
= NULL
;
898 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
)
899 beacon
= rcu_dereference(sdata
->u
.ap
.beacon
);
900 else if (sdata
->vif
.type
== NL80211_IFTYPE_ADHOC
)
901 beacon
= rcu_dereference(sdata
->u
.ibss
.presp
);
902 else if (ieee80211_vif_is_mesh(&sdata
->vif
))
903 beacon
= rcu_dereference(sdata
->u
.mesh
.beacon
);
906 for (i
= 0; i
< params
->n_csa_offsets
; i
++)
907 data
[params
->csa_offsets
[i
]] =
908 beacon
->csa_current_counter
;
913 IEEE80211_SKB_CB(skb
)->flags
= flags
;
915 skb
->dev
= sdata
->dev
;
917 if (!params
->dont_wait_for_ack
) {
918 /* make a copy to preserve the frame contents
919 * in case of encryption.
921 ret
= ieee80211_attach_ack_skb(local
, skb
, cookie
, GFP_KERNEL
);
927 /* Assign a dummy non-zero cookie, it's not sent to
928 * userspace in this case but we rely on its value
929 * internally in the need_offchan case to distinguish
930 * mgmt-tx from remain-on-channel.
932 *cookie
= 0xffffffff;
936 ieee80211_tx_skb(sdata
, skb
);
941 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_CTL_TX_OFFCHAN
|
942 IEEE80211_TX_INTFL_OFFCHAN_TX_OK
;
943 if (ieee80211_hw_check(&local
->hw
, QUEUE_CONTROL
))
944 IEEE80211_SKB_CB(skb
)->hw_queue
=
945 local
->hw
.offchannel_tx_hw_queue
;
947 /* This will handle all kinds of coalescing and immediate TX */
948 ret
= ieee80211_start_roc_work(local
, sdata
, params
->chan
,
949 params
->wait
, cookie
, skb
,
950 IEEE80211_ROC_TYPE_MGMT_TX
);
952 ieee80211_free_txskb(&local
->hw
, skb
);
954 mutex_unlock(&local
->mtx
);
958 int ieee80211_mgmt_tx_cancel_wait(struct wiphy
*wiphy
,
959 struct wireless_dev
*wdev
, u64 cookie
)
961 struct ieee80211_local
*local
= wiphy_priv(wiphy
);
963 return ieee80211_cancel_roc(local
, cookie
, true);
966 void ieee80211_roc_setup(struct ieee80211_local
*local
)
968 INIT_WORK(&local
->hw_roc_start
, ieee80211_hw_roc_start
);
969 INIT_WORK(&local
->hw_roc_done
, ieee80211_hw_roc_done
);
970 INIT_DELAYED_WORK(&local
->roc_work
, ieee80211_roc_work
);
971 INIT_LIST_HEAD(&local
->roc_list
);
974 void ieee80211_roc_purge(struct ieee80211_local
*local
,
975 struct ieee80211_sub_if_data
*sdata
)
977 struct ieee80211_roc_work
*roc
, *tmp
;
978 bool work_to_do
= false;
980 mutex_lock(&local
->mtx
);
981 list_for_each_entry_safe(roc
, tmp
, &local
->roc_list
, list
) {
982 if (sdata
&& roc
->sdata
!= sdata
)
986 if (local
->ops
->remain_on_channel
) {
987 /* can race, so ignore return value */
988 drv_cancel_remain_on_channel(local
);
989 ieee80211_roc_notify_destroy(roc
);
995 ieee80211_roc_notify_destroy(roc
);
999 __ieee80211_roc_work(local
);
1000 mutex_unlock(&local
->mtx
);