2
* Interface handling (except master interface)
4
* Copyright 2002-2005, Instant802 Networks, Inc.
5
* Copyright 2005-2006, Devicescape Software, Inc.
6
* Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
7
* Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
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.
13
#include <linux/slab.h>
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>
19
#include <net/ieee80211_radiotap.h>
20
#include "ieee80211_i.h"
22
#include "debugfs_netdev.h"
25
#include "driver-ops.h"
30
* DOC: Interface list locking
32
* The interface list in each struct ieee80211_local is protected
35
* (1) modifications may only be done under the RTNL
36
* (2) modifications and readers are protected against each other by
38
* (3) modifications are done in an RCU manner so atomic readers
39
* can traverse the list in RCU-safe blocks.
41
* As a consequence, reads (traversals) of the list can be protected
42
* by either the RTNL, the iflist_mtx or RCU.
46
static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
49
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
51
meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;
53
/* FIX: what would be proper limits for MTU?
54
* This interface uses 802.3 frames. */
56
new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {
60
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
61
printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu);
62
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
67
static int ieee80211_change_mac(struct net_device *dev, void *addr)
69
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
70
struct sockaddr *sa = addr;
73
if (ieee80211_sdata_running(sdata))
76
ret = eth_mac_addr(dev, sa);
79
memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
84
static inline int identical_mac_addr_allowed(int type1, int type2)
86
return type1 == NL80211_IFTYPE_MONITOR ||
87
type2 == NL80211_IFTYPE_MONITOR ||
88
(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
89
(type1 == NL80211_IFTYPE_WDS &&
90
(type2 == NL80211_IFTYPE_WDS ||
91
type2 == NL80211_IFTYPE_AP)) ||
92
(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
93
(type1 == NL80211_IFTYPE_AP_VLAN &&
94
(type2 == NL80211_IFTYPE_AP ||
95
type2 == NL80211_IFTYPE_AP_VLAN));
98
static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
99
enum nl80211_iftype iftype)
101
struct ieee80211_local *local = sdata->local;
102
struct ieee80211_sub_if_data *nsdata;
103
struct net_device *dev = sdata->dev;
107
/* we hold the RTNL here so can safely walk the list */
108
list_for_each_entry(nsdata, &local->interfaces, list) {
109
struct net_device *ndev = nsdata->dev;
111
if (ndev != dev && ieee80211_sdata_running(nsdata)) {
113
* Allow only a single IBSS interface to be up at any
114
* time. This is restricted because beacon distribution
115
* cannot work properly if both are in the same IBSS.
117
* To remove this restriction we'd have to disallow them
118
* from setting the same SSID on different IBSS interfaces
119
* belonging to the same hardware. Then, however, we're
120
* faced with having to adopt two different TSF timers...
122
if (iftype == NL80211_IFTYPE_ADHOC &&
123
nsdata->vif.type == NL80211_IFTYPE_ADHOC)
127
* The remaining checks are only performed for interfaces
128
* with the same MAC address.
130
if (compare_ether_addr(dev->dev_addr, ndev->dev_addr))
134
* check whether it may have the same address
136
if (!identical_mac_addr_allowed(iftype,
141
* can only add VLANs to enabled APs
143
if (iftype == NL80211_IFTYPE_AP_VLAN &&
144
nsdata->vif.type == NL80211_IFTYPE_AP)
145
sdata->bss = &nsdata->u.ap;
152
void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
155
struct ieee80211_local *local = sdata->local;
156
u32 flags = sdata->u.mntr_flags;
158
#define ADJUST(_f, _s) do { \
159
if (flags & MONITOR_FLAG_##_f) \
160
local->fif_##_s += offset; \
163
ADJUST(FCSFAIL, fcsfail);
164
ADJUST(PLCPFAIL, plcpfail);
165
ADJUST(CONTROL, control);
166
ADJUST(CONTROL, pspoll);
167
ADJUST(OTHER_BSS, other_bss);
173
* NOTE: Be very careful when changing this function, it must NOT return
174
* an error on interface type changes that have been pre-checked, so most
175
* checks should be in ieee80211_check_concurrent_iface.
177
static int ieee80211_do_open(struct net_device *dev, bool coming_up)
179
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
180
struct ieee80211_local *local = sdata->local;
181
struct sta_info *sta;
184
u32 hw_reconf_flags = 0;
186
switch (sdata->vif.type) {
187
case NL80211_IFTYPE_WDS:
188
if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
191
case NL80211_IFTYPE_AP_VLAN: {
192
struct ieee80211_sub_if_data *master;
197
list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
199
master = container_of(sdata->bss,
200
struct ieee80211_sub_if_data, u.ap);
201
sdata->control_port_protocol =
202
master->control_port_protocol;
203
sdata->control_port_no_encrypt =
204
master->control_port_no_encrypt;
207
case NL80211_IFTYPE_AP:
208
sdata->bss = &sdata->u.ap;
210
case NL80211_IFTYPE_MESH_POINT:
211
case NL80211_IFTYPE_STATION:
212
case NL80211_IFTYPE_MONITOR:
213
case NL80211_IFTYPE_ADHOC:
214
/* no special treatment */
216
case NL80211_IFTYPE_UNSPECIFIED:
217
case NUM_NL80211_IFTYPES:
218
case NL80211_IFTYPE_P2P_CLIENT:
219
case NL80211_IFTYPE_P2P_GO:
225
if (local->open_count == 0) {
226
res = drv_start(local);
229
if (local->ops->napi_poll)
230
napi_enable(&local->napi);
231
/* we're brought up, everything changes */
232
hw_reconf_flags = ~0;
233
ieee80211_led_radio(local, true);
234
ieee80211_mod_tpt_led_trig(local,
235
IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
239
* Copy the hopefully now-present MAC address to
240
* this interface, if it has the special null one.
242
if (is_zero_ether_addr(dev->dev_addr)) {
243
memcpy(dev->dev_addr,
244
local->hw.wiphy->perm_addr,
246
memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
248
if (!is_valid_ether_addr(dev->dev_addr)) {
249
if (!local->open_count)
251
return -EADDRNOTAVAIL;
255
switch (sdata->vif.type) {
256
case NL80211_IFTYPE_AP_VLAN:
257
/* no need to tell driver */
259
case NL80211_IFTYPE_MONITOR:
260
if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
261
local->cooked_mntrs++;
265
/* must be before the call to ieee80211_configure_filter */
267
if (local->monitors == 1) {
268
local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
269
hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
272
ieee80211_adjust_monitor_flags(sdata, 1);
273
ieee80211_configure_filter(local);
275
netif_carrier_on(dev);
279
res = drv_add_interface(local, sdata);
284
if (sdata->vif.type == NL80211_IFTYPE_AP) {
286
local->fif_probe_req++;
288
ieee80211_configure_filter(local);
289
} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
290
local->fif_probe_req++;
293
changed |= ieee80211_reset_erp_info(sdata);
294
ieee80211_bss_info_change_notify(sdata, changed);
296
if (sdata->vif.type == NL80211_IFTYPE_STATION ||
297
sdata->vif.type == NL80211_IFTYPE_ADHOC)
298
netif_carrier_off(dev);
300
netif_carrier_on(dev);
303
* set default queue parameters so drivers don't
304
* need to initialise the hardware if the hardware
305
* doesn't start up with sane defaults
307
ieee80211_set_wmm_default(sdata);
310
set_bit(SDATA_STATE_RUNNING, &sdata->state);
312
if (sdata->vif.type == NL80211_IFTYPE_WDS) {
313
/* Create STA entry for the WDS peer */
314
sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
318
goto err_del_interface;
321
sta_info_move_state(sta, IEEE80211_STA_AUTH);
322
sta_info_move_state(sta, IEEE80211_STA_ASSOC);
323
sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
325
res = sta_info_insert(sta);
327
/* STA has been freed */
328
goto err_del_interface;
331
rate_control_rate_init(sta);
335
* set_multicast_list will be invoked by the networking core
336
* which will check whether any increments here were done in
337
* error and sync them down to the hardware as filter flags.
339
if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
340
atomic_inc(&local->iff_allmultis);
342
if (sdata->flags & IEEE80211_SDATA_PROMISC)
343
atomic_inc(&local->iff_promiscs);
345
mutex_lock(&local->mtx);
346
hw_reconf_flags |= __ieee80211_recalc_idle(local);
347
mutex_unlock(&local->mtx);
353
ieee80211_hw_config(local, hw_reconf_flags);
355
ieee80211_recalc_ps(local, -1);
357
netif_tx_start_all_queues(dev);
361
drv_remove_interface(local, sdata);
363
if (!local->open_count)
367
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
368
list_del(&sdata->u.vlan.list);
369
clear_bit(SDATA_STATE_RUNNING, &sdata->state);
373
static int ieee80211_open(struct net_device *dev)
375
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
378
/* fail early if user set an invalid address */
379
if (!is_valid_ether_addr(dev->dev_addr))
380
return -EADDRNOTAVAIL;
382
err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
386
return ieee80211_do_open(dev, true);
389
static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
392
struct ieee80211_local *local = sdata->local;
394
struct sk_buff *skb, *tmp;
395
u32 hw_reconf_flags = 0;
397
enum nl80211_channel_type orig_ct;
399
clear_bit(SDATA_STATE_RUNNING, &sdata->state);
401
if (local->scan_sdata == sdata)
402
ieee80211_scan_cancel(local);
405
* Stop TX on this interface first.
407
netif_tx_stop_all_queues(sdata->dev);
410
* Purge work for this interface.
412
ieee80211_work_purge(sdata);
415
* Remove all stations associated with this interface.
417
* This must be done before calling ops->remove_interface()
418
* because otherwise we can later invoke ops->sta_notify()
419
* whenever the STAs are removed, and that invalidates driver
420
* assumptions about always getting a vif pointer that is valid
421
* (because if we remove a STA after ops->remove_interface()
422
* the driver will have removed the vif info already!)
424
* This is relevant only in AP, WDS and mesh modes, since in
425
* all other modes we've already removed all stations when
428
sta_info_flush(local, sdata);
431
* Don't count this interface for promisc/allmulti while it
432
* is down. dev_mc_unsync() will invoke set_multicast_list
433
* on the master interface which will sync these down to the
434
* hardware as filter flags.
436
if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
437
atomic_dec(&local->iff_allmultis);
439
if (sdata->flags & IEEE80211_SDATA_PROMISC)
440
atomic_dec(&local->iff_promiscs);
442
if (sdata->vif.type == NL80211_IFTYPE_AP) {
444
local->fif_probe_req--;
445
} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
446
local->fif_probe_req--;
449
netif_addr_lock_bh(sdata->dev);
450
spin_lock_bh(&local->filter_lock);
451
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
452
__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
453
sdata->dev->addr_len);
455
__dev_addr_unsync(&local->mc_list, &local->mc_count,
456
&sdata->dev->mc_list, &sdata->dev->mc_count);
458
spin_unlock_bh(&local->filter_lock);
459
netif_addr_unlock_bh(sdata->dev);
461
ieee80211_configure_filter(local);
463
del_timer_sync(&local->dynamic_ps_timer);
464
cancel_work_sync(&local->dynamic_ps_enable_work);
466
/* APs need special treatment */
467
if (sdata->vif.type == NL80211_IFTYPE_AP) {
468
struct ieee80211_sub_if_data *vlan, *tmpsdata;
469
struct beacon_data *old_beacon =
470
rtnl_dereference(sdata->u.ap.beacon);
471
struct sk_buff *old_probe_resp =
472
rtnl_dereference(sdata->u.ap.probe_resp);
474
/* sdata_running will return false, so this will disable */
475
ieee80211_bss_info_change_notify(sdata,
476
BSS_CHANGED_BEACON_ENABLED);
478
/* remove beacon and probe response */
479
RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
480
RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
483
kfree_skb(old_probe_resp);
485
/* down all dependent devices, that is VLANs */
486
list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
488
dev_close(vlan->dev);
489
WARN_ON(!list_empty(&sdata->u.ap.vlans));
491
/* free all potentially still buffered bcast frames */
492
local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps_bc_buf);
493
skb_queue_purge(&sdata->u.ap.ps_bc_buf);
499
switch (sdata->vif.type) {
500
case NL80211_IFTYPE_AP_VLAN:
501
list_del(&sdata->u.vlan.list);
502
/* no need to tell driver */
504
case NL80211_IFTYPE_MONITOR:
505
if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
506
local->cooked_mntrs--;
511
if (local->monitors == 0) {
512
local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
513
hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
516
ieee80211_adjust_monitor_flags(sdata, -1);
517
ieee80211_configure_filter(local);
520
flush_work(&sdata->work);
522
* When we get here, the interface is marked down.
523
* Call synchronize_rcu() to wait for the RX path
524
* should it be using the interface and enqueuing
525
* frames at this very time on another CPU.
528
skb_queue_purge(&sdata->skb_queue);
531
* Disable beaconing here for mesh only, AP and IBSS
532
* are already taken care of.
534
if (sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
535
ieee80211_bss_info_change_notify(sdata,
536
BSS_CHANGED_BEACON_ENABLED);
539
* Free all remaining keys, there shouldn't be any,
540
* except maybe group keys in AP more or WDS?
542
ieee80211_free_keys(sdata);
545
drv_remove_interface(local, sdata);
550
mutex_lock(&local->mtx);
551
hw_reconf_flags |= __ieee80211_recalc_idle(local);
552
mutex_unlock(&local->mtx);
554
ieee80211_recalc_ps(local, -1);
556
if (local->open_count == 0) {
557
if (local->ops->napi_poll)
558
napi_disable(&local->napi);
559
ieee80211_clear_tx_pending(local);
560
ieee80211_stop_device(local);
562
/* no reconfiguring after stop! */
566
/* Re-calculate channel-type, in case there are multiple vifs
567
* on different channel types.
569
orig_ct = local->_oper_channel_type;
570
ieee80211_set_channel_type(local, NULL, NL80211_CHAN_NO_HT);
572
/* do after stop to avoid reconfiguring when we stop anyway */
573
if (hw_reconf_flags || (orig_ct != local->_oper_channel_type))
574
ieee80211_hw_config(local, hw_reconf_flags);
576
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
577
for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
578
skb_queue_walk_safe(&local->pending[i], skb, tmp) {
579
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
580
if (info->control.vif == &sdata->vif) {
581
__skb_unlink(skb, &local->pending[i]);
582
dev_kfree_skb_irq(skb);
586
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
589
static int ieee80211_stop(struct net_device *dev)
591
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
593
ieee80211_do_stop(sdata, true);
598
static void ieee80211_set_multicast_list(struct net_device *dev)
600
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
601
struct ieee80211_local *local = sdata->local;
602
int allmulti, promisc, sdata_allmulti, sdata_promisc;
604
allmulti = !!(dev->flags & IFF_ALLMULTI);
605
promisc = !!(dev->flags & IFF_PROMISC);
606
sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
607
sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
609
if (allmulti != sdata_allmulti) {
610
if (dev->flags & IFF_ALLMULTI)
611
atomic_inc(&local->iff_allmultis);
613
atomic_dec(&local->iff_allmultis);
614
sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
617
if (promisc != sdata_promisc) {
618
if (dev->flags & IFF_PROMISC)
619
atomic_inc(&local->iff_promiscs);
621
atomic_dec(&local->iff_promiscs);
622
sdata->flags ^= IEEE80211_SDATA_PROMISC;
624
spin_lock_bh(&local->filter_lock);
625
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
626
__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
628
__dev_addr_sync(&local->mc_list, &local->mc_count,
629
&dev->mc_list, &dev->mc_count);
631
spin_unlock_bh(&local->filter_lock);
632
ieee80211_queue_work(&local->hw, &local->reconfig_filter);
636
* Called when the netdev is removed or, by the code below, before
637
* the interface type changes.
639
static void ieee80211_teardown_sdata(struct net_device *dev)
641
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
642
struct ieee80211_local *local = sdata->local;
646
/* free extra data */
647
ieee80211_free_keys(sdata);
649
ieee80211_debugfs_remove_netdev(sdata);
651
for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
652
__skb_queue_purge(&sdata->fragments[i].skb_list);
653
sdata->fragment_next = 0;
655
if (ieee80211_vif_is_mesh(&sdata->vif))
656
mesh_rmc_free(sdata);
658
flushed = sta_info_flush(local, sdata);
662
static u16 ieee80211_netdev_select_queue(struct net_device *dev,
665
return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
668
static const struct net_device_ops ieee80211_dataif_ops = {
669
.ndo_open = ieee80211_open,
670
.ndo_stop = ieee80211_stop,
671
.ndo_uninit = ieee80211_teardown_sdata,
672
.ndo_start_xmit = ieee80211_subif_start_xmit,
673
.ndo_set_rx_mode = ieee80211_set_multicast_list,
674
.ndo_change_mtu = ieee80211_change_mtu,
675
.ndo_set_mac_address = ieee80211_change_mac,
676
.ndo_select_queue = ieee80211_netdev_select_queue,
679
static u16 ieee80211_monitor_select_queue(struct net_device *dev,
682
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
683
struct ieee80211_local *local = sdata->local;
684
struct ieee80211_hdr *hdr;
685
struct ieee80211_radiotap_header *rtap = (void *)skb->data;
687
if (local->hw.queues < 4)
691
skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
692
return 0; /* doesn't matter, frame will be dropped */
694
hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
696
return ieee80211_select_queue_80211(local, skb, hdr);
699
static const struct net_device_ops ieee80211_monitorif_ops = {
700
.ndo_open = ieee80211_open,
701
.ndo_stop = ieee80211_stop,
702
.ndo_uninit = ieee80211_teardown_sdata,
703
.ndo_start_xmit = ieee80211_monitor_start_xmit,
704
.ndo_set_rx_mode = ieee80211_set_multicast_list,
705
.ndo_change_mtu = ieee80211_change_mtu,
706
.ndo_set_mac_address = eth_mac_addr,
707
.ndo_select_queue = ieee80211_monitor_select_queue,
710
static void ieee80211_if_setup(struct net_device *dev)
713
dev->priv_flags &= ~IFF_TX_SKB_SHARING;
714
netdev_attach_ops(dev, &ieee80211_dataif_ops);
715
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))
716
/* Do we need this ? */
717
/* we will validate the address ourselves in ->open */
718
dev->validate_addr = NULL;
720
dev->destructor = free_netdev;
723
static void ieee80211_iface_work(struct work_struct *work)
725
struct ieee80211_sub_if_data *sdata =
726
container_of(work, struct ieee80211_sub_if_data, work);
727
struct ieee80211_local *local = sdata->local;
729
struct sta_info *sta;
730
struct ieee80211_ra_tid *ra_tid;
732
if (!ieee80211_sdata_running(sdata))
739
* ieee80211_queue_work() should have picked up most cases,
740
* here we'll pick the rest.
742
if (WARN(local->suspended,
743
"interface work scheduled while going to suspend\n"))
746
/* first process frames */
747
while ((skb = skb_dequeue(&sdata->skb_queue))) {
748
struct ieee80211_mgmt *mgmt = (void *)skb->data;
750
if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {
751
ra_tid = (void *)&skb->cb;
752
ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,
754
} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {
755
ra_tid = (void *)&skb->cb;
756
ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,
758
} else if (ieee80211_is_action(mgmt->frame_control) &&
759
mgmt->u.action.category == WLAN_CATEGORY_BACK) {
762
mutex_lock(&local->sta_mtx);
763
sta = sta_info_get_bss(sdata, mgmt->sa);
765
switch (mgmt->u.action.u.addba_req.action_code) {
766
case WLAN_ACTION_ADDBA_REQ:
767
ieee80211_process_addba_request(
768
local, sta, mgmt, len);
770
case WLAN_ACTION_ADDBA_RESP:
771
ieee80211_process_addba_resp(local, sta,
774
case WLAN_ACTION_DELBA:
775
ieee80211_process_delba(sdata, sta,
783
mutex_unlock(&local->sta_mtx);
784
} else if (ieee80211_is_data_qos(mgmt->frame_control)) {
785
struct ieee80211_hdr *hdr = (void *)mgmt;
787
* So the frame isn't mgmt, but frame_control
788
* is at the right place anyway, of course, so
789
* the if statement is correct.
791
* Warn if we have other data frame types here,
792
* they must not get here.
794
WARN_ON(hdr->frame_control &
795
cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
796
WARN_ON(!(hdr->seq_ctrl &
797
cpu_to_le16(IEEE80211_SCTL_FRAG)));
799
* This was a fragment of a frame, received while
800
* a block-ack session was active. That cannot be
801
* right, so terminate the session.
803
mutex_lock(&local->sta_mtx);
804
sta = sta_info_get_bss(sdata, mgmt->sa);
806
u16 tid = *ieee80211_get_qos_ctl(hdr) &
807
IEEE80211_QOS_CTL_TID_MASK;
809
__ieee80211_stop_rx_ba_session(
810
sta, tid, WLAN_BACK_RECIPIENT,
811
WLAN_REASON_QSTA_REQUIRE_SETUP,
814
mutex_unlock(&local->sta_mtx);
815
} else switch (sdata->vif.type) {
816
case NL80211_IFTYPE_STATION:
817
ieee80211_sta_rx_queued_mgmt(sdata, skb);
819
case NL80211_IFTYPE_ADHOC:
820
ieee80211_ibss_rx_queued_mgmt(sdata, skb);
822
case NL80211_IFTYPE_MESH_POINT:
823
if (!ieee80211_vif_is_mesh(&sdata->vif))
825
ieee80211_mesh_rx_queued_mgmt(sdata, skb);
828
WARN(1, "frame for unexpected interface type");
835
/* then other type-dependent work */
836
switch (sdata->vif.type) {
837
case NL80211_IFTYPE_STATION:
838
ieee80211_sta_work(sdata);
840
case NL80211_IFTYPE_ADHOC:
841
ieee80211_ibss_work(sdata);
843
case NL80211_IFTYPE_MESH_POINT:
844
if (!ieee80211_vif_is_mesh(&sdata->vif))
846
ieee80211_mesh_work(sdata);
855
* Helper function to initialise an interface to a specific type.
857
static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
858
enum nl80211_iftype type)
860
/* clear type-dependent union */
861
memset(&sdata->u, 0, sizeof(sdata->u));
863
/* and set some type-dependent values */
864
sdata->vif.type = type;
865
sdata->vif.p2p = false;
866
netdev_attach_ops(sdata->dev, &ieee80211_dataif_ops);
867
sdata->wdev.iftype = type;
869
sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
870
sdata->control_port_no_encrypt = false;
872
sdata->noack_map = 0;
874
/* only monitor differs */
875
sdata->dev->type = ARPHRD_ETHER;
877
skb_queue_head_init(&sdata->skb_queue);
878
INIT_WORK(&sdata->work, ieee80211_iface_work);
881
case NL80211_IFTYPE_P2P_GO:
882
type = NL80211_IFTYPE_AP;
883
sdata->vif.type = type;
884
sdata->vif.p2p = true;
886
case NL80211_IFTYPE_AP:
887
skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
888
INIT_LIST_HEAD(&sdata->u.ap.vlans);
890
case NL80211_IFTYPE_P2P_CLIENT:
891
type = NL80211_IFTYPE_STATION;
892
sdata->vif.type = type;
893
sdata->vif.p2p = true;
895
case NL80211_IFTYPE_STATION:
896
ieee80211_sta_setup_sdata(sdata);
898
case NL80211_IFTYPE_ADHOC:
899
ieee80211_ibss_setup_sdata(sdata);
901
case NL80211_IFTYPE_MESH_POINT:
902
if (ieee80211_vif_is_mesh(&sdata->vif))
903
ieee80211_mesh_init_sdata(sdata);
905
case NL80211_IFTYPE_MONITOR:
906
sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
907
netdev_attach_ops(sdata->dev, &ieee80211_monitorif_ops);
908
sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
909
MONITOR_FLAG_OTHER_BSS;
911
case NL80211_IFTYPE_WDS:
912
case NL80211_IFTYPE_AP_VLAN:
914
case NL80211_IFTYPE_UNSPECIFIED:
915
case NUM_NL80211_IFTYPES:
920
ieee80211_debugfs_add_netdev(sdata);
923
static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
924
enum nl80211_iftype type)
926
struct ieee80211_local *local = sdata->local;
928
enum nl80211_iftype internal_type = type;
933
if (!local->ops->change_interface)
936
switch (sdata->vif.type) {
937
case NL80211_IFTYPE_AP:
938
case NL80211_IFTYPE_STATION:
939
case NL80211_IFTYPE_ADHOC:
941
* Could maybe also all others here?
942
* Just not sure how that interacts
943
* with the RX/config path e.g. for
952
case NL80211_IFTYPE_AP:
953
case NL80211_IFTYPE_STATION:
954
case NL80211_IFTYPE_ADHOC:
956
* Could probably support everything
957
* but WDS here (WDS do_open can fail
958
* under memory pressure, which this
959
* code isn't prepared to handle).
962
case NL80211_IFTYPE_P2P_CLIENT:
964
internal_type = NL80211_IFTYPE_STATION;
966
case NL80211_IFTYPE_P2P_GO:
968
internal_type = NL80211_IFTYPE_AP;
974
ret = ieee80211_check_concurrent_iface(sdata, internal_type);
978
ieee80211_do_stop(sdata, false);
980
ieee80211_teardown_sdata(sdata->dev);
982
ret = drv_change_interface(local, sdata, internal_type, p2p);
984
type = sdata->vif.type;
986
ieee80211_setup_sdata(sdata, type);
988
err = ieee80211_do_open(sdata->dev, false);
989
WARN(err, "type change: do_open returned %d", err);
994
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
995
enum nl80211_iftype type)
1001
if (type == ieee80211_vif_type_p2p(&sdata->vif))
1004
/* Setting ad-hoc mode on non-IBSS channel is not supported. */
1005
if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS &&
1006
type == NL80211_IFTYPE_ADHOC)
1009
if (ieee80211_sdata_running(sdata)) {
1010
ret = ieee80211_runtime_change_iftype(sdata, type);
1014
/* Purge and reset type-dependent state. */
1015
ieee80211_teardown_sdata(sdata->dev);
1016
ieee80211_setup_sdata(sdata, type);
1019
/* reset some values that shouldn't be kept across type changes */
1020
sdata->vif.bss_conf.basic_rates =
1021
ieee80211_mandatory_rates(sdata->local,
1022
sdata->local->hw.conf.channel->band);
1023
sdata->drop_unencrypted = 0;
1024
if (type == NL80211_IFTYPE_STATION)
1025
sdata->u.mgd.use_4addr = false;
1030
static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
1031
struct net_device *dev,
1032
enum nl80211_iftype type)
1034
struct ieee80211_sub_if_data *sdata;
1035
u64 mask, start, addr, val, inc;
1037
u8 tmp_addr[ETH_ALEN];
1040
/* default ... something at least */
1041
memcpy(dev->perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
1043
if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
1044
local->hw.wiphy->n_addresses <= 1)
1048
mutex_lock(&local->iflist_mtx);
1051
case NL80211_IFTYPE_MONITOR:
1052
/* doesn't matter */
1054
case NL80211_IFTYPE_WDS:
1055
case NL80211_IFTYPE_AP_VLAN:
1056
/* match up with an AP interface */
1057
list_for_each_entry(sdata, &local->interfaces, list) {
1058
if (sdata->vif.type != NL80211_IFTYPE_AP)
1060
memcpy(dev->perm_addr, sdata->vif.addr, ETH_ALEN);
1063
/* keep default if no AP interface present */
1066
/* assign a new address if possible -- try n_addresses first */
1067
for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
1070
list_for_each_entry(sdata, &local->interfaces, list) {
1071
if (memcmp(local->hw.wiphy->addresses[i].addr,
1072
sdata->vif.addr, ETH_ALEN) == 0) {
1079
memcpy(dev->perm_addr,
1080
local->hw.wiphy->addresses[i].addr,
1086
/* try mask if available */
1087
if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
1090
m = local->hw.wiphy->addr_mask;
1091
mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1092
((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1093
((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1095
if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
1096
/* not a contiguous mask ... not handled now! */
1097
printk(KERN_DEBUG "not contiguous\n");
1101
m = local->hw.wiphy->perm_addr;
1102
start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1103
((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1104
((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1106
inc = 1ULL<<__ffs64(mask);
1107
val = (start & mask);
1108
addr = (start & ~mask) | (val & mask);
1112
tmp_addr[5] = addr >> 0*8;
1113
tmp_addr[4] = addr >> 1*8;
1114
tmp_addr[3] = addr >> 2*8;
1115
tmp_addr[2] = addr >> 3*8;
1116
tmp_addr[1] = addr >> 4*8;
1117
tmp_addr[0] = addr >> 5*8;
1121
list_for_each_entry(sdata, &local->interfaces, list) {
1122
if (memcmp(tmp_addr, sdata->vif.addr,
1130
memcpy(dev->perm_addr, tmp_addr, ETH_ALEN);
1133
addr = (start & ~mask) | (val & mask);
1134
} while (addr != start);
1139
mutex_unlock(&local->iflist_mtx);
1142
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
1143
struct net_device **new_dev, enum nl80211_iftype type,
1144
struct vif_params *params)
1146
struct net_device *ndev;
1147
struct ieee80211_sub_if_data *sdata = NULL;
1152
ndev = alloc_netdev_mqs(sizeof(*sdata) + local->hw.vif_data_size,
1153
name, ieee80211_if_setup, local->hw.queues, 1);
1156
dev_net_set(ndev, wiphy_net(local->hw.wiphy));
1158
/* This is an optimization, just ignore for older kernels */
1159
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
1160
ndev->needed_headroom = local->tx_headroom +
1161
4*6 /* four MAC addresses */
1162
+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
1164
+ 8 /* rfc1042/bridge tunnel */
1165
- ETH_HLEN /* ethernet hard_header_len */
1166
+ IEEE80211_ENCRYPT_HEADROOM;
1167
ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
1170
ret = dev_alloc_name(ndev, ndev->name);
1174
ieee80211_assign_perm_addr(local, ndev, type);
1175
memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
1176
SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
1178
/* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
1179
sdata = netdev_priv(ndev);
1180
ndev->ieee80211_ptr = &sdata->wdev;
1181
memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
1182
memcpy(sdata->name, ndev->name, IFNAMSIZ);
1184
/* initialise type-independent data */
1185
sdata->wdev.wiphy = local->hw.wiphy;
1186
sdata->local = local;
1189
sdata->arp_filter_state = true;
1192
for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
1193
skb_queue_head_init(&sdata->fragments[i].skb_list);
1195
INIT_LIST_HEAD(&sdata->key_list);
1197
for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
1198
struct ieee80211_supported_band *sband;
1199
sband = local->hw.wiphy->bands[i];
1200
sdata->rc_rateidx_mask[i] =
1201
sband ? (1 << sband->n_bitrates) - 1 : 0;
1204
/* setup type-dependent data */
1205
ieee80211_setup_sdata(sdata, type);
1208
ndev->ieee80211_ptr->use_4addr = params->use_4addr;
1209
if (type == NL80211_IFTYPE_STATION)
1210
sdata->u.mgd.use_4addr = params->use_4addr;
1213
ret = register_netdevice(ndev);
1217
mutex_lock(&local->iflist_mtx);
1218
list_add_tail_rcu(&sdata->list, &local->interfaces);
1219
mutex_unlock(&local->iflist_mtx);
1231
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
1235
mutex_lock(&sdata->local->iflist_mtx);
1236
list_del_rcu(&sdata->list);
1237
mutex_unlock(&sdata->local->iflist_mtx);
1239
if (ieee80211_vif_is_mesh(&sdata->vif))
1240
mesh_path_flush_by_iface(sdata);
1243
unregister_netdevice(sdata->dev);
1247
* Remove all interfaces, may only be called at hardware unregistration
1248
* time because it doesn't do RCU-safe list removals.
1250
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
1251
void ieee80211_remove_interfaces(struct ieee80211_local *local)
1253
struct ieee80211_sub_if_data *sdata, *tmp;
1254
LIST_HEAD(unreg_list);
1258
mutex_lock(&local->iflist_mtx);
1259
list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
1260
list_del(&sdata->list);
1262
if (ieee80211_vif_is_mesh(&sdata->vif))
1263
mesh_path_flush_by_iface(sdata);
1265
unregister_netdevice_queue(sdata->dev, &unreg_list);
1267
mutex_unlock(&local->iflist_mtx);
1268
unregister_netdevice_many(&unreg_list);
1269
list_del(&unreg_list);
1272
void ieee80211_remove_interfaces(struct ieee80211_local *local)
1274
struct ieee80211_sub_if_data *sdata, *tmp;
1278
list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
1279
mutex_lock(&local->iflist_mtx);
1280
list_del(&sdata->list);
1281
mutex_unlock(&local->iflist_mtx);
1283
unregister_netdevice(sdata->dev);
1288
static u32 ieee80211_idle_off(struct ieee80211_local *local,
1291
if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
1294
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1295
wiphy_debug(local->hw.wiphy, "device no longer idle - %s\n", reason);
1298
local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
1299
return IEEE80211_CONF_CHANGE_IDLE;
1302
static u32 ieee80211_idle_on(struct ieee80211_local *local)
1304
if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
1307
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1308
wiphy_debug(local->hw.wiphy, "device now idle\n");
1311
drv_flush(local, false);
1313
local->hw.conf.flags |= IEEE80211_CONF_IDLE;
1314
return IEEE80211_CONF_CHANGE_IDLE;
1317
u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
1319
struct ieee80211_sub_if_data *sdata;
1321
bool working = false, scanning = false, hw_roc = false;
1322
struct ieee80211_work *wk;
1323
unsigned int led_trig_start = 0, led_trig_stop = 0;
1325
#ifdef CONFIG_PROVE_LOCKING
1326
WARN_ON(debug_locks && !lockdep_rtnl_is_held() &&
1327
!lockdep_is_held(&local->iflist_mtx));
1329
lockdep_assert_held(&local->mtx);
1331
list_for_each_entry(sdata, &local->interfaces, list) {
1332
if (!ieee80211_sdata_running(sdata)) {
1333
sdata->vif.bss_conf.idle = true;
1337
sdata->old_idle = sdata->vif.bss_conf.idle;
1339
/* do not count disabled managed interfaces */
1340
if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1341
!sdata->u.mgd.associated) {
1342
sdata->vif.bss_conf.idle = true;
1345
/* do not count unused IBSS interfaces */
1346
if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
1347
!sdata->u.ibss.ssid_len) {
1348
sdata->vif.bss_conf.idle = true;
1351
/* count everything else */
1355
list_for_each_entry(wk, &local->work_list, list) {
1357
wk->sdata->vif.bss_conf.idle = false;
1360
if (local->scan_sdata) {
1362
local->scan_sdata->vif.bss_conf.idle = false;
1365
if (local->hw_roc_channel)
1368
list_for_each_entry(sdata, &local->interfaces, list) {
1369
if (sdata->old_idle == sdata->vif.bss_conf.idle)
1371
if (!ieee80211_sdata_running(sdata))
1373
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_IDLE);
1376
if (working || scanning || hw_roc)
1377
led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
1379
led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
1382
led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
1384
led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
1386
ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
1389
return ieee80211_idle_off(local, "hw remain-on-channel");
1391
return ieee80211_idle_off(local, "working");
1393
return ieee80211_idle_off(local, "scanning");
1395
return ieee80211_idle_on(local);
1397
return ieee80211_idle_off(local, "in use");
1402
void ieee80211_recalc_idle(struct ieee80211_local *local)
1406
mutex_lock(&local->iflist_mtx);
1407
chg = __ieee80211_recalc_idle(local);
1408
mutex_unlock(&local->iflist_mtx);
1410
ieee80211_hw_config(local, chg);
1413
static int netdev_notify(struct notifier_block *nb,
1414
unsigned long state,
1417
struct net_device *dev = ndev;
1418
struct ieee80211_sub_if_data *sdata;
1420
if (state != NETDEV_CHANGENAME)
1423
if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
1426
if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
1429
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1431
memcpy(sdata->name, dev->name, IFNAMSIZ);
1433
ieee80211_debugfs_rename_netdev(sdata);
1437
static struct notifier_block mac80211_netdev_notifier = {
1438
.notifier_call = netdev_notify,
1441
int ieee80211_iface_init(void)
1443
return register_netdevice_notifier(&mac80211_netdev_notifier);
1446
void ieee80211_iface_exit(void)
1448
unregister_netdevice_notifier(&mac80211_netdev_notifier);