projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mac80211: add radar detection command/event
[linux-2.6-block.git] / net / mac80211 / iface.c
CommitLineData
f0706e82 1/*
0d143fe1
JB		 2 * Interface handling (except master interface)
3 *
f0706e82
JB		 4 * Copyright 2002-2005, Instant802 Networks, Inc.
5 * Copyright 2005-2006, Devicescape Software, Inc.
6 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
75636525 7 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
f0706e82
JB		 8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
5a0e3ad6 13#include <linux/slab.h>
f0706e82
JB		 14#include <linux/kernel.h>
15#include <linux/if_arp.h>
16#include <linux/netdevice.h>
17#include <linux/rtnetlink.h>
18#include <net/mac80211.h>
cf0277e7 19#include <net/ieee80211_radiotap.h>
f0706e82
JB		 20#include "ieee80211_i.h"
21#include "sta_info.h"
e9f207f0 22#include "debugfs_netdev.h"
ee385855 23#include "mesh.h"
0d143fe1 24#include "led.h"
24487981 25#include "driver-ops.h"
cf0277e7 26#include "wme.h"
1be7fe8d 27#include "rate.h"
0d143fe1 28
c771c9d8
JB		 29/**
30 * DOC: Interface list locking
31 *
32 * The interface list in each struct ieee80211_local is protected
33 * three-fold:
34 *
35 * (1) modifications may only be done under the RTNL
36 * (2) modifications and readers are protected against each other by
37 * the iflist_mtx.
38 * (3) modifications are done in an RCU manner so atomic readers
39 * can traverse the list in RCU-safe blocks.
40 *
41 * As a consequence, reads (traversals) of the list can be protected
42 * by either the RTNL, the iflist_mtx or RCU.
43 */
44
1ea6f9c0
JB		 45bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
46{
47 struct ieee80211_chanctx_conf *chanctx_conf;
48 int power;
49
50 rcu_read_lock();
51 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
52 if (!chanctx_conf) {
53 rcu_read_unlock();
54 return false;
55 }
56
4bf88530 57 power = chanctx_conf->def.chan->max_power;
1ea6f9c0
JB		 58 rcu_read_unlock();
59
60 if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)
61 power = min(power, sdata->user_power_level);
62
63 if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
64 power = min(power, sdata->ap_power_level);
65
66 if (power != sdata->vif.bss_conf.txpower) {
67 sdata->vif.bss_conf.txpower = power;
68 ieee80211_hw_config(sdata->local, 0);
69 return true;
70 }
71
72 return false;
73}
74
75void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
76{
77 if (__ieee80211_recalc_txpower(sdata))
78 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
79}
c771c9d8 80
fd0f979a 81static u32 ieee80211_idle_off(struct ieee80211_local *local)
cc45ae54
JB		 82{
83 if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
84 return 0;
85
86 local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
87 return IEEE80211_CONF_CHANGE_IDLE;
88}
89
90static u32 ieee80211_idle_on(struct ieee80211_local *local)
91{
92 if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
93 return 0;
94
95 drv_flush(local, false);
96
97 local->hw.conf.flags |= IEEE80211_CONF_IDLE;
98 return IEEE80211_CONF_CHANGE_IDLE;
99}
100
fd0f979a 101void ieee80211_recalc_idle(struct ieee80211_local *local)
cc45ae54 102{
fd0f979a 103 bool working = false, scanning, active;
cc45ae54
JB		 104 unsigned int led_trig_start = 0, led_trig_stop = 0;
105 struct ieee80211_roc_work *roc;
fd0f979a 106 u32 change;
cc45ae54 107
cc45ae54
JB		 108 lockdep_assert_held(&local->mtx);
109
fd0f979a 110 active = !list_empty(&local->chanctx_list);
cc45ae54
JB		 111
112 if (!local->ops->remain_on_channel) {
113 list_for_each_entry(roc, &local->roc_list, list) {
114 working = true;
fd0f979a 115 break;
cc45ae54
JB		 116 }
117 }
118
f1e3e051
JB		 119 scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
120 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
cc45ae54 121
cc45ae54
JB		 122 if (working || scanning)
123 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
124 else
125 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
126
fd0f979a 127 if (active)
cc45ae54
JB		 128 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
129 else
130 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
131
132 ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
133
fd0f979a
JB		 134 if (working || scanning || active)
135 change = ieee80211_idle_off(local);
cc45ae54 136 else
fd0f979a
JB		 137 change = ieee80211_idle_on(local);
138 if (change)
139 ieee80211_hw_config(local, change);
cc45ae54
JB		 140}
141
0d143fe1
JB		 142static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
143{
09b1426e 144 if (new_mtu < 256 || new_mtu > IEEE80211_MAX_DATA_LEN)
0d143fe1 145 return -EINVAL;
0d143fe1 146
0d143fe1
JB		 147 dev->mtu = new_mtu;
148 return 0;
149}
150
478622e8
HS		 151static int ieee80211_verify_mac(struct ieee80211_local *local, u8 *addr)
152{
153 struct ieee80211_sub_if_data *sdata;
154 u64 new, mask, tmp;
155 u8 *m;
156 int ret = 0;
157
158 if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
159 return 0;
160
161 m = addr;
162 new = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
163 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
164 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
165
166 m = local->hw.wiphy->addr_mask;
167 mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
168 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
169 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
170
171
172 mutex_lock(&local->iflist_mtx);
173 list_for_each_entry(sdata, &local->interfaces, list) {
174 if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
175 continue;
176
177 m = sdata->vif.addr;
178 tmp = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
179 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
180 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
181
182 if ((new & ~mask) != (tmp & ~mask)) {
183 ret = -EINVAL;
184 break;
185 }
186 }
187 mutex_unlock(&local->iflist_mtx);
188
189 return ret;
190}
191
47846c9b
JB		 192static int ieee80211_change_mac(struct net_device *dev, void *addr)
193{
194 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
fc5f7577 195 struct sockaddr *sa = addr;
47846c9b
JB		 196 int ret;
197
9607e6b6 198 if (ieee80211_sdata_running(sdata))
47846c9b
JB		 199 return -EBUSY;
200
478622e8
HS		 201 ret = ieee80211_verify_mac(sdata->local, sa->sa_data);
202 if (ret)
203 return ret;
204
fc5f7577 205 ret = eth_mac_addr(dev, sa);
47846c9b
JB		 206
207 if (ret == 0)
fc5f7577 208 memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
47846c9b
JB		 209
210 return ret;
211}
212
0d143fe1
JB		 213static inline int identical_mac_addr_allowed(int type1, int type2)
214{
215 return type1 == NL80211_IFTYPE_MONITOR ||
216 type2 == NL80211_IFTYPE_MONITOR ||
f142c6b9
JB		 217 type1 == NL80211_IFTYPE_P2P_DEVICE ||
218 type2 == NL80211_IFTYPE_P2P_DEVICE ||
0d143fe1
JB		 219 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
220 (type1 == NL80211_IFTYPE_WDS &&
221 (type2 == NL80211_IFTYPE_WDS ||
222 type2 == NL80211_IFTYPE_AP)) ||
223 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
224 (type1 == NL80211_IFTYPE_AP_VLAN &&
225 (type2 == NL80211_IFTYPE_AP ||
226 type2 == NL80211_IFTYPE_AP_VLAN));
227}
228
87490f6d
JB		 229static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
230 enum nl80211_iftype iftype)
0d143fe1 231{
b4a4bf5d 232 struct ieee80211_local *local = sdata->local;
87490f6d 233 struct ieee80211_sub_if_data *nsdata;
0d143fe1 234
87490f6d 235 ASSERT_RTNL();
0d143fe1
JB		 236
237 /* we hold the RTNL here so can safely walk the list */
238 list_for_each_entry(nsdata, &local->interfaces, list) {
371a255e 239 if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
0d143fe1
JB		 240 /*
241 * Allow only a single IBSS interface to be up at any
242 * time. This is restricted because beacon distribution
243 * cannot work properly if both are in the same IBSS.
244 *
245 * To remove this restriction we'd have to disallow them
246 * from setting the same SSID on different IBSS interfaces
247 * belonging to the same hardware. Then, however, we're
248 * faced with having to adopt two different TSF timers...
249 */
87490f6d 250 if (iftype == NL80211_IFTYPE_ADHOC &&
0d143fe1
JB		 251 nsdata->vif.type == NL80211_IFTYPE_ADHOC)
252 return -EBUSY;
253
254 /*
255 * The remaining checks are only performed for interfaces
256 * with the same MAC address.
257 */
371a255e
JB		 258 if (!ether_addr_equal(sdata->vif.addr,
259 nsdata->vif.addr))
0d143fe1
JB		 260 continue;
261
262 /*
263 * check whether it may have the same address
264 */
87490f6d 265 if (!identical_mac_addr_allowed(iftype,
0d143fe1
JB		 266 nsdata->vif.type))
267 return -ENOTUNIQ;
268
269 /*
270 * can only add VLANs to enabled APs
271 */
87490f6d 272 if (iftype == NL80211_IFTYPE_AP_VLAN &&
0d143fe1
JB		 273 nsdata->vif.type == NL80211_IFTYPE_AP)
274 sdata->bss = &nsdata->u.ap;
275 }
276 }
277
87490f6d
JB		 278 return 0;
279}
280
3a25a8c8
JB		 281static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata)
282{
283 int n_queues = sdata->local->hw.queues;
284 int i;
285
0ef24e52
IP		 286 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
287 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
288 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==
289 IEEE80211_INVAL_HW_QUEUE))
290 return -EINVAL;
291 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=
292 n_queues))
293 return -EINVAL;
294 }
3a25a8c8
JB		 295 }
296
bb3e10fb
LC		 297 if ((sdata->vif.type != NL80211_IFTYPE_AP) ||
298 !(sdata->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) {
3a25a8c8
JB		 299 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
300 return 0;
301 }
302
303 if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))
304 return -EINVAL;
305
306 if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))
307 return -EINVAL;
308
309 return 0;
310}
311
85416a4f
CL		 312void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
313 const int offset)
314{
315 struct ieee80211_local *local = sdata->local;
316 u32 flags = sdata->u.mntr_flags;
317
318#define ADJUST(_f, _s) do { \
319 if (flags & MONITOR_FLAG_##_f) \
320 local->fif_##_s += offset; \
321 } while (0)
322
323 ADJUST(FCSFAIL, fcsfail);
324 ADJUST(PLCPFAIL, plcpfail);
325 ADJUST(CONTROL, control);
326 ADJUST(CONTROL, pspoll);
327 ADJUST(OTHER_BSS, other_bss);
328
329#undef ADJUST
330}
331
3a25a8c8
JB		 332static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)
333{
334 struct ieee80211_local *local = sdata->local;
335 int i;
336
337 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
338 if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
339 sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
a9d3c05c 340 else if (local->hw.queues >= IEEE80211_NUM_ACS)
3a25a8c8 341 sdata->vif.hw_queue[i] = i;
a9d3c05c
JB		 342 else
343 sdata->vif.hw_queue[i] = 0;
3a25a8c8
JB		 344 }
345 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
346}
347
075e0847 348static int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
4b6f1dd6
JB		 349{
350 struct ieee80211_sub_if_data *sdata;
685fb72b 351 int ret = 0;
4b6f1dd6
JB		 352
353 if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
354 return 0;
355
685fb72b
JB		 356 mutex_lock(&local->iflist_mtx);
357
4b6f1dd6 358 if (local->monitor_sdata)
685fb72b 359 goto out_unlock;
4b6f1dd6
JB		 360
361 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
685fb72b
JB		 362 if (!sdata) {
363 ret = -ENOMEM;
364 goto out_unlock;
365 }
4b6f1dd6
JB		 366
367 /* set up data */
368 sdata->local = local;
369 sdata->vif.type = NL80211_IFTYPE_MONITOR;
370 snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
371 wiphy_name(local->hw.wiphy));
372
3a25a8c8
JB		 373 ieee80211_set_default_queues(sdata);
374
4b6f1dd6
JB		 375 ret = drv_add_interface(local, sdata);
376 if (WARN_ON(ret)) {
377 /* ok .. stupid driver, it asked for this! */
378 kfree(sdata);
685fb72b 379 goto out_unlock;
4b6f1dd6
JB		 380 }
381
3a25a8c8
JB		 382 ret = ieee80211_check_queues(sdata);
383 if (ret) {
384 kfree(sdata);
685fb72b 385 goto out_unlock;
3a25a8c8
JB		 386 }
387
4bf88530 388 ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,
55de908a
JB		 389 IEEE80211_CHANCTX_EXCLUSIVE);
390 if (ret) {
391 drv_remove_interface(local, sdata);
392 kfree(sdata);
393 goto out_unlock;
394 }
395
4b6f1dd6 396 rcu_assign_pointer(local->monitor_sdata, sdata);
685fb72b
JB		 397 out_unlock:
398 mutex_unlock(&local->iflist_mtx);
399 return ret;
4b6f1dd6
JB		 400}
401
075e0847 402static void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
4b6f1dd6
JB		 403{
404 struct ieee80211_sub_if_data *sdata;
405
406 if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
407 return;
408
685fb72b 409 mutex_lock(&local->iflist_mtx);
4b6f1dd6 410
685fb72b
JB		 411 sdata = rcu_dereference_protected(local->monitor_sdata,
412 lockdep_is_held(&local->iflist_mtx));
4b6f1dd6 413 if (!sdata)
685fb72b 414 goto out_unlock;
4b6f1dd6
JB		 415
416 rcu_assign_pointer(local->monitor_sdata, NULL);
417 synchronize_net();
418
55de908a
JB		 419 ieee80211_vif_release_channel(sdata);
420
4b6f1dd6
JB		 421 drv_remove_interface(local, sdata);
422
423 kfree(sdata);
685fb72b
JB		 424 out_unlock:
425 mutex_unlock(&local->iflist_mtx);
4b6f1dd6
JB		 426}
427
34d4bc4d
JB		 428/*
429 * NOTE: Be very careful when changing this function, it must NOT return
430 * an error on interface type changes that have been pre-checked, so most
431 * checks should be in ieee80211_check_concurrent_iface.
432 */
f142c6b9 433int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
87490f6d 434{
f142c6b9
JB		 435 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
436 struct net_device *dev = wdev->netdev;
87490f6d
JB		 437 struct ieee80211_local *local = sdata->local;
438 struct sta_info *sta;
439 u32 changed = 0;
440 int res;
441 u32 hw_reconf_flags = 0;
442
0d143fe1
JB		 443 switch (sdata->vif.type) {
444 case NL80211_IFTYPE_WDS:
445 if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
446 return -ENOLINK;
447 break;
665c93a9
JB		 448 case NL80211_IFTYPE_AP_VLAN: {
449 struct ieee80211_sub_if_data *master;
450
0d143fe1
JB		 451 if (!sdata->bss)
452 return -ENOLINK;
665c93a9 453
0d143fe1 454 list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
665c93a9
JB		 455
456 master = container_of(sdata->bss,
457 struct ieee80211_sub_if_data, u.ap);
458 sdata->control_port_protocol =
459 master->control_port_protocol;
460 sdata->control_port_no_encrypt =
461 master->control_port_no_encrypt;
0d143fe1 462 break;
665c93a9 463 }
0d143fe1
JB		 464 case NL80211_IFTYPE_AP:
465 sdata->bss = &sdata->u.ap;
466 break;
467 case NL80211_IFTYPE_MESH_POINT:
0d143fe1
JB		 468 case NL80211_IFTYPE_STATION:
469 case NL80211_IFTYPE_MONITOR:
470 case NL80211_IFTYPE_ADHOC:
f142c6b9 471 case NL80211_IFTYPE_P2P_DEVICE:
0d143fe1
JB		 472 /* no special treatment */
473 break;
474 case NL80211_IFTYPE_UNSPECIFIED:
2e161f78 475 case NUM_NL80211_IFTYPES:
2ca27bcf
JB		 476 case NL80211_IFTYPE_P2P_CLIENT:
477 case NL80211_IFTYPE_P2P_GO:
0d143fe1
JB		 478 /* cannot happen */
479 WARN_ON(1);
480 break;
481 }
482
483 if (local->open_count == 0) {
24487981 484 res = drv_start(local);
0d143fe1
JB		 485 if (res)
486 goto err_del_bss;
4e6cbfd0
JL		 487 if (local->ops->napi_poll)
488 napi_enable(&local->napi);
e8975581
JB		 489 /* we're brought up, everything changes */
490 hw_reconf_flags = ~0;
1f87f7d3 491 ieee80211_led_radio(local, true);
67408c8c
JB		 492 ieee80211_mod_tpt_led_trig(local,
493 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
0d143fe1
JB		 494 }
495
496 /*
bf533e0b
JB		 497 * Copy the hopefully now-present MAC address to
498 * this interface, if it has the special null one.
0d143fe1 499 */
f142c6b9 500 if (dev && is_zero_ether_addr(dev->dev_addr)) {
bf533e0b
JB		 501 memcpy(dev->dev_addr,
502 local->hw.wiphy->perm_addr,
503 ETH_ALEN);
504 memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
505
506 if (!is_valid_ether_addr(dev->dev_addr)) {
4d6c36fa
JB		 507 res = -EADDRNOTAVAIL;
508 goto err_stop;
0adc23f5 509 }
0d143fe1
JB		 510 }
511
0d143fe1
JB		 512 switch (sdata->vif.type) {
513 case NL80211_IFTYPE_AP_VLAN:
4d76d21b
JB		 514 /* no need to tell driver, but set carrier and chanctx */
515 if (rtnl_dereference(sdata->bss->beacon)) {
516 ieee80211_vif_vlan_copy_chanctx(sdata);
3edaf3e6 517 netif_carrier_on(dev);
4d76d21b 518 } else {
3edaf3e6 519 netif_carrier_off(dev);
4d76d21b 520 }
0d143fe1
JB		 521 break;
522 case NL80211_IFTYPE_MONITOR:
523 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
524 local->cooked_mntrs++;
525 break;
526 }
527
075e0847
JB		 528 if (local->monitors == 0 && local->open_count == 0) {
529 res = ieee80211_add_virtual_monitor(local);
530 if (res)
531 goto err_stop;
532 }
533
0d143fe1
JB		 534 /* must be before the call to ieee80211_configure_filter */
535 local->monitors++;
e8975581 536 if (local->monitors == 1) {
0869aea0
JB		 537 local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
538 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
e8975581 539 }
0d143fe1 540
85416a4f 541 ieee80211_adjust_monitor_flags(sdata, 1);
0d143fe1 542 ieee80211_configure_filter(local);
53e9b1de
DG		 543
544 netif_carrier_on(dev);
0d143fe1 545 break;
0d143fe1 546 default:
34d4bc4d 547 if (coming_up) {
075e0847
JB		 548 ieee80211_del_virtual_monitor(local);
549
7b7eab6f 550 res = drv_add_interface(local, sdata);
34d4bc4d
JB		 551 if (res)
552 goto err_stop;
3a25a8c8
JB		 553 res = ieee80211_check_queues(sdata);
554 if (res)
555 goto err_del_interface;
34d4bc4d 556 }
0d143fe1 557
b207cdb0
AB		 558 drv_add_interface_debugfs(local, sdata);
559
29cbe68c 560 if (sdata->vif.type == NL80211_IFTYPE_AP) {
e3b90ca2 561 local->fif_pspoll++;
7be5086d 562 local->fif_probe_req++;
e3b90ca2 563
e3b90ca2 564 ieee80211_configure_filter(local);
7be5086d
JB		 565 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
566 local->fif_probe_req++;
a3c9aa51 567 }
e3b90ca2 568
f142c6b9
JB		 569 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
570 changed |= ieee80211_reset_erp_info(sdata);
0d143fe1 571 ieee80211_bss_info_change_notify(sdata, changed);
0d143fe1 572
c405c629
JB		 573 switch (sdata->vif.type) {
574 case NL80211_IFTYPE_STATION:
575 case NL80211_IFTYPE_ADHOC:
576 case NL80211_IFTYPE_AP:
577 case NL80211_IFTYPE_MESH_POINT:
0d143fe1 578 netif_carrier_off(dev);
c405c629 579 break;
1411af15 580 case NL80211_IFTYPE_WDS:
f142c6b9 581 case NL80211_IFTYPE_P2P_DEVICE:
1411af15 582 break;
c405c629 583 default:
0d143fe1 584 netif_carrier_on(dev);
c405c629 585 }
59034591
EP		 586
587 /*
588 * set default queue parameters so drivers don't
589 * need to initialise the hardware if the hardware
590 * doesn't start up with sane defaults
591 */
3abead59 592 ieee80211_set_wmm_default(sdata, true);
0d143fe1
JB		 593 }
594
2d2080c3
JB		 595 set_bit(SDATA_STATE_RUNNING, &sdata->state);
596
0d143fe1
JB		 597 if (sdata->vif.type == NL80211_IFTYPE_WDS) {
598 /* Create STA entry for the WDS peer */
599 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
600 GFP_KERNEL);
601 if (!sta) {
602 res = -ENOMEM;
603 goto err_del_interface;
604 }
605
83d5cc01
JB		 606 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
607 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
608 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
0d143fe1
JB		 609
610 res = sta_info_insert(sta);
611 if (res) {
612 /* STA has been freed */
613 goto err_del_interface;
614 }
1be7fe8d
BJ		 615
616 rate_control_rate_init(sta);
1411af15 617 netif_carrier_on(dev);
f142c6b9
JB		 618 } else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
619 rcu_assign_pointer(local->p2p_sdata, sdata);
0d143fe1
JB		 620 }
621
0d143fe1
JB		 622 /*
623 * set_multicast_list will be invoked by the networking core
624 * which will check whether any increments here were done in
625 * error and sync them down to the hardware as filter flags.
626 */
627 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
628 atomic_inc(&local->iff_allmultis);
629
630 if (sdata->flags & IEEE80211_SDATA_PROMISC)
631 atomic_inc(&local->iff_promiscs);
632
34d4bc4d
JB		 633 if (coming_up)
634 local->open_count++;
635
59034591 636 if (hw_reconf_flags)
e8975581 637 ieee80211_hw_config(local, hw_reconf_flags);
0d143fe1 638
10f644a4 639 ieee80211_recalc_ps(local, -1);
965bedad 640
f142c6b9
JB		 641 if (dev)
642 netif_tx_start_all_queues(dev);
0d143fe1
JB		 643
644 return 0;
645 err_del_interface:
7b7eab6f 646 drv_remove_interface(local, sdata);
0d143fe1 647 err_stop:
24487981
JB		 648 if (!local->open_count)
649 drv_stop(local);
0d143fe1
JB		 650 err_del_bss:
651 sdata->bss = NULL;
652 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
653 list_del(&sdata->u.vlan.list);
4d6c36fa 654 /* might already be clear but that doesn't matter */
2d2080c3 655 clear_bit(SDATA_STATE_RUNNING, &sdata->state);
0d143fe1
JB		 656 return res;
657}
658
34d4bc4d 659static int ieee80211_open(struct net_device *dev)
0d143fe1
JB		 660{
661 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
34d4bc4d
JB		 662 int err;
663
664 /* fail early if user set an invalid address */
2fcf2824 665 if (!is_valid_ether_addr(dev->dev_addr))
34d4bc4d
JB		 666 return -EADDRNOTAVAIL;
667
668 err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
669 if (err)
670 return err;
671
f142c6b9 672 return ieee80211_do_open(&sdata->wdev, true);
34d4bc4d
JB		 673}
674
675static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
676 bool going_down)
677{
0d143fe1 678 struct ieee80211_local *local = sdata->local;
5061b0c2
JB		 679 unsigned long flags;
680 struct sk_buff *skb, *tmp;
e8975581 681 u32 hw_reconf_flags = 0;
09f4114e 682 int i, flushed;
0d143fe1 683
c29acf20
RM		 684 clear_bit(SDATA_STATE_RUNNING, &sdata->state);
685
e2fd5dbc 686 if (rcu_access_pointer(local->scan_sdata) == sdata)
352ffad6
BC		 687 ieee80211_scan_cancel(local);
688
0d143fe1
JB		 689 /*
690 * Stop TX on this interface first.
691 */
f142c6b9
JB		 692 if (sdata->dev)
693 netif_tx_stop_all_queues(sdata->dev);
0d143fe1 694
2eb278e0 695 ieee80211_roc_purge(sdata);
af6b6374 696
0d143fe1
JB		 697 /*
698 * Remove all stations associated with this interface.
699 *
700 * This must be done before calling ops->remove_interface()
701 * because otherwise we can later invoke ops->sta_notify()
702 * whenever the STAs are removed, and that invalidates driver
703 * assumptions about always getting a vif pointer that is valid
704 * (because if we remove a STA after ops->remove_interface()
705 * the driver will have removed the vif info already!)
706 *
09f4114e
JB		 707 * This is relevant only in WDS mode, in all other modes we've
708 * already removed all stations when disconnecting or similar,
709 * so warn otherwise.
051007d9
JB		 710 *
711 * We call sta_info_flush_cleanup() later, to combine RCU waits.
0d143fe1 712 */
051007d9 713 flushed = sta_info_flush_defer(sdata);
09f4114e
JB		 714 WARN_ON_ONCE((sdata->vif.type != NL80211_IFTYPE_WDS && flushed > 0) ||
715 (sdata->vif.type == NL80211_IFTYPE_WDS && flushed != 1));
0d143fe1
JB		 716
717 /*
718 * Don't count this interface for promisc/allmulti while it
719 * is down. dev_mc_unsync() will invoke set_multicast_list
720 * on the master interface which will sync these down to the
721 * hardware as filter flags.
722 */
723 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
724 atomic_dec(&local->iff_allmultis);
725
726 if (sdata->flags & IEEE80211_SDATA_PROMISC)
727 atomic_dec(&local->iff_promiscs);
728
7be5086d 729 if (sdata->vif.type == NL80211_IFTYPE_AP) {
e3b90ca2 730 local->fif_pspoll--;
7be5086d
JB		 731 local->fif_probe_req--;
732 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
733 local->fif_probe_req--;
734 }
e3b90ca2 735
f142c6b9
JB		 736 if (sdata->dev) {
737 netif_addr_lock_bh(sdata->dev);
738 spin_lock_bh(&local->filter_lock);
739 __hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
740 sdata->dev->addr_len);
741 spin_unlock_bh(&local->filter_lock);
742 netif_addr_unlock_bh(sdata->dev);
3b8d81e0 743
f142c6b9
JB		 744 ieee80211_configure_filter(local);
745 }
3ac64bee 746
7cbf0ba5
VN		 747 del_timer_sync(&local->dynamic_ps_timer);
748 cancel_work_sync(&local->dynamic_ps_enable_work);
0d143fe1 749
04ecd257
JB		 750 cancel_work_sync(&sdata->recalc_smps);
751
164eb02d
SW		 752 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
753
754 if (sdata->wdev.cac_started) {
755 mutex_lock(&local->iflist_mtx);
756 ieee80211_vif_release_channel(sdata);
757 mutex_unlock(&local->iflist_mtx);
758 cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,
759 GFP_KERNEL);
760 }
761
0d143fe1
JB		 762 /* APs need special treatment */
763 if (sdata->vif.type == NL80211_IFTYPE_AP) {
57c9fff3 764 struct ieee80211_sub_if_data *vlan, *tmpsdata;
0d143fe1
JB		 765
766 /* down all dependent devices, that is VLANs */
57c9fff3 767 list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
0d143fe1
JB		 768 u.vlan.list)
769 dev_close(vlan->dev);
770 WARN_ON(!list_empty(&sdata->u.ap.vlans));
afa762f6
EP		 771 } else if (sdata->vif.type == NL80211_IFTYPE_STATION) {
772 ieee80211_mgd_stop(sdata);
0d143fe1
JB		 773 }
774
34d4bc4d
JB		 775 if (going_down)
776 local->open_count--;
0d143fe1
JB		 777
778 switch (sdata->vif.type) {
779 case NL80211_IFTYPE_AP_VLAN:
780 list_del(&sdata->u.vlan.list);
4d76d21b 781 rcu_assign_pointer(sdata->vif.chanctx_conf, NULL);
0d143fe1
JB		 782 /* no need to tell driver */
783 break;
784 case NL80211_IFTYPE_MONITOR:
785 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
786 local->cooked_mntrs--;
787 break;
788 }
789
790 local->monitors--;
e8975581 791 if (local->monitors == 0) {
0869aea0
JB		 792 local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
793 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
075e0847 794 ieee80211_del_virtual_monitor(local);
e8975581 795 }
0d143fe1 796
85416a4f 797 ieee80211_adjust_monitor_flags(sdata, -1);
0d143fe1 798 ieee80211_configure_filter(local);
0d143fe1 799 break;
f142c6b9
JB		 800 case NL80211_IFTYPE_P2P_DEVICE:
801 /* relies on synchronize_rcu() below */
802 rcu_assign_pointer(local->p2p_sdata, NULL);
803 /* fall through */
0d143fe1 804 default:
0b7dff4f 805 cancel_work_sync(&sdata->work);
35f20c14
JB		 806 /*
807 * When we get here, the interface is marked down.
75de9113
JB		 808 *
809 * sta_info_flush_cleanup() requires rcu_barrier()
810 * first to wait for the station call_rcu() calls
811 * to complete, here we need at least sychronize_rcu()
812 * it to wait for the RX path in case it is using the
813 * interface and enqueuing frames at this very time on
814 * another CPU.
35f20c14 815 */
75de9113 816 rcu_barrier();
051007d9
JB		 817 sta_info_flush_cleanup(sdata);
818
35f20c14
JB		 819 skb_queue_purge(&sdata->skb_queue);
820
b9dcf712
JB		 821 /*
822 * Free all remaining keys, there shouldn't be any,
823 * except maybe group keys in AP more or WDS?
824 */
ad0e2b5a 825 ieee80211_free_keys(sdata);
b9dcf712 826
b207cdb0
AB		 827 drv_remove_interface_debugfs(local, sdata);
828
34d4bc4d 829 if (going_down)
7b7eab6f 830 drv_remove_interface(local, sdata);
0d143fe1
JB		 831 }
832
833 sdata->bss = NULL;
834
5cff20e6
JB		 835 ieee80211_recalc_ps(local, -1);
836
0d143fe1 837 if (local->open_count == 0) {
4e6cbfd0
JL		 838 if (local->ops->napi_poll)
839 napi_disable(&local->napi);
ea77f12f 840 ieee80211_clear_tx_pending(local);
84f6a01c 841 ieee80211_stop_device(local);
0d143fe1 842
e8975581
JB		 843 /* no reconfiguring after stop! */
844 hw_reconf_flags = 0;
0d143fe1
JB		 845 }
846
e8975581 847 /* do after stop to avoid reconfiguring when we stop anyway */
55de908a 848 if (hw_reconf_flags)
e8975581
JB		 849 ieee80211_hw_config(local, hw_reconf_flags);
850
5061b0c2
JB		 851 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
852 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
853 skb_queue_walk_safe(&local->pending[i], skb, tmp) {
854 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
855 if (info->control.vif == &sdata->vif) {
856 __skb_unlink(skb, &local->pending[i]);
d4fa14cd 857 ieee80211_free_txskb(&local->hw, skb);
5061b0c2
JB		 858 }
859 }
860 }
861 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
075e0847
JB		 862
863 if (local->monitors == local->open_count && local->monitors > 0)
864 ieee80211_add_virtual_monitor(local);
34d4bc4d
JB		 865}
866
867static int ieee80211_stop(struct net_device *dev)
868{
869 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
870
871 ieee80211_do_stop(sdata, true);
5061b0c2 872
0d143fe1
JB		 873 return 0;
874}
875
876static void ieee80211_set_multicast_list(struct net_device *dev)
877{
0d143fe1 878 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
b4a4bf5d 879 struct ieee80211_local *local = sdata->local;
0d143fe1
JB		 880 int allmulti, promisc, sdata_allmulti, sdata_promisc;
881
882 allmulti = !!(dev->flags & IFF_ALLMULTI);
883 promisc = !!(dev->flags & IFF_PROMISC);
884 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
885 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
886
887 if (allmulti != sdata_allmulti) {
888 if (dev->flags & IFF_ALLMULTI)
889 atomic_inc(&local->iff_allmultis);
890 else
891 atomic_dec(&local->iff_allmultis);
892 sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
893 }
894
895 if (promisc != sdata_promisc) {
896 if (dev->flags & IFF_PROMISC)
897 atomic_inc(&local->iff_promiscs);
898 else
899 atomic_dec(&local->iff_promiscs);
900 sdata->flags ^= IEEE80211_SDATA_PROMISC;
901 }
3b8d81e0 902 spin_lock_bh(&local->filter_lock);
22bedad3 903 __hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
3b8d81e0 904 spin_unlock_bh(&local->filter_lock);
3ac64bee 905 ieee80211_queue_work(&local->hw, &local->reconfig_filter);
0d143fe1
JB		 906}
907
75636525
JB		 908/*
909 * Called when the netdev is removed or, by the code below, before
910 * the interface type changes.
911 */
f142c6b9 912static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
f0706e82 913{
75636525 914 int flushed;
f0706e82
JB		 915 int i;
916
75636525
JB		 917 /* free extra data */
918 ieee80211_free_keys(sdata);
919
aee14ceb
JM		 920 ieee80211_debugfs_remove_netdev(sdata);
921
f0706e82 922 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
75636525
JB		 923 __skb_queue_purge(&sdata->fragments[i].skb_list);
924 sdata->fragment_next = 0;
11a843b7 925
b9dcf712
JB		 926 if (ieee80211_vif_is_mesh(&sdata->vif))
927 mesh_rmc_free(sdata);
75636525 928
b998e8bb 929 flushed = sta_info_flush(sdata);
75636525 930 WARN_ON(flushed);
f0706e82
JB		 931}
932
f142c6b9
JB		 933static void ieee80211_uninit(struct net_device *dev)
934{
935 ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
936}
937
cf0277e7
JB		 938static u16 ieee80211_netdev_select_queue(struct net_device *dev,
939 struct sk_buff *skb)
940{
941 return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
942}
943
587e729e
JB		 944static const struct net_device_ops ieee80211_dataif_ops = {
945 .ndo_open = ieee80211_open,
946 .ndo_stop = ieee80211_stop,
f142c6b9 947 .ndo_uninit = ieee80211_uninit,
587e729e 948 .ndo_start_xmit = ieee80211_subif_start_xmit,
afc4b13d 949 .ndo_set_rx_mode = ieee80211_set_multicast_list,
587e729e 950 .ndo_change_mtu = ieee80211_change_mtu,
47846c9b 951 .ndo_set_mac_address = ieee80211_change_mac,
cf0277e7 952 .ndo_select_queue = ieee80211_netdev_select_queue,
587e729e
JB		 953};
954
cf0277e7
JB		 955static u16 ieee80211_monitor_select_queue(struct net_device *dev,
956 struct sk_buff *skb)
957{
958 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
959 struct ieee80211_local *local = sdata->local;
960 struct ieee80211_hdr *hdr;
961 struct ieee80211_radiotap_header *rtap = (void *)skb->data;
962
32c5057b 963 if (local->hw.queues < IEEE80211_NUM_ACS)
cf0277e7
JB		 964 return 0;
965
966 if (skb->len < 4 ||
b49bb574 967 skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
cf0277e7
JB		 968 return 0; /* doesn't matter, frame will be dropped */
969
b49bb574 970 hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
cf0277e7 971
00e96dec 972 return ieee80211_select_queue_80211(sdata, skb, hdr);
cf0277e7
JB		 973}
974
587e729e
JB		 975static const struct net_device_ops ieee80211_monitorif_ops = {
976 .ndo_open = ieee80211_open,
977 .ndo_stop = ieee80211_stop,
f142c6b9 978 .ndo_uninit = ieee80211_uninit,
587e729e 979 .ndo_start_xmit = ieee80211_monitor_start_xmit,
afc4b13d 980 .ndo_set_rx_mode = ieee80211_set_multicast_list,
587e729e
JB		 981 .ndo_change_mtu = ieee80211_change_mtu,
982 .ndo_set_mac_address = eth_mac_addr,
cf0277e7 983 .ndo_select_queue = ieee80211_monitor_select_queue,
587e729e
JB		 984};
985
986static void ieee80211_if_setup(struct net_device *dev)
987{
988 ether_setup(dev);
550fd08c 989 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
587e729e 990 dev->netdev_ops = &ieee80211_dataif_ops;
587e729e
JB		 991 dev->destructor = free_netdev;
992}
993
1fa57d01
JB		 994static void ieee80211_iface_work(struct work_struct *work)
995{
996 struct ieee80211_sub_if_data *sdata =
997 container_of(work, struct ieee80211_sub_if_data, work);
998 struct ieee80211_local *local = sdata->local;
999 struct sk_buff *skb;
344eec67 1000 struct sta_info *sta;
c1475ca9 1001 struct ieee80211_ra_tid *ra_tid;
1fa57d01
JB		 1002
1003 if (!ieee80211_sdata_running(sdata))
1004 return;
1005
1006 if (local->scanning)
1007 return;
1008
1009 /*
1010 * ieee80211_queue_work() should have picked up most cases,
1011 * here we'll pick the rest.
1012 */
1013 if (WARN(local->suspended,
1014 "interface work scheduled while going to suspend\n"))
1015 return;
1016
1017 /* first process frames */
1018 while ((skb = skb_dequeue(&sdata->skb_queue))) {
bed7ee6e
JB		 1019 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1020
c1475ca9
JB		 1021 if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {
1022 ra_tid = (void *)&skb->cb;
1023 ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,
1024 ra_tid->tid);
1025 } else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {
1026 ra_tid = (void *)&skb->cb;
1027 ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,
1028 ra_tid->tid);
1029 } else if (ieee80211_is_action(mgmt->frame_control) &&
1030 mgmt->u.action.category == WLAN_CATEGORY_BACK) {
bed7ee6e 1031 int len = skb->len;
bed7ee6e 1032
a93e3644 1033 mutex_lock(&local->sta_mtx);
875ae5f6 1034 sta = sta_info_get_bss(sdata, mgmt->sa);
bed7ee6e
JB		 1035 if (sta) {
1036 switch (mgmt->u.action.u.addba_req.action_code) {
1037 case WLAN_ACTION_ADDBA_REQ:
1038 ieee80211_process_addba_request(
1039 local, sta, mgmt, len);
1040 break;
1041 case WLAN_ACTION_ADDBA_RESP:
1042 ieee80211_process_addba_resp(local, sta,
1043 mgmt, len);
1044 break;
1045 case WLAN_ACTION_DELBA:
1046 ieee80211_process_delba(sdata, sta,
1047 mgmt, len);
1048 break;
1049 default:
1050 WARN_ON(1);
1051 break;
1052 }
1053 }
a93e3644 1054 mutex_unlock(&local->sta_mtx);
344eec67
JB		 1055 } else if (ieee80211_is_data_qos(mgmt->frame_control)) {
1056 struct ieee80211_hdr *hdr = (void *)mgmt;
1057 /*
1058 * So the frame isn't mgmt, but frame_control
1059 * is at the right place anyway, of course, so
1060 * the if statement is correct.
1061 *
1062 * Warn if we have other data frame types here,
1063 * they must not get here.
1064 */
1065 WARN_ON(hdr->frame_control &
1066 cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
1067 WARN_ON(!(hdr->seq_ctrl &
1068 cpu_to_le16(IEEE80211_SCTL_FRAG)));
1069 /*
1070 * This was a fragment of a frame, received while
1071 * a block-ack session was active. That cannot be
1072 * right, so terminate the session.
1073 */
a93e3644 1074 mutex_lock(&local->sta_mtx);
875ae5f6 1075 sta = sta_info_get_bss(sdata, mgmt->sa);
344eec67
JB		 1076 if (sta) {
1077 u16 tid = *ieee80211_get_qos_ctl(hdr) &
1078 IEEE80211_QOS_CTL_TID_MASK;
1079
1080 __ieee80211_stop_rx_ba_session(
1081 sta, tid, WLAN_BACK_RECIPIENT,
53f73c09
JB		 1082 WLAN_REASON_QSTA_REQUIRE_SETUP,
1083 true);
344eec67 1084 }
a93e3644 1085 mutex_unlock(&local->sta_mtx);
bed7ee6e 1086 } else switch (sdata->vif.type) {
1fa57d01
JB		 1087 case NL80211_IFTYPE_STATION:
1088 ieee80211_sta_rx_queued_mgmt(sdata, skb);
1089 break;
1090 case NL80211_IFTYPE_ADHOC:
1091 ieee80211_ibss_rx_queued_mgmt(sdata, skb);
1092 break;
1093 case NL80211_IFTYPE_MESH_POINT:
1094 if (!ieee80211_vif_is_mesh(&sdata->vif))
1095 break;
1096 ieee80211_mesh_rx_queued_mgmt(sdata, skb);
1097 break;
1098 default:
1099 WARN(1, "frame for unexpected interface type");
1fa57d01
JB		 1100 break;
1101 }
36b3a628
JB		 1102
1103 kfree_skb(skb);
1fa57d01
JB		 1104 }
1105
1106 /* then other type-dependent work */
1107 switch (sdata->vif.type) {
1108 case NL80211_IFTYPE_STATION:
1109 ieee80211_sta_work(sdata);
1110 break;
1111 case NL80211_IFTYPE_ADHOC:
1112 ieee80211_ibss_work(sdata);
1113 break;
1114 case NL80211_IFTYPE_MESH_POINT:
1115 if (!ieee80211_vif_is_mesh(&sdata->vif))
1116 break;
1117 ieee80211_mesh_work(sdata);
1118 break;
1119 default:
1120 break;
1121 }
1122}
1123
04ecd257
JB		 1124static void ieee80211_recalc_smps_work(struct work_struct *work)
1125{
1126 struct ieee80211_sub_if_data *sdata =
1127 container_of(work, struct ieee80211_sub_if_data, recalc_smps);
1128
1129 ieee80211_recalc_smps(sdata);
1130}
1fa57d01 1131
75636525
JB		 1132/*
1133 * Helper function to initialise an interface to a specific type.
1134 */
1135static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
05c914fe 1136 enum nl80211_iftype type)
f0706e82 1137{
75636525
JB		 1138 /* clear type-dependent union */
1139 memset(&sdata->u, 0, sizeof(sdata->u));
1140
1141 /* and set some type-dependent values */
1142 sdata->vif.type = type;
2ca27bcf 1143 sdata->vif.p2p = false;
60719ffd 1144 sdata->wdev.iftype = type;
75636525 1145
a621fa4d
JB		 1146 sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
1147 sdata->control_port_no_encrypt = false;
1148
b53be792
SW		 1149 sdata->noack_map = 0;
1150
f142c6b9
JB		 1151 /* only monitor/p2p-device differ */
1152 if (sdata->dev) {
1153 sdata->dev->netdev_ops = &ieee80211_dataif_ops;
1154 sdata->dev->type = ARPHRD_ETHER;
1155 }
75636525 1156
35f20c14 1157 skb_queue_head_init(&sdata->skb_queue);
1fa57d01 1158 INIT_WORK(&sdata->work, ieee80211_iface_work);
04ecd257 1159 INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
35f20c14 1160
75636525 1161 switch (type) {
2ca27bcf
JB		 1162 case NL80211_IFTYPE_P2P_GO:
1163 type = NL80211_IFTYPE_AP;
1164 sdata->vif.type = type;
1165 sdata->vif.p2p = true;
1166 /* fall through */
05c914fe 1167 case NL80211_IFTYPE_AP:
d012a605 1168 skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
75636525 1169 INIT_LIST_HEAD(&sdata->u.ap.vlans);
ad2d223a 1170 sdata->vif.bss_conf.bssid = sdata->vif.addr;
75636525 1171 break;
2ca27bcf
JB		 1172 case NL80211_IFTYPE_P2P_CLIENT:
1173 type = NL80211_IFTYPE_STATION;
1174 sdata->vif.type = type;
1175 sdata->vif.p2p = true;
1176 /* fall through */
05c914fe 1177 case NL80211_IFTYPE_STATION:
ad2d223a 1178 sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;
9c6bd790 1179 ieee80211_sta_setup_sdata(sdata);
472dbc45 1180 break;
46900298 1181 case NL80211_IFTYPE_ADHOC:
ad2d223a 1182 sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
46900298
JB		 1183 ieee80211_ibss_setup_sdata(sdata);
1184 break;
05c914fe 1185 case NL80211_IFTYPE_MESH_POINT:
75636525
JB		 1186 if (ieee80211_vif_is_mesh(&sdata->vif))
1187 ieee80211_mesh_init_sdata(sdata);
1188 break;
05c914fe 1189 case NL80211_IFTYPE_MONITOR:
75636525 1190 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
587e729e 1191 sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
75636525
JB		 1192 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
1193 MONITOR_FLAG_OTHER_BSS;
1194 break;
05c914fe 1195 case NL80211_IFTYPE_WDS:
ad2d223a
JB		 1196 sdata->vif.bss_conf.bssid = NULL;
1197 break;
05c914fe 1198 case NL80211_IFTYPE_AP_VLAN:
ad2d223a 1199 break;
98104fde 1200 case NL80211_IFTYPE_P2P_DEVICE:
ad2d223a 1201 sdata->vif.bss_conf.bssid = sdata->vif.addr;
f142c6b9 1202 break;
05c914fe 1203 case NL80211_IFTYPE_UNSPECIFIED:
2e161f78 1204 case NUM_NL80211_IFTYPES:
75636525
JB		 1205 BUG();
1206 break;
1207 }
1208
1209 ieee80211_debugfs_add_netdev(sdata);
1210}
1211
34d4bc4d
JB		 1212static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
1213 enum nl80211_iftype type)
1214{
1215 struct ieee80211_local *local = sdata->local;
1216 int ret, err;
2ca27bcf
JB		 1217 enum nl80211_iftype internal_type = type;
1218 bool p2p = false;
34d4bc4d
JB		 1219
1220 ASSERT_RTNL();
1221
1222 if (!local->ops->change_interface)
1223 return -EBUSY;
1224
1225 switch (sdata->vif.type) {
1226 case NL80211_IFTYPE_AP:
1227 case NL80211_IFTYPE_STATION:
1228 case NL80211_IFTYPE_ADHOC:
1229 /*
1230 * Could maybe also all others here?
1231 * Just not sure how that interacts
1232 * with the RX/config path e.g. for
1233 * mesh.
1234 */
1235 break;
1236 default:
1237 return -EBUSY;
1238 }
1239
1240 switch (type) {
1241 case NL80211_IFTYPE_AP:
1242 case NL80211_IFTYPE_STATION:
1243 case NL80211_IFTYPE_ADHOC:
1244 /*
1245 * Could probably support everything
1246 * but WDS here (WDS do_open can fail
1247 * under memory pressure, which this
1248 * code isn't prepared to handle).
1249 */
1250 break;
2ca27bcf
JB		 1251 case NL80211_IFTYPE_P2P_CLIENT:
1252 p2p = true;
1253 internal_type = NL80211_IFTYPE_STATION;
1254 break;
1255 case NL80211_IFTYPE_P2P_GO:
1256 p2p = true;
1257 internal_type = NL80211_IFTYPE_AP;
1258 break;
34d4bc4d
JB		 1259 default:
1260 return -EBUSY;
1261 }
1262
2ca27bcf 1263 ret = ieee80211_check_concurrent_iface(sdata, internal_type);
34d4bc4d
JB		 1264 if (ret)
1265 return ret;
1266
1267 ieee80211_do_stop(sdata, false);
1268
f142c6b9 1269 ieee80211_teardown_sdata(sdata);
34d4bc4d 1270
2ca27bcf 1271 ret = drv_change_interface(local, sdata, internal_type, p2p);
34d4bc4d
JB		 1272 if (ret)
1273 type = sdata->vif.type;
1274
3a25a8c8
JB		 1275 /*
1276 * Ignore return value here, there's not much we can do since
1277 * the driver changed the interface type internally already.
1278 * The warnings will hopefully make driver authors fix it :-)
1279 */
1280 ieee80211_check_queues(sdata);
1281
34d4bc4d
JB		 1282 ieee80211_setup_sdata(sdata, type);
1283
f142c6b9 1284 err = ieee80211_do_open(&sdata->wdev, false);
34d4bc4d
JB		 1285 WARN(err, "type change: do_open returned %d", err);
1286
1287 return ret;
1288}
1289
f3947e2d 1290int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
05c914fe 1291 enum nl80211_iftype type)
75636525 1292{
34d4bc4d
JB		 1293 int ret;
1294
f3947e2d
JB		 1295 ASSERT_RTNL();
1296
2ca27bcf 1297 if (type == ieee80211_vif_type_p2p(&sdata->vif))
f3947e2d
JB		 1298 return 0;
1299
34d4bc4d
JB		 1300 if (ieee80211_sdata_running(sdata)) {
1301 ret = ieee80211_runtime_change_iftype(sdata, type);
1302 if (ret)
1303 return ret;
1304 } else {
1305 /* Purge and reset type-dependent state. */
f142c6b9 1306 ieee80211_teardown_sdata(sdata);
34d4bc4d
JB		 1307 ieee80211_setup_sdata(sdata, type);
1308 }
75636525
JB		 1309
1310 /* reset some values that shouldn't be kept across type changes */
75636525 1311 sdata->drop_unencrypted = 0;
9bc383de
JB		 1312 if (type == NL80211_IFTYPE_STATION)
1313 sdata->u.mgd.use_4addr = false;
f3947e2d
JB		 1314
1315 return 0;
f0706e82
JB		 1316}
1317
fa9029f8 1318static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
f142c6b9 1319 u8 *perm_addr, enum nl80211_iftype type)
fa9029f8
JB		 1320{
1321 struct ieee80211_sub_if_data *sdata;
1322 u64 mask, start, addr, val, inc;
1323 u8 *m;
1324 u8 tmp_addr[ETH_ALEN];
1325 int i;
1326
1327 /* default ... something at least */
f142c6b9 1328 memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
fa9029f8
JB		 1329
1330 if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
1331 local->hw.wiphy->n_addresses <= 1)
1332 return;
1333
fa9029f8
JB		 1334 mutex_lock(&local->iflist_mtx);
1335
1336 switch (type) {
1337 case NL80211_IFTYPE_MONITOR:
1338 /* doesn't matter */
1339 break;
1340 case NL80211_IFTYPE_WDS:
1341 case NL80211_IFTYPE_AP_VLAN:
1342 /* match up with an AP interface */
1343 list_for_each_entry(sdata, &local->interfaces, list) {
1344 if (sdata->vif.type != NL80211_IFTYPE_AP)
1345 continue;
f142c6b9 1346 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
fa9029f8
JB		 1347 break;
1348 }
1349 /* keep default if no AP interface present */
1350 break;
6d71117a
JB		 1351 case NL80211_IFTYPE_P2P_CLIENT:
1352 case NL80211_IFTYPE_P2P_GO:
1353 if (local->hw.flags & IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF) {
1354 list_for_each_entry(sdata, &local->interfaces, list) {
1355 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
1356 continue;
1357 if (!ieee80211_sdata_running(sdata))
1358 continue;
1359 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
1360 goto out_unlock;
1361 }
1362 }
1363 /* otherwise fall through */
fa9029f8
JB		 1364 default:
1365 /* assign a new address if possible -- try n_addresses first */
1366 for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
1367 bool used = false;
1368
1369 list_for_each_entry(sdata, &local->interfaces, list) {
1370 if (memcmp(local->hw.wiphy->addresses[i].addr,
1371 sdata->vif.addr, ETH_ALEN) == 0) {
1372 used = true;
1373 break;
1374 }
1375 }
1376
1377 if (!used) {
f142c6b9 1378 memcpy(perm_addr,
fa9029f8
JB		 1379 local->hw.wiphy->addresses[i].addr,
1380 ETH_ALEN);
1381 break;
1382 }
1383 }
1384
1385 /* try mask if available */
1386 if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
1387 break;
1388
1389 m = local->hw.wiphy->addr_mask;
1390 mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1391 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1392 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1393
1394 if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
1395 /* not a contiguous mask ... not handled now! */
bdcbd8e0 1396 pr_info("not contiguous\n");
fa9029f8
JB		 1397 break;
1398 }
1399
1400 m = local->hw.wiphy->perm_addr;
1401 start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1402 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1403 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1404
1405 inc = 1ULL<<__ffs64(mask);
1406 val = (start & mask);
1407 addr = (start & ~mask) | (val & mask);
1408 do {
1409 bool used = false;
1410
1411 tmp_addr[5] = addr >> 0*8;
1412 tmp_addr[4] = addr >> 1*8;
1413 tmp_addr[3] = addr >> 2*8;
1414 tmp_addr[2] = addr >> 3*8;
1415 tmp_addr[1] = addr >> 4*8;
1416 tmp_addr[0] = addr >> 5*8;
1417
1418 val += inc;
1419
1420 list_for_each_entry(sdata, &local->interfaces, list) {
1421 if (memcmp(tmp_addr, sdata->vif.addr,
1422 ETH_ALEN) == 0) {
1423 used = true;
1424 break;
1425 }
1426 }
1427
1428 if (!used) {
f142c6b9 1429 memcpy(perm_addr, tmp_addr, ETH_ALEN);
fa9029f8
JB		 1430 break;
1431 }
1432 addr = (start & ~mask) | (val & mask);
1433 } while (addr != start);
1434
1435 break;
1436 }
1437
6d71117a 1438 out_unlock:
fa9029f8
JB		 1439 mutex_unlock(&local->iflist_mtx);
1440}
1441
97f97b1f
JB		 1442static void ieee80211_cleanup_sdata_stas_wk(struct work_struct *wk)
1443{
1444 struct ieee80211_sub_if_data *sdata;
1445
1446 sdata = container_of(wk, struct ieee80211_sub_if_data, cleanup_stations_wk);
1447
1448 ieee80211_cleanup_sdata_stas(sdata);
1449}
1450
3e122be0 1451int ieee80211_if_add(struct ieee80211_local *local, const char *name,
84efbb84 1452 struct wireless_dev **new_wdev, enum nl80211_iftype type,
ee385855 1453 struct vif_params *params)
f0706e82 1454{
f142c6b9 1455 struct net_device *ndev = NULL;
f0706e82 1456 struct ieee80211_sub_if_data *sdata = NULL;
75636525 1457 int ret, i;
ded81f6b 1458 int txqs = 1;
f0706e82
JB		 1459
1460 ASSERT_RTNL();
75636525 1461
f142c6b9
JB		 1462 if (type == NL80211_IFTYPE_P2P_DEVICE) {
1463 struct wireless_dev *wdev;
1464
1465 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,
1466 GFP_KERNEL);
1467 if (!sdata)
1468 return -ENOMEM;
1469 wdev = &sdata->wdev;
1470
1471 sdata->dev = NULL;
1472 strlcpy(sdata->name, name, IFNAMSIZ);
1473 ieee80211_assign_perm_addr(local, wdev->address, type);
1474 memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
1475 } else {
1476 if (local->hw.queues >= IEEE80211_NUM_ACS)
1477 txqs = IEEE80211_NUM_ACS;
1478
1479 ndev = alloc_netdev_mqs(sizeof(*sdata) +
1480 local->hw.vif_data_size,
1481 name, ieee80211_if_setup, txqs, 1);
1482 if (!ndev)
1483 return -ENOMEM;
1484 dev_net_set(ndev, wiphy_net(local->hw.wiphy));
1485
1486 ndev->needed_headroom = local->tx_headroom +
1487 4*6 /* four MAC addresses */
1488 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
1489 + 6 /* mesh */
1490 + 8 /* rfc1042/bridge tunnel */
1491 - ETH_HLEN /* ethernet hard_header_len */
1492 + IEEE80211_ENCRYPT_HEADROOM;
1493 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
1494
1495 ret = dev_alloc_name(ndev, ndev->name);
1496 if (ret < 0) {
1497 free_netdev(ndev);
1498 return ret;
1499 }
1500
1501 ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
1502 memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
1503 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
1504
1505 /* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */
1506 sdata = netdev_priv(ndev);
1507 ndev->ieee80211_ptr = &sdata->wdev;
1508 memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
1509 memcpy(sdata->name, ndev->name, IFNAMSIZ);
1510
1511 sdata->dev = ndev;
1512 }
75636525
JB		 1513
1514 /* initialise type-independent data */
f0706e82 1515 sdata->wdev.wiphy = local->hw.wiphy;
f0706e82 1516 sdata->local = local;
75636525
JB		 1517
1518 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
1519 skb_queue_head_init(&sdata->fragments[i].skb_list);
1520
1521 INIT_LIST_HEAD(&sdata->key_list);
1522
97f97b1f
JB		 1523 spin_lock_init(&sdata->cleanup_stations_lock);
1524 INIT_LIST_HEAD(&sdata->cleanup_stations);
1525 INIT_WORK(&sdata->cleanup_stations_wk, ieee80211_cleanup_sdata_stas_wk);
164eb02d
SW		 1526 INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work,
1527 ieee80211_dfs_cac_timer_work);
97f97b1f 1528
37eb0b16
JM		 1529 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
1530 struct ieee80211_supported_band *sband;
1531 sband = local->hw.wiphy->bands[i];
1532 sdata->rc_rateidx_mask[i] =
1533 sband ? (1 << sband->n_bitrates) - 1 : 0;
19468413
SW		 1534 if (sband)
1535 memcpy(sdata->rc_rateidx_mcs_mask[i],
1536 sband->ht_cap.mcs.rx_mask,
1537 sizeof(sdata->rc_rateidx_mcs_mask[i]));
1538 else
1539 memset(sdata->rc_rateidx_mcs_mask[i], 0,
1540 sizeof(sdata->rc_rateidx_mcs_mask[i]));
37eb0b16 1541 }
75636525 1542
3a25a8c8
JB		 1543 ieee80211_set_default_queues(sdata);
1544
1ea6f9c0
JB		 1545 sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
1546 sdata->user_power_level = local->user_power_level;
1547
75636525
JB		 1548 /* setup type-dependent data */
1549 ieee80211_setup_sdata(sdata, type);
f0706e82 1550
f142c6b9
JB		 1551 if (ndev) {
1552 if (params) {
1553 ndev->ieee80211_ptr->use_4addr = params->use_4addr;
1554 if (type == NL80211_IFTYPE_STATION)
1555 sdata->u.mgd.use_4addr = params->use_4addr;
1556 }
9bc383de 1557
f142c6b9 1558 ndev->features |= local->hw.netdev_features;
72d78728 1559
f142c6b9
JB		 1560 ret = register_netdevice(ndev);
1561 if (ret) {
1562 free_netdev(ndev);
1563 return ret;
1564 }
1565 }
f0706e82 1566
c771c9d8 1567 mutex_lock(&local->iflist_mtx);
79010420 1568 list_add_tail_rcu(&sdata->list, &local->interfaces);
c771c9d8 1569 mutex_unlock(&local->iflist_mtx);
79010420 1570
84efbb84
JB		 1571 if (new_wdev)
1572 *new_wdev = &sdata->wdev;
f0706e82 1573
f0706e82 1574 return 0;
f0706e82
JB		 1575}
1576
f698d856 1577void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
f0706e82 1578{
f0706e82 1579 ASSERT_RTNL();
11a843b7 1580
c771c9d8 1581 mutex_lock(&sdata->local->iflist_mtx);
75636525 1582 list_del_rcu(&sdata->list);
c771c9d8
JB		 1583 mutex_unlock(&sdata->local->iflist_mtx);
1584
75636525 1585 synchronize_rcu();
f142c6b9
JB		 1586
1587 if (sdata->dev) {
1588 unregister_netdevice(sdata->dev);
1589 } else {
1590 cfg80211_unregister_wdev(&sdata->wdev);
1591 kfree(sdata);
1592 }
1593}
1594
1595void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)
1596{
1597 if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))
1598 return;
1599 ieee80211_do_stop(sdata, true);
1600 ieee80211_teardown_sdata(sdata);
f0706e82
JB		 1601}
1602
75636525
JB		 1603/*
1604 * Remove all interfaces, may only be called at hardware unregistration
1605 * time because it doesn't do RCU-safe list removals.
1606 */
1607void ieee80211_remove_interfaces(struct ieee80211_local *local)
f0706e82 1608{
75636525 1609 struct ieee80211_sub_if_data *sdata, *tmp;
efe117ab 1610 LIST_HEAD(unreg_list);
f142c6b9 1611 LIST_HEAD(wdev_list);
f0706e82
JB		 1612
1613 ASSERT_RTNL();
1614
efe117ab 1615 mutex_lock(&local->iflist_mtx);
75636525
JB		 1616 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
1617 list_del(&sdata->list);
c771c9d8 1618
f142c6b9
JB		 1619 if (sdata->dev)
1620 unregister_netdevice_queue(sdata->dev, &unreg_list);
1621 else
1622 list_add(&sdata->list, &wdev_list);
f0706e82 1623 }
efe117ab
ED		 1624 mutex_unlock(&local->iflist_mtx);
1625 unregister_netdevice_many(&unreg_list);
5f04d506 1626 list_del(&unreg_list);
f142c6b9
JB		 1627
1628 list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {
1629 list_del(&sdata->list);
1630 cfg80211_unregister_wdev(&sdata->wdev);
1631 kfree(sdata);
1632 }
f0706e82 1633}
5cff20e6 1634
47846c9b
JB		 1635static int netdev_notify(struct notifier_block *nb,
1636 unsigned long state,
1637 void *ndev)
1638{
1639 struct net_device *dev = ndev;
1640 struct ieee80211_sub_if_data *sdata;
1641
1642 if (state != NETDEV_CHANGENAME)
1643 return 0;
1644
1645 if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
1646 return 0;
1647
1648 if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
1649 return 0;
1650
1651 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1652
2f5265e6 1653 memcpy(sdata->name, dev->name, IFNAMSIZ);
47846c9b
JB		 1654
1655 ieee80211_debugfs_rename_netdev(sdata);
1656 return 0;
1657}
1658
1659static struct notifier_block mac80211_netdev_notifier = {
1660 .notifier_call = netdev_notify,
1661};
1662
1663int ieee80211_iface_init(void)
1664{
1665 return register_netdevice_notifier(&mac80211_netdev_notifier);
1666}
1667
1668void ieee80211_iface_exit(void)
1669{
1670 unregister_netdevice_notifier(&mac80211_netdev_notifier);
1671}
Linux 6.x block layer and io_uring tree(s)