blob: e08fa8eda1b36aabfda2b591b31ac4f2fe641817 [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
Johannes Berg0d143fe2008-09-11 00:01:59 +0200324 /*
325 * ieee80211_sta_work is disabled while network interface
326 * is down. Therefore, some configuration changes may not
327 * yet be effective. Trigger execution of ieee80211_sta_work
328 * to fix this.
329 */
Johannes Berg46900292009-02-15 12:44:28 +0100330 if (sdata->vif.type == NL80211_IFTYPE_STATION)
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400331 ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200332
John W. Linville8a5b33f2010-01-06 15:39:39 -0500333 netif_tx_start_all_queues(dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200334
335 return 0;
336 err_del_interface:
Johannes Berg1ed32e42009-12-23 13:15:45 +0100337 drv_remove_interface(local, &sdata->vif);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200338 err_stop:
Johannes Berg24487982009-04-23 18:52:52 +0200339 if (!local->open_count)
340 drv_stop(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200341 err_del_bss:
342 sdata->bss = NULL;
343 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
344 list_del(&sdata->u.vlan.list);
345 return res;
346}
347
348static int ieee80211_stop(struct net_device *dev)
349{
350 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
351 struct ieee80211_local *local = sdata->local;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200352 struct sta_info *sta;
Johannes Berg5061b0c2009-07-14 00:33:34 +0200353 unsigned long flags;
354 struct sk_buff *skb, *tmp;
Johannes Berge8975582008-10-09 12:18:51 +0200355 u32 hw_reconf_flags = 0;
Johannes Berg5061b0c2009-07-14 00:33:34 +0200356 int i;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200357
358 /*
359 * Stop TX on this interface first.
360 */
John W. Linville8a5b33f2010-01-06 15:39:39 -0500361 netif_tx_stop_all_queues(dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200362
363 /*
Johannes Bergaf6b6372009-12-23 13:15:35 +0100364 * Purge work for this interface.
365 */
366 ieee80211_work_purge(sdata);
367
368 /*
Johannes Berg0d143fe2008-09-11 00:01:59 +0200369 * Now delete all active aggregation sessions.
370 */
371 rcu_read_lock();
372
373 list_for_each_entry_rcu(sta, &local->sta_list, list) {
374 if (sta->sdata == sdata)
Johannes Berg2dace102009-02-10 21:25:52 +0100375 ieee80211_sta_tear_down_BA_sessions(sta);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200376 }
377
378 rcu_read_unlock();
379
380 /*
381 * Remove all stations associated with this interface.
382 *
383 * This must be done before calling ops->remove_interface()
384 * because otherwise we can later invoke ops->sta_notify()
385 * whenever the STAs are removed, and that invalidates driver
386 * assumptions about always getting a vif pointer that is valid
387 * (because if we remove a STA after ops->remove_interface()
388 * the driver will have removed the vif info already!)
389 *
390 * We could relax this and only unlink the stations from the
391 * hash table and list but keep them on a per-sdata list that
392 * will be inserted back again when the interface is brought
393 * up again, but I don't currently see a use case for that,
394 * except with WDS which gets a STA entry created when it is
395 * brought up.
396 */
397 sta_info_flush(local, sdata);
398
399 /*
400 * Don't count this interface for promisc/allmulti while it
401 * is down. dev_mc_unsync() will invoke set_multicast_list
402 * on the master interface which will sync these down to the
403 * hardware as filter flags.
404 */
405 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
406 atomic_dec(&local->iff_allmultis);
407
408 if (sdata->flags & IEEE80211_SDATA_PROMISC)
409 atomic_dec(&local->iff_promiscs);
410
Igor Perminove3b90ca2009-08-04 16:48:51 +0400411 if (sdata->vif.type == NL80211_IFTYPE_AP)
412 local->fif_pspoll--;
413
Johannes Berg3b8d81e2009-06-17 17:43:56 +0200414 netif_addr_lock_bh(dev);
415 spin_lock_bh(&local->filter_lock);
416 __dev_addr_unsync(&local->mc_list, &local->mc_count,
417 &dev->mc_list, &dev->mc_count);
Johannes Berg3b8d81e2009-06-17 17:43:56 +0200418 spin_unlock_bh(&local->filter_lock);
419 netif_addr_unlock_bh(dev);
420
Johannes Berg3ac64be2009-08-17 16:16:53 +0200421 ieee80211_configure_filter(local);
422
Vivek Natarajan7cbf0ba2008-12-24 00:34:37 -0800423 del_timer_sync(&local->dynamic_ps_timer);
424 cancel_work_sync(&local->dynamic_ps_enable_work);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200425
426 /* APs need special treatment */
427 if (sdata->vif.type == NL80211_IFTYPE_AP) {
Johannes Berg57c9fff2009-07-29 15:46:21 +0200428 struct ieee80211_sub_if_data *vlan, *tmpsdata;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200429 struct beacon_data *old_beacon = sdata->u.ap.beacon;
430
431 /* remove beacon */
432 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
433 synchronize_rcu();
434 kfree(old_beacon);
435
436 /* down all dependent devices, that is VLANs */
Johannes Berg57c9fff2009-07-29 15:46:21 +0200437 list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
Johannes Berg0d143fe2008-09-11 00:01:59 +0200438 u.vlan.list)
439 dev_close(vlan->dev);
440 WARN_ON(!list_empty(&sdata->u.ap.vlans));
441 }
442
443 local->open_count--;
444
445 switch (sdata->vif.type) {
446 case NL80211_IFTYPE_AP_VLAN:
447 list_del(&sdata->u.vlan.list);
448 /* no need to tell driver */
449 break;
450 case NL80211_IFTYPE_MONITOR:
451 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
452 local->cooked_mntrs--;
453 break;
454 }
455
456 local->monitors--;
Johannes Berge8975582008-10-09 12:18:51 +0200457 if (local->monitors == 0) {
Johannes Berg0869aea2009-10-28 10:03:35 +0100458 local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
459 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
Johannes Berge8975582008-10-09 12:18:51 +0200460 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200461
462 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
463 local->fif_fcsfail--;
464 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL)
465 local->fif_plcpfail--;
Igor Perminove3b90ca2009-08-04 16:48:51 +0400466 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) {
467 local->fif_pspoll--;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200468 local->fif_control--;
Igor Perminove3b90ca2009-08-04 16:48:51 +0400469 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200470 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS)
471 local->fif_other_bss--;
472
Johannes Berg0d143fe2008-09-11 00:01:59 +0200473 ieee80211_configure_filter(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200474 break;
475 case NL80211_IFTYPE_STATION:
Johannes Berg46900292009-02-15 12:44:28 +0100476 del_timer_sync(&sdata->u.mgd.chswitch_timer);
477 del_timer_sync(&sdata->u.mgd.timer);
Johannes Berg0e2b6282009-07-13 13:23:39 +0200478 del_timer_sync(&sdata->u.mgd.conn_mon_timer);
479 del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200480 /*
Johannes Berg0e2b6282009-07-13 13:23:39 +0200481 * If any of the timers fired while we waited for it, it will
482 * have queued its work. Now the work will be running again
Johannes Berg0d143fe2008-09-11 00:01:59 +0200483 * but will not rearm the timer again because it checks
484 * whether the interface is running, which, at this point,
485 * it no longer is.
486 */
Johannes Berg46900292009-02-15 12:44:28 +0100487 cancel_work_sync(&sdata->u.mgd.work);
488 cancel_work_sync(&sdata->u.mgd.chswitch_work);
Johannes Berg0e2b6282009-07-13 13:23:39 +0200489 cancel_work_sync(&sdata->u.mgd.monitor_work);
Kalle Valo04de8382009-03-22 21:57:35 +0200490 cancel_work_sync(&sdata->u.mgd.beacon_loss_work);
491
Johannes Berg0d143fe2008-09-11 00:01:59 +0200492 /*
493 * When we get here, the interface is marked down.
494 * Call synchronize_rcu() to wait for the RX path
495 * should it be using the interface and enqueuing
496 * frames at this very time on another CPU.
497 */
498 synchronize_rcu();
Johannes Berg46900292009-02-15 12:44:28 +0100499 skb_queue_purge(&sdata->u.mgd.skb_queue);
Johannes Berg46900292009-02-15 12:44:28 +0100500 /* fall through */
501 case NL80211_IFTYPE_ADHOC:
502 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
Johannes Berg46900292009-02-15 12:44:28 +0100503 del_timer_sync(&sdata->u.ibss.timer);
504 cancel_work_sync(&sdata->u.ibss.work);
505 synchronize_rcu();
506 skb_queue_purge(&sdata->u.ibss.skb_queue);
507 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200508 /* fall through */
509 case NL80211_IFTYPE_MESH_POINT:
510 if (ieee80211_vif_is_mesh(&sdata->vif)) {
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700511 /* other_bss and allmulti are always set on mesh
512 * ifaces */
513 local->fif_other_bss--;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200514 atomic_dec(&local->iff_allmultis);
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700515
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700516 ieee80211_configure_filter(local);
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700517
Johannes Berg0d143fe2008-09-11 00:01:59 +0200518 ieee80211_stop_mesh(sdata);
519 }
520 /* fall through */
521 default:
Johannes Berg15db0b72009-08-25 16:33:47 +0200522 if (local->scan_sdata == sdata)
523 ieee80211_scan_cancel(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200524
Bob Copeland97af7432009-07-29 10:13:03 +0200525 /*
526 * Disable beaconing for AP and mesh, IBSS can't
527 * still be joined to a network at this point.
528 */
529 if (sdata->vif.type == NL80211_IFTYPE_AP ||
530 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
531 ieee80211_bss_info_change_notify(sdata,
532 BSS_CHANGED_BEACON_ENABLED);
533 }
534
Johannes Berg0d143fe2008-09-11 00:01:59 +0200535 /* disable all keys for as long as this netdev is down */
536 ieee80211_disable_keys(sdata);
Johannes Berg1ed32e42009-12-23 13:15:45 +0100537 drv_remove_interface(local, &sdata->vif);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200538 }
539
540 sdata->bss = NULL;
541
Johannes Berg5cff20e2009-04-29 12:26:17 +0200542 hw_reconf_flags |= __ieee80211_recalc_idle(local);
543
544 ieee80211_recalc_ps(local, -1);
545
Johannes Berg0d143fe2008-09-11 00:01:59 +0200546 if (local->open_count == 0) {
Johannes Bergea77f122009-08-21 14:44:45 +0200547 ieee80211_clear_tx_pending(local);
Johannes Berg84f6a012009-08-20 20:02:20 +0200548 ieee80211_stop_device(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200549
Johannes Berge8975582008-10-09 12:18:51 +0200550 /* no reconfiguring after stop! */
551 hw_reconf_flags = 0;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200552 }
553
Johannes Berge8975582008-10-09 12:18:51 +0200554 /* do after stop to avoid reconfiguring when we stop anyway */
555 if (hw_reconf_flags)
556 ieee80211_hw_config(local, hw_reconf_flags);
557
Johannes Berg5061b0c2009-07-14 00:33:34 +0200558 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
559 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
560 skb_queue_walk_safe(&local->pending[i], skb, tmp) {
561 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
562 if (info->control.vif == &sdata->vif) {
563 __skb_unlink(skb, &local->pending[i]);
564 dev_kfree_skb_irq(skb);
565 }
566 }
567 }
568 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
569
Johannes Berg0d143fe2008-09-11 00:01:59 +0200570 return 0;
571}
572
573static void ieee80211_set_multicast_list(struct net_device *dev)
574{
Johannes Berg0d143fe2008-09-11 00:01:59 +0200575 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Bergb4a4bf52008-09-26 13:34:54 +0200576 struct ieee80211_local *local = sdata->local;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200577 int allmulti, promisc, sdata_allmulti, sdata_promisc;
578
579 allmulti = !!(dev->flags & IFF_ALLMULTI);
580 promisc = !!(dev->flags & IFF_PROMISC);
581 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
582 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
583
584 if (allmulti != sdata_allmulti) {
585 if (dev->flags & IFF_ALLMULTI)
586 atomic_inc(&local->iff_allmultis);
587 else
588 atomic_dec(&local->iff_allmultis);
589 sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
590 }
591
592 if (promisc != sdata_promisc) {
593 if (dev->flags & IFF_PROMISC)
594 atomic_inc(&local->iff_promiscs);
595 else
596 atomic_dec(&local->iff_promiscs);
597 sdata->flags ^= IEEE80211_SDATA_PROMISC;
598 }
Johannes Berg3b8d81e2009-06-17 17:43:56 +0200599 spin_lock_bh(&local->filter_lock);
600 __dev_addr_sync(&local->mc_list, &local->mc_count,
601 &dev->mc_list, &dev->mc_count);
Johannes Berg3b8d81e2009-06-17 17:43:56 +0200602 spin_unlock_bh(&local->filter_lock);
Johannes Berg3ac64be2009-08-17 16:16:53 +0200603 ieee80211_queue_work(&local->hw, &local->reconfig_filter);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200604}
605
Johannes Berg75636522008-07-09 14:40:35 +0200606/*
607 * Called when the netdev is removed or, by the code below, before
608 * the interface type changes.
609 */
610static void ieee80211_teardown_sdata(struct net_device *dev)
Jiri Bencf0706e82007-05-05 11:45:53 -0700611{
Johannes Berg75636522008-07-09 14:40:35 +0200612 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
613 struct ieee80211_local *local = sdata->local;
614 struct beacon_data *beacon;
615 struct sk_buff *skb;
616 int flushed;
Jiri Bencf0706e82007-05-05 11:45:53 -0700617 int i;
618
Johannes Berg75636522008-07-09 14:40:35 +0200619 /* free extra data */
620 ieee80211_free_keys(sdata);
Jiri Bencf0706e82007-05-05 11:45:53 -0700621
Jouni Malinenaee14ce2008-09-09 16:33:15 +0200622 ieee80211_debugfs_remove_netdev(sdata);
623
Johannes Berg988c0f72008-04-17 19:21:22 +0200624 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
Jiri Bencf0706e82007-05-05 11:45:53 -0700625 __skb_queue_purge(&sdata->fragments[i].skb_list);
Johannes Berg75636522008-07-09 14:40:35 +0200626 sdata->fragment_next = 0;
627
628 switch (sdata->vif.type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200629 case NL80211_IFTYPE_AP:
Johannes Berg75636522008-07-09 14:40:35 +0200630 beacon = sdata->u.ap.beacon;
631 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
632 synchronize_rcu();
633 kfree(beacon);
634
635 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {
636 local->total_ps_buffered--;
637 dev_kfree_skb(skb);
638 }
639
640 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200641 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg75636522008-07-09 14:40:35 +0200642 if (ieee80211_vif_is_mesh(&sdata->vif))
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200643 mesh_rmc_free(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200644 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200645 case NL80211_IFTYPE_ADHOC:
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200646 if (WARN_ON(sdata->u.ibss.presp))
647 kfree_skb(sdata->u.ibss.presp);
Johannes Berg46900292009-02-15 12:44:28 +0100648 break;
649 case NL80211_IFTYPE_STATION:
Johannes Berg05c914f2008-09-11 00:01:58 +0200650 case NL80211_IFTYPE_WDS:
651 case NL80211_IFTYPE_AP_VLAN:
652 case NL80211_IFTYPE_MONITOR:
Johannes Berg75636522008-07-09 14:40:35 +0200653 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200654 case NL80211_IFTYPE_UNSPECIFIED:
655 case __NL80211_IFTYPE_AFTER_LAST:
Johannes Berg75636522008-07-09 14:40:35 +0200656 BUG();
657 break;
658 }
659
660 flushed = sta_info_flush(local, sdata);
661 WARN_ON(flushed);
Jiri Bencf0706e82007-05-05 11:45:53 -0700662}
663
Johannes Bergcf0277e2010-01-05 18:00:58 +0100664static u16 ieee80211_netdev_select_queue(struct net_device *dev,
665 struct sk_buff *skb)
666{
667 return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
668}
669
Johannes Berg587e7292009-01-30 13:35:22 +0100670static const struct net_device_ops ieee80211_dataif_ops = {
671 .ndo_open = ieee80211_open,
672 .ndo_stop = ieee80211_stop,
673 .ndo_uninit = ieee80211_teardown_sdata,
674 .ndo_start_xmit = ieee80211_subif_start_xmit,
675 .ndo_set_multicast_list = ieee80211_set_multicast_list,
676 .ndo_change_mtu = ieee80211_change_mtu,
Johannes Berg47846c92009-11-25 17:46:19 +0100677 .ndo_set_mac_address = ieee80211_change_mac,
Johannes Bergcf0277e2010-01-05 18:00:58 +0100678 .ndo_select_queue = ieee80211_netdev_select_queue,
Johannes Berg587e7292009-01-30 13:35:22 +0100679};
680
Johannes Bergcf0277e2010-01-05 18:00:58 +0100681static u16 ieee80211_monitor_select_queue(struct net_device *dev,
682 struct sk_buff *skb)
683{
684 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
685 struct ieee80211_local *local = sdata->local;
686 struct ieee80211_hdr *hdr;
687 struct ieee80211_radiotap_header *rtap = (void *)skb->data;
Felix Fietkau193e70e2010-01-11 06:47:00 +0100688 u8 *p;
Johannes Bergcf0277e2010-01-05 18:00:58 +0100689
690 if (local->hw.queues < 4)
691 return 0;
692
693 if (skb->len < 4 ||
Johannes Bergb49bb572010-01-08 19:00:00 +0100694 skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
Johannes Bergcf0277e2010-01-05 18:00:58 +0100695 return 0; /* doesn't matter, frame will be dropped */
696
Johannes Bergb49bb572010-01-08 19:00:00 +0100697 hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
Johannes Bergcf0277e2010-01-05 18:00:58 +0100698
Felix Fietkau861a57c2010-01-12 04:08:26 +0100699 if (!ieee80211_is_data(hdr->frame_control)) {
Johannes Bergcf0277e2010-01-05 18:00:58 +0100700 skb->priority = 7;
701 return ieee802_1d_to_ac[skb->priority];
702 }
Felix Fietkau861a57c2010-01-12 04:08:26 +0100703 if (!ieee80211_is_data_qos(hdr->frame_control)) {
704 skb->priority = 0;
705 return ieee802_1d_to_ac[skb->priority];
706 }
Johannes Bergcf0277e2010-01-05 18:00:58 +0100707
Felix Fietkau193e70e2010-01-11 06:47:00 +0100708 p = ieee80211_get_qos_ctl(hdr);
709 skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK;
710
Johannes Bergcf0277e2010-01-05 18:00:58 +0100711 return ieee80211_downgrade_queue(local, skb);
712}
713
Johannes Berg587e7292009-01-30 13:35:22 +0100714static const struct net_device_ops ieee80211_monitorif_ops = {
715 .ndo_open = ieee80211_open,
716 .ndo_stop = ieee80211_stop,
717 .ndo_uninit = ieee80211_teardown_sdata,
718 .ndo_start_xmit = ieee80211_monitor_start_xmit,
719 .ndo_set_multicast_list = ieee80211_set_multicast_list,
720 .ndo_change_mtu = ieee80211_change_mtu,
721 .ndo_set_mac_address = eth_mac_addr,
Johannes Bergcf0277e2010-01-05 18:00:58 +0100722 .ndo_select_queue = ieee80211_monitor_select_queue,
Johannes Berg587e7292009-01-30 13:35:22 +0100723};
724
725static void ieee80211_if_setup(struct net_device *dev)
726{
727 ether_setup(dev);
728 dev->netdev_ops = &ieee80211_dataif_ops;
Johannes Berg587e7292009-01-30 13:35:22 +0100729 dev->destructor = free_netdev;
730}
731
Johannes Berg75636522008-07-09 14:40:35 +0200732/*
733 * Helper function to initialise an interface to a specific type.
734 */
735static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
Johannes Berg05c914f2008-09-11 00:01:58 +0200736 enum nl80211_iftype type)
Johannes Berg75636522008-07-09 14:40:35 +0200737{
Johannes Berg75636522008-07-09 14:40:35 +0200738 /* clear type-dependent union */
739 memset(&sdata->u, 0, sizeof(sdata->u));
740
741 /* and set some type-dependent values */
742 sdata->vif.type = type;
Johannes Berg587e7292009-01-30 13:35:22 +0100743 sdata->dev->netdev_ops = &ieee80211_dataif_ops;
Johannes Berg60719ff2008-09-16 14:55:09 +0200744 sdata->wdev.iftype = type;
Johannes Berg75636522008-07-09 14:40:35 +0200745
746 /* only monitor differs */
747 sdata->dev->type = ARPHRD_ETHER;
748
749 switch (type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200750 case NL80211_IFTYPE_AP:
Johannes Berg75636522008-07-09 14:40:35 +0200751 skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
752 INIT_LIST_HEAD(&sdata->u.ap.vlans);
753 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200754 case NL80211_IFTYPE_STATION:
Johannes Berg9c6bd792008-09-11 00:01:52 +0200755 ieee80211_sta_setup_sdata(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200756 break;
Johannes Berg46900292009-02-15 12:44:28 +0100757 case NL80211_IFTYPE_ADHOC:
758 ieee80211_ibss_setup_sdata(sdata);
759 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200760 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg75636522008-07-09 14:40:35 +0200761 if (ieee80211_vif_is_mesh(&sdata->vif))
762 ieee80211_mesh_init_sdata(sdata);
763 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200764 case NL80211_IFTYPE_MONITOR:
Johannes Berg75636522008-07-09 14:40:35 +0200765 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
Johannes Berg587e7292009-01-30 13:35:22 +0100766 sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
Johannes Berg75636522008-07-09 14:40:35 +0200767 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
768 MONITOR_FLAG_OTHER_BSS;
769 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200770 case NL80211_IFTYPE_WDS:
771 case NL80211_IFTYPE_AP_VLAN:
Johannes Berg75636522008-07-09 14:40:35 +0200772 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200773 case NL80211_IFTYPE_UNSPECIFIED:
774 case __NL80211_IFTYPE_AFTER_LAST:
Johannes Berg75636522008-07-09 14:40:35 +0200775 BUG();
776 break;
777 }
778
779 ieee80211_debugfs_add_netdev(sdata);
780}
781
Johannes Bergf3947e22008-07-09 14:40:36 +0200782int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
Johannes Berg05c914f2008-09-11 00:01:58 +0200783 enum nl80211_iftype type)
Johannes Berg75636522008-07-09 14:40:35 +0200784{
Johannes Bergf3947e22008-07-09 14:40:36 +0200785 ASSERT_RTNL();
786
787 if (type == sdata->vif.type)
788 return 0;
789
Johannes Berge60c7742008-11-26 23:31:40 +0100790 /* Setting ad-hoc mode on non-IBSS channel is not supported. */
Pavel Roskindcebf452008-12-22 16:39:36 -0500791 if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS &&
792 type == NL80211_IFTYPE_ADHOC)
Johannes Berge60c7742008-11-26 23:31:40 +0100793 return -EOPNOTSUPP;
794
Johannes Bergf3947e22008-07-09 14:40:36 +0200795 /*
796 * We could, here, on changes between IBSS/STA/MESH modes,
797 * invoke an MLME function instead that disassociates etc.
798 * and goes into the requested mode.
799 */
800
Johannes Berg9607e6b2009-12-23 13:15:31 +0100801 if (ieee80211_sdata_running(sdata))
Johannes Bergf3947e22008-07-09 14:40:36 +0200802 return -EBUSY;
803
Johannes Berg75636522008-07-09 14:40:35 +0200804 /* Purge and reset type-dependent state. */
805 ieee80211_teardown_sdata(sdata->dev);
806 ieee80211_setup_sdata(sdata, type);
807
808 /* reset some values that shouldn't be kept across type changes */
Johannes Bergbda39332008-10-11 01:51:51 +0200809 sdata->vif.bss_conf.basic_rates =
Johannes Berg96dd22a2008-09-11 00:01:57 +0200810 ieee80211_mandatory_rates(sdata->local,
811 sdata->local->hw.conf.channel->band);
Johannes Berg75636522008-07-09 14:40:35 +0200812 sdata->drop_unencrypted = 0;
Johannes Berg9bc383d2009-11-19 11:55:19 +0100813 if (type == NL80211_IFTYPE_STATION)
814 sdata->u.mgd.use_4addr = false;
Johannes Bergf3947e22008-07-09 14:40:36 +0200815
816 return 0;
Johannes Berg75636522008-07-09 14:40:35 +0200817}
818
Johannes Berg3e122be2008-07-09 14:40:34 +0200819int ieee80211_if_add(struct ieee80211_local *local, const char *name,
Johannes Berg05c914f2008-09-11 00:01:58 +0200820 struct net_device **new_dev, enum nl80211_iftype type,
Luis Carlos Coboee385852008-02-23 15:17:11 +0100821 struct vif_params *params)
Jiri Bencf0706e82007-05-05 11:45:53 -0700822{
823 struct net_device *ndev;
Jiri Bencf0706e82007-05-05 11:45:53 -0700824 struct ieee80211_sub_if_data *sdata = NULL;
Johannes Berg75636522008-07-09 14:40:35 +0200825 int ret, i;
Jiri Bencf0706e82007-05-05 11:45:53 -0700826
827 ASSERT_RTNL();
Johannes Berg75636522008-07-09 14:40:35 +0200828
Johannes Bergcf0277e2010-01-05 18:00:58 +0100829 ndev = alloc_netdev_mq(sizeof(*sdata) + local->hw.vif_data_size,
830 name, ieee80211_if_setup, local->hw.queues);
Jiri Bencf0706e82007-05-05 11:45:53 -0700831 if (!ndev)
832 return -ENOMEM;
Johannes Berga272a722009-07-14 00:33:36 +0200833 dev_net_set(ndev, wiphy_net(local->hw.wiphy));
Jiri Bencf0706e82007-05-05 11:45:53 -0700834
Johannes Bergf3994ec2008-05-12 20:51:44 -0700835 ndev->needed_headroom = local->tx_headroom +
836 4*6 /* four MAC addresses */
837 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
838 + 6 /* mesh */
839 + 8 /* rfc1042/bridge tunnel */
840 - ETH_HLEN /* ethernet hard_header_len */
841 + IEEE80211_ENCRYPT_HEADROOM;
842 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
843
Jiri Bencf0706e82007-05-05 11:45:53 -0700844 ret = dev_alloc_name(ndev, ndev->name);
845 if (ret < 0)
846 goto fail;
847
848 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
John W. Linville0adc23f2009-10-06 16:27:18 -0400849 memcpy(ndev->perm_addr, ndev->dev_addr, ETH_ALEN);
Jiri Bencf0706e82007-05-05 11:45:53 -0700850 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
851
Johannes Berg3e122be2008-07-09 14:40:34 +0200852 /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
853 sdata = netdev_priv(ndev);
Jiri Bencf0706e82007-05-05 11:45:53 -0700854 ndev->ieee80211_ptr = &sdata->wdev;
Johannes Berg47846c92009-11-25 17:46:19 +0100855 memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
856 memcpy(sdata->name, ndev->name, IFNAMSIZ);
Johannes Berg75636522008-07-09 14:40:35 +0200857
858 /* initialise type-independent data */
Jiri Bencf0706e82007-05-05 11:45:53 -0700859 sdata->wdev.wiphy = local->hw.wiphy;
Jiri Bencf0706e82007-05-05 11:45:53 -0700860 sdata->local = local;
Johannes Berg75636522008-07-09 14:40:35 +0200861 sdata->dev = ndev;
862
863 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
864 skb_queue_head_init(&sdata->fragments[i].skb_list);
865
866 INIT_LIST_HEAD(&sdata->key_list);
867
Jouni Malinen37eb0b12010-01-06 13:09:08 +0200868 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
869 struct ieee80211_supported_band *sband;
870 sband = local->hw.wiphy->bands[i];
871 sdata->rc_rateidx_mask[i] =
872 sband ? (1 << sband->n_bitrates) - 1 : 0;
873 }
Johannes Berg75636522008-07-09 14:40:35 +0200874
875 /* setup type-dependent data */
876 ieee80211_setup_sdata(sdata, type);
Jiri Bencf0706e82007-05-05 11:45:53 -0700877
Johannes Berg9bc383d2009-11-19 11:55:19 +0100878 if (params) {
879 ndev->ieee80211_ptr->use_4addr = params->use_4addr;
880 if (type == NL80211_IFTYPE_STATION)
881 sdata->u.mgd.use_4addr = params->use_4addr;
882 }
883
Jiri Bencf0706e82007-05-05 11:45:53 -0700884 ret = register_netdevice(ndev);
885 if (ret)
886 goto fail;
887
Johannes Berg902acc72008-02-23 15:17:19 +0100888 if (ieee80211_vif_is_mesh(&sdata->vif) &&
889 params && params->mesh_id_len)
Johannes Berg472dbc42008-09-11 00:01:49 +0200890 ieee80211_sdata_set_mesh_id(sdata,
891 params->mesh_id_len,
892 params->mesh_id);
Luis Carlos Coboee385852008-02-23 15:17:11 +0100893
Johannes Bergc771c9d2009-01-23 22:54:03 +0100894 mutex_lock(&local->iflist_mtx);
Johannes Berg79010422007-09-18 17:29:21 -0400895 list_add_tail_rcu(&sdata->list, &local->interfaces);
Johannes Bergc771c9d2009-01-23 22:54:03 +0100896 mutex_unlock(&local->iflist_mtx);
Johannes Berg79010422007-09-18 17:29:21 -0400897
Jiri Bencf0706e82007-05-05 11:45:53 -0700898 if (new_dev)
899 *new_dev = ndev;
Jiri Bencf0706e82007-05-05 11:45:53 -0700900
Jiri Bencf0706e82007-05-05 11:45:53 -0700901 return 0;
902
Johannes Berg75636522008-07-09 14:40:35 +0200903 fail:
Jiri Bencf0706e82007-05-05 11:45:53 -0700904 free_netdev(ndev);
905 return ret;
906}
907
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200908void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
Jiri Bencf0706e82007-05-05 11:45:53 -0700909{
Jiri Bencf0706e82007-05-05 11:45:53 -0700910 ASSERT_RTNL();
Johannes Berg11a843b2007-08-28 17:01:55 -0400911
Johannes Bergc771c9d2009-01-23 22:54:03 +0100912 mutex_lock(&sdata->local->iflist_mtx);
Johannes Berg75636522008-07-09 14:40:35 +0200913 list_del_rcu(&sdata->list);
Johannes Bergc771c9d2009-01-23 22:54:03 +0100914 mutex_unlock(&sdata->local->iflist_mtx);
915
Johannes Berg75636522008-07-09 14:40:35 +0200916 synchronize_rcu();
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200917 unregister_netdevice(sdata->dev);
Jiri Bencf0706e82007-05-05 11:45:53 -0700918}
919
Johannes Berg75636522008-07-09 14:40:35 +0200920/*
921 * Remove all interfaces, may only be called at hardware unregistration
922 * time because it doesn't do RCU-safe list removals.
923 */
924void ieee80211_remove_interfaces(struct ieee80211_local *local)
Jiri Bencf0706e82007-05-05 11:45:53 -0700925{
Johannes Berg75636522008-07-09 14:40:35 +0200926 struct ieee80211_sub_if_data *sdata, *tmp;
Eric Dumazetefe117a2009-11-05 11:06:40 +0100927 LIST_HEAD(unreg_list);
Jiri Bencf0706e82007-05-05 11:45:53 -0700928
929 ASSERT_RTNL();
930
Eric Dumazetefe117a2009-11-05 11:06:40 +0100931 mutex_lock(&local->iflist_mtx);
Johannes Berg75636522008-07-09 14:40:35 +0200932 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
933 list_del(&sdata->list);
Johannes Bergc771c9d2009-01-23 22:54:03 +0100934
Eric Dumazetefe117a2009-11-05 11:06:40 +0100935 unregister_netdevice_queue(sdata->dev, &unreg_list);
Jiri Bencf0706e82007-05-05 11:45:53 -0700936 }
Eric Dumazetefe117a2009-11-05 11:06:40 +0100937 mutex_unlock(&local->iflist_mtx);
938 unregister_netdevice_many(&unreg_list);
Jiri Bencf0706e82007-05-05 11:45:53 -0700939}
Johannes Berg5cff20e2009-04-29 12:26:17 +0200940
941static u32 ieee80211_idle_off(struct ieee80211_local *local,
942 const char *reason)
943{
944 if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
945 return 0;
946
947#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
948 printk(KERN_DEBUG "%s: device no longer idle - %s\n",
949 wiphy_name(local->hw.wiphy), reason);
950#endif
951
952 local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
953 return IEEE80211_CONF_CHANGE_IDLE;
954}
955
956static u32 ieee80211_idle_on(struct ieee80211_local *local)
957{
958 if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
959 return 0;
960
961#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
962 printk(KERN_DEBUG "%s: device now idle\n",
963 wiphy_name(local->hw.wiphy));
964#endif
965
Johannes Berga80f7c02009-12-23 13:15:32 +0100966 drv_flush(local, false);
967
Johannes Berg5cff20e2009-04-29 12:26:17 +0200968 local->hw.conf.flags |= IEEE80211_CONF_IDLE;
969 return IEEE80211_CONF_CHANGE_IDLE;
970}
971
972u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
973{
974 struct ieee80211_sub_if_data *sdata;
975 int count = 0;
976
Johannes Bergaf6b6372009-12-23 13:15:35 +0100977 if (!list_empty(&local->work_list))
978 return ieee80211_idle_off(local, "working");
979
Helmut Schaafbe9c422009-07-23 12:14:04 +0200980 if (local->scanning)
Johannes Berg5cff20e2009-04-29 12:26:17 +0200981 return ieee80211_idle_off(local, "scanning");
982
983 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +0100984 if (!ieee80211_sdata_running(sdata))
Johannes Berg5cff20e2009-04-29 12:26:17 +0200985 continue;
986 /* do not count disabled managed interfaces */
987 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
Johannes Bergaf6b6372009-12-23 13:15:35 +0100988 !sdata->u.mgd.associated)
Johannes Berg5cff20e2009-04-29 12:26:17 +0200989 continue;
990 /* do not count unused IBSS interfaces */
991 if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
992 !sdata->u.ibss.ssid_len)
993 continue;
994 /* count everything else */
995 count++;
996 }
997
998 if (!count)
999 return ieee80211_idle_on(local);
1000 else
1001 return ieee80211_idle_off(local, "in use");
1002
1003 return 0;
1004}
1005
1006void ieee80211_recalc_idle(struct ieee80211_local *local)
1007{
1008 u32 chg;
1009
1010 mutex_lock(&local->iflist_mtx);
1011 chg = __ieee80211_recalc_idle(local);
1012 mutex_unlock(&local->iflist_mtx);
Johannes Berg58905ca2009-05-07 14:23:01 +02001013 if (chg)
1014 ieee80211_hw_config(local, chg);
Johannes Berg5cff20e2009-04-29 12:26:17 +02001015}
Johannes Berg47846c92009-11-25 17:46:19 +01001016
1017static int netdev_notify(struct notifier_block *nb,
1018 unsigned long state,
1019 void *ndev)
1020{
1021 struct net_device *dev = ndev;
1022 struct ieee80211_sub_if_data *sdata;
1023
1024 if (state != NETDEV_CHANGENAME)
1025 return 0;
1026
1027 if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
1028 return 0;
1029
1030 if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
1031 return 0;
1032
1033 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1034
Johannes Berg2f5265e2010-02-12 10:45:05 +01001035 memcpy(sdata->name, dev->name, IFNAMSIZ);
Johannes Berg47846c92009-11-25 17:46:19 +01001036
1037 ieee80211_debugfs_rename_netdev(sdata);
1038 return 0;
1039}
1040
1041static struct notifier_block mac80211_netdev_notifier = {
1042 .notifier_call = netdev_notify,
1043};
1044
1045int ieee80211_iface_init(void)
1046{
1047 return register_netdevice_notifier(&mac80211_netdev_notifier);
1048}
1049
1050void ieee80211_iface_exit(void)
1051{
1052 unregister_netdevice_notifier(&mac80211_netdev_notifier);
1053}