blob: eede5c6db8d5a784a27da0c53fc6f34b75dcf0bb [file] [log] [blame]
Jouni Malinenb203ffc2009-12-23 13:15:40 +01001/*
2 * Off-channel operation helpers
3 *
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>
10 *
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.
14 */
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040015#include <linux/export.h>
Jouni Malinenb203ffc2009-12-23 13:15:40 +010016#include <net/mac80211.h>
17#include "ieee80211_i.h"
Johannes Berg2eb278e2012-06-05 14:28:42 +020018#include "driver-ops.h"
Jouni Malinenb203ffc2009-12-23 13:15:40 +010019
20/*
Ben Greearb23b0252011-02-04 11:54:17 -080021 * 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.
Jouni Malinenb203ffc2009-12-23 13:15:40 +010026 */
Rajkumar Manoharan559cef92012-06-18 19:03:52 +053027static void ieee80211_offchannel_ps_enable(struct ieee80211_sub_if_data *sdata)
Jouni Malinenb203ffc2009-12-23 13:15:40 +010028{
29 struct ieee80211_local *local = sdata->local;
Luis R. Rodriguez4730d592010-09-16 15:12:31 -040030 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jouni Malinenb203ffc2009-12-23 13:15:40 +010031
32 local->offchannel_ps_enabled = false;
33
34 /* FIXME: what to do when local->pspolling is true? */
35
36 del_timer_sync(&local->dynamic_ps_timer);
Luis R. Rodriguez3bc3c0d2010-09-16 15:12:33 -040037 del_timer_sync(&ifmgd->bcn_mon_timer);
Luis R. Rodriguez4730d592010-09-16 15:12:31 -040038 del_timer_sync(&ifmgd->conn_mon_timer);
39
Jouni Malinenb203ffc2009-12-23 13:15:40 +010040 cancel_work_sync(&local->dynamic_ps_enable_work);
41
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);
46 }
47
Rajkumar Manoharan559cef92012-06-18 19:03:52 +053048 if (!local->offchannel_ps_enabled ||
Johannes Berg30686bf2015-06-02 21:39:54 +020049 !ieee80211_hw_check(&local->hw, PS_NULLFUNC_STACK))
Jouni Malinenb203ffc2009-12-23 13:15:40 +010050 /*
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
58 * are again sleeping.
59 */
Johannes Berg076cdcb2015-09-24 16:14:55 +020060 ieee80211_send_nullfunc(local, sdata, true);
Jouni Malinenb203ffc2009-12-23 13:15:40 +010061}
62
63/* inform AP that we are awake again, unless power save is enabled */
64static void ieee80211_offchannel_ps_disable(struct ieee80211_sub_if_data *sdata)
65{
66 struct ieee80211_local *local = sdata->local;
67
68 if (!local->ps_sdata)
Johannes Berg076cdcb2015-09-24 16:14:55 +020069 ieee80211_send_nullfunc(local, sdata, false);
Jouni Malinenb203ffc2009-12-23 13:15:40 +010070 else if (local->offchannel_ps_enabled) {
71 /*
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.
78 *
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
82 * hardware.
83 */
Ben Greearb23b0252011-02-04 11:54:17 -080084 /* TODO: Only set hardware if CONF_PS changed?
85 * TODO: Should we set offchannel_ps_enabled to false?
86 */
Jouni Malinenb203ffc2009-12-23 13:15:40 +010087 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) {
90 /*
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.
95 */
Johannes Berg076cdcb2015-09-24 16:14:55 +020096 ieee80211_send_nullfunc(local, sdata, false);
Jouni Malinenb203ffc2009-12-23 13:15:40 +010097 mod_timer(&local->dynamic_ps_timer, jiffies +
98 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
99 }
Luis R. Rodriguez4730d592010-09-16 15:12:31 -0400100
Luis R. Rodriguez3bc3c0d2010-09-16 15:12:33 -0400101 ieee80211_sta_reset_beacon_monitor(sdata);
Luis R. Rodriguez4730d592010-09-16 15:12:31 -0400102 ieee80211_sta_reset_conn_monitor(sdata);
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100103}
104
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100105void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local)
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100106{
107 struct ieee80211_sub_if_data *sdata;
108
Johannes Bergfe57d9f2012-07-26 14:55:08 +0200109 if (WARN_ON(local->use_chanctx))
110 return;
111
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100112 /*
Ben Greearb23b0252011-02-04 11:54:17 -0800113 * notify the AP about us leaving the channel and stop all
114 * STA interfaces.
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100115 */
Seth Forshee6c17b772013-02-11 11:21:07 -0600116
Seth Forshee9c35d7d2013-02-11 11:21:08 -0600117 /*
118 * Stop queues and transmit all frames queued by the driver
119 * before sending nullfunc to enable powersave at the AP.
120 */
Johannes Berg445ea4e2013-02-13 12:25:28 +0100121 ieee80211_stop_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300122 IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
123 false);
Emmanuel Grumbach3b24f4c2015-01-07 15:42:39 +0200124 ieee80211_flush_queues(local, NULL, false);
Seth Forshee6c17b772013-02-11 11:21:07 -0600125
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100126 mutex_lock(&local->iflist_mtx);
127 list_for_each_entry(sdata, &local->interfaces, list) {
128 if (!ieee80211_sdata_running(sdata))
129 continue;
130
Ayala Beker708d50e2016-09-20 17:31:14 +0300131 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE ||
132 sdata->vif.type == NL80211_IFTYPE_NAN)
Johannes Bergf142c6b2012-06-18 20:07:15 +0200133 continue;
134
Ben Greearb23b0252011-02-04 11:54:17 -0800135 if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
Johannes Berg5b714c62010-08-27 13:45:28 +0200136 set_bit(SDATA_STATE_OFFCHANNEL, &sdata->state);
Ben Greearb23b0252011-02-04 11:54:17 -0800137
138 /* Check to see if we should disable beaconing. */
Johannes Bergd6a83222012-12-14 14:06:28 +0100139 if (sdata->vif.bss_conf.enable_beacon) {
140 set_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
141 &sdata->state);
142 sdata->vif.bss_conf.enable_beacon = false;
Ben Greearb23b0252011-02-04 11:54:17 -0800143 ieee80211_bss_info_change_notify(
144 sdata, BSS_CHANGED_BEACON_ENABLED);
Johannes Bergd6a83222012-12-14 14:06:28 +0100145 }
Ben Greearb23b0252011-02-04 11:54:17 -0800146
Seth Forshee6c17b772013-02-11 11:21:07 -0600147 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
148 sdata->u.mgd.associated)
149 ieee80211_offchannel_ps_enable(sdata);
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100150 }
151 mutex_unlock(&local->iflist_mtx);
152}
153
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100154void ieee80211_offchannel_return(struct ieee80211_local *local)
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100155{
156 struct ieee80211_sub_if_data *sdata;
157
Johannes Bergfe57d9f2012-07-26 14:55:08 +0200158 if (WARN_ON(local->use_chanctx))
159 return;
160
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100161 mutex_lock(&local->iflist_mtx);
162 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Bergf142c6b2012-06-18 20:07:15 +0200163 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
164 continue;
165
Eliad Pellerf6e8cb72011-12-23 01:48:06 +0200166 if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
167 clear_bit(SDATA_STATE_OFFCHANNEL, &sdata->state);
168
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100169 if (!ieee80211_sdata_running(sdata))
170 continue;
171
172 /* Tell AP we're back */
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100173 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
174 sdata->u.mgd.associated)
175 ieee80211_offchannel_ps_disable(sdata);
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100176
Johannes Bergd6a83222012-12-14 14:06:28 +0100177 if (test_and_clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
178 &sdata->state)) {
179 sdata->vif.bss_conf.enable_beacon = true;
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100180 ieee80211_bss_info_change_notify(
181 sdata, BSS_CHANGED_BEACON_ENABLED);
Johannes Bergd6a83222012-12-14 14:06:28 +0100182 }
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100183 }
184 mutex_unlock(&local->iflist_mtx);
Seth Forshee6c17b772013-02-11 11:21:07 -0600185
Johannes Berg445ea4e2013-02-13 12:25:28 +0100186 ieee80211_wake_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300187 IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
188 false);
Jouni Malinenb203ffc2009-12-23 13:15:40 +0100189}
Johannes Berg21f83582010-12-18 17:20:47 +0100190
Johannes Bergaaa016c2015-11-23 23:53:51 +0100191static void ieee80211_roc_notify_destroy(struct ieee80211_roc_work *roc)
Johannes Berg2eb278e2012-06-05 14:28:42 +0200192{
Johannes Bergaaa016c2015-11-23 23:53:51 +0100193 /* was never transmitted */
194 if (roc->frame) {
195 cfg80211_mgmt_tx_status(&roc->sdata->wdev, roc->mgmt_tx_cookie,
196 roc->frame->data, roc->frame->len,
197 false, GFP_KERNEL);
198 ieee80211_free_txskb(&roc->sdata->local->hw, roc->frame);
199 }
200
201 if (!roc->mgmt_tx_cookie)
202 cfg80211_remain_on_channel_expired(&roc->sdata->wdev,
203 roc->cookie, roc->chan,
204 GFP_KERNEL);
205
206 list_del(&roc->list);
207 kfree(roc);
208}
209
210static unsigned long ieee80211_end_finished_rocs(struct ieee80211_local *local,
211 unsigned long now)
212{
213 struct ieee80211_roc_work *roc, *tmp;
214 long remaining_dur_min = LONG_MAX;
215
216 lockdep_assert_held(&local->mtx);
217
218 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
219 long remaining;
220
221 if (!roc->started)
222 break;
223
224 remaining = roc->start_time +
225 msecs_to_jiffies(roc->duration) -
226 now;
227
Ilan Peer1b894522015-12-06 21:19:15 +0200228 /* In case of HW ROC, it is possible that the HW finished the
229 * ROC session before the actual requested time. In such a case
230 * end the ROC session (disregarding the remaining time).
231 */
232 if (roc->abort || roc->hw_begun || remaining <= 0)
Johannes Bergaaa016c2015-11-23 23:53:51 +0100233 ieee80211_roc_notify_destroy(roc);
234 else
235 remaining_dur_min = min(remaining_dur_min, remaining);
236 }
237
238 return remaining_dur_min;
239}
240
241static bool ieee80211_recalc_sw_work(struct ieee80211_local *local,
242 unsigned long now)
243{
244 long dur = ieee80211_end_finished_rocs(local, now);
245
246 if (dur == LONG_MAX)
247 return false;
248
249 mod_delayed_work(local->workqueue, &local->roc_work, dur);
250 return true;
251}
252
253static void ieee80211_handle_roc_started(struct ieee80211_roc_work *roc,
254 unsigned long start_time)
255{
Johannes Bergaaa016c2015-11-23 23:53:51 +0100256 if (WARN_ON(roc->notified))
Johannes Berg2eb278e2012-06-05 14:28:42 +0200257 return;
258
Johannes Bergaaa016c2015-11-23 23:53:51 +0100259 roc->start_time = start_time;
260 roc->started = true;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100261
Johannes Berg2eb278e2012-06-05 14:28:42 +0200262 if (roc->mgmt_tx_cookie) {
263 if (!WARN_ON(!roc->frame)) {
Johannes Berg55de9082012-07-26 17:24:39 +0200264 ieee80211_tx_skb_tid_band(roc->sdata, roc->frame, 7,
265 roc->chan->band);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200266 roc->frame = NULL;
267 }
268 } else {
Johannes Berg50febf62012-10-26 16:13:06 +0200269 cfg80211_ready_on_channel(&roc->sdata->wdev, roc->cookie,
Johannes Berg42d97a52012-11-08 18:31:02 +0100270 roc->chan, roc->req_duration,
271 GFP_KERNEL);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200272 }
273
274 roc->notified = true;
275}
276
Johannes Berg21f83582010-12-18 17:20:47 +0100277static void ieee80211_hw_roc_start(struct work_struct *work)
278{
279 struct ieee80211_local *local =
280 container_of(work, struct ieee80211_local, hw_roc_start);
Johannes Bergaaa016c2015-11-23 23:53:51 +0100281 struct ieee80211_roc_work *roc;
Johannes Berg21f83582010-12-18 17:20:47 +0100282
283 mutex_lock(&local->mtx);
284
Johannes Bergaaa016c2015-11-23 23:53:51 +0100285 list_for_each_entry(roc, &local->roc_list, list) {
286 if (!roc->started)
287 break;
Johannes Berg21f83582010-12-18 17:20:47 +0100288
Johannes Berge6a8a3a2015-12-08 23:46:33 +0100289 roc->hw_begun = true;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100290 ieee80211_handle_roc_started(roc, local->hw_roc_start_time);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200291 }
Johannes Bergaaa016c2015-11-23 23:53:51 +0100292
Johannes Berg21f83582010-12-18 17:20:47 +0100293 mutex_unlock(&local->mtx);
294}
295
296void ieee80211_ready_on_channel(struct ieee80211_hw *hw)
297{
298 struct ieee80211_local *local = hw_to_local(hw);
299
Johannes Berg2eb278e2012-06-05 14:28:42 +0200300 local->hw_roc_start_time = jiffies;
301
Johannes Berg21f83582010-12-18 17:20:47 +0100302 trace_api_ready_on_channel(local);
303
304 ieee80211_queue_work(hw, &local->hw_roc_start);
305}
306EXPORT_SYMBOL_GPL(ieee80211_ready_on_channel);
307
Johannes Bergaaa016c2015-11-23 23:53:51 +0100308static void _ieee80211_start_next_roc(struct ieee80211_local *local)
Johannes Berg2eb278e2012-06-05 14:28:42 +0200309{
Johannes Bergaaa016c2015-11-23 23:53:51 +0100310 struct ieee80211_roc_work *roc, *tmp;
311 enum ieee80211_roc_type type;
312 u32 min_dur, max_dur;
Johannes Berg2eb278e2012-06-05 14:28:42 +0200313
314 lockdep_assert_held(&local->mtx);
315
Johannes Bergaaa016c2015-11-23 23:53:51 +0100316 if (WARN_ON(list_empty(&local->roc_list)))
Johannes Berg2eb278e2012-06-05 14:28:42 +0200317 return;
Johannes Berg2eb278e2012-06-05 14:28:42 +0200318
319 roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work,
320 list);
321
Johannes Bergaaa016c2015-11-23 23:53:51 +0100322 if (WARN_ON(roc->started))
Johannes Berg0f6b3f52012-06-20 20:11:33 +0200323 return;
324
Johannes Bergaaa016c2015-11-23 23:53:51 +0100325 min_dur = roc->duration;
326 max_dur = roc->duration;
327 type = roc->type;
328
329 list_for_each_entry(tmp, &local->roc_list, list) {
330 if (tmp == roc)
331 continue;
332 if (tmp->sdata != roc->sdata || tmp->chan != roc->chan)
333 break;
334 max_dur = max(tmp->duration, max_dur);
335 min_dur = min(tmp->duration, min_dur);
336 type = max(tmp->type, type);
337 }
338
Johannes Berg2eb278e2012-06-05 14:28:42 +0200339 if (local->ops->remain_on_channel) {
Johannes Bergaaa016c2015-11-23 23:53:51 +0100340 int ret = drv_remain_on_channel(local, roc->sdata, roc->chan,
341 max_dur, type);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200342
343 if (ret) {
344 wiphy_warn(local->hw.wiphy,
345 "failed to start next HW ROC (%d)\n", ret);
346 /*
347 * queue the work struct again to avoid recursion
348 * when multiple failures occur
349 */
Johannes Bergaaa016c2015-11-23 23:53:51 +0100350 list_for_each_entry(tmp, &local->roc_list, list) {
351 if (tmp->sdata != roc->sdata ||
352 tmp->chan != roc->chan)
353 break;
354 tmp->started = true;
355 tmp->abort = true;
356 }
357 ieee80211_queue_work(&local->hw, &local->hw_roc_done);
358 return;
359 }
360
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)
364 break;
365 tmp->started = true;
Johannes Berg2eb278e2012-06-05 14:28:42 +0200366 }
367 } else {
Johannes Bergb4b177a2014-05-14 15:34:41 +0200368 /* 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.
372 */
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;
376
377 /* start this ROC */
Johannes Berg2eb278e2012-06-05 14:28:42 +0200378 ieee80211_recalc_idle(local);
379
Johannes Bergb4b177a2014-05-14 15:34:41 +0200380 if (!roc->on_channel) {
381 ieee80211_offchannel_stop_vifs(local);
382
383 local->tmp_channel = roc->chan;
384 ieee80211_hw_config(local, 0);
385 }
Johannes Berg2eb278e2012-06-05 14:28:42 +0200386
Johannes Bergaaa016c2015-11-23 23:53:51 +0100387 ieee80211_queue_delayed_work(&local->hw, &local->roc_work,
388 msecs_to_jiffies(min_dur));
Johannes Berg2eb278e2012-06-05 14:28:42 +0200389
Johannes Bergaaa016c2015-11-23 23:53:51 +0100390 /* 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)
393 break;
Johannes Berg2eb278e2012-06-05 14:28:42 +0200394
Johannes Bergaaa016c2015-11-23 23:53:51 +0100395 tmp->on_channel = roc->on_channel;
396 ieee80211_handle_roc_started(tmp, jiffies);
397 }
398 }
399}
400
401void ieee80211_start_next_roc(struct ieee80211_local *local)
402{
403 struct ieee80211_roc_work *roc;
404
405 lockdep_assert_held(&local->mtx);
406
407 if (list_empty(&local->roc_list)) {
408 ieee80211_run_deferred_scan(local);
409 return;
410 }
411
Eliad Peller470f4d62015-12-14 16:26:57 +0200412 /* defer roc if driver is not started (i.e. during reconfig) */
413 if (local->in_reconfig)
414 return;
415
Johannes Bergaaa016c2015-11-23 23:53:51 +0100416 roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work,
417 list);
418
419 if (WARN_ON_ONCE(roc->started))
420 return;
421
422 if (local->ops->remain_on_channel) {
423 _ieee80211_start_next_roc(local);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200424 } else {
Johannes Bergaaa016c2015-11-23 23:53:51 +0100425 /* delay it a bit */
426 ieee80211_queue_delayed_work(&local->hw, &local->roc_work,
427 round_jiffies_relative(HZ/2));
428 }
429}
Johannes Berg2eb278e2012-06-05 14:28:42 +0200430
Johannes Bergaaa016c2015-11-23 23:53:51 +0100431static void __ieee80211_roc_work(struct ieee80211_local *local)
432{
433 struct ieee80211_roc_work *roc;
434 bool on_channel;
435
436 lockdep_assert_held(&local->mtx);
437
438 if (WARN_ON(local->ops->remain_on_channel))
439 return;
440
441 roc = list_first_entry_or_null(&local->roc_list,
442 struct ieee80211_roc_work, list);
443 if (!roc)
444 return;
445
446 if (!roc->started) {
447 WARN_ON(local->use_chanctx);
448 _ieee80211_start_next_roc(local);
449 } else {
450 on_channel = roc->on_channel;
451 if (ieee80211_recalc_sw_work(local, jiffies))
452 return;
453
454 /* careful - roc pointer became invalid during recalc */
455
456 if (!on_channel) {
Emmanuel Grumbach3b24f4c2015-01-07 15:42:39 +0200457 ieee80211_flush_queues(local, NULL, false);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200458
459 local->tmp_channel = NULL;
460 ieee80211_hw_config(local, 0);
461
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100462 ieee80211_offchannel_return(local);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200463 }
464
465 ieee80211_recalc_idle(local);
Johannes Bergaaa016c2015-11-23 23:53:51 +0100466 ieee80211_start_next_roc(local);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200467 }
Johannes Bergaaa016c2015-11-23 23:53:51 +0100468}
Johannes Berg2eb278e2012-06-05 14:28:42 +0200469
Johannes Bergaaa016c2015-11-23 23:53:51 +0100470static void ieee80211_roc_work(struct work_struct *work)
471{
472 struct ieee80211_local *local =
473 container_of(work, struct ieee80211_local, roc_work.work);
474
475 mutex_lock(&local->mtx);
476 __ieee80211_roc_work(local);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200477 mutex_unlock(&local->mtx);
478}
479
Johannes Berg21f83582010-12-18 17:20:47 +0100480static void ieee80211_hw_roc_done(struct work_struct *work)
481{
482 struct ieee80211_local *local =
483 container_of(work, struct ieee80211_local, hw_roc_done);
484
485 mutex_lock(&local->mtx);
486
Johannes Bergaaa016c2015-11-23 23:53:51 +0100487 ieee80211_end_finished_rocs(local, jiffies);
Johannes Berg71ecfa12012-05-31 15:09:27 +0200488
Johannes Berg2eb278e2012-06-05 14:28:42 +0200489 /* if there's another roc, start it now */
490 ieee80211_start_next_roc(local);
Johannes Berg21f83582010-12-18 17:20:47 +0100491
Johannes Berg21f83582010-12-18 17:20:47 +0100492 mutex_unlock(&local->mtx);
493}
494
495void ieee80211_remain_on_channel_expired(struct ieee80211_hw *hw)
496{
497 struct ieee80211_local *local = hw_to_local(hw);
498
499 trace_api_remain_on_channel_expired(local);
500
501 ieee80211_queue_work(hw, &local->hw_roc_done);
502}
503EXPORT_SYMBOL_GPL(ieee80211_remain_on_channel_expired);
504
Johannes Bergaaa016c2015-11-23 23:53:51 +0100505static bool
506ieee80211_coalesce_hw_started_roc(struct ieee80211_local *local,
507 struct ieee80211_roc_work *new_roc,
508 struct ieee80211_roc_work *cur_roc)
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100509{
510 unsigned long now = jiffies;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100511 unsigned long remaining;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100512
Johannes Bergaaa016c2015-11-23 23:53:51 +0100513 if (WARN_ON(!cur_roc->started))
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100514 return false;
515
Johannes Bergaaa016c2015-11-23 23:53:51 +0100516 /* if it was scheduled in the hardware, but not started yet,
517 * we can only combine if the older one had a longer duration
518 */
519 if (!cur_roc->hw_begun && new_roc->duration > cur_roc->duration)
520 return false;
521
522 remaining = cur_roc->start_time +
523 msecs_to_jiffies(cur_roc->duration) -
524 now;
525
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100526 /* if it doesn't fit entirely, schedule a new one */
527 if (new_roc->duration > jiffies_to_msecs(remaining))
528 return false;
529
Johannes Bergaaa016c2015-11-23 23:53:51 +0100530 /* add just after the current one so we combine their finish later */
531 list_add(&new_roc->list, &cur_roc->list);
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100532
Johannes Bergaaa016c2015-11-23 23:53:51 +0100533 /* 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
536 */
Johannes Berge6a8a3a2015-12-08 23:46:33 +0100537 if (cur_roc->hw_begun) {
538 new_roc->hw_begun = true;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100539 ieee80211_handle_roc_started(new_roc, now);
Johannes Berge6a8a3a2015-12-08 23:46:33 +0100540 }
Johannes Bergaaa016c2015-11-23 23:53:51 +0100541
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100542 return true;
543}
544
545static int ieee80211_start_roc_work(struct ieee80211_local *local,
546 struct ieee80211_sub_if_data *sdata,
547 struct ieee80211_channel *channel,
548 unsigned int duration, u64 *cookie,
549 struct sk_buff *txskb,
550 enum ieee80211_roc_type type)
551{
552 struct ieee80211_roc_work *roc, *tmp;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100553 bool queued = false, combine_started = true;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100554 int ret;
555
556 lockdep_assert_held(&local->mtx);
557
558 if (local->use_chanctx && !local->ops->remain_on_channel)
559 return -EOPNOTSUPP;
560
561 roc = kzalloc(sizeof(*roc), GFP_KERNEL);
562 if (!roc)
563 return -ENOMEM;
564
565 /*
566 * If the duration is zero, then the driver
567 * wouldn't actually do anything. Set it to
568 * 10 for now.
569 *
570 * TODO: cancel the off-channel operation
571 * when we get the SKB's TX status and
572 * the wait time was zero before.
573 */
574 if (!duration)
575 duration = 10;
576
577 roc->chan = channel;
578 roc->duration = duration;
579 roc->req_duration = duration;
580 roc->frame = txskb;
581 roc->type = type;
582 roc->sdata = sdata;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100583
584 /*
585 * cookie is either the roc cookie (for normal roc)
586 * or the SKB (for mgmt TX)
587 */
588 if (!txskb) {
589 roc->cookie = ieee80211_mgmt_tx_cookie(local);
590 *cookie = roc->cookie;
591 } else {
592 roc->mgmt_tx_cookie = *cookie;
593 }
594
Johannes Bergaaa016c2015-11-23 23:53:51 +0100595 /* if there's no need to queue, handle it immediately */
596 if (list_empty(&local->roc_list) &&
597 !local->scanning && !ieee80211_is_radar_required(local)) {
598 /* if not HW assist, just queue & schedule work */
599 if (!local->ops->remain_on_channel) {
600 list_add_tail(&roc->list, &local->roc_list);
601 ieee80211_queue_delayed_work(&local->hw,
602 &local->roc_work, 0);
603 } else {
604 /* otherwise actually kick it off here
605 * (for error handling)
606 */
607 ret = drv_remain_on_channel(local, sdata, channel,
608 duration, type);
609 if (ret) {
610 kfree(roc);
611 return ret;
612 }
613 roc->started = true;
614 list_add_tail(&roc->list, &local->roc_list);
615 }
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100616
Johannes Bergaaa016c2015-11-23 23:53:51 +0100617 return 0;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100618 }
619
Johannes Bergaaa016c2015-11-23 23:53:51 +0100620 /* otherwise handle queueing */
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100621
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100622 list_for_each_entry(tmp, &local->roc_list, list) {
623 if (tmp->chan != channel || tmp->sdata != sdata)
624 continue;
625
626 /*
Johannes Bergaaa016c2015-11-23 23:53:51 +0100627 * Extend this ROC if possible: If it hasn't started, add
628 * just after the new one to combine.
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100629 */
630 if (!tmp->started) {
Johannes Bergaaa016c2015-11-23 23:53:51 +0100631 list_add(&roc->list, &tmp->list);
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100632 queued = true;
633 break;
634 }
635
Johannes Bergaaa016c2015-11-23 23:53:51 +0100636 if (!combine_started)
637 continue;
638
639 if (!local->ops->remain_on_channel) {
640 /* If there's no hardware remain-on-channel, and
641 * doing so won't push us over the maximum r-o-c
642 * we allow, then we can just add the new one to
643 * the list and mark it as having started now.
644 * If it would push over the limit, don't try to
645 * combine with other started ones (that haven't
646 * been running as long) but potentially sort it
647 * with others that had the same fate.
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100648 */
Johannes Bergaaa016c2015-11-23 23:53:51 +0100649 unsigned long now = jiffies;
650 u32 elapsed = jiffies_to_msecs(now - tmp->start_time);
651 struct wiphy *wiphy = local->hw.wiphy;
652 u32 max_roc = wiphy->max_remain_on_channel_duration;
653
654 if (elapsed + roc->duration > max_roc) {
655 combine_started = false;
656 continue;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100657 }
658
Johannes Bergaaa016c2015-11-23 23:53:51 +0100659 list_add(&roc->list, &tmp->list);
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100660 queued = true;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100661 roc->on_channel = tmp->on_channel;
662 ieee80211_handle_roc_started(roc, now);
Johannes Berge9db4552015-12-08 13:16:41 +0100663 ieee80211_recalc_sw_work(local, now);
Johannes Bergaaa016c2015-11-23 23:53:51 +0100664 break;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100665 }
Johannes Bergaaa016c2015-11-23 23:53:51 +0100666
667 queued = ieee80211_coalesce_hw_started_roc(local, roc, tmp);
668 if (queued)
669 break;
670 /* if it wasn't queued, perhaps it can be combined with
671 * another that also couldn't get combined previously,
672 * but no need to check for already started ones, since
673 * that can't work.
674 */
675 combine_started = false;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100676 }
677
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100678 if (!queued)
679 list_add_tail(&roc->list, &local->roc_list);
680
681 return 0;
682}
683
684int ieee80211_remain_on_channel(struct wiphy *wiphy, struct wireless_dev *wdev,
685 struct ieee80211_channel *chan,
686 unsigned int duration, u64 *cookie)
687{
688 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
689 struct ieee80211_local *local = sdata->local;
690 int ret;
691
692 mutex_lock(&local->mtx);
693 ret = ieee80211_start_roc_work(local, sdata, chan,
694 duration, cookie, NULL,
695 IEEE80211_ROC_TYPE_NORMAL);
696 mutex_unlock(&local->mtx);
697
698 return ret;
699}
700
701static int ieee80211_cancel_roc(struct ieee80211_local *local,
702 u64 cookie, bool mgmt_tx)
703{
704 struct ieee80211_roc_work *roc, *tmp, *found = NULL;
705 int ret;
706
Johannes Berg7d37fcd2015-12-01 23:15:26 +0100707 if (!cookie)
708 return -ENOENT;
709
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100710 mutex_lock(&local->mtx);
711 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100712 if (!mgmt_tx && roc->cookie != cookie)
713 continue;
714 else if (mgmt_tx && roc->mgmt_tx_cookie != cookie)
715 continue;
716
717 found = roc;
718 break;
719 }
720
721 if (!found) {
722 mutex_unlock(&local->mtx);
723 return -ENOENT;
724 }
725
Johannes Bergaaa016c2015-11-23 23:53:51 +0100726 if (!found->started) {
727 ieee80211_roc_notify_destroy(found);
728 goto out_unlock;
729 }
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100730
731 if (local->ops->remain_on_channel) {
Johannes Bergaaa016c2015-11-23 23:53:51 +0100732 ret = drv_cancel_remain_on_channel(local);
733 if (WARN_ON_ONCE(ret)) {
734 mutex_unlock(&local->mtx);
735 return ret;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100736 }
737
Johannes Bergaaa016c2015-11-23 23:53:51 +0100738 /* TODO:
739 * if multiple items were combined here then we really shouldn't
740 * cancel them all - we should wait for as much time as needed
741 * for the longest remaining one, and only then cancel ...
742 */
743 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
744 if (!roc->started)
745 break;
746 if (roc == found)
747 found = NULL;
748 ieee80211_roc_notify_destroy(roc);
749 }
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100750
Johannes Bergaaa016c2015-11-23 23:53:51 +0100751 /* that really must not happen - it was started */
752 WARN_ON(found);
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100753
Johannes Bergaaa016c2015-11-23 23:53:51 +0100754 ieee80211_start_next_roc(local);
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100755 } else {
Johannes Bergaaa016c2015-11-23 23:53:51 +0100756 /* go through work struct to return to the operating channel */
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100757 found->abort = true;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100758 mod_delayed_work(local->workqueue, &local->roc_work, 0);
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100759 }
760
Johannes Bergaaa016c2015-11-23 23:53:51 +0100761 out_unlock:
762 mutex_unlock(&local->mtx);
763
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100764 return 0;
765}
766
767int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
768 struct wireless_dev *wdev, u64 cookie)
769{
770 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
771 struct ieee80211_local *local = sdata->local;
772
773 return ieee80211_cancel_roc(local, cookie, false);
774}
775
776int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
777 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
778{
779 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
780 struct ieee80211_local *local = sdata->local;
Johannes Berg5ee00db2015-11-24 14:25:49 +0100781 struct sk_buff *skb;
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100782 struct sta_info *sta;
783 const struct ieee80211_mgmt *mgmt = (void *)params->buf;
784 bool need_offchan = false;
785 u32 flags;
786 int ret;
787 u8 *data;
788
789 if (params->dont_wait_for_ack)
790 flags = IEEE80211_TX_CTL_NO_ACK;
791 else
792 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
793 IEEE80211_TX_CTL_REQ_TX_STATUS;
794
795 if (params->no_cck)
796 flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
797
798 switch (sdata->vif.type) {
799 case NL80211_IFTYPE_ADHOC:
800 if (!sdata->vif.bss_conf.ibss_joined)
801 need_offchan = true;
802 /* fall through */
803#ifdef CONFIG_MAC80211_MESH
804 case NL80211_IFTYPE_MESH_POINT:
805 if (ieee80211_vif_is_mesh(&sdata->vif) &&
806 !sdata->u.mesh.mesh_id_len)
807 need_offchan = true;
808 /* fall through */
809#endif
810 case NL80211_IFTYPE_AP:
811 case NL80211_IFTYPE_AP_VLAN:
812 case NL80211_IFTYPE_P2P_GO:
813 if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
814 !ieee80211_vif_is_mesh(&sdata->vif) &&
815 !rcu_access_pointer(sdata->bss->beacon))
816 need_offchan = true;
817 if (!ieee80211_is_action(mgmt->frame_control) ||
818 mgmt->u.action.category == WLAN_CATEGORY_PUBLIC ||
819 mgmt->u.action.category == WLAN_CATEGORY_SELF_PROTECTED ||
820 mgmt->u.action.category == WLAN_CATEGORY_SPECTRUM_MGMT)
821 break;
822 rcu_read_lock();
Michael Braun1d4de2e2016-10-03 13:14:15 +0200823 sta = sta_info_get_bss(sdata, mgmt->da);
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100824 rcu_read_unlock();
825 if (!sta)
826 return -ENOLINK;
827 break;
828 case NL80211_IFTYPE_STATION:
829 case NL80211_IFTYPE_P2P_CLIENT:
830 sdata_lock(sdata);
831 if (!sdata->u.mgd.associated ||
832 (params->offchan && params->wait &&
833 local->ops->remain_on_channel &&
834 memcmp(sdata->u.mgd.associated->bssid,
835 mgmt->bssid, ETH_ALEN)))
836 need_offchan = true;
837 sdata_unlock(sdata);
838 break;
839 case NL80211_IFTYPE_P2P_DEVICE:
840 need_offchan = true;
841 break;
Ayala Bekercb3b7d82016-09-20 17:31:13 +0300842 case NL80211_IFTYPE_NAN:
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100843 default:
844 return -EOPNOTSUPP;
845 }
846
847 /* configurations requiring offchan cannot work if no channel has been
848 * specified
849 */
850 if (need_offchan && !params->chan)
851 return -EINVAL;
852
853 mutex_lock(&local->mtx);
854
855 /* Check if the operating channel is the requested channel */
856 if (!need_offchan) {
857 struct ieee80211_chanctx_conf *chanctx_conf;
858
859 rcu_read_lock();
860 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
861
862 if (chanctx_conf) {
863 need_offchan = params->chan &&
864 (params->chan !=
865 chanctx_conf->def.chan);
866 } else if (!params->chan) {
867 ret = -EINVAL;
868 rcu_read_unlock();
869 goto out_unlock;
870 } else {
871 need_offchan = true;
872 }
873 rcu_read_unlock();
874 }
875
876 if (need_offchan && !params->offchan) {
877 ret = -EBUSY;
878 goto out_unlock;
879 }
880
881 skb = dev_alloc_skb(local->hw.extra_tx_headroom + params->len);
882 if (!skb) {
883 ret = -ENOMEM;
884 goto out_unlock;
885 }
886 skb_reserve(skb, local->hw.extra_tx_headroom);
887
888 data = skb_put(skb, params->len);
889 memcpy(data, params->buf, params->len);
890
891 /* Update CSA counters */
892 if (sdata->vif.csa_active &&
893 (sdata->vif.type == NL80211_IFTYPE_AP ||
894 sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
895 sdata->vif.type == NL80211_IFTYPE_ADHOC) &&
896 params->n_csa_offsets) {
897 int i;
898 struct beacon_data *beacon = NULL;
899
900 rcu_read_lock();
901
902 if (sdata->vif.type == NL80211_IFTYPE_AP)
903 beacon = rcu_dereference(sdata->u.ap.beacon);
904 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
905 beacon = rcu_dereference(sdata->u.ibss.presp);
906 else if (ieee80211_vif_is_mesh(&sdata->vif))
907 beacon = rcu_dereference(sdata->u.mesh.beacon);
908
909 if (beacon)
910 for (i = 0; i < params->n_csa_offsets; i++)
911 data[params->csa_offsets[i]] =
912 beacon->csa_current_counter;
913
914 rcu_read_unlock();
915 }
916
917 IEEE80211_SKB_CB(skb)->flags = flags;
918
919 skb->dev = sdata->dev;
920
921 if (!params->dont_wait_for_ack) {
922 /* make a copy to preserve the frame contents
923 * in case of encryption.
924 */
Johannes Berg5ee00db2015-11-24 14:25:49 +0100925 ret = ieee80211_attach_ack_skb(local, skb, cookie, GFP_KERNEL);
926 if (ret) {
Johannes Berga2fcfccb2015-11-23 17:18:35 +0100927 kfree_skb(skb);
928 goto out_unlock;
929 }
930 } else {
931 /* Assign a dummy non-zero cookie, it's not sent to
932 * userspace in this case but we rely on its value
933 * internally in the need_offchan case to distinguish
934 * mgmt-tx from remain-on-channel.
935 */
936 *cookie = 0xffffffff;
937 }
938
939 if (!need_offchan) {
940 ieee80211_tx_skb(sdata, skb);
941 ret = 0;
942 goto out_unlock;
943 }
944
945 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN |
946 IEEE80211_TX_INTFL_OFFCHAN_TX_OK;
947 if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
948 IEEE80211_SKB_CB(skb)->hw_queue =
949 local->hw.offchannel_tx_hw_queue;
950
951 /* This will handle all kinds of coalescing and immediate TX */
952 ret = ieee80211_start_roc_work(local, sdata, params->chan,
953 params->wait, cookie, skb,
954 IEEE80211_ROC_TYPE_MGMT_TX);
955 if (ret)
956 ieee80211_free_txskb(&local->hw, skb);
957 out_unlock:
958 mutex_unlock(&local->mtx);
959 return ret;
960}
961
962int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
963 struct wireless_dev *wdev, u64 cookie)
964{
965 struct ieee80211_local *local = wiphy_priv(wiphy);
966
967 return ieee80211_cancel_roc(local, cookie, true);
968}
969
Johannes Berg2eb278e2012-06-05 14:28:42 +0200970void ieee80211_roc_setup(struct ieee80211_local *local)
Johannes Berg21f83582010-12-18 17:20:47 +0100971{
972 INIT_WORK(&local->hw_roc_start, ieee80211_hw_roc_start);
973 INIT_WORK(&local->hw_roc_done, ieee80211_hw_roc_done);
Johannes Bergaaa016c2015-11-23 23:53:51 +0100974 INIT_DELAYED_WORK(&local->roc_work, ieee80211_roc_work);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200975 INIT_LIST_HEAD(&local->roc_list);
976}
977
Johannes Bergc8f994e2013-03-27 22:49:19 +0100978void ieee80211_roc_purge(struct ieee80211_local *local,
979 struct ieee80211_sub_if_data *sdata)
Johannes Berg2eb278e2012-06-05 14:28:42 +0200980{
Johannes Berg2eb278e2012-06-05 14:28:42 +0200981 struct ieee80211_roc_work *roc, *tmp;
Johannes Bergaaa016c2015-11-23 23:53:51 +0100982 bool work_to_do = false;
Johannes Berg2eb278e2012-06-05 14:28:42 +0200983
984 mutex_lock(&local->mtx);
985 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
Johannes Bergc8f994e2013-03-27 22:49:19 +0100986 if (sdata && roc->sdata != sdata)
Johannes Berg2eb278e2012-06-05 14:28:42 +0200987 continue;
988
Johannes Bergaaa016c2015-11-23 23:53:51 +0100989 if (roc->started) {
990 if (local->ops->remain_on_channel) {
991 /* can race, so ignore return value */
992 drv_cancel_remain_on_channel(local);
993 ieee80211_roc_notify_destroy(roc);
994 } else {
995 roc->abort = true;
996 work_to_do = true;
997 }
Johannes Berg2eb278e2012-06-05 14:28:42 +0200998 } else {
Johannes Bergaaa016c2015-11-23 23:53:51 +0100999 ieee80211_roc_notify_destroy(roc);
Johannes Berg2eb278e2012-06-05 14:28:42 +02001000 }
1001 }
Johannes Bergaaa016c2015-11-23 23:53:51 +01001002 if (work_to_do)
1003 __ieee80211_roc_work(local);
1004 mutex_unlock(&local->mtx);
Johannes Berg21f83582010-12-18 17:20:47 +01001005}