blob: 3d3a094d398718905728852e77fefdc09bd4d991 [file] [log] [blame]
Jiri Bencf0706e82007-05-05 11:45:53 -07001/*
Johannes Berg0d143fe2008-09-11 00:01:59 +02002 * Interface handling (except master interface)
3 *
Jiri Bencf0706e82007-05-05 11:45:53 -07004 * Copyright 2002-2005, Instant802 Networks, Inc.
5 * Copyright 2005-2006, Devicescape Software, Inc.
6 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
Johannes Berg75636522008-07-09 14:40:35 +02007 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
Jiri Bencf0706e82007-05-05 11:45:53 -07008 *
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 */
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090013#include <linux/slab.h>
Jiri Bencf0706e82007-05-05 11:45:53 -070014#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>
Johannes Bergcf0277e2010-01-05 18:00:58 +010019#include <net/ieee80211_radiotap.h>
Jiri Bencf0706e82007-05-05 11:45:53 -070020#include "ieee80211_i.h"
21#include "sta_info.h"
Jiri Bence9f207f2007-05-05 11:46:38 -070022#include "debugfs_netdev.h"
Luis Carlos Coboee385852008-02-23 15:17:11 +010023#include "mesh.h"
Johannes Berg0d143fe2008-09-11 00:01:59 +020024#include "led.h"
Johannes Berg24487982009-04-23 18:52:52 +020025#include "driver-ops.h"
Johannes Bergcf0277e2010-01-05 18:00:58 +010026#include "wme.h"
Jiri Bencf0706e82007-05-05 11:45:53 -070027
Johannes Bergc771c9d2009-01-23 22:54:03 +010028/**
29 * DOC: Interface list locking
30 *
31 * The interface list in each struct ieee80211_local is protected
32 * three-fold:
33 *
34 * (1) modifications may only be done under the RTNL
35 * (2) modifications and readers are protected against each other by
36 * the iflist_mtx.
37 * (3) modifications are done in an RCU manner so atomic readers
38 * can traverse the list in RCU-safe blocks.
39 *
40 * As a consequence, reads (traversals) of the list can be protected
41 * by either the RTNL, the iflist_mtx or RCU.
42 */
43
44
Johannes Berg0d143fe2008-09-11 00:01:59 +020045static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
46{
47 int meshhdrlen;
48 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
49
50 meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;
51
52 /* FIX: what would be proper limits for MTU?
53 * This interface uses 802.3 frames. */
54 if (new_mtu < 256 ||
55 new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {
56 return -EINVAL;
57 }
58
59#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
60 printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu);
61#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
62 dev->mtu = new_mtu;
63 return 0;
64}
65
Johannes Berg47846c92009-11-25 17:46:19 +010066static int ieee80211_change_mac(struct net_device *dev, void *addr)
67{
68 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Kalle Valofc5f7572009-12-30 15:54:03 +020069 struct sockaddr *sa = addr;
Johannes Berg47846c92009-11-25 17:46:19 +010070 int ret;
71
Johannes Berg9607e6b2009-12-23 13:15:31 +010072 if (ieee80211_sdata_running(sdata))
Johannes Berg47846c92009-11-25 17:46:19 +010073 return -EBUSY;
74
Kalle Valofc5f7572009-12-30 15:54:03 +020075 ret = eth_mac_addr(dev, sa);
Johannes Berg47846c92009-11-25 17:46:19 +010076
77 if (ret == 0)
Kalle Valofc5f7572009-12-30 15:54:03 +020078 memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +010079
80 return ret;
81}
82
Johannes Berg0d143fe2008-09-11 00:01:59 +020083static inline int identical_mac_addr_allowed(int type1, int type2)
84{
85 return type1 == NL80211_IFTYPE_MONITOR ||
86 type2 == NL80211_IFTYPE_MONITOR ||
87 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
88 (type1 == NL80211_IFTYPE_WDS &&
89 (type2 == NL80211_IFTYPE_WDS ||
90 type2 == NL80211_IFTYPE_AP)) ||
91 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
92 (type1 == NL80211_IFTYPE_AP_VLAN &&
93 (type2 == NL80211_IFTYPE_AP ||
94 type2 == NL80211_IFTYPE_AP_VLAN));
95}
96
97static int ieee80211_open(struct net_device *dev)
98{
Johannes Bergb4a4bf52008-09-26 13:34:54 +020099 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
100 struct ieee80211_sub_if_data *nsdata;
101 struct ieee80211_local *local = sdata->local;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200102 struct sta_info *sta;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200103 u32 changed = 0;
104 int res;
Johannes Berge8975582008-10-09 12:18:51 +0200105 u32 hw_reconf_flags = 0;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200106 u8 null_addr[ETH_ALEN] = {0};
107
Johannes Berg0d143fe2008-09-11 00:01:59 +0200108 /* fail early if user set an invalid address */
109 if (compare_ether_addr(dev->dev_addr, null_addr) &&
110 !is_valid_ether_addr(dev->dev_addr))
111 return -EADDRNOTAVAIL;
112
113 /* we hold the RTNL here so can safely walk the list */
114 list_for_each_entry(nsdata, &local->interfaces, list) {
115 struct net_device *ndev = nsdata->dev;
116
Johannes Berg9607e6b2009-12-23 13:15:31 +0100117 if (ndev != dev && ieee80211_sdata_running(nsdata)) {
Johannes Berg0d143fe2008-09-11 00:01:59 +0200118 /*
119 * Allow only a single IBSS interface to be up at any
120 * time. This is restricted because beacon distribution
121 * cannot work properly if both are in the same IBSS.
122 *
123 * To remove this restriction we'd have to disallow them
124 * from setting the same SSID on different IBSS interfaces
125 * belonging to the same hardware. Then, however, we're
126 * faced with having to adopt two different TSF timers...
127 */
128 if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
129 nsdata->vif.type == NL80211_IFTYPE_ADHOC)
130 return -EBUSY;
131
132 /*
133 * The remaining checks are only performed for interfaces
134 * with the same MAC address.
135 */
136 if (compare_ether_addr(dev->dev_addr, ndev->dev_addr))
137 continue;
138
139 /*
140 * check whether it may have the same address
141 */
142 if (!identical_mac_addr_allowed(sdata->vif.type,
143 nsdata->vif.type))
144 return -ENOTUNIQ;
145
146 /*
147 * can only add VLANs to enabled APs
148 */
149 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
150 nsdata->vif.type == NL80211_IFTYPE_AP)
151 sdata->bss = &nsdata->u.ap;
152 }
153 }
154
155 switch (sdata->vif.type) {
156 case NL80211_IFTYPE_WDS:
157 if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
158 return -ENOLINK;
159 break;
160 case NL80211_IFTYPE_AP_VLAN:
161 if (!sdata->bss)
162 return -ENOLINK;
163 list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
164 break;
165 case NL80211_IFTYPE_AP:
166 sdata->bss = &sdata->u.ap;
167 break;
168 case NL80211_IFTYPE_MESH_POINT:
169 if (!ieee80211_vif_is_mesh(&sdata->vif))
170 break;
171 /* mesh ifaces must set allmulti to forward mcast traffic */
172 atomic_inc(&local->iff_allmultis);
173 break;
174 case NL80211_IFTYPE_STATION:
175 case NL80211_IFTYPE_MONITOR:
176 case NL80211_IFTYPE_ADHOC:
177 /* no special treatment */
178 break;
179 case NL80211_IFTYPE_UNSPECIFIED:
180 case __NL80211_IFTYPE_AFTER_LAST:
181 /* cannot happen */
182 WARN_ON(1);
183 break;
184 }
185
186 if (local->open_count == 0) {
Johannes Berg24487982009-04-23 18:52:52 +0200187 res = drv_start(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200188 if (res)
189 goto err_del_bss;
Johannes Berge8975582008-10-09 12:18:51 +0200190 /* we're brought up, everything changes */
191 hw_reconf_flags = ~0;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200192 ieee80211_led_radio(local, true);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200193 }
194
195 /*
196 * Check all interfaces and copy the hopefully now-present
197 * MAC address to those that have the special null one.
198 */
199 list_for_each_entry(nsdata, &local->interfaces, list) {
200 struct net_device *ndev = nsdata->dev;
201
202 /*
Johannes Berg9607e6b2009-12-23 13:15:31 +0100203 * No need to check running since we do not allow
Johannes Berg0d143fe2008-09-11 00:01:59 +0200204 * it to start up with this invalid address.
205 */
John W. Linville0adc23f2009-10-06 16:27:18 -0400206 if (compare_ether_addr(null_addr, ndev->dev_addr) == 0) {
Johannes Berg0d143fe2008-09-11 00:01:59 +0200207 memcpy(ndev->dev_addr,
208 local->hw.wiphy->perm_addr,
209 ETH_ALEN);
John W. Linville0adc23f2009-10-06 16:27:18 -0400210 memcpy(ndev->perm_addr, ndev->dev_addr, ETH_ALEN);
211 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200212 }
213
Johannes Berg0d143fe2008-09-11 00:01:59 +0200214 /*
215 * Validate the MAC address for this device.
216 */
217 if (!is_valid_ether_addr(dev->dev_addr)) {
Johannes Berg24487982009-04-23 18:52:52 +0200218 if (!local->open_count)
219 drv_stop(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200220 return -EADDRNOTAVAIL;
221 }
222
223 switch (sdata->vif.type) {
224 case NL80211_IFTYPE_AP_VLAN:
225 /* no need to tell driver */
226 break;
227 case NL80211_IFTYPE_MONITOR:
228 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
229 local->cooked_mntrs++;
230 break;
231 }
232
233 /* must be before the call to ieee80211_configure_filter */
234 local->monitors++;
Johannes Berge8975582008-10-09 12:18:51 +0200235 if (local->monitors == 1) {
Johannes Berg0869aea2009-10-28 10:03:35 +0100236 local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
237 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
Johannes Berge8975582008-10-09 12:18:51 +0200238 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200239
240 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
241 local->fif_fcsfail++;
242 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL)
243 local->fif_plcpfail++;
Igor Perminove3b90ca2009-08-04 16:48:51 +0400244 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) {
Johannes Berg0d143fe2008-09-11 00:01:59 +0200245 local->fif_control++;
Igor Perminove3b90ca2009-08-04 16:48:51 +0400246 local->fif_pspoll++;
247 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200248 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS)
249 local->fif_other_bss++;
250
Johannes Berg0d143fe2008-09-11 00:01:59 +0200251 ieee80211_configure_filter(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200252 break;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200253 default:
Johannes Berg1ed32e42009-12-23 13:15:45 +0100254 res = drv_add_interface(local, &sdata->vif);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200255 if (res)
256 goto err_stop;
257
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700258 if (ieee80211_vif_is_mesh(&sdata->vif)) {
259 local->fif_other_bss++;
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700260 ieee80211_configure_filter(local);
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700261
Johannes Berg0d143fe2008-09-11 00:01:59 +0200262 ieee80211_start_mesh(sdata);
Igor Perminove3b90ca2009-08-04 16:48:51 +0400263 } else if (sdata->vif.type == NL80211_IFTYPE_AP) {
264 local->fif_pspoll++;
265
Igor Perminove3b90ca2009-08-04 16:48:51 +0400266 ieee80211_configure_filter(local);
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700267 }
Igor Perminove3b90ca2009-08-04 16:48:51 +0400268
Johannes Berg0d143fe2008-09-11 00:01:59 +0200269 changed |= ieee80211_reset_erp_info(sdata);
270 ieee80211_bss_info_change_notify(sdata, changed);
271 ieee80211_enable_keys(sdata);
272
Johannes Berg7986cf92009-03-21 17:08:43 +0100273 if (sdata->vif.type == NL80211_IFTYPE_STATION)
Johannes Berg0d143fe2008-09-11 00:01:59 +0200274 netif_carrier_off(dev);
275 else
276 netif_carrier_on(dev);
277 }
278
279 if (sdata->vif.type == NL80211_IFTYPE_WDS) {
280 /* Create STA entry for the WDS peer */
281 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
282 GFP_KERNEL);
283 if (!sta) {
284 res = -ENOMEM;
285 goto err_del_interface;
286 }
287
288 /* no locking required since STA is not live yet */
289 sta->flags |= WLAN_STA_AUTHORIZED;
290
291 res = sta_info_insert(sta);
292 if (res) {
293 /* STA has been freed */
294 goto err_del_interface;
295 }
296 }
297
Johannes Berg0d143fe2008-09-11 00:01:59 +0200298 /*
299 * set_multicast_list will be invoked by the networking core
300 * which will check whether any increments here were done in
301 * error and sync them down to the hardware as filter flags.
302 */
303 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
304 atomic_inc(&local->iff_allmultis);
305
306 if (sdata->flags & IEEE80211_SDATA_PROMISC)
307 atomic_inc(&local->iff_promiscs);
308
Johannes Berg5cff20e2009-04-29 12:26:17 +0200309 hw_reconf_flags |= __ieee80211_recalc_idle(local);
310
Johannes Berg0d143fe2008-09-11 00:01:59 +0200311 local->open_count++;
Johannes Berge8975582008-10-09 12:18:51 +0200312 if (hw_reconf_flags) {
313 ieee80211_hw_config(local, hw_reconf_flags);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200314 /*
315 * set default queue parameters so drivers don't
316 * need to initialise the hardware if the hardware
317 * doesn't start up with sane defaults
318 */
319 ieee80211_set_wmm_default(sdata);
320 }
321
Johannes Berg10f644a2009-04-16 13:17:25 +0200322 ieee80211_recalc_ps(local, -1);
Johannes Berg965beda2009-04-16 13:17:24 +0200323
John W. Linville8a5b33f2010-01-06 15:39:39 -0500324 netif_tx_start_all_queues(dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200325
326 return 0;
327 err_del_interface:
Johannes Berg1ed32e42009-12-23 13:15:45 +0100328 drv_remove_interface(local, &sdata->vif);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200329 err_stop:
Johannes Berg24487982009-04-23 18:52:52 +0200330 if (!local->open_count)
331 drv_stop(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200332 err_del_bss:
333 sdata->bss = NULL;
334 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
335 list_del(&sdata->u.vlan.list);
336 return res;
337}
338
339static int ieee80211_stop(struct net_device *dev)
340{
341 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
342 struct ieee80211_local *local = sdata->local;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200343 struct sta_info *sta;
Johannes Berg5061b0c2009-07-14 00:33:34 +0200344 unsigned long flags;
345 struct sk_buff *skb, *tmp;
Johannes Berge8975582008-10-09 12:18:51 +0200346 u32 hw_reconf_flags = 0;
Johannes Berg5061b0c2009-07-14 00:33:34 +0200347 int i;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200348
349 /*
350 * Stop TX on this interface first.
351 */
John W. Linville8a5b33f2010-01-06 15:39:39 -0500352 netif_tx_stop_all_queues(dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200353
354 /*
Johannes Bergaf6b6372009-12-23 13:15:35 +0100355 * Purge work for this interface.
356 */
357 ieee80211_work_purge(sdata);
358
359 /*
Johannes Berg0d143fe2008-09-11 00:01:59 +0200360 * Now delete all active aggregation sessions.
361 */
362 rcu_read_lock();
363
364 list_for_each_entry_rcu(sta, &local->sta_list, list) {
365 if (sta->sdata == sdata)
Johannes Berg2dace102009-02-10 21:25:52 +0100366 ieee80211_sta_tear_down_BA_sessions(sta);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200367 }
368
369 rcu_read_unlock();
370
371 /*
372 * Remove all stations associated with this interface.
373 *
374 * This must be done before calling ops->remove_interface()
375 * because otherwise we can later invoke ops->sta_notify()
376 * whenever the STAs are removed, and that invalidates driver
377 * assumptions about always getting a vif pointer that is valid
378 * (because if we remove a STA after ops->remove_interface()
379 * the driver will have removed the vif info already!)
380 *
381 * We could relax this and only unlink the stations from the
382 * hash table and list but keep them on a per-sdata list that
383 * will be inserted back again when the interface is brought
384 * up again, but I don't currently see a use case for that,
385 * except with WDS which gets a STA entry created when it is
386 * brought up.
387 */
388 sta_info_flush(local, sdata);
389
390 /*
391 * Don't count this interface for promisc/allmulti while it
392 * is down. dev_mc_unsync() will invoke set_multicast_list
393 * on the master interface which will sync these down to the
394 * hardware as filter flags.
395 */
396 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
397 atomic_dec(&local->iff_allmultis);
398
399 if (sdata->flags & IEEE80211_SDATA_PROMISC)
400 atomic_dec(&local->iff_promiscs);
401
Igor Perminove3b90ca2009-08-04 16:48:51 +0400402 if (sdata->vif.type == NL80211_IFTYPE_AP)
403 local->fif_pspoll--;
404
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200405 netif_addr_lock_bh(dev);
406 spin_lock_bh(&local->filter_lock);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000407 __hw_addr_unsync(&local->mc_list, &dev->mc, dev->addr_len);
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200408 spin_unlock_bh(&local->filter_lock);
409 netif_addr_unlock_bh(dev);
410
Johannes Berg3ac64be2009-08-17 16:16:53 +0200411 ieee80211_configure_filter(local);
412
Vivek Natarajan7cbf0ba2008-12-24 00:34:37 -0800413 del_timer_sync(&local->dynamic_ps_timer);
414 cancel_work_sync(&local->dynamic_ps_enable_work);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200415
416 /* APs need special treatment */
417 if (sdata->vif.type == NL80211_IFTYPE_AP) {
Johannes Berg57c9fff2009-07-29 15:46:21 +0200418 struct ieee80211_sub_if_data *vlan, *tmpsdata;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200419 struct beacon_data *old_beacon = sdata->u.ap.beacon;
420
421 /* remove beacon */
422 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
423 synchronize_rcu();
424 kfree(old_beacon);
425
426 /* down all dependent devices, that is VLANs */
Johannes Berg57c9fff2009-07-29 15:46:21 +0200427 list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
Johannes Berg0d143fe2008-09-11 00:01:59 +0200428 u.vlan.list)
429 dev_close(vlan->dev);
430 WARN_ON(!list_empty(&sdata->u.ap.vlans));
431 }
432
433 local->open_count--;
434
435 switch (sdata->vif.type) {
436 case NL80211_IFTYPE_AP_VLAN:
437 list_del(&sdata->u.vlan.list);
438 /* no need to tell driver */
439 break;
440 case NL80211_IFTYPE_MONITOR:
441 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
442 local->cooked_mntrs--;
443 break;
444 }
445
446 local->monitors--;
Johannes Berge8975582008-10-09 12:18:51 +0200447 if (local->monitors == 0) {
Johannes Berg0869aea2009-10-28 10:03:35 +0100448 local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
449 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
Johannes Berge8975582008-10-09 12:18:51 +0200450 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200451
452 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
453 local->fif_fcsfail--;
454 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL)
455 local->fif_plcpfail--;
Igor Perminove3b90ca2009-08-04 16:48:51 +0400456 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) {
457 local->fif_pspoll--;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200458 local->fif_control--;
Igor Perminove3b90ca2009-08-04 16:48:51 +0400459 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200460 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS)
461 local->fif_other_bss--;
462
Johannes Berg0d143fe2008-09-11 00:01:59 +0200463 ieee80211_configure_filter(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200464 break;
465 case NL80211_IFTYPE_STATION:
Johannes Berg46900292009-02-15 12:44:28 +0100466 del_timer_sync(&sdata->u.mgd.chswitch_timer);
467 del_timer_sync(&sdata->u.mgd.timer);
Johannes Berg0e2b6282009-07-13 13:23:39 +0200468 del_timer_sync(&sdata->u.mgd.conn_mon_timer);
469 del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200470 /*
Johannes Berg0e2b6282009-07-13 13:23:39 +0200471 * If any of the timers fired while we waited for it, it will
472 * have queued its work. Now the work will be running again
Johannes Berg0d143fe2008-09-11 00:01:59 +0200473 * but will not rearm the timer again because it checks
474 * whether the interface is running, which, at this point,
475 * it no longer is.
476 */
Johannes Berg46900292009-02-15 12:44:28 +0100477 cancel_work_sync(&sdata->u.mgd.work);
478 cancel_work_sync(&sdata->u.mgd.chswitch_work);
Johannes Berg0e2b6282009-07-13 13:23:39 +0200479 cancel_work_sync(&sdata->u.mgd.monitor_work);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +0200480 cancel_work_sync(&sdata->u.mgd.beacon_connection_loss_work);
Kalle Valo04de8382009-03-22 21:57:35 +0200481
Johannes Berg0d143fe2008-09-11 00:01:59 +0200482 /*
483 * When we get here, the interface is marked down.
484 * Call synchronize_rcu() to wait for the RX path
485 * should it be using the interface and enqueuing
486 * frames at this very time on another CPU.
487 */
488 synchronize_rcu();
Johannes Berg46900292009-02-15 12:44:28 +0100489 skb_queue_purge(&sdata->u.mgd.skb_queue);
Johannes Berg46900292009-02-15 12:44:28 +0100490 /* fall through */
491 case NL80211_IFTYPE_ADHOC:
492 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
Johannes Berg46900292009-02-15 12:44:28 +0100493 del_timer_sync(&sdata->u.ibss.timer);
494 cancel_work_sync(&sdata->u.ibss.work);
495 synchronize_rcu();
496 skb_queue_purge(&sdata->u.ibss.skb_queue);
497 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200498 /* fall through */
499 case NL80211_IFTYPE_MESH_POINT:
500 if (ieee80211_vif_is_mesh(&sdata->vif)) {
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700501 /* other_bss and allmulti are always set on mesh
502 * ifaces */
503 local->fif_other_bss--;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200504 atomic_dec(&local->iff_allmultis);
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700505
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700506 ieee80211_configure_filter(local);
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700507
Johannes Berg0d143fe2008-09-11 00:01:59 +0200508 ieee80211_stop_mesh(sdata);
509 }
510 /* fall through */
511 default:
Johannes Berg15db0b72009-08-25 16:33:47 +0200512 if (local->scan_sdata == sdata)
513 ieee80211_scan_cancel(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200514
Bob Copeland97af7432009-07-29 10:13:03 +0200515 /*
516 * Disable beaconing for AP and mesh, IBSS can't
517 * still be joined to a network at this point.
518 */
519 if (sdata->vif.type == NL80211_IFTYPE_AP ||
520 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
521 ieee80211_bss_info_change_notify(sdata,
522 BSS_CHANGED_BEACON_ENABLED);
523 }
524
Johannes Berg0d143fe2008-09-11 00:01:59 +0200525 /* disable all keys for as long as this netdev is down */
526 ieee80211_disable_keys(sdata);
Johannes Berg1ed32e42009-12-23 13:15:45 +0100527 drv_remove_interface(local, &sdata->vif);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200528 }
529
530 sdata->bss = NULL;
531
Johannes Berg5cff20e2009-04-29 12:26:17 +0200532 hw_reconf_flags |= __ieee80211_recalc_idle(local);
533
534 ieee80211_recalc_ps(local, -1);
535
Johannes Berg0d143fe2008-09-11 00:01:59 +0200536 if (local->open_count == 0) {
Johannes Bergea77f122009-08-21 14:44:45 +0200537 ieee80211_clear_tx_pending(local);
Johannes Berg84f6a012009-08-20 20:02:20 +0200538 ieee80211_stop_device(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200539
Johannes Berge8975582008-10-09 12:18:51 +0200540 /* no reconfiguring after stop! */
541 hw_reconf_flags = 0;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200542 }
543
Johannes Berge8975582008-10-09 12:18:51 +0200544 /* do after stop to avoid reconfiguring when we stop anyway */
545 if (hw_reconf_flags)
546 ieee80211_hw_config(local, hw_reconf_flags);
547
Johannes Berg5061b0c2009-07-14 00:33:34 +0200548 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
549 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
550 skb_queue_walk_safe(&local->pending[i], skb, tmp) {
551 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
552 if (info->control.vif == &sdata->vif) {
553 __skb_unlink(skb, &local->pending[i]);
554 dev_kfree_skb_irq(skb);
555 }
556 }
557 }
558 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
559
Johannes Berg0d143fe2008-09-11 00:01:59 +0200560 return 0;
561}
562
563static void ieee80211_set_multicast_list(struct net_device *dev)
564{
Johannes Berg0d143fe2008-09-11 00:01:59 +0200565 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Bergb4a4bf52008-09-26 13:34:54 +0200566 struct ieee80211_local *local = sdata->local;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200567 int allmulti, promisc, sdata_allmulti, sdata_promisc;
568
569 allmulti = !!(dev->flags & IFF_ALLMULTI);
570 promisc = !!(dev->flags & IFF_PROMISC);
571 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
572 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
573
574 if (allmulti != sdata_allmulti) {
575 if (dev->flags & IFF_ALLMULTI)
576 atomic_inc(&local->iff_allmultis);
577 else
578 atomic_dec(&local->iff_allmultis);
579 sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
580 }
581
582 if (promisc != sdata_promisc) {
583 if (dev->flags & IFF_PROMISC)
584 atomic_inc(&local->iff_promiscs);
585 else
586 atomic_dec(&local->iff_promiscs);
587 sdata->flags ^= IEEE80211_SDATA_PROMISC;
588 }
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200589 spin_lock_bh(&local->filter_lock);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000590 __hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200591 spin_unlock_bh(&local->filter_lock);
Johannes Berg3ac64be2009-08-17 16:16:53 +0200592 ieee80211_queue_work(&local->hw, &local->reconfig_filter);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200593}
594
Johannes Berg75636522008-07-09 14:40:35 +0200595/*
596 * Called when the netdev is removed or, by the code below, before
597 * the interface type changes.
598 */
599static void ieee80211_teardown_sdata(struct net_device *dev)
Jiri Bencf0706e82007-05-05 11:45:53 -0700600{
Johannes Berg75636522008-07-09 14:40:35 +0200601 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
602 struct ieee80211_local *local = sdata->local;
603 struct beacon_data *beacon;
604 struct sk_buff *skb;
605 int flushed;
Jiri Bencf0706e82007-05-05 11:45:53 -0700606 int i;
607
Johannes Berg75636522008-07-09 14:40:35 +0200608 /* free extra data */
609 ieee80211_free_keys(sdata);
Jiri Bencf0706e82007-05-05 11:45:53 -0700610
Jouni Malinenaee14ce2008-09-09 16:33:15 +0200611 ieee80211_debugfs_remove_netdev(sdata);
612
Johannes Berg988c0f72008-04-17 19:21:22 +0200613 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
Jiri Bencf0706e82007-05-05 11:45:53 -0700614 __skb_queue_purge(&sdata->fragments[i].skb_list);
Johannes Berg75636522008-07-09 14:40:35 +0200615 sdata->fragment_next = 0;
616
617 switch (sdata->vif.type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200618 case NL80211_IFTYPE_AP:
Johannes Berg75636522008-07-09 14:40:35 +0200619 beacon = sdata->u.ap.beacon;
620 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
621 synchronize_rcu();
622 kfree(beacon);
623
624 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {
625 local->total_ps_buffered--;
626 dev_kfree_skb(skb);
627 }
628
629 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200630 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg75636522008-07-09 14:40:35 +0200631 if (ieee80211_vif_is_mesh(&sdata->vif))
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200632 mesh_rmc_free(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200633 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200634 case NL80211_IFTYPE_ADHOC:
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200635 if (WARN_ON(sdata->u.ibss.presp))
636 kfree_skb(sdata->u.ibss.presp);
Johannes Berg46900292009-02-15 12:44:28 +0100637 break;
638 case NL80211_IFTYPE_STATION:
Johannes Berg05c914f2008-09-11 00:01:58 +0200639 case NL80211_IFTYPE_WDS:
640 case NL80211_IFTYPE_AP_VLAN:
641 case NL80211_IFTYPE_MONITOR:
Johannes Berg75636522008-07-09 14:40:35 +0200642 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200643 case NL80211_IFTYPE_UNSPECIFIED:
644 case __NL80211_IFTYPE_AFTER_LAST:
Johannes Berg75636522008-07-09 14:40:35 +0200645 BUG();
646 break;
647 }
648
649 flushed = sta_info_flush(local, sdata);
650 WARN_ON(flushed);
Jiri Bencf0706e82007-05-05 11:45:53 -0700651}
652
Johannes Bergcf0277e2010-01-05 18:00:58 +0100653static u16 ieee80211_netdev_select_queue(struct net_device *dev,
654 struct sk_buff *skb)
655{
656 return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
657}
658
Johannes Berg587e7292009-01-30 13:35:22 +0100659static const struct net_device_ops ieee80211_dataif_ops = {
660 .ndo_open = ieee80211_open,
661 .ndo_stop = ieee80211_stop,
662 .ndo_uninit = ieee80211_teardown_sdata,
663 .ndo_start_xmit = ieee80211_subif_start_xmit,
664 .ndo_set_multicast_list = ieee80211_set_multicast_list,
665 .ndo_change_mtu = ieee80211_change_mtu,
Johannes Berg47846c92009-11-25 17:46:19 +0100666 .ndo_set_mac_address = ieee80211_change_mac,
Johannes Bergcf0277e2010-01-05 18:00:58 +0100667 .ndo_select_queue = ieee80211_netdev_select_queue,
Johannes Berg587e7292009-01-30 13:35:22 +0100668};
669
Johannes Bergcf0277e2010-01-05 18:00:58 +0100670static u16 ieee80211_monitor_select_queue(struct net_device *dev,
671 struct sk_buff *skb)
672{
673 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
674 struct ieee80211_local *local = sdata->local;
675 struct ieee80211_hdr *hdr;
676 struct ieee80211_radiotap_header *rtap = (void *)skb->data;
Felix Fietkau193e70e2010-01-11 06:47:00 +0100677 u8 *p;
Johannes Bergcf0277e2010-01-05 18:00:58 +0100678
679 if (local->hw.queues < 4)
680 return 0;
681
682 if (skb->len < 4 ||
Johannes Bergb49bb572010-01-08 19:00:00 +0100683 skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
Johannes Bergcf0277e2010-01-05 18:00:58 +0100684 return 0; /* doesn't matter, frame will be dropped */
685
Johannes Bergb49bb572010-01-08 19:00:00 +0100686 hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
Johannes Bergcf0277e2010-01-05 18:00:58 +0100687
Felix Fietkau861a57c2010-01-12 04:08:26 +0100688 if (!ieee80211_is_data(hdr->frame_control)) {
Johannes Bergcf0277e2010-01-05 18:00:58 +0100689 skb->priority = 7;
690 return ieee802_1d_to_ac[skb->priority];
691 }
Felix Fietkau861a57c2010-01-12 04:08:26 +0100692 if (!ieee80211_is_data_qos(hdr->frame_control)) {
693 skb->priority = 0;
694 return ieee802_1d_to_ac[skb->priority];
695 }
Johannes Bergcf0277e2010-01-05 18:00:58 +0100696
Felix Fietkau193e70e2010-01-11 06:47:00 +0100697 p = ieee80211_get_qos_ctl(hdr);
698 skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK;
699
Johannes Bergcf0277e2010-01-05 18:00:58 +0100700 return ieee80211_downgrade_queue(local, skb);
701}
702
Johannes Berg587e7292009-01-30 13:35:22 +0100703static const struct net_device_ops ieee80211_monitorif_ops = {
704 .ndo_open = ieee80211_open,
705 .ndo_stop = ieee80211_stop,
706 .ndo_uninit = ieee80211_teardown_sdata,
707 .ndo_start_xmit = ieee80211_monitor_start_xmit,
708 .ndo_set_multicast_list = ieee80211_set_multicast_list,
709 .ndo_change_mtu = ieee80211_change_mtu,
710 .ndo_set_mac_address = eth_mac_addr,
Johannes Bergcf0277e2010-01-05 18:00:58 +0100711 .ndo_select_queue = ieee80211_monitor_select_queue,
Johannes Berg587e7292009-01-30 13:35:22 +0100712};
713
714static void ieee80211_if_setup(struct net_device *dev)
715{
716 ether_setup(dev);
717 dev->netdev_ops = &ieee80211_dataif_ops;
Johannes Berg587e7292009-01-30 13:35:22 +0100718 dev->destructor = free_netdev;
719}
720
Johannes Berg75636522008-07-09 14:40:35 +0200721/*
722 * Helper function to initialise an interface to a specific type.
723 */
724static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
Johannes Berg05c914f2008-09-11 00:01:58 +0200725 enum nl80211_iftype type)
Johannes Berg75636522008-07-09 14:40:35 +0200726{
Johannes Berg75636522008-07-09 14:40:35 +0200727 /* clear type-dependent union */
728 memset(&sdata->u, 0, sizeof(sdata->u));
729
730 /* and set some type-dependent values */
731 sdata->vif.type = type;
Johannes Berg587e7292009-01-30 13:35:22 +0100732 sdata->dev->netdev_ops = &ieee80211_dataif_ops;
Johannes Berg60719ff2008-09-16 14:55:09 +0200733 sdata->wdev.iftype = type;
Johannes Berg75636522008-07-09 14:40:35 +0200734
735 /* only monitor differs */
736 sdata->dev->type = ARPHRD_ETHER;
737
738 switch (type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200739 case NL80211_IFTYPE_AP:
Johannes Berg75636522008-07-09 14:40:35 +0200740 skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
741 INIT_LIST_HEAD(&sdata->u.ap.vlans);
742 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200743 case NL80211_IFTYPE_STATION:
Johannes Berg9c6bd792008-09-11 00:01:52 +0200744 ieee80211_sta_setup_sdata(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200745 break;
Johannes Berg46900292009-02-15 12:44:28 +0100746 case NL80211_IFTYPE_ADHOC:
747 ieee80211_ibss_setup_sdata(sdata);
748 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200749 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg75636522008-07-09 14:40:35 +0200750 if (ieee80211_vif_is_mesh(&sdata->vif))
751 ieee80211_mesh_init_sdata(sdata);
752 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200753 case NL80211_IFTYPE_MONITOR:
Johannes Berg75636522008-07-09 14:40:35 +0200754 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
Johannes Berg587e7292009-01-30 13:35:22 +0100755 sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
Johannes Berg75636522008-07-09 14:40:35 +0200756 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
757 MONITOR_FLAG_OTHER_BSS;
758 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200759 case NL80211_IFTYPE_WDS:
760 case NL80211_IFTYPE_AP_VLAN:
Johannes Berg75636522008-07-09 14:40:35 +0200761 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200762 case NL80211_IFTYPE_UNSPECIFIED:
763 case __NL80211_IFTYPE_AFTER_LAST:
Johannes Berg75636522008-07-09 14:40:35 +0200764 BUG();
765 break;
766 }
767
768 ieee80211_debugfs_add_netdev(sdata);
769}
770
Johannes Bergf3947e22008-07-09 14:40:36 +0200771int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
Johannes Berg05c914f2008-09-11 00:01:58 +0200772 enum nl80211_iftype type)
Johannes Berg75636522008-07-09 14:40:35 +0200773{
Johannes Bergf3947e22008-07-09 14:40:36 +0200774 ASSERT_RTNL();
775
776 if (type == sdata->vif.type)
777 return 0;
778
Johannes Berge60c7742008-11-26 23:31:40 +0100779 /* Setting ad-hoc mode on non-IBSS channel is not supported. */
Pavel Roskindcebf452008-12-22 16:39:36 -0500780 if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS &&
781 type == NL80211_IFTYPE_ADHOC)
Johannes Berge60c7742008-11-26 23:31:40 +0100782 return -EOPNOTSUPP;
783
Johannes Bergf3947e22008-07-09 14:40:36 +0200784 /*
785 * We could, here, on changes between IBSS/STA/MESH modes,
786 * invoke an MLME function instead that disassociates etc.
787 * and goes into the requested mode.
788 */
789
Johannes Berg9607e6b2009-12-23 13:15:31 +0100790 if (ieee80211_sdata_running(sdata))
Johannes Bergf3947e22008-07-09 14:40:36 +0200791 return -EBUSY;
792
Johannes Berg75636522008-07-09 14:40:35 +0200793 /* Purge and reset type-dependent state. */
794 ieee80211_teardown_sdata(sdata->dev);
795 ieee80211_setup_sdata(sdata, type);
796
797 /* reset some values that shouldn't be kept across type changes */
Johannes Bergbda39332008-10-11 01:51:51 +0200798 sdata->vif.bss_conf.basic_rates =
Johannes Berg96dd22a2008-09-11 00:01:57 +0200799 ieee80211_mandatory_rates(sdata->local,
800 sdata->local->hw.conf.channel->band);
Johannes Berg75636522008-07-09 14:40:35 +0200801 sdata->drop_unencrypted = 0;
Johannes Berg9bc383d2009-11-19 11:55:19 +0100802 if (type == NL80211_IFTYPE_STATION)
803 sdata->u.mgd.use_4addr = false;
Johannes Bergf3947e22008-07-09 14:40:36 +0200804
805 return 0;
Johannes Berg75636522008-07-09 14:40:35 +0200806}
807
Johannes Bergfa9029f2010-02-25 15:13:11 +0100808static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
809 struct net_device *dev,
810 enum nl80211_iftype type)
811{
812 struct ieee80211_sub_if_data *sdata;
813 u64 mask, start, addr, val, inc;
814 u8 *m;
815 u8 tmp_addr[ETH_ALEN];
816 int i;
817
818 /* default ... something at least */
819 memcpy(dev->perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
820
821 if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
822 local->hw.wiphy->n_addresses <= 1)
823 return;
824
825
826 mutex_lock(&local->iflist_mtx);
827
828 switch (type) {
829 case NL80211_IFTYPE_MONITOR:
830 /* doesn't matter */
831 break;
832 case NL80211_IFTYPE_WDS:
833 case NL80211_IFTYPE_AP_VLAN:
834 /* match up with an AP interface */
835 list_for_each_entry(sdata, &local->interfaces, list) {
836 if (sdata->vif.type != NL80211_IFTYPE_AP)
837 continue;
838 memcpy(dev->perm_addr, sdata->vif.addr, ETH_ALEN);
839 break;
840 }
841 /* keep default if no AP interface present */
842 break;
843 default:
844 /* assign a new address if possible -- try n_addresses first */
845 for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
846 bool used = false;
847
848 list_for_each_entry(sdata, &local->interfaces, list) {
849 if (memcmp(local->hw.wiphy->addresses[i].addr,
850 sdata->vif.addr, ETH_ALEN) == 0) {
851 used = true;
852 break;
853 }
854 }
855
856 if (!used) {
857 memcpy(dev->perm_addr,
858 local->hw.wiphy->addresses[i].addr,
859 ETH_ALEN);
860 break;
861 }
862 }
863
864 /* try mask if available */
865 if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
866 break;
867
868 m = local->hw.wiphy->addr_mask;
869 mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
870 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
871 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
872
873 if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
874 /* not a contiguous mask ... not handled now! */
875 printk(KERN_DEBUG "not contiguous\n");
876 break;
877 }
878
879 m = local->hw.wiphy->perm_addr;
880 start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
881 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
882 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
883
884 inc = 1ULL<<__ffs64(mask);
885 val = (start & mask);
886 addr = (start & ~mask) | (val & mask);
887 do {
888 bool used = false;
889
890 tmp_addr[5] = addr >> 0*8;
891 tmp_addr[4] = addr >> 1*8;
892 tmp_addr[3] = addr >> 2*8;
893 tmp_addr[2] = addr >> 3*8;
894 tmp_addr[1] = addr >> 4*8;
895 tmp_addr[0] = addr >> 5*8;
896
897 val += inc;
898
899 list_for_each_entry(sdata, &local->interfaces, list) {
900 if (memcmp(tmp_addr, sdata->vif.addr,
901 ETH_ALEN) == 0) {
902 used = true;
903 break;
904 }
905 }
906
907 if (!used) {
908 memcpy(dev->perm_addr, tmp_addr, ETH_ALEN);
909 break;
910 }
911 addr = (start & ~mask) | (val & mask);
912 } while (addr != start);
913
914 break;
915 }
916
917 mutex_unlock(&local->iflist_mtx);
918}
919
Johannes Berg3e122be2008-07-09 14:40:34 +0200920int ieee80211_if_add(struct ieee80211_local *local, const char *name,
Johannes Berg05c914f2008-09-11 00:01:58 +0200921 struct net_device **new_dev, enum nl80211_iftype type,
Luis Carlos Coboee385852008-02-23 15:17:11 +0100922 struct vif_params *params)
Jiri Bencf0706e82007-05-05 11:45:53 -0700923{
924 struct net_device *ndev;
Jiri Bencf0706e82007-05-05 11:45:53 -0700925 struct ieee80211_sub_if_data *sdata = NULL;
Johannes Berg75636522008-07-09 14:40:35 +0200926 int ret, i;
Jiri Bencf0706e82007-05-05 11:45:53 -0700927
928 ASSERT_RTNL();
Johannes Berg75636522008-07-09 14:40:35 +0200929
Johannes Bergcf0277e2010-01-05 18:00:58 +0100930 ndev = alloc_netdev_mq(sizeof(*sdata) + local->hw.vif_data_size,
931 name, ieee80211_if_setup, local->hw.queues);
Jiri Bencf0706e82007-05-05 11:45:53 -0700932 if (!ndev)
933 return -ENOMEM;
Johannes Berga272a722009-07-14 00:33:36 +0200934 dev_net_set(ndev, wiphy_net(local->hw.wiphy));
Jiri Bencf0706e82007-05-05 11:45:53 -0700935
Johannes Bergf3994ec2008-05-12 20:51:44 -0700936 ndev->needed_headroom = local->tx_headroom +
937 4*6 /* four MAC addresses */
938 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
939 + 6 /* mesh */
940 + 8 /* rfc1042/bridge tunnel */
941 - ETH_HLEN /* ethernet hard_header_len */
942 + IEEE80211_ENCRYPT_HEADROOM;
943 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
944
Jiri Bencf0706e82007-05-05 11:45:53 -0700945 ret = dev_alloc_name(ndev, ndev->name);
946 if (ret < 0)
947 goto fail;
948
Johannes Bergfa9029f2010-02-25 15:13:11 +0100949 ieee80211_assign_perm_addr(local, ndev, type);
950 memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
Jiri Bencf0706e82007-05-05 11:45:53 -0700951 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
952
Johannes Berg3e122be2008-07-09 14:40:34 +0200953 /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
954 sdata = netdev_priv(ndev);
Jiri Bencf0706e82007-05-05 11:45:53 -0700955 ndev->ieee80211_ptr = &sdata->wdev;
Johannes Berg47846c92009-11-25 17:46:19 +0100956 memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
957 memcpy(sdata->name, ndev->name, IFNAMSIZ);
Johannes Berg75636522008-07-09 14:40:35 +0200958
959 /* initialise type-independent data */
Jiri Bencf0706e82007-05-05 11:45:53 -0700960 sdata->wdev.wiphy = local->hw.wiphy;
Jiri Bencf0706e82007-05-05 11:45:53 -0700961 sdata->local = local;
Johannes Berg75636522008-07-09 14:40:35 +0200962 sdata->dev = ndev;
963
964 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
965 skb_queue_head_init(&sdata->fragments[i].skb_list);
966
967 INIT_LIST_HEAD(&sdata->key_list);
968
Jouni Malinen37eb0b12010-01-06 13:09:08 +0200969 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
970 struct ieee80211_supported_band *sband;
971 sband = local->hw.wiphy->bands[i];
972 sdata->rc_rateidx_mask[i] =
973 sband ? (1 << sband->n_bitrates) - 1 : 0;
974 }
Johannes Berg75636522008-07-09 14:40:35 +0200975
976 /* setup type-dependent data */
977 ieee80211_setup_sdata(sdata, type);
Jiri Bencf0706e82007-05-05 11:45:53 -0700978
Johannes Berg9bc383d2009-11-19 11:55:19 +0100979 if (params) {
980 ndev->ieee80211_ptr->use_4addr = params->use_4addr;
981 if (type == NL80211_IFTYPE_STATION)
982 sdata->u.mgd.use_4addr = params->use_4addr;
983 }
984
Jiri Bencf0706e82007-05-05 11:45:53 -0700985 ret = register_netdevice(ndev);
986 if (ret)
987 goto fail;
988
Johannes Berg902acc72008-02-23 15:17:19 +0100989 if (ieee80211_vif_is_mesh(&sdata->vif) &&
990 params && params->mesh_id_len)
Johannes Berg472dbc42008-09-11 00:01:49 +0200991 ieee80211_sdata_set_mesh_id(sdata,
992 params->mesh_id_len,
993 params->mesh_id);
Luis Carlos Coboee385852008-02-23 15:17:11 +0100994
Johannes Bergc771c9d2009-01-23 22:54:03 +0100995 mutex_lock(&local->iflist_mtx);
Johannes Berg79010422007-09-18 17:29:21 -0400996 list_add_tail_rcu(&sdata->list, &local->interfaces);
Johannes Bergc771c9d2009-01-23 22:54:03 +0100997 mutex_unlock(&local->iflist_mtx);
Johannes Berg79010422007-09-18 17:29:21 -0400998
Jiri Bencf0706e82007-05-05 11:45:53 -0700999 if (new_dev)
1000 *new_dev = ndev;
Jiri Bencf0706e82007-05-05 11:45:53 -07001001
Jiri Bencf0706e82007-05-05 11:45:53 -07001002 return 0;
1003
Johannes Berg75636522008-07-09 14:40:35 +02001004 fail:
Jiri Bencf0706e82007-05-05 11:45:53 -07001005 free_netdev(ndev);
1006 return ret;
1007}
1008
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001009void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
Jiri Bencf0706e82007-05-05 11:45:53 -07001010{
Jiri Bencf0706e82007-05-05 11:45:53 -07001011 ASSERT_RTNL();
Johannes Berg11a843b2007-08-28 17:01:55 -04001012
Johannes Bergc771c9d2009-01-23 22:54:03 +01001013 mutex_lock(&sdata->local->iflist_mtx);
Johannes Berg75636522008-07-09 14:40:35 +02001014 list_del_rcu(&sdata->list);
Johannes Bergc771c9d2009-01-23 22:54:03 +01001015 mutex_unlock(&sdata->local->iflist_mtx);
1016
Johannes Berg75636522008-07-09 14:40:35 +02001017 synchronize_rcu();
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001018 unregister_netdevice(sdata->dev);
Jiri Bencf0706e82007-05-05 11:45:53 -07001019}
1020
Johannes Berg75636522008-07-09 14:40:35 +02001021/*
1022 * Remove all interfaces, may only be called at hardware unregistration
1023 * time because it doesn't do RCU-safe list removals.
1024 */
1025void ieee80211_remove_interfaces(struct ieee80211_local *local)
Jiri Bencf0706e82007-05-05 11:45:53 -07001026{
Johannes Berg75636522008-07-09 14:40:35 +02001027 struct ieee80211_sub_if_data *sdata, *tmp;
Eric Dumazetefe117a2009-11-05 11:06:40 +01001028 LIST_HEAD(unreg_list);
Jiri Bencf0706e82007-05-05 11:45:53 -07001029
1030 ASSERT_RTNL();
1031
Eric Dumazetefe117a2009-11-05 11:06:40 +01001032 mutex_lock(&local->iflist_mtx);
Johannes Berg75636522008-07-09 14:40:35 +02001033 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
1034 list_del(&sdata->list);
Johannes Bergc771c9d2009-01-23 22:54:03 +01001035
Eric Dumazetefe117a2009-11-05 11:06:40 +01001036 unregister_netdevice_queue(sdata->dev, &unreg_list);
Jiri Bencf0706e82007-05-05 11:45:53 -07001037 }
Eric Dumazetefe117a2009-11-05 11:06:40 +01001038 mutex_unlock(&local->iflist_mtx);
1039 unregister_netdevice_many(&unreg_list);
Jiri Bencf0706e82007-05-05 11:45:53 -07001040}
Johannes Berg5cff20e2009-04-29 12:26:17 +02001041
1042static u32 ieee80211_idle_off(struct ieee80211_local *local,
1043 const char *reason)
1044{
1045 if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
1046 return 0;
1047
1048#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1049 printk(KERN_DEBUG "%s: device no longer idle - %s\n",
1050 wiphy_name(local->hw.wiphy), reason);
1051#endif
1052
1053 local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
1054 return IEEE80211_CONF_CHANGE_IDLE;
1055}
1056
1057static u32 ieee80211_idle_on(struct ieee80211_local *local)
1058{
1059 if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
1060 return 0;
1061
1062#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1063 printk(KERN_DEBUG "%s: device now idle\n",
1064 wiphy_name(local->hw.wiphy));
1065#endif
1066
Johannes Berga80f7c02009-12-23 13:15:32 +01001067 drv_flush(local, false);
1068
Johannes Berg5cff20e2009-04-29 12:26:17 +02001069 local->hw.conf.flags |= IEEE80211_CONF_IDLE;
1070 return IEEE80211_CONF_CHANGE_IDLE;
1071}
1072
1073u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
1074{
1075 struct ieee80211_sub_if_data *sdata;
1076 int count = 0;
1077
Johannes Bergaf6b6372009-12-23 13:15:35 +01001078 if (!list_empty(&local->work_list))
1079 return ieee80211_idle_off(local, "working");
1080
Helmut Schaafbe9c422009-07-23 12:14:04 +02001081 if (local->scanning)
Johannes Berg5cff20e2009-04-29 12:26:17 +02001082 return ieee80211_idle_off(local, "scanning");
1083
1084 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +01001085 if (!ieee80211_sdata_running(sdata))
Johannes Berg5cff20e2009-04-29 12:26:17 +02001086 continue;
1087 /* do not count disabled managed interfaces */
1088 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
Johannes Bergaf6b6372009-12-23 13:15:35 +01001089 !sdata->u.mgd.associated)
Johannes Berg5cff20e2009-04-29 12:26:17 +02001090 continue;
1091 /* do not count unused IBSS interfaces */
1092 if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
1093 !sdata->u.ibss.ssid_len)
1094 continue;
1095 /* count everything else */
1096 count++;
1097 }
1098
1099 if (!count)
1100 return ieee80211_idle_on(local);
1101 else
1102 return ieee80211_idle_off(local, "in use");
1103
1104 return 0;
1105}
1106
1107void ieee80211_recalc_idle(struct ieee80211_local *local)
1108{
1109 u32 chg;
1110
1111 mutex_lock(&local->iflist_mtx);
1112 chg = __ieee80211_recalc_idle(local);
1113 mutex_unlock(&local->iflist_mtx);
Johannes Berg58905ca2009-05-07 14:23:01 +02001114 if (chg)
1115 ieee80211_hw_config(local, chg);
Johannes Berg5cff20e2009-04-29 12:26:17 +02001116}
Johannes Berg47846c92009-11-25 17:46:19 +01001117
1118static int netdev_notify(struct notifier_block *nb,
1119 unsigned long state,
1120 void *ndev)
1121{
1122 struct net_device *dev = ndev;
1123 struct ieee80211_sub_if_data *sdata;
1124
1125 if (state != NETDEV_CHANGENAME)
1126 return 0;
1127
1128 if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
1129 return 0;
1130
1131 if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
1132 return 0;
1133
1134 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1135
Johannes Berg2f5265e2010-02-12 10:45:05 +01001136 memcpy(sdata->name, dev->name, IFNAMSIZ);
Johannes Berg47846c92009-11-25 17:46:19 +01001137
1138 ieee80211_debugfs_rename_netdev(sdata);
1139 return 0;
1140}
1141
1142static struct notifier_block mac80211_netdev_notifier = {
1143 .notifier_call = netdev_notify,
1144};
1145
1146int ieee80211_iface_init(void)
1147{
1148 return register_netdevice_notifier(&mac80211_netdev_notifier);
1149}
1150
1151void ieee80211_iface_exit(void)
1152{
1153 unregister_netdevice_notifier(&mac80211_netdev_notifier);
1154}