blob: c50cf6b9e28df025a25d56f453633e4f320c8929 [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"
Bill Jordan1be7fe82010-10-01 11:20:41 -040027#include "rate.h"
Jiri Bencf0706e82007-05-05 11:45:53 -070028
Johannes Bergc771c9d2009-01-23 22:54:03 +010029/**
30 * DOC: Interface list locking
31 *
32 * The interface list in each struct ieee80211_local is protected
33 * three-fold:
34 *
35 * (1) modifications may only be done under the RTNL
36 * (2) modifications and readers are protected against each other by
37 * the iflist_mtx.
38 * (3) modifications are done in an RCU manner so atomic readers
39 * can traverse the list in RCU-safe blocks.
40 *
41 * As a consequence, reads (traversals) of the list can be protected
42 * by either the RTNL, the iflist_mtx or RCU.
43 */
44
45
Johannes Bergcc45ae542012-06-21 22:30:52 +020046static u32 ieee80211_idle_off(struct ieee80211_local *local,
47 const char *reason)
48{
49 if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
50 return 0;
51
52 local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
53 return IEEE80211_CONF_CHANGE_IDLE;
54}
55
56static u32 ieee80211_idle_on(struct ieee80211_local *local)
57{
58 if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
59 return 0;
60
61 drv_flush(local, false);
62
63 local->hw.conf.flags |= IEEE80211_CONF_IDLE;
64 return IEEE80211_CONF_CHANGE_IDLE;
65}
66
67static u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
68{
69 struct ieee80211_sub_if_data *sdata;
70 int count = 0;
71 bool working = false, scanning = false;
72 unsigned int led_trig_start = 0, led_trig_stop = 0;
73 struct ieee80211_roc_work *roc;
74
75#ifdef CONFIG_PROVE_LOCKING
76 WARN_ON(debug_locks && !lockdep_rtnl_is_held() &&
77 !lockdep_is_held(&local->iflist_mtx));
78#endif
79 lockdep_assert_held(&local->mtx);
80
81 list_for_each_entry(sdata, &local->interfaces, list) {
82 if (!ieee80211_sdata_running(sdata)) {
83 sdata->vif.bss_conf.idle = true;
84 continue;
85 }
86
87 sdata->old_idle = sdata->vif.bss_conf.idle;
88
89 /* do not count disabled managed interfaces */
90 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
91 !sdata->u.mgd.associated &&
92 !sdata->u.mgd.auth_data &&
93 !sdata->u.mgd.assoc_data) {
94 sdata->vif.bss_conf.idle = true;
95 continue;
96 }
97 /* do not count unused IBSS interfaces */
98 if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
99 !sdata->u.ibss.ssid_len) {
100 sdata->vif.bss_conf.idle = true;
101 continue;
102 }
Johannes Bergf142c6b2012-06-18 20:07:15 +0200103
104 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
105 continue;
106
Johannes Bergcc45ae542012-06-21 22:30:52 +0200107 /* count everything else */
108 sdata->vif.bss_conf.idle = false;
109 count++;
110 }
111
112 if (!local->ops->remain_on_channel) {
113 list_for_each_entry(roc, &local->roc_list, list) {
114 working = true;
115 roc->sdata->vif.bss_conf.idle = false;
116 }
117 }
118
Johannes Berge2fd5dbc2012-07-06 21:39:28 +0200119 sdata = rcu_dereference_protected(local->scan_sdata,
120 lockdep_is_held(&local->mtx));
121 if (sdata && !(local->hw.flags & IEEE80211_HW_SCAN_WHILE_IDLE)) {
Johannes Bergcc45ae542012-06-21 22:30:52 +0200122 scanning = true;
Johannes Berge2fd5dbc2012-07-06 21:39:28 +0200123 sdata->vif.bss_conf.idle = false;
Johannes Bergcc45ae542012-06-21 22:30:52 +0200124 }
125
126 list_for_each_entry(sdata, &local->interfaces, list) {
127 if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
Johannes Bergf142c6b2012-06-18 20:07:15 +0200128 sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
129 sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
Johannes Bergcc45ae542012-06-21 22:30:52 +0200130 continue;
131 if (sdata->old_idle == sdata->vif.bss_conf.idle)
132 continue;
133 if (!ieee80211_sdata_running(sdata))
134 continue;
135 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_IDLE);
136 }
137
138 if (working || scanning)
139 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
140 else
141 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
142
143 if (count)
144 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
145 else
146 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
147
148 ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
149
150 if (working)
151 return ieee80211_idle_off(local, "working");
152 if (scanning)
153 return ieee80211_idle_off(local, "scanning");
154 if (!count)
155 return ieee80211_idle_on(local);
156 else
157 return ieee80211_idle_off(local, "in use");
158
159 return 0;
160}
161
162void ieee80211_recalc_idle(struct ieee80211_local *local)
163{
164 u32 chg;
165
166 mutex_lock(&local->iflist_mtx);
167 chg = __ieee80211_recalc_idle(local);
168 mutex_unlock(&local->iflist_mtx);
169 if (chg)
170 ieee80211_hw_config(local, chg);
171}
172
Johannes Berg0d143fe2008-09-11 00:01:59 +0200173static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
174{
175 int meshhdrlen;
176 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
177
178 meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;
179
180 /* FIX: what would be proper limits for MTU?
181 * This interface uses 802.3 frames. */
182 if (new_mtu < 256 ||
183 new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {
184 return -EINVAL;
185 }
186
Johannes Berg0d143fe2008-09-11 00:01:59 +0200187 dev->mtu = new_mtu;
188 return 0;
189}
190
Johannes Berg47846c92009-11-25 17:46:19 +0100191static int ieee80211_change_mac(struct net_device *dev, void *addr)
192{
193 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Kalle Valofc5f7572009-12-30 15:54:03 +0200194 struct sockaddr *sa = addr;
Johannes Berg47846c92009-11-25 17:46:19 +0100195 int ret;
196
Johannes Berg9607e6b2009-12-23 13:15:31 +0100197 if (ieee80211_sdata_running(sdata))
Johannes Berg47846c92009-11-25 17:46:19 +0100198 return -EBUSY;
199
Kalle Valofc5f7572009-12-30 15:54:03 +0200200 ret = eth_mac_addr(dev, sa);
Johannes Berg47846c92009-11-25 17:46:19 +0100201
202 if (ret == 0)
Kalle Valofc5f7572009-12-30 15:54:03 +0200203 memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +0100204
205 return ret;
206}
207
Johannes Berg0d143fe2008-09-11 00:01:59 +0200208static inline int identical_mac_addr_allowed(int type1, int type2)
209{
210 return type1 == NL80211_IFTYPE_MONITOR ||
211 type2 == NL80211_IFTYPE_MONITOR ||
Johannes Bergf142c6b2012-06-18 20:07:15 +0200212 type1 == NL80211_IFTYPE_P2P_DEVICE ||
213 type2 == NL80211_IFTYPE_P2P_DEVICE ||
Johannes Berg0d143fe2008-09-11 00:01:59 +0200214 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
215 (type1 == NL80211_IFTYPE_WDS &&
216 (type2 == NL80211_IFTYPE_WDS ||
217 type2 == NL80211_IFTYPE_AP)) ||
218 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
219 (type1 == NL80211_IFTYPE_AP_VLAN &&
220 (type2 == NL80211_IFTYPE_AP ||
221 type2 == NL80211_IFTYPE_AP_VLAN));
222}
223
Johannes Berg87490f62010-08-27 12:35:57 +0200224static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
225 enum nl80211_iftype iftype)
Johannes Berg0d143fe2008-09-11 00:01:59 +0200226{
Johannes Bergb4a4bf52008-09-26 13:34:54 +0200227 struct ieee80211_local *local = sdata->local;
Johannes Berg87490f62010-08-27 12:35:57 +0200228 struct ieee80211_sub_if_data *nsdata;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200229
Johannes Berg87490f62010-08-27 12:35:57 +0200230 ASSERT_RTNL();
Johannes Berg0d143fe2008-09-11 00:01:59 +0200231
232 /* we hold the RTNL here so can safely walk the list */
233 list_for_each_entry(nsdata, &local->interfaces, list) {
Johannes Berg371a2552012-06-19 15:54:05 +0200234 if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
Johannes Berg0d143fe2008-09-11 00:01:59 +0200235 /*
236 * Allow only a single IBSS interface to be up at any
237 * time. This is restricted because beacon distribution
238 * cannot work properly if both are in the same IBSS.
239 *
240 * To remove this restriction we'd have to disallow them
241 * from setting the same SSID on different IBSS interfaces
242 * belonging to the same hardware. Then, however, we're
243 * faced with having to adopt two different TSF timers...
244 */
Johannes Berg87490f62010-08-27 12:35:57 +0200245 if (iftype == NL80211_IFTYPE_ADHOC &&
Johannes Berg0d143fe2008-09-11 00:01:59 +0200246 nsdata->vif.type == NL80211_IFTYPE_ADHOC)
247 return -EBUSY;
248
249 /*
250 * The remaining checks are only performed for interfaces
251 * with the same MAC address.
252 */
Johannes Berg371a2552012-06-19 15:54:05 +0200253 if (!ether_addr_equal(sdata->vif.addr,
254 nsdata->vif.addr))
Johannes Berg0d143fe2008-09-11 00:01:59 +0200255 continue;
256
257 /*
258 * check whether it may have the same address
259 */
Johannes Berg87490f62010-08-27 12:35:57 +0200260 if (!identical_mac_addr_allowed(iftype,
Johannes Berg0d143fe2008-09-11 00:01:59 +0200261 nsdata->vif.type))
262 return -ENOTUNIQ;
263
264 /*
265 * can only add VLANs to enabled APs
266 */
Johannes Berg87490f62010-08-27 12:35:57 +0200267 if (iftype == NL80211_IFTYPE_AP_VLAN &&
Johannes Berg0d143fe2008-09-11 00:01:59 +0200268 nsdata->vif.type == NL80211_IFTYPE_AP)
269 sdata->bss = &nsdata->u.ap;
270 }
271 }
272
Johannes Berg87490f62010-08-27 12:35:57 +0200273 return 0;
274}
275
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200276static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata)
277{
278 int n_queues = sdata->local->hw.queues;
279 int i;
280
Ilan Peer0ef24e52012-08-21 12:43:35 +0300281 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
282 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
283 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==
284 IEEE80211_INVAL_HW_QUEUE))
285 return -EINVAL;
286 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=
287 n_queues))
288 return -EINVAL;
289 }
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200290 }
291
Luciano Coelhobb3e10f2012-04-12 16:09:49 +0300292 if ((sdata->vif.type != NL80211_IFTYPE_AP) ||
293 !(sdata->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) {
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200294 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
295 return 0;
296 }
297
298 if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))
299 return -EINVAL;
300
301 if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))
302 return -EINVAL;
303
304 return 0;
305}
306
Christian Lamparter85416a42010-10-02 13:17:07 +0200307void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
308 const int offset)
309{
310 struct ieee80211_local *local = sdata->local;
311 u32 flags = sdata->u.mntr_flags;
312
313#define ADJUST(_f, _s) do { \
314 if (flags & MONITOR_FLAG_##_f) \
315 local->fif_##_s += offset; \
316 } while (0)
317
318 ADJUST(FCSFAIL, fcsfail);
319 ADJUST(PLCPFAIL, plcpfail);
320 ADJUST(CONTROL, control);
321 ADJUST(CONTROL, pspoll);
322 ADJUST(OTHER_BSS, other_bss);
323
324#undef ADJUST
325}
326
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200327static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)
328{
329 struct ieee80211_local *local = sdata->local;
330 int i;
331
332 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
333 if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
334 sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
Johannes Berga9d3c052012-05-07 17:45:29 +0200335 else if (local->hw.queues >= IEEE80211_NUM_ACS)
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200336 sdata->vif.hw_queue[i] = i;
Johannes Berga9d3c052012-05-07 17:45:29 +0200337 else
338 sdata->vif.hw_queue[i] = 0;
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200339 }
340 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
341}
342
Johannes Berg075e0842012-07-12 19:28:31 +0200343static int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200344{
345 struct ieee80211_sub_if_data *sdata;
Johannes Berg685fb722012-07-11 16:38:09 +0200346 int ret = 0;
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200347
348 if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
349 return 0;
350
Johannes Berg685fb722012-07-11 16:38:09 +0200351 mutex_lock(&local->iflist_mtx);
352
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200353 if (local->monitor_sdata)
Johannes Berg685fb722012-07-11 16:38:09 +0200354 goto out_unlock;
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200355
356 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
Johannes Berg685fb722012-07-11 16:38:09 +0200357 if (!sdata) {
358 ret = -ENOMEM;
359 goto out_unlock;
360 }
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200361
362 /* set up data */
363 sdata->local = local;
364 sdata->vif.type = NL80211_IFTYPE_MONITOR;
365 snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
366 wiphy_name(local->hw.wiphy));
367
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200368 ieee80211_set_default_queues(sdata);
369
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200370 ret = drv_add_interface(local, sdata);
371 if (WARN_ON(ret)) {
372 /* ok .. stupid driver, it asked for this! */
373 kfree(sdata);
Johannes Berg685fb722012-07-11 16:38:09 +0200374 goto out_unlock;
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200375 }
376
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200377 ret = ieee80211_check_queues(sdata);
378 if (ret) {
379 kfree(sdata);
Johannes Berg685fb722012-07-11 16:38:09 +0200380 goto out_unlock;
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200381 }
382
Johannes Berg55de9082012-07-26 17:24:39 +0200383 ret = ieee80211_vif_use_channel(sdata, local->monitor_channel,
384 local->monitor_channel_type,
385 IEEE80211_CHANCTX_EXCLUSIVE);
386 if (ret) {
387 drv_remove_interface(local, sdata);
388 kfree(sdata);
389 goto out_unlock;
390 }
391
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200392 rcu_assign_pointer(local->monitor_sdata, sdata);
Johannes Berg685fb722012-07-11 16:38:09 +0200393 out_unlock:
394 mutex_unlock(&local->iflist_mtx);
395 return ret;
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200396}
397
Johannes Berg075e0842012-07-12 19:28:31 +0200398static void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200399{
400 struct ieee80211_sub_if_data *sdata;
401
402 if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
403 return;
404
Johannes Berg685fb722012-07-11 16:38:09 +0200405 mutex_lock(&local->iflist_mtx);
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200406
Johannes Berg685fb722012-07-11 16:38:09 +0200407 sdata = rcu_dereference_protected(local->monitor_sdata,
408 lockdep_is_held(&local->iflist_mtx));
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200409 if (!sdata)
Johannes Berg685fb722012-07-11 16:38:09 +0200410 goto out_unlock;
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200411
412 rcu_assign_pointer(local->monitor_sdata, NULL);
413 synchronize_net();
414
Johannes Berg55de9082012-07-26 17:24:39 +0200415 ieee80211_vif_release_channel(sdata);
416
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200417 drv_remove_interface(local, sdata);
418
419 kfree(sdata);
Johannes Berg685fb722012-07-11 16:38:09 +0200420 out_unlock:
421 mutex_unlock(&local->iflist_mtx);
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200422}
423
Johannes Berg34d4bc42010-08-27 12:35:58 +0200424/*
425 * NOTE: Be very careful when changing this function, it must NOT return
426 * an error on interface type changes that have been pre-checked, so most
427 * checks should be in ieee80211_check_concurrent_iface.
428 */
Johannes Bergf142c6b2012-06-18 20:07:15 +0200429int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
Johannes Berg87490f62010-08-27 12:35:57 +0200430{
Johannes Bergf142c6b2012-06-18 20:07:15 +0200431 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
432 struct net_device *dev = wdev->netdev;
Johannes Berg87490f62010-08-27 12:35:57 +0200433 struct ieee80211_local *local = sdata->local;
434 struct sta_info *sta;
435 u32 changed = 0;
436 int res;
437 u32 hw_reconf_flags = 0;
438
Johannes Berg0d143fe2008-09-11 00:01:59 +0200439 switch (sdata->vif.type) {
440 case NL80211_IFTYPE_WDS:
441 if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
442 return -ENOLINK;
443 break;
Johannes Berg665c93a2011-11-04 11:18:11 +0100444 case NL80211_IFTYPE_AP_VLAN: {
445 struct ieee80211_sub_if_data *master;
446
Johannes Berg0d143fe2008-09-11 00:01:59 +0200447 if (!sdata->bss)
448 return -ENOLINK;
Johannes Berg665c93a2011-11-04 11:18:11 +0100449
Johannes Berg0d143fe2008-09-11 00:01:59 +0200450 list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
Johannes Berg665c93a2011-11-04 11:18:11 +0100451
452 master = container_of(sdata->bss,
453 struct ieee80211_sub_if_data, u.ap);
454 sdata->control_port_protocol =
455 master->control_port_protocol;
456 sdata->control_port_no_encrypt =
457 master->control_port_no_encrypt;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200458 break;
Johannes Berg665c93a2011-11-04 11:18:11 +0100459 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200460 case NL80211_IFTYPE_AP:
461 sdata->bss = &sdata->u.ap;
462 break;
463 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg0d143fe2008-09-11 00:01:59 +0200464 case NL80211_IFTYPE_STATION:
465 case NL80211_IFTYPE_MONITOR:
466 case NL80211_IFTYPE_ADHOC:
Johannes Bergf142c6b2012-06-18 20:07:15 +0200467 case NL80211_IFTYPE_P2P_DEVICE:
Johannes Berg0d143fe2008-09-11 00:01:59 +0200468 /* no special treatment */
469 break;
470 case NL80211_IFTYPE_UNSPECIFIED:
Johannes Berg2e161f72010-08-12 15:38:38 +0200471 case NUM_NL80211_IFTYPES:
Johannes Berg2ca27bc2010-09-16 14:58:23 +0200472 case NL80211_IFTYPE_P2P_CLIENT:
473 case NL80211_IFTYPE_P2P_GO:
Johannes Berg0d143fe2008-09-11 00:01:59 +0200474 /* cannot happen */
475 WARN_ON(1);
476 break;
477 }
478
479 if (local->open_count == 0) {
Johannes Berg24487982009-04-23 18:52:52 +0200480 res = drv_start(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200481 if (res)
482 goto err_del_bss;
John W. Linville4e6cbfd2010-07-29 16:14:13 -0400483 if (local->ops->napi_poll)
484 napi_enable(&local->napi);
Johannes Berge8975582008-10-09 12:18:51 +0200485 /* we're brought up, everything changes */
486 hw_reconf_flags = ~0;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200487 ieee80211_led_radio(local, true);
Johannes Berg67408c82010-11-30 08:59:23 +0100488 ieee80211_mod_tpt_led_trig(local,
489 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200490 }
491
492 /*
Johannes Bergbf533e02010-08-27 12:35:56 +0200493 * Copy the hopefully now-present MAC address to
494 * this interface, if it has the special null one.
Johannes Berg0d143fe2008-09-11 00:01:59 +0200495 */
Johannes Bergf142c6b2012-06-18 20:07:15 +0200496 if (dev && is_zero_ether_addr(dev->dev_addr)) {
Johannes Bergbf533e02010-08-27 12:35:56 +0200497 memcpy(dev->dev_addr,
498 local->hw.wiphy->perm_addr,
499 ETH_ALEN);
500 memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200501
Johannes Bergbf533e02010-08-27 12:35:56 +0200502 if (!is_valid_ether_addr(dev->dev_addr)) {
Johannes Berg4d6c36f2012-04-03 14:45:54 +0200503 res = -EADDRNOTAVAIL;
504 goto err_stop;
John W. Linville0adc23f2009-10-06 16:27:18 -0400505 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200506 }
507
Johannes Berg0d143fe2008-09-11 00:01:59 +0200508 switch (sdata->vif.type) {
509 case NL80211_IFTYPE_AP_VLAN:
Johannes Berg3edaf3e2012-04-03 10:24:00 +0200510 /* no need to tell driver, but set carrier */
511 if (rtnl_dereference(sdata->bss->beacon))
512 netif_carrier_on(dev);
513 else
514 netif_carrier_off(dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200515 break;
516 case NL80211_IFTYPE_MONITOR:
517 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
518 local->cooked_mntrs++;
519 break;
520 }
521
Johannes Berg075e0842012-07-12 19:28:31 +0200522 if (local->monitors == 0 && local->open_count == 0) {
523 res = ieee80211_add_virtual_monitor(local);
524 if (res)
525 goto err_stop;
526 }
527
Johannes Berg0d143fe2008-09-11 00:01:59 +0200528 /* must be before the call to ieee80211_configure_filter */
529 local->monitors++;
Johannes Berge8975582008-10-09 12:18:51 +0200530 if (local->monitors == 1) {
Johannes Berg0869aea2009-10-28 10:03:35 +0100531 local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
532 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
Johannes Berge8975582008-10-09 12:18:51 +0200533 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200534
Christian Lamparter85416a42010-10-02 13:17:07 +0200535 ieee80211_adjust_monitor_flags(sdata, 1);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200536 ieee80211_configure_filter(local);
David Gnedt53e9b1d2010-07-19 20:44:02 +0200537
538 netif_carrier_on(dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200539 break;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200540 default:
Johannes Berg34d4bc42010-08-27 12:35:58 +0200541 if (coming_up) {
Johannes Berg075e0842012-07-12 19:28:31 +0200542 ieee80211_del_virtual_monitor(local);
543
Johannes Berg7b7eab62011-11-03 14:41:13 +0100544 res = drv_add_interface(local, sdata);
Johannes Berg34d4bc42010-08-27 12:35:58 +0200545 if (res)
546 goto err_stop;
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200547 res = ieee80211_check_queues(sdata);
548 if (res)
549 goto err_del_interface;
Johannes Berg34d4bc42010-08-27 12:35:58 +0200550 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200551
Johannes Berg29cbe682010-12-03 09:20:44 +0100552 if (sdata->vif.type == NL80211_IFTYPE_AP) {
Igor Perminove3b90ca2009-08-04 16:48:51 +0400553 local->fif_pspoll++;
Johannes Berg7be50862010-10-13 12:06:24 +0200554 local->fif_probe_req++;
Igor Perminove3b90ca2009-08-04 16:48:51 +0400555
Igor Perminove3b90ca2009-08-04 16:48:51 +0400556 ieee80211_configure_filter(local);
Johannes Berg7be50862010-10-13 12:06:24 +0200557 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
558 local->fif_probe_req++;
Andrey Yurovskya3c9aa52008-10-31 14:50:12 -0700559 }
Igor Perminove3b90ca2009-08-04 16:48:51 +0400560
Johannes Bergf142c6b2012-06-18 20:07:15 +0200561 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
562 changed |= ieee80211_reset_erp_info(sdata);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200563 ieee80211_bss_info_change_notify(sdata, changed);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200564
Johannes Bergc405c622012-07-30 19:44:12 +0200565 switch (sdata->vif.type) {
566 case NL80211_IFTYPE_STATION:
567 case NL80211_IFTYPE_ADHOC:
568 case NL80211_IFTYPE_AP:
569 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg0d143fe2008-09-11 00:01:59 +0200570 netif_carrier_off(dev);
Johannes Bergc405c622012-07-30 19:44:12 +0200571 break;
Johannes Berg1411af12012-07-30 19:48:09 +0200572 case NL80211_IFTYPE_WDS:
Johannes Bergf142c6b2012-06-18 20:07:15 +0200573 case NL80211_IFTYPE_P2P_DEVICE:
Johannes Berg1411af12012-07-30 19:48:09 +0200574 break;
Johannes Bergc405c622012-07-30 19:44:12 +0200575 default:
Johannes Berg0d143fe2008-09-11 00:01:59 +0200576 netif_carrier_on(dev);
Johannes Bergc405c622012-07-30 19:44:12 +0200577 }
Eliad Peller59034592011-10-16 10:57:31 +0200578
579 /*
580 * set default queue parameters so drivers don't
581 * need to initialise the hardware if the hardware
582 * doesn't start up with sane defaults
583 */
Johannes Berg3abead52012-03-02 15:56:59 +0100584 ieee80211_set_wmm_default(sdata, true);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200585 }
586
Johannes Berg2d2080c2010-09-15 15:13:13 +0200587 set_bit(SDATA_STATE_RUNNING, &sdata->state);
588
Johannes Berg0d143fe2008-09-11 00:01:59 +0200589 if (sdata->vif.type == NL80211_IFTYPE_WDS) {
590 /* Create STA entry for the WDS peer */
591 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
592 GFP_KERNEL);
593 if (!sta) {
594 res = -ENOMEM;
595 goto err_del_interface;
596 }
597
Johannes Berg83d5cc02012-01-12 09:31:10 +0100598 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
599 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
600 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200601
602 res = sta_info_insert(sta);
603 if (res) {
604 /* STA has been freed */
605 goto err_del_interface;
606 }
Bill Jordan1be7fe82010-10-01 11:20:41 -0400607
608 rate_control_rate_init(sta);
Johannes Berg1411af12012-07-30 19:48:09 +0200609 netif_carrier_on(dev);
Johannes Bergf142c6b2012-06-18 20:07:15 +0200610 } else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
611 rcu_assign_pointer(local->p2p_sdata, sdata);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200612 }
613
Johannes Berg0d143fe2008-09-11 00:01:59 +0200614 /*
615 * set_multicast_list will be invoked by the networking core
616 * which will check whether any increments here were done in
617 * error and sync them down to the hardware as filter flags.
618 */
619 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
620 atomic_inc(&local->iff_allmultis);
621
622 if (sdata->flags & IEEE80211_SDATA_PROMISC)
623 atomic_inc(&local->iff_promiscs);
624
Johannes Berg7da7cc12010-08-05 17:02:38 +0200625 mutex_lock(&local->mtx);
Johannes Berg5cff20e2009-04-29 12:26:17 +0200626 hw_reconf_flags |= __ieee80211_recalc_idle(local);
Johannes Berg7da7cc12010-08-05 17:02:38 +0200627 mutex_unlock(&local->mtx);
Johannes Berg5cff20e2009-04-29 12:26:17 +0200628
Johannes Berg34d4bc42010-08-27 12:35:58 +0200629 if (coming_up)
630 local->open_count++;
631
Eliad Peller59034592011-10-16 10:57:31 +0200632 if (hw_reconf_flags)
Johannes Berge8975582008-10-09 12:18:51 +0200633 ieee80211_hw_config(local, hw_reconf_flags);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200634
Johannes Berg10f644a2009-04-16 13:17:25 +0200635 ieee80211_recalc_ps(local, -1);
Johannes Berg965beda2009-04-16 13:17:24 +0200636
Johannes Bergf142c6b2012-06-18 20:07:15 +0200637 if (dev)
638 netif_tx_start_all_queues(dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200639
640 return 0;
641 err_del_interface:
Johannes Berg7b7eab62011-11-03 14:41:13 +0100642 drv_remove_interface(local, sdata);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200643 err_stop:
Johannes Berg24487982009-04-23 18:52:52 +0200644 if (!local->open_count)
645 drv_stop(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200646 err_del_bss:
647 sdata->bss = NULL;
648 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
649 list_del(&sdata->u.vlan.list);
Johannes Berg4d6c36f2012-04-03 14:45:54 +0200650 /* might already be clear but that doesn't matter */
Johannes Berg2d2080c2010-09-15 15:13:13 +0200651 clear_bit(SDATA_STATE_RUNNING, &sdata->state);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200652 return res;
653}
654
Johannes Berg34d4bc42010-08-27 12:35:58 +0200655static int ieee80211_open(struct net_device *dev)
Johannes Berg0d143fe2008-09-11 00:01:59 +0200656{
657 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Berg34d4bc42010-08-27 12:35:58 +0200658 int err;
659
660 /* fail early if user set an invalid address */
Mohammed Shafi Shajakhan2fcf28242011-07-12 15:19:04 +0530661 if (!is_valid_ether_addr(dev->dev_addr))
Johannes Berg34d4bc42010-08-27 12:35:58 +0200662 return -EADDRNOTAVAIL;
663
664 err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
665 if (err)
666 return err;
667
Johannes Bergf142c6b2012-06-18 20:07:15 +0200668 return ieee80211_do_open(&sdata->wdev, true);
Johannes Berg34d4bc42010-08-27 12:35:58 +0200669}
670
671static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
672 bool going_down)
673{
Johannes Berg0d143fe2008-09-11 00:01:59 +0200674 struct ieee80211_local *local = sdata->local;
Johannes Berg5061b0c2009-07-14 00:33:34 +0200675 unsigned long flags;
676 struct sk_buff *skb, *tmp;
Johannes Berge8975582008-10-09 12:18:51 +0200677 u32 hw_reconf_flags = 0;
Johannes Berg5061b0c2009-07-14 00:33:34 +0200678 int i;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200679
Rajkumar Manoharanc29acf22011-05-14 09:43:28 +0530680 clear_bit(SDATA_STATE_RUNNING, &sdata->state);
681
Johannes Berge2fd5dbc2012-07-06 21:39:28 +0200682 if (rcu_access_pointer(local->scan_sdata) == sdata)
Brian Cavagnolo352ffad2010-11-04 16:59:28 -0700683 ieee80211_scan_cancel(local);
684
Johannes Berg0d143fe2008-09-11 00:01:59 +0200685 /*
686 * Stop TX on this interface first.
687 */
Johannes Bergf142c6b2012-06-18 20:07:15 +0200688 if (sdata->dev)
689 netif_tx_stop_all_queues(sdata->dev);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200690
Johannes Berg2eb278e2012-06-05 14:28:42 +0200691 ieee80211_roc_purge(sdata);
Johannes Bergaf6b6372009-12-23 13:15:35 +0100692
693 /*
Johannes Berg0d143fe2008-09-11 00:01:59 +0200694 * Remove all stations associated with this interface.
695 *
696 * This must be done before calling ops->remove_interface()
697 * because otherwise we can later invoke ops->sta_notify()
698 * whenever the STAs are removed, and that invalidates driver
699 * assumptions about always getting a vif pointer that is valid
700 * (because if we remove a STA after ops->remove_interface()
701 * the driver will have removed the vif info already!)
702 *
Johannes Bergb9dcf712010-08-27 12:35:54 +0200703 * This is relevant only in AP, WDS and mesh modes, since in
704 * all other modes we've already removed all stations when
705 * disconnecting etc.
Johannes Berg0d143fe2008-09-11 00:01:59 +0200706 */
707 sta_info_flush(local, sdata);
708
709 /*
710 * Don't count this interface for promisc/allmulti while it
711 * is down. dev_mc_unsync() will invoke set_multicast_list
712 * on the master interface which will sync these down to the
713 * hardware as filter flags.
714 */
715 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
716 atomic_dec(&local->iff_allmultis);
717
718 if (sdata->flags & IEEE80211_SDATA_PROMISC)
719 atomic_dec(&local->iff_promiscs);
720
Johannes Berg7be50862010-10-13 12:06:24 +0200721 if (sdata->vif.type == NL80211_IFTYPE_AP) {
Igor Perminove3b90ca2009-08-04 16:48:51 +0400722 local->fif_pspoll--;
Johannes Berg7be50862010-10-13 12:06:24 +0200723 local->fif_probe_req--;
724 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
725 local->fif_probe_req--;
726 }
Igor Perminove3b90ca2009-08-04 16:48:51 +0400727
Johannes Bergf142c6b2012-06-18 20:07:15 +0200728 if (sdata->dev) {
729 netif_addr_lock_bh(sdata->dev);
730 spin_lock_bh(&local->filter_lock);
731 __hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
732 sdata->dev->addr_len);
733 spin_unlock_bh(&local->filter_lock);
734 netif_addr_unlock_bh(sdata->dev);
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200735
Johannes Bergf142c6b2012-06-18 20:07:15 +0200736 ieee80211_configure_filter(local);
737 }
Johannes Berg3ac64be2009-08-17 16:16:53 +0200738
Vivek Natarajan7cbf0ba2008-12-24 00:34:37 -0800739 del_timer_sync(&local->dynamic_ps_timer);
740 cancel_work_sync(&local->dynamic_ps_enable_work);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200741
Johannes Berg04ecd252012-09-11 14:34:12 +0200742 cancel_work_sync(&sdata->recalc_smps);
743
Johannes Berg0d143fe2008-09-11 00:01:59 +0200744 /* APs need special treatment */
745 if (sdata->vif.type == NL80211_IFTYPE_AP) {
Johannes Berg57c9fff2009-07-29 15:46:21 +0200746 struct ieee80211_sub_if_data *vlan, *tmpsdata;
Johannes Berg40b275b2011-05-13 14:15:49 +0200747 struct beacon_data *old_beacon =
748 rtnl_dereference(sdata->u.ap.beacon);
Eyal Shapiraaa7a0082012-08-06 14:26:16 +0300749 struct probe_resp *old_probe_resp =
Arik Nemtsov02945822011-11-10 11:28:57 +0200750 rtnl_dereference(sdata->u.ap.probe_resp);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200751
Johannes Bergb9dcf712010-08-27 12:35:54 +0200752 /* sdata_running will return false, so this will disable */
753 ieee80211_bss_info_change_notify(sdata,
754 BSS_CHANGED_BEACON_ENABLED);
755
Arik Nemtsov02945822011-11-10 11:28:57 +0200756 /* remove beacon and probe response */
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +0000757 RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
Arik Nemtsov02945822011-11-10 11:28:57 +0200758 RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200759 synchronize_rcu();
760 kfree(old_beacon);
Eyal Shapiraaa7a0082012-08-06 14:26:16 +0300761 kfree(old_probe_resp);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200762
763 /* down all dependent devices, that is VLANs */
Johannes Berg57c9fff2009-07-29 15:46:21 +0200764 list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
Johannes Berg0d143fe2008-09-11 00:01:59 +0200765 u.vlan.list)
766 dev_close(vlan->dev);
767 WARN_ON(!list_empty(&sdata->u.ap.vlans));
Johannes Berg6f2d9332011-09-20 17:40:51 +0200768
769 /* free all potentially still buffered bcast frames */
Marco Porschd012a602012-10-10 12:39:50 -0700770 local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps.bc_buf);
771 skb_queue_purge(&sdata->u.ap.ps.bc_buf);
Eliad Pellerafa762f2012-04-23 14:45:15 +0300772 } else if (sdata->vif.type == NL80211_IFTYPE_STATION) {
773 ieee80211_mgd_stop(sdata);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200774 }
775
Johannes Berg34d4bc42010-08-27 12:35:58 +0200776 if (going_down)
777 local->open_count--;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200778
779 switch (sdata->vif.type) {
780 case NL80211_IFTYPE_AP_VLAN:
781 list_del(&sdata->u.vlan.list);
782 /* no need to tell driver */
783 break;
784 case NL80211_IFTYPE_MONITOR:
785 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
786 local->cooked_mntrs--;
787 break;
788 }
789
790 local->monitors--;
Johannes Berge8975582008-10-09 12:18:51 +0200791 if (local->monitors == 0) {
Johannes Berg0869aea2009-10-28 10:03:35 +0100792 local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
793 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
Johannes Berg075e0842012-07-12 19:28:31 +0200794 ieee80211_del_virtual_monitor(local);
Johannes Berge8975582008-10-09 12:18:51 +0200795 }
Johannes Berg0d143fe2008-09-11 00:01:59 +0200796
Christian Lamparter85416a42010-10-02 13:17:07 +0200797 ieee80211_adjust_monitor_flags(sdata, -1);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200798 ieee80211_configure_filter(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200799 break;
Johannes Bergf142c6b2012-06-18 20:07:15 +0200800 case NL80211_IFTYPE_P2P_DEVICE:
801 /* relies on synchronize_rcu() below */
802 rcu_assign_pointer(local->p2p_sdata, NULL);
803 /* fall through */
Johannes Berg0d143fe2008-09-11 00:01:59 +0200804 default:
Johannes Bergc1475ca2010-06-10 10:21:37 +0200805 flush_work(&sdata->work);
Johannes Berg35f20c12010-06-10 10:21:30 +0200806 /*
807 * When we get here, the interface is marked down.
Eliad Pellerb22cfcf2012-09-09 14:43:51 +0300808 * Call rcu_barrier() to wait both for the RX path
Johannes Berg35f20c12010-06-10 10:21:30 +0200809 * should it be using the interface and enqueuing
Eliad Pellerb22cfcf2012-09-09 14:43:51 +0300810 * frames at this very time on another CPU, and
811 * for the sta free call_rcu callbacks.
Johannes Berg35f20c12010-06-10 10:21:30 +0200812 */
Eliad Pellerb22cfcf2012-09-09 14:43:51 +0300813 rcu_barrier();
814
815 /*
816 * free_sta_rcu() enqueues a work for the actual
817 * sta cleanup, so we need to flush it while
818 * sdata is still valid.
819 */
820 flush_workqueue(local->workqueue);
821
Johannes Berg35f20c12010-06-10 10:21:30 +0200822 skb_queue_purge(&sdata->skb_queue);
823
Bob Copeland97af7432009-07-29 10:13:03 +0200824 /*
Johannes Bergb9dcf712010-08-27 12:35:54 +0200825 * Free all remaining keys, there shouldn't be any,
826 * except maybe group keys in AP more or WDS?
827 */
Johannes Bergad0e2b52010-06-01 10:19:19 +0200828 ieee80211_free_keys(sdata);
Johannes Bergb9dcf712010-08-27 12:35:54 +0200829
Johannes Berg34d4bc42010-08-27 12:35:58 +0200830 if (going_down)
Johannes Berg7b7eab62011-11-03 14:41:13 +0100831 drv_remove_interface(local, sdata);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200832 }
833
834 sdata->bss = NULL;
835
Johannes Berg7da7cc12010-08-05 17:02:38 +0200836 mutex_lock(&local->mtx);
Johannes Berg5cff20e2009-04-29 12:26:17 +0200837 hw_reconf_flags |= __ieee80211_recalc_idle(local);
Johannes Berg7da7cc12010-08-05 17:02:38 +0200838 mutex_unlock(&local->mtx);
Johannes Berg5cff20e2009-04-29 12:26:17 +0200839
840 ieee80211_recalc_ps(local, -1);
841
Johannes Berg0d143fe2008-09-11 00:01:59 +0200842 if (local->open_count == 0) {
John W. Linville4e6cbfd2010-07-29 16:14:13 -0400843 if (local->ops->napi_poll)
844 napi_disable(&local->napi);
Johannes Bergea77f122009-08-21 14:44:45 +0200845 ieee80211_clear_tx_pending(local);
Johannes Berg84f6a012009-08-20 20:02:20 +0200846 ieee80211_stop_device(local);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200847
Johannes Berge8975582008-10-09 12:18:51 +0200848 /* no reconfiguring after stop! */
849 hw_reconf_flags = 0;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200850 }
851
Johannes Berge8975582008-10-09 12:18:51 +0200852 /* do after stop to avoid reconfiguring when we stop anyway */
Johannes Berg55de9082012-07-26 17:24:39 +0200853 if (hw_reconf_flags)
Johannes Berge8975582008-10-09 12:18:51 +0200854 ieee80211_hw_config(local, hw_reconf_flags);
855
Johannes Berg5061b0c2009-07-14 00:33:34 +0200856 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
857 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
858 skb_queue_walk_safe(&local->pending[i], skb, tmp) {
859 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
860 if (info->control.vif == &sdata->vif) {
861 __skb_unlink(skb, &local->pending[i]);
862 dev_kfree_skb_irq(skb);
863 }
864 }
865 }
866 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
Johannes Berg075e0842012-07-12 19:28:31 +0200867
868 if (local->monitors == local->open_count && local->monitors > 0)
869 ieee80211_add_virtual_monitor(local);
Johannes Berg34d4bc42010-08-27 12:35:58 +0200870}
871
872static int ieee80211_stop(struct net_device *dev)
873{
874 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
875
876 ieee80211_do_stop(sdata, true);
Johannes Berg5061b0c2009-07-14 00:33:34 +0200877
Johannes Berg0d143fe2008-09-11 00:01:59 +0200878 return 0;
879}
880
881static void ieee80211_set_multicast_list(struct net_device *dev)
882{
Johannes Berg0d143fe2008-09-11 00:01:59 +0200883 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Bergb4a4bf52008-09-26 13:34:54 +0200884 struct ieee80211_local *local = sdata->local;
Johannes Berg0d143fe2008-09-11 00:01:59 +0200885 int allmulti, promisc, sdata_allmulti, sdata_promisc;
886
887 allmulti = !!(dev->flags & IFF_ALLMULTI);
888 promisc = !!(dev->flags & IFF_PROMISC);
889 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
890 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
891
892 if (allmulti != sdata_allmulti) {
893 if (dev->flags & IFF_ALLMULTI)
894 atomic_inc(&local->iff_allmultis);
895 else
896 atomic_dec(&local->iff_allmultis);
897 sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
898 }
899
900 if (promisc != sdata_promisc) {
901 if (dev->flags & IFF_PROMISC)
902 atomic_inc(&local->iff_promiscs);
903 else
904 atomic_dec(&local->iff_promiscs);
905 sdata->flags ^= IEEE80211_SDATA_PROMISC;
906 }
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200907 spin_lock_bh(&local->filter_lock);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000908 __hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200909 spin_unlock_bh(&local->filter_lock);
Johannes Berg3ac64be2009-08-17 16:16:53 +0200910 ieee80211_queue_work(&local->hw, &local->reconfig_filter);
Johannes Berg0d143fe2008-09-11 00:01:59 +0200911}
912
Johannes Berg75636522008-07-09 14:40:35 +0200913/*
914 * Called when the netdev is removed or, by the code below, before
915 * the interface type changes.
916 */
Johannes Bergf142c6b2012-06-18 20:07:15 +0200917static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
Jiri Bencf0706e82007-05-05 11:45:53 -0700918{
Johannes Berg75636522008-07-09 14:40:35 +0200919 struct ieee80211_local *local = sdata->local;
Johannes Berg75636522008-07-09 14:40:35 +0200920 int flushed;
Jiri Bencf0706e82007-05-05 11:45:53 -0700921 int i;
922
Johannes Berg75636522008-07-09 14:40:35 +0200923 /* free extra data */
924 ieee80211_free_keys(sdata);
Jiri Bencf0706e82007-05-05 11:45:53 -0700925
Jouni Malinenaee14ce2008-09-09 16:33:15 +0200926 ieee80211_debugfs_remove_netdev(sdata);
927
Johannes Berg988c0f72008-04-17 19:21:22 +0200928 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
Jiri Bencf0706e82007-05-05 11:45:53 -0700929 __skb_queue_purge(&sdata->fragments[i].skb_list);
Johannes Berg75636522008-07-09 14:40:35 +0200930 sdata->fragment_next = 0;
931
Johannes Bergb9dcf712010-08-27 12:35:54 +0200932 if (ieee80211_vif_is_mesh(&sdata->vif))
933 mesh_rmc_free(sdata);
Johannes Berg75636522008-07-09 14:40:35 +0200934
935 flushed = sta_info_flush(local, sdata);
936 WARN_ON(flushed);
Jiri Bencf0706e82007-05-05 11:45:53 -0700937}
938
Johannes Bergf142c6b2012-06-18 20:07:15 +0200939static void ieee80211_uninit(struct net_device *dev)
940{
941 ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
942}
943
Johannes Bergcf0277e2010-01-05 18:00:58 +0100944static u16 ieee80211_netdev_select_queue(struct net_device *dev,
945 struct sk_buff *skb)
946{
947 return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
948}
949
Johannes Berg587e7292009-01-30 13:35:22 +0100950static const struct net_device_ops ieee80211_dataif_ops = {
951 .ndo_open = ieee80211_open,
952 .ndo_stop = ieee80211_stop,
Johannes Bergf142c6b2012-06-18 20:07:15 +0200953 .ndo_uninit = ieee80211_uninit,
Johannes Berg587e7292009-01-30 13:35:22 +0100954 .ndo_start_xmit = ieee80211_subif_start_xmit,
Jiri Pirkoafc4b132011-08-16 06:29:01 +0000955 .ndo_set_rx_mode = ieee80211_set_multicast_list,
Johannes Berg587e7292009-01-30 13:35:22 +0100956 .ndo_change_mtu = ieee80211_change_mtu,
Johannes Berg47846c92009-11-25 17:46:19 +0100957 .ndo_set_mac_address = ieee80211_change_mac,
Johannes Bergcf0277e2010-01-05 18:00:58 +0100958 .ndo_select_queue = ieee80211_netdev_select_queue,
Johannes Berg587e7292009-01-30 13:35:22 +0100959};
960
Johannes Bergcf0277e2010-01-05 18:00:58 +0100961static u16 ieee80211_monitor_select_queue(struct net_device *dev,
962 struct sk_buff *skb)
963{
964 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
965 struct ieee80211_local *local = sdata->local;
966 struct ieee80211_hdr *hdr;
967 struct ieee80211_radiotap_header *rtap = (void *)skb->data;
968
Johannes Berg32c50572012-03-28 11:04:29 +0200969 if (local->hw.queues < IEEE80211_NUM_ACS)
Johannes Bergcf0277e2010-01-05 18:00:58 +0100970 return 0;
971
972 if (skb->len < 4 ||
Johannes Bergb49bb572010-01-08 19:00:00 +0100973 skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
Johannes Bergcf0277e2010-01-05 18:00:58 +0100974 return 0; /* doesn't matter, frame will be dropped */
975
Johannes Bergb49bb572010-01-08 19:00:00 +0100976 hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
Johannes Bergcf0277e2010-01-05 18:00:58 +0100977
Yoni Divinsky00e96de2012-06-20 15:39:13 +0300978 return ieee80211_select_queue_80211(sdata, skb, hdr);
Johannes Bergcf0277e2010-01-05 18:00:58 +0100979}
980
Johannes Berg587e7292009-01-30 13:35:22 +0100981static const struct net_device_ops ieee80211_monitorif_ops = {
982 .ndo_open = ieee80211_open,
983 .ndo_stop = ieee80211_stop,
Johannes Bergf142c6b2012-06-18 20:07:15 +0200984 .ndo_uninit = ieee80211_uninit,
Johannes Berg587e7292009-01-30 13:35:22 +0100985 .ndo_start_xmit = ieee80211_monitor_start_xmit,
Jiri Pirkoafc4b132011-08-16 06:29:01 +0000986 .ndo_set_rx_mode = ieee80211_set_multicast_list,
Johannes Berg587e7292009-01-30 13:35:22 +0100987 .ndo_change_mtu = ieee80211_change_mtu,
988 .ndo_set_mac_address = eth_mac_addr,
Johannes Bergcf0277e2010-01-05 18:00:58 +0100989 .ndo_select_queue = ieee80211_monitor_select_queue,
Johannes Berg587e7292009-01-30 13:35:22 +0100990};
991
992static void ieee80211_if_setup(struct net_device *dev)
993{
994 ether_setup(dev);
Neil Horman550fd082011-07-26 06:05:38 +0000995 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
Johannes Berg587e7292009-01-30 13:35:22 +0100996 dev->netdev_ops = &ieee80211_dataif_ops;
Johannes Berg587e7292009-01-30 13:35:22 +0100997 dev->destructor = free_netdev;
998}
999
Johannes Berg1fa57d02010-06-10 10:21:32 +02001000static void ieee80211_iface_work(struct work_struct *work)
1001{
1002 struct ieee80211_sub_if_data *sdata =
1003 container_of(work, struct ieee80211_sub_if_data, work);
1004 struct ieee80211_local *local = sdata->local;
1005 struct sk_buff *skb;
Johannes Berg344eec62010-06-10 10:21:36 +02001006 struct sta_info *sta;
Johannes Bergc1475ca2010-06-10 10:21:37 +02001007 struct ieee80211_ra_tid *ra_tid;
Johannes Berg1fa57d02010-06-10 10:21:32 +02001008
1009 if (!ieee80211_sdata_running(sdata))
1010 return;
1011
1012 if (local->scanning)
1013 return;
1014
1015 /*
1016 * ieee80211_queue_work() should have picked up most cases,
1017 * here we'll pick the rest.
1018 */
1019 if (WARN(local->suspended,
1020 "interface work scheduled while going to suspend\n"))
1021 return;
1022
1023 /* first process frames */
1024 while ((skb = skb_dequeue(&sdata->skb_queue))) {
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02001025 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1026
Johannes Bergc1475ca2010-06-10 10:21:37 +02001027 if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {
1028 ra_tid = (void *)&skb->cb;
1029 ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,
1030 ra_tid->tid);
1031 } else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {
1032 ra_tid = (void *)&skb->cb;
1033 ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,
1034 ra_tid->tid);
1035 } else if (ieee80211_is_action(mgmt->frame_control) &&
1036 mgmt->u.action.category == WLAN_CATEGORY_BACK) {
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02001037 int len = skb->len;
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02001038
Johannes Berga93e3642010-06-10 10:21:46 +02001039 mutex_lock(&local->sta_mtx);
Felix Fietkau875ae5f2010-07-17 15:59:07 +02001040 sta = sta_info_get_bss(sdata, mgmt->sa);
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02001041 if (sta) {
1042 switch (mgmt->u.action.u.addba_req.action_code) {
1043 case WLAN_ACTION_ADDBA_REQ:
1044 ieee80211_process_addba_request(
1045 local, sta, mgmt, len);
1046 break;
1047 case WLAN_ACTION_ADDBA_RESP:
1048 ieee80211_process_addba_resp(local, sta,
1049 mgmt, len);
1050 break;
1051 case WLAN_ACTION_DELBA:
1052 ieee80211_process_delba(sdata, sta,
1053 mgmt, len);
1054 break;
1055 default:
1056 WARN_ON(1);
1057 break;
1058 }
1059 }
Johannes Berga93e3642010-06-10 10:21:46 +02001060 mutex_unlock(&local->sta_mtx);
Johannes Berg344eec62010-06-10 10:21:36 +02001061 } else if (ieee80211_is_data_qos(mgmt->frame_control)) {
1062 struct ieee80211_hdr *hdr = (void *)mgmt;
1063 /*
1064 * So the frame isn't mgmt, but frame_control
1065 * is at the right place anyway, of course, so
1066 * the if statement is correct.
1067 *
1068 * Warn if we have other data frame types here,
1069 * they must not get here.
1070 */
1071 WARN_ON(hdr->frame_control &
1072 cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
1073 WARN_ON(!(hdr->seq_ctrl &
1074 cpu_to_le16(IEEE80211_SCTL_FRAG)));
1075 /*
1076 * This was a fragment of a frame, received while
1077 * a block-ack session was active. That cannot be
1078 * right, so terminate the session.
1079 */
Johannes Berga93e3642010-06-10 10:21:46 +02001080 mutex_lock(&local->sta_mtx);
Felix Fietkau875ae5f2010-07-17 15:59:07 +02001081 sta = sta_info_get_bss(sdata, mgmt->sa);
Johannes Berg344eec62010-06-10 10:21:36 +02001082 if (sta) {
1083 u16 tid = *ieee80211_get_qos_ctl(hdr) &
1084 IEEE80211_QOS_CTL_TID_MASK;
1085
1086 __ieee80211_stop_rx_ba_session(
1087 sta, tid, WLAN_BACK_RECIPIENT,
Johannes Berg53f73c02010-10-05 19:37:40 +02001088 WLAN_REASON_QSTA_REQUIRE_SETUP,
1089 true);
Johannes Berg344eec62010-06-10 10:21:36 +02001090 }
Johannes Berga93e3642010-06-10 10:21:46 +02001091 mutex_unlock(&local->sta_mtx);
Johannes Bergbed7ee6e2010-06-10 10:21:35 +02001092 } else switch (sdata->vif.type) {
Johannes Berg1fa57d02010-06-10 10:21:32 +02001093 case NL80211_IFTYPE_STATION:
1094 ieee80211_sta_rx_queued_mgmt(sdata, skb);
1095 break;
1096 case NL80211_IFTYPE_ADHOC:
1097 ieee80211_ibss_rx_queued_mgmt(sdata, skb);
1098 break;
1099 case NL80211_IFTYPE_MESH_POINT:
1100 if (!ieee80211_vif_is_mesh(&sdata->vif))
1101 break;
1102 ieee80211_mesh_rx_queued_mgmt(sdata, skb);
1103 break;
1104 default:
1105 WARN(1, "frame for unexpected interface type");
Johannes Berg1fa57d02010-06-10 10:21:32 +02001106 break;
1107 }
Johannes Berg36b3a622010-06-10 10:21:33 +02001108
1109 kfree_skb(skb);
Johannes Berg1fa57d02010-06-10 10:21:32 +02001110 }
1111
1112 /* then other type-dependent work */
1113 switch (sdata->vif.type) {
1114 case NL80211_IFTYPE_STATION:
1115 ieee80211_sta_work(sdata);
1116 break;
1117 case NL80211_IFTYPE_ADHOC:
1118 ieee80211_ibss_work(sdata);
1119 break;
1120 case NL80211_IFTYPE_MESH_POINT:
1121 if (!ieee80211_vif_is_mesh(&sdata->vif))
1122 break;
1123 ieee80211_mesh_work(sdata);
1124 break;
1125 default:
1126 break;
1127 }
1128}
1129
Johannes Berg04ecd252012-09-11 14:34:12 +02001130static void ieee80211_recalc_smps_work(struct work_struct *work)
1131{
1132 struct ieee80211_sub_if_data *sdata =
1133 container_of(work, struct ieee80211_sub_if_data, recalc_smps);
1134
1135 ieee80211_recalc_smps(sdata);
1136}
Johannes Berg1fa57d02010-06-10 10:21:32 +02001137
Johannes Berg75636522008-07-09 14:40:35 +02001138/*
1139 * Helper function to initialise an interface to a specific type.
1140 */
1141static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
Johannes Berg05c914f2008-09-11 00:01:58 +02001142 enum nl80211_iftype type)
Johannes Berg75636522008-07-09 14:40:35 +02001143{
Johannes Berg75636522008-07-09 14:40:35 +02001144 /* clear type-dependent union */
1145 memset(&sdata->u, 0, sizeof(sdata->u));
1146
1147 /* and set some type-dependent values */
1148 sdata->vif.type = type;
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001149 sdata->vif.p2p = false;
Johannes Berg60719ff2008-09-16 14:55:09 +02001150 sdata->wdev.iftype = type;
Johannes Berg75636522008-07-09 14:40:35 +02001151
Johannes Berga621fa42010-08-27 14:26:54 +03001152 sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
1153 sdata->control_port_no_encrypt = false;
1154
Simon Wunderlichb53be792011-11-18 14:20:44 +01001155 sdata->noack_map = 0;
1156
Johannes Bergf142c6b2012-06-18 20:07:15 +02001157 /* only monitor/p2p-device differ */
1158 if (sdata->dev) {
1159 sdata->dev->netdev_ops = &ieee80211_dataif_ops;
1160 sdata->dev->type = ARPHRD_ETHER;
1161 }
Johannes Berg75636522008-07-09 14:40:35 +02001162
Johannes Berg35f20c12010-06-10 10:21:30 +02001163 skb_queue_head_init(&sdata->skb_queue);
Johannes Berg1fa57d02010-06-10 10:21:32 +02001164 INIT_WORK(&sdata->work, ieee80211_iface_work);
Johannes Berg04ecd252012-09-11 14:34:12 +02001165 INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
Johannes Berg35f20c12010-06-10 10:21:30 +02001166
Johannes Berg75636522008-07-09 14:40:35 +02001167 switch (type) {
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001168 case NL80211_IFTYPE_P2P_GO:
1169 type = NL80211_IFTYPE_AP;
1170 sdata->vif.type = type;
1171 sdata->vif.p2p = true;
1172 /* fall through */
Johannes Berg05c914f2008-09-11 00:01:58 +02001173 case NL80211_IFTYPE_AP:
Marco Porschd012a602012-10-10 12:39:50 -07001174 skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
Johannes Berg75636522008-07-09 14:40:35 +02001175 INIT_LIST_HEAD(&sdata->u.ap.vlans);
1176 break;
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001177 case NL80211_IFTYPE_P2P_CLIENT:
1178 type = NL80211_IFTYPE_STATION;
1179 sdata->vif.type = type;
1180 sdata->vif.p2p = true;
1181 /* fall through */
Johannes Berg05c914f2008-09-11 00:01:58 +02001182 case NL80211_IFTYPE_STATION:
Johannes Berg9c6bd792008-09-11 00:01:52 +02001183 ieee80211_sta_setup_sdata(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +02001184 break;
Johannes Berg46900292009-02-15 12:44:28 +01001185 case NL80211_IFTYPE_ADHOC:
1186 ieee80211_ibss_setup_sdata(sdata);
1187 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02001188 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg75636522008-07-09 14:40:35 +02001189 if (ieee80211_vif_is_mesh(&sdata->vif))
1190 ieee80211_mesh_init_sdata(sdata);
1191 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02001192 case NL80211_IFTYPE_MONITOR:
Johannes Berg75636522008-07-09 14:40:35 +02001193 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
Johannes Berg587e7292009-01-30 13:35:22 +01001194 sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
Johannes Berg75636522008-07-09 14:40:35 +02001195 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
1196 MONITOR_FLAG_OTHER_BSS;
1197 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02001198 case NL80211_IFTYPE_WDS:
1199 case NL80211_IFTYPE_AP_VLAN:
Johannes Berg98104fde2012-06-16 00:19:54 +02001200 case NL80211_IFTYPE_P2P_DEVICE:
Johannes Bergf142c6b2012-06-18 20:07:15 +02001201 break;
Johannes Berg05c914f2008-09-11 00:01:58 +02001202 case NL80211_IFTYPE_UNSPECIFIED:
Johannes Berg2e161f72010-08-12 15:38:38 +02001203 case NUM_NL80211_IFTYPES:
Johannes Berg75636522008-07-09 14:40:35 +02001204 BUG();
1205 break;
1206 }
1207
1208 ieee80211_debugfs_add_netdev(sdata);
1209}
1210
Johannes Berg34d4bc42010-08-27 12:35:58 +02001211static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
1212 enum nl80211_iftype type)
1213{
1214 struct ieee80211_local *local = sdata->local;
1215 int ret, err;
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001216 enum nl80211_iftype internal_type = type;
1217 bool p2p = false;
Johannes Berg34d4bc42010-08-27 12:35:58 +02001218
1219 ASSERT_RTNL();
1220
1221 if (!local->ops->change_interface)
1222 return -EBUSY;
1223
1224 switch (sdata->vif.type) {
1225 case NL80211_IFTYPE_AP:
1226 case NL80211_IFTYPE_STATION:
1227 case NL80211_IFTYPE_ADHOC:
1228 /*
1229 * Could maybe also all others here?
1230 * Just not sure how that interacts
1231 * with the RX/config path e.g. for
1232 * mesh.
1233 */
1234 break;
1235 default:
1236 return -EBUSY;
1237 }
1238
1239 switch (type) {
1240 case NL80211_IFTYPE_AP:
1241 case NL80211_IFTYPE_STATION:
1242 case NL80211_IFTYPE_ADHOC:
1243 /*
1244 * Could probably support everything
1245 * but WDS here (WDS do_open can fail
1246 * under memory pressure, which this
1247 * code isn't prepared to handle).
1248 */
1249 break;
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001250 case NL80211_IFTYPE_P2P_CLIENT:
1251 p2p = true;
1252 internal_type = NL80211_IFTYPE_STATION;
1253 break;
1254 case NL80211_IFTYPE_P2P_GO:
1255 p2p = true;
1256 internal_type = NL80211_IFTYPE_AP;
1257 break;
Johannes Berg34d4bc42010-08-27 12:35:58 +02001258 default:
1259 return -EBUSY;
1260 }
1261
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001262 ret = ieee80211_check_concurrent_iface(sdata, internal_type);
Johannes Berg34d4bc42010-08-27 12:35:58 +02001263 if (ret)
1264 return ret;
1265
1266 ieee80211_do_stop(sdata, false);
1267
Johannes Bergf142c6b2012-06-18 20:07:15 +02001268 ieee80211_teardown_sdata(sdata);
Johannes Berg34d4bc42010-08-27 12:35:58 +02001269
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001270 ret = drv_change_interface(local, sdata, internal_type, p2p);
Johannes Berg34d4bc42010-08-27 12:35:58 +02001271 if (ret)
1272 type = sdata->vif.type;
1273
Johannes Berg3a25a8c2012-04-03 16:28:50 +02001274 /*
1275 * Ignore return value here, there's not much we can do since
1276 * the driver changed the interface type internally already.
1277 * The warnings will hopefully make driver authors fix it :-)
1278 */
1279 ieee80211_check_queues(sdata);
1280
Johannes Berg34d4bc42010-08-27 12:35:58 +02001281 ieee80211_setup_sdata(sdata, type);
1282
Johannes Bergf142c6b2012-06-18 20:07:15 +02001283 err = ieee80211_do_open(&sdata->wdev, false);
Johannes Berg34d4bc42010-08-27 12:35:58 +02001284 WARN(err, "type change: do_open returned %d", err);
1285
1286 return ret;
1287}
1288
Johannes Bergf3947e22008-07-09 14:40:36 +02001289int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
Johannes Berg05c914f2008-09-11 00:01:58 +02001290 enum nl80211_iftype type)
Johannes Berg75636522008-07-09 14:40:35 +02001291{
Johannes Berg34d4bc42010-08-27 12:35:58 +02001292 int ret;
1293
Johannes Bergf3947e22008-07-09 14:40:36 +02001294 ASSERT_RTNL();
1295
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001296 if (type == ieee80211_vif_type_p2p(&sdata->vif))
Johannes Bergf3947e22008-07-09 14:40:36 +02001297 return 0;
1298
Johannes Berg34d4bc42010-08-27 12:35:58 +02001299 if (ieee80211_sdata_running(sdata)) {
1300 ret = ieee80211_runtime_change_iftype(sdata, type);
1301 if (ret)
1302 return ret;
1303 } else {
1304 /* Purge and reset type-dependent state. */
Johannes Bergf142c6b2012-06-18 20:07:15 +02001305 ieee80211_teardown_sdata(sdata);
Johannes Berg34d4bc42010-08-27 12:35:58 +02001306 ieee80211_setup_sdata(sdata, type);
1307 }
Johannes Berg75636522008-07-09 14:40:35 +02001308
1309 /* reset some values that shouldn't be kept across type changes */
Johannes Berg75636522008-07-09 14:40:35 +02001310 sdata->drop_unencrypted = 0;
Johannes Berg9bc383d2009-11-19 11:55:19 +01001311 if (type == NL80211_IFTYPE_STATION)
1312 sdata->u.mgd.use_4addr = false;
Johannes Bergf3947e22008-07-09 14:40:36 +02001313
1314 return 0;
Johannes Berg75636522008-07-09 14:40:35 +02001315}
1316
Johannes Bergfa9029f2010-02-25 15:13:11 +01001317static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
Johannes Bergf142c6b2012-06-18 20:07:15 +02001318 u8 *perm_addr, enum nl80211_iftype type)
Johannes Bergfa9029f2010-02-25 15:13:11 +01001319{
1320 struct ieee80211_sub_if_data *sdata;
1321 u64 mask, start, addr, val, inc;
1322 u8 *m;
1323 u8 tmp_addr[ETH_ALEN];
1324 int i;
1325
1326 /* default ... something at least */
Johannes Bergf142c6b2012-06-18 20:07:15 +02001327 memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
Johannes Bergfa9029f2010-02-25 15:13:11 +01001328
1329 if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
1330 local->hw.wiphy->n_addresses <= 1)
1331 return;
1332
Johannes Bergfa9029f2010-02-25 15:13:11 +01001333 mutex_lock(&local->iflist_mtx);
1334
1335 switch (type) {
1336 case NL80211_IFTYPE_MONITOR:
1337 /* doesn't matter */
1338 break;
1339 case NL80211_IFTYPE_WDS:
1340 case NL80211_IFTYPE_AP_VLAN:
1341 /* match up with an AP interface */
1342 list_for_each_entry(sdata, &local->interfaces, list) {
1343 if (sdata->vif.type != NL80211_IFTYPE_AP)
1344 continue;
Johannes Bergf142c6b2012-06-18 20:07:15 +02001345 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
Johannes Bergfa9029f2010-02-25 15:13:11 +01001346 break;
1347 }
1348 /* keep default if no AP interface present */
1349 break;
Johannes Berg6d711172012-06-19 17:19:44 +02001350 case NL80211_IFTYPE_P2P_CLIENT:
1351 case NL80211_IFTYPE_P2P_GO:
1352 if (local->hw.flags & IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF) {
1353 list_for_each_entry(sdata, &local->interfaces, list) {
1354 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
1355 continue;
1356 if (!ieee80211_sdata_running(sdata))
1357 continue;
1358 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
1359 goto out_unlock;
1360 }
1361 }
1362 /* otherwise fall through */
Johannes Bergfa9029f2010-02-25 15:13:11 +01001363 default:
1364 /* assign a new address if possible -- try n_addresses first */
1365 for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
1366 bool used = false;
1367
1368 list_for_each_entry(sdata, &local->interfaces, list) {
1369 if (memcmp(local->hw.wiphy->addresses[i].addr,
1370 sdata->vif.addr, ETH_ALEN) == 0) {
1371 used = true;
1372 break;
1373 }
1374 }
1375
1376 if (!used) {
Johannes Bergf142c6b2012-06-18 20:07:15 +02001377 memcpy(perm_addr,
Johannes Bergfa9029f2010-02-25 15:13:11 +01001378 local->hw.wiphy->addresses[i].addr,
1379 ETH_ALEN);
1380 break;
1381 }
1382 }
1383
1384 /* try mask if available */
1385 if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
1386 break;
1387
1388 m = local->hw.wiphy->addr_mask;
1389 mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1390 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1391 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1392
1393 if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
1394 /* not a contiguous mask ... not handled now! */
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001395 pr_info("not contiguous\n");
Johannes Bergfa9029f2010-02-25 15:13:11 +01001396 break;
1397 }
1398
1399 m = local->hw.wiphy->perm_addr;
1400 start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1401 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1402 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1403
1404 inc = 1ULL<<__ffs64(mask);
1405 val = (start & mask);
1406 addr = (start & ~mask) | (val & mask);
1407 do {
1408 bool used = false;
1409
1410 tmp_addr[5] = addr >> 0*8;
1411 tmp_addr[4] = addr >> 1*8;
1412 tmp_addr[3] = addr >> 2*8;
1413 tmp_addr[2] = addr >> 3*8;
1414 tmp_addr[1] = addr >> 4*8;
1415 tmp_addr[0] = addr >> 5*8;
1416
1417 val += inc;
1418
1419 list_for_each_entry(sdata, &local->interfaces, list) {
1420 if (memcmp(tmp_addr, sdata->vif.addr,
1421 ETH_ALEN) == 0) {
1422 used = true;
1423 break;
1424 }
1425 }
1426
1427 if (!used) {
Johannes Bergf142c6b2012-06-18 20:07:15 +02001428 memcpy(perm_addr, tmp_addr, ETH_ALEN);
Johannes Bergfa9029f2010-02-25 15:13:11 +01001429 break;
1430 }
1431 addr = (start & ~mask) | (val & mask);
1432 } while (addr != start);
1433
1434 break;
1435 }
1436
Johannes Berg6d711172012-06-19 17:19:44 +02001437 out_unlock:
Johannes Bergfa9029f2010-02-25 15:13:11 +01001438 mutex_unlock(&local->iflist_mtx);
1439}
1440
Johannes Berg3e122be2008-07-09 14:40:34 +02001441int ieee80211_if_add(struct ieee80211_local *local, const char *name,
Johannes Berg84efbb82012-06-16 00:00:26 +02001442 struct wireless_dev **new_wdev, enum nl80211_iftype type,
Luis Carlos Coboee385852008-02-23 15:17:11 +01001443 struct vif_params *params)
Jiri Bencf0706e82007-05-05 11:45:53 -07001444{
Johannes Bergf142c6b2012-06-18 20:07:15 +02001445 struct net_device *ndev = NULL;
Jiri Bencf0706e82007-05-05 11:45:53 -07001446 struct ieee80211_sub_if_data *sdata = NULL;
Johannes Berg75636522008-07-09 14:40:35 +02001447 int ret, i;
Johannes Bergded81f62012-03-28 11:04:26 +02001448 int txqs = 1;
Jiri Bencf0706e82007-05-05 11:45:53 -07001449
1450 ASSERT_RTNL();
Johannes Berg75636522008-07-09 14:40:35 +02001451
Johannes Bergf142c6b2012-06-18 20:07:15 +02001452 if (type == NL80211_IFTYPE_P2P_DEVICE) {
1453 struct wireless_dev *wdev;
Johannes Bergded81f62012-03-28 11:04:26 +02001454
Johannes Bergf142c6b2012-06-18 20:07:15 +02001455 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,
1456 GFP_KERNEL);
1457 if (!sdata)
1458 return -ENOMEM;
1459 wdev = &sdata->wdev;
Jiri Bencf0706e82007-05-05 11:45:53 -07001460
Johannes Bergf142c6b2012-06-18 20:07:15 +02001461 sdata->dev = NULL;
1462 strlcpy(sdata->name, name, IFNAMSIZ);
1463 ieee80211_assign_perm_addr(local, wdev->address, type);
1464 memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
1465 } else {
1466 if (local->hw.queues >= IEEE80211_NUM_ACS)
1467 txqs = IEEE80211_NUM_ACS;
Johannes Bergf3994ec2008-05-12 20:51:44 -07001468
Johannes Bergf142c6b2012-06-18 20:07:15 +02001469 ndev = alloc_netdev_mqs(sizeof(*sdata) +
1470 local->hw.vif_data_size,
1471 name, ieee80211_if_setup, txqs, 1);
1472 if (!ndev)
1473 return -ENOMEM;
1474 dev_net_set(ndev, wiphy_net(local->hw.wiphy));
Thadeu Lima de Souza Cascardo59e7e702011-06-02 17:28:37 -03001475
Johannes Bergf142c6b2012-06-18 20:07:15 +02001476 ndev->needed_headroom = local->tx_headroom +
1477 4*6 /* four MAC addresses */
1478 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
1479 + 6 /* mesh */
1480 + 8 /* rfc1042/bridge tunnel */
1481 - ETH_HLEN /* ethernet hard_header_len */
1482 + IEEE80211_ENCRYPT_HEADROOM;
1483 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
Jiri Bencf0706e82007-05-05 11:45:53 -07001484
Johannes Bergf142c6b2012-06-18 20:07:15 +02001485 ret = dev_alloc_name(ndev, ndev->name);
1486 if (ret < 0) {
1487 free_netdev(ndev);
1488 return ret;
1489 }
1490
1491 ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
1492 memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
1493 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
1494
1495 /* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */
1496 sdata = netdev_priv(ndev);
1497 ndev->ieee80211_ptr = &sdata->wdev;
1498 memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
1499 memcpy(sdata->name, ndev->name, IFNAMSIZ);
1500
1501 sdata->dev = ndev;
1502 }
Johannes Berg75636522008-07-09 14:40:35 +02001503
1504 /* initialise type-independent data */
Jiri Bencf0706e82007-05-05 11:45:53 -07001505 sdata->wdev.wiphy = local->hw.wiphy;
Jiri Bencf0706e82007-05-05 11:45:53 -07001506 sdata->local = local;
Juuso Oikarinen68542962010-06-09 13:43:26 +03001507#ifdef CONFIG_INET
1508 sdata->arp_filter_state = true;
1509#endif
Johannes Berg75636522008-07-09 14:40:35 +02001510
1511 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
1512 skb_queue_head_init(&sdata->fragments[i].skb_list);
1513
1514 INIT_LIST_HEAD(&sdata->key_list);
1515
Jouni Malinen37eb0b12010-01-06 13:09:08 +02001516 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
1517 struct ieee80211_supported_band *sband;
1518 sband = local->hw.wiphy->bands[i];
1519 sdata->rc_rateidx_mask[i] =
1520 sband ? (1 << sband->n_bitrates) - 1 : 0;
Simon Wunderlich19468412012-01-28 17:25:33 +01001521 if (sband)
1522 memcpy(sdata->rc_rateidx_mcs_mask[i],
1523 sband->ht_cap.mcs.rx_mask,
1524 sizeof(sdata->rc_rateidx_mcs_mask[i]));
1525 else
1526 memset(sdata->rc_rateidx_mcs_mask[i], 0,
1527 sizeof(sdata->rc_rateidx_mcs_mask[i]));
Jouni Malinen37eb0b12010-01-06 13:09:08 +02001528 }
Johannes Berg75636522008-07-09 14:40:35 +02001529
Johannes Berg3a25a8c2012-04-03 16:28:50 +02001530 ieee80211_set_default_queues(sdata);
1531
Johannes Berg75636522008-07-09 14:40:35 +02001532 /* setup type-dependent data */
1533 ieee80211_setup_sdata(sdata, type);
Jiri Bencf0706e82007-05-05 11:45:53 -07001534
Johannes Bergf142c6b2012-06-18 20:07:15 +02001535 if (ndev) {
1536 if (params) {
1537 ndev->ieee80211_ptr->use_4addr = params->use_4addr;
1538 if (type == NL80211_IFTYPE_STATION)
1539 sdata->u.mgd.use_4addr = params->use_4addr;
1540 }
1541
1542 ndev->features |= local->hw.netdev_features;
1543
1544 ret = register_netdevice(ndev);
1545 if (ret) {
1546 free_netdev(ndev);
1547 return ret;
1548 }
Johannes Berg9bc383d2009-11-19 11:55:19 +01001549 }
1550
Johannes Bergc771c9d2009-01-23 22:54:03 +01001551 mutex_lock(&local->iflist_mtx);
Johannes Berg79010422007-09-18 17:29:21 -04001552 list_add_tail_rcu(&sdata->list, &local->interfaces);
Johannes Bergc771c9d2009-01-23 22:54:03 +01001553 mutex_unlock(&local->iflist_mtx);
Johannes Berg79010422007-09-18 17:29:21 -04001554
Johannes Berg84efbb82012-06-16 00:00:26 +02001555 if (new_wdev)
1556 *new_wdev = &sdata->wdev;
Jiri Bencf0706e82007-05-05 11:45:53 -07001557
Jiri Bencf0706e82007-05-05 11:45:53 -07001558 return 0;
Jiri Bencf0706e82007-05-05 11:45:53 -07001559}
1560
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001561void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
Jiri Bencf0706e82007-05-05 11:45:53 -07001562{
Jiri Bencf0706e82007-05-05 11:45:53 -07001563 ASSERT_RTNL();
Johannes Berg11a843b2007-08-28 17:01:55 -04001564
Johannes Bergc771c9d2009-01-23 22:54:03 +01001565 mutex_lock(&sdata->local->iflist_mtx);
Johannes Berg75636522008-07-09 14:40:35 +02001566 list_del_rcu(&sdata->list);
Johannes Bergc771c9d2009-01-23 22:54:03 +01001567 mutex_unlock(&sdata->local->iflist_mtx);
1568
Johannes Berg75636522008-07-09 14:40:35 +02001569 synchronize_rcu();
Johannes Bergf142c6b2012-06-18 20:07:15 +02001570
1571 if (sdata->dev) {
1572 unregister_netdevice(sdata->dev);
1573 } else {
1574 cfg80211_unregister_wdev(&sdata->wdev);
1575 kfree(sdata);
1576 }
1577}
1578
1579void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)
1580{
1581 if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))
1582 return;
1583 ieee80211_do_stop(sdata, true);
1584 ieee80211_teardown_sdata(sdata);
Jiri Bencf0706e82007-05-05 11:45:53 -07001585}
1586
Johannes Berg75636522008-07-09 14:40:35 +02001587/*
1588 * Remove all interfaces, may only be called at hardware unregistration
1589 * time because it doesn't do RCU-safe list removals.
1590 */
1591void ieee80211_remove_interfaces(struct ieee80211_local *local)
Jiri Bencf0706e82007-05-05 11:45:53 -07001592{
Johannes Berg75636522008-07-09 14:40:35 +02001593 struct ieee80211_sub_if_data *sdata, *tmp;
Eric Dumazetefe117a2009-11-05 11:06:40 +01001594 LIST_HEAD(unreg_list);
Johannes Bergf142c6b2012-06-18 20:07:15 +02001595 LIST_HEAD(wdev_list);
Jiri Bencf0706e82007-05-05 11:45:53 -07001596
1597 ASSERT_RTNL();
1598
Eric Dumazetefe117a2009-11-05 11:06:40 +01001599 mutex_lock(&local->iflist_mtx);
Johannes Berg75636522008-07-09 14:40:35 +02001600 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
1601 list_del(&sdata->list);
Johannes Bergc771c9d2009-01-23 22:54:03 +01001602
Johannes Bergf142c6b2012-06-18 20:07:15 +02001603 if (sdata->dev)
1604 unregister_netdevice_queue(sdata->dev, &unreg_list);
1605 else
1606 list_add(&sdata->list, &wdev_list);
Jiri Bencf0706e82007-05-05 11:45:53 -07001607 }
Eric Dumazetefe117a2009-11-05 11:06:40 +01001608 mutex_unlock(&local->iflist_mtx);
1609 unregister_netdevice_many(&unreg_list);
Eric W. Biederman5f04d502011-02-20 11:49:45 -08001610 list_del(&unreg_list);
Johannes Bergf142c6b2012-06-18 20:07:15 +02001611
1612 list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {
1613 list_del(&sdata->list);
1614 cfg80211_unregister_wdev(&sdata->wdev);
1615 kfree(sdata);
1616 }
Jiri Bencf0706e82007-05-05 11:45:53 -07001617}
Johannes Berg5cff20e2009-04-29 12:26:17 +02001618
Johannes Berg47846c92009-11-25 17:46:19 +01001619static int netdev_notify(struct notifier_block *nb,
1620 unsigned long state,
1621 void *ndev)
1622{
1623 struct net_device *dev = ndev;
1624 struct ieee80211_sub_if_data *sdata;
1625
1626 if (state != NETDEV_CHANGENAME)
1627 return 0;
1628
1629 if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
1630 return 0;
1631
1632 if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
1633 return 0;
1634
1635 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1636
Johannes Berg2f5265e2010-02-12 10:45:05 +01001637 memcpy(sdata->name, dev->name, IFNAMSIZ);
Johannes Berg47846c92009-11-25 17:46:19 +01001638
1639 ieee80211_debugfs_rename_netdev(sdata);
1640 return 0;
1641}
1642
1643static struct notifier_block mac80211_netdev_notifier = {
1644 .notifier_call = netdev_notify,
1645};
1646
1647int ieee80211_iface_init(void)
1648{
1649 return register_netdevice_notifier(&mac80211_netdev_notifier);
1650}
1651
1652void ieee80211_iface_exit(void)
1653{
1654 unregister_netdevice_notifier(&mac80211_netdev_notifier);
1655}