xref: /linux/net/mac80211/iface.c (revision bb1c928df78ee6e3665a0d013e74108cc9abf34b)
1 /*
2  * Interface handling
3  *
4  * Copyright 2002-2005, Instant802 Networks, Inc.
5  * Copyright 2005-2006, Devicescape Software, Inc.
6  * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
7  * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
8  * Copyright 2013-2014  Intel Mobile Communications GmbH
9  * Copyright (c) 2016        Intel Deutschland GmbH
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  */
15 #include <linux/slab.h>
16 #include <linux/kernel.h>
17 #include <linux/if_arp.h>
18 #include <linux/netdevice.h>
19 #include <linux/rtnetlink.h>
20 #include <net/mac80211.h>
21 #include <net/ieee80211_radiotap.h>
22 #include "ieee80211_i.h"
23 #include "sta_info.h"
24 #include "debugfs_netdev.h"
25 #include "mesh.h"
26 #include "led.h"
27 #include "driver-ops.h"
28 #include "wme.h"
29 #include "rate.h"
30 
31 /**
32  * DOC: Interface list locking
33  *
34  * The interface list in each struct ieee80211_local is protected
35  * three-fold:
36  *
37  * (1) modifications may only be done under the RTNL
38  * (2) modifications and readers are protected against each other by
39  *     the iflist_mtx.
40  * (3) modifications are done in an RCU manner so atomic readers
41  *     can traverse the list in RCU-safe blocks.
42  *
43  * As a consequence, reads (traversals) of the list can be protected
44  * by either the RTNL, the iflist_mtx or RCU.
45  */
46 
47 static void ieee80211_iface_work(struct work_struct *work);
48 
49 bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
50 {
51 	struct ieee80211_chanctx_conf *chanctx_conf;
52 	int power;
53 
54 	rcu_read_lock();
55 	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
56 	if (!chanctx_conf) {
57 		rcu_read_unlock();
58 		return false;
59 	}
60 
61 	power = ieee80211_chandef_max_power(&chanctx_conf->def);
62 	rcu_read_unlock();
63 
64 	if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)
65 		power = min(power, sdata->user_power_level);
66 
67 	if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
68 		power = min(power, sdata->ap_power_level);
69 
70 	if (power != sdata->vif.bss_conf.txpower) {
71 		sdata->vif.bss_conf.txpower = power;
72 		ieee80211_hw_config(sdata->local, 0);
73 		return true;
74 	}
75 
76 	return false;
77 }
78 
79 void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
80 			      bool update_bss)
81 {
82 	if (__ieee80211_recalc_txpower(sdata) ||
83 	    (update_bss && ieee80211_sdata_running(sdata)))
84 		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
85 }
86 
87 static u32 __ieee80211_idle_off(struct ieee80211_local *local)
88 {
89 	if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
90 		return 0;
91 
92 	local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
93 	return IEEE80211_CONF_CHANGE_IDLE;
94 }
95 
96 static u32 __ieee80211_idle_on(struct ieee80211_local *local)
97 {
98 	if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
99 		return 0;
100 
101 	ieee80211_flush_queues(local, NULL, false);
102 
103 	local->hw.conf.flags |= IEEE80211_CONF_IDLE;
104 	return IEEE80211_CONF_CHANGE_IDLE;
105 }
106 
107 static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
108 				   bool force_active)
109 {
110 	bool working, scanning, active;
111 	unsigned int led_trig_start = 0, led_trig_stop = 0;
112 
113 	lockdep_assert_held(&local->mtx);
114 
115 	active = force_active ||
116 		 !list_empty(&local->chanctx_list) ||
117 		 local->monitors;
118 
119 	working = !local->ops->remain_on_channel &&
120 		  !list_empty(&local->roc_list);
121 
122 	scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
123 		   test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
124 
125 	if (working || scanning)
126 		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
127 	else
128 		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
129 
130 	if (active)
131 		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
132 	else
133 		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
134 
135 	ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
136 
137 	if (working || scanning || active)
138 		return __ieee80211_idle_off(local);
139 	return __ieee80211_idle_on(local);
140 }
141 
142 u32 ieee80211_idle_off(struct ieee80211_local *local)
143 {
144 	return __ieee80211_recalc_idle(local, true);
145 }
146 
147 void ieee80211_recalc_idle(struct ieee80211_local *local)
148 {
149 	u32 change = __ieee80211_recalc_idle(local, false);
150 	if (change)
151 		ieee80211_hw_config(local, change);
152 }
153 
154 static int ieee80211_verify_mac(struct ieee80211_sub_if_data *sdata, u8 *addr,
155 				bool check_dup)
156 {
157 	struct ieee80211_local *local = sdata->local;
158 	struct ieee80211_sub_if_data *iter;
159 	u64 new, mask, tmp;
160 	u8 *m;
161 	int ret = 0;
162 
163 	if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
164 		return 0;
165 
166 	m = addr;
167 	new =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
168 		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
169 		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
170 
171 	m = local->hw.wiphy->addr_mask;
172 	mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
173 		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
174 		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
175 
176 	if (!check_dup)
177 		return ret;
178 
179 	mutex_lock(&local->iflist_mtx);
180 	list_for_each_entry(iter, &local->interfaces, list) {
181 		if (iter == sdata)
182 			continue;
183 
184 		if (iter->vif.type == NL80211_IFTYPE_MONITOR &&
185 		    !(iter->u.mntr.flags & MONITOR_FLAG_ACTIVE))
186 			continue;
187 
188 		m = iter->vif.addr;
189 		tmp =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
190 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
191 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
192 
193 		if ((new & ~mask) != (tmp & ~mask)) {
194 			ret = -EINVAL;
195 			break;
196 		}
197 	}
198 	mutex_unlock(&local->iflist_mtx);
199 
200 	return ret;
201 }
202 
203 static int ieee80211_change_mac(struct net_device *dev, void *addr)
204 {
205 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
206 	struct sockaddr *sa = addr;
207 	bool check_dup = true;
208 	int ret;
209 
210 	if (ieee80211_sdata_running(sdata))
211 		return -EBUSY;
212 
213 	if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
214 	    !(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
215 		check_dup = false;
216 
217 	ret = ieee80211_verify_mac(sdata, sa->sa_data, check_dup);
218 	if (ret)
219 		return ret;
220 
221 	ret = eth_mac_addr(dev, sa);
222 
223 	if (ret == 0)
224 		memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
225 
226 	return ret;
227 }
228 
229 static inline int identical_mac_addr_allowed(int type1, int type2)
230 {
231 	return type1 == NL80211_IFTYPE_MONITOR ||
232 		type2 == NL80211_IFTYPE_MONITOR ||
233 		type1 == NL80211_IFTYPE_P2P_DEVICE ||
234 		type2 == NL80211_IFTYPE_P2P_DEVICE ||
235 		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
236 		(type1 == NL80211_IFTYPE_WDS &&
237 			(type2 == NL80211_IFTYPE_WDS ||
238 			 type2 == NL80211_IFTYPE_AP)) ||
239 		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
240 		(type1 == NL80211_IFTYPE_AP_VLAN &&
241 			(type2 == NL80211_IFTYPE_AP ||
242 			 type2 == NL80211_IFTYPE_AP_VLAN));
243 }
244 
245 static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
246 					    enum nl80211_iftype iftype)
247 {
248 	struct ieee80211_local *local = sdata->local;
249 	struct ieee80211_sub_if_data *nsdata;
250 	int ret;
251 
252 	ASSERT_RTNL();
253 
254 	/* we hold the RTNL here so can safely walk the list */
255 	list_for_each_entry(nsdata, &local->interfaces, list) {
256 		if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
257 			/*
258 			 * Only OCB and monitor mode may coexist
259 			 */
260 			if ((sdata->vif.type == NL80211_IFTYPE_OCB &&
261 			     nsdata->vif.type != NL80211_IFTYPE_MONITOR) ||
262 			    (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
263 			     nsdata->vif.type == NL80211_IFTYPE_OCB))
264 				return -EBUSY;
265 
266 			/*
267 			 * Allow only a single IBSS interface to be up at any
268 			 * time. This is restricted because beacon distribution
269 			 * cannot work properly if both are in the same IBSS.
270 			 *
271 			 * To remove this restriction we'd have to disallow them
272 			 * from setting the same SSID on different IBSS interfaces
273 			 * belonging to the same hardware. Then, however, we're
274 			 * faced with having to adopt two different TSF timers...
275 			 */
276 			if (iftype == NL80211_IFTYPE_ADHOC &&
277 			    nsdata->vif.type == NL80211_IFTYPE_ADHOC)
278 				return -EBUSY;
279 			/*
280 			 * will not add another interface while any channel
281 			 * switch is active.
282 			 */
283 			if (nsdata->vif.csa_active)
284 				return -EBUSY;
285 
286 			/*
287 			 * The remaining checks are only performed for interfaces
288 			 * with the same MAC address.
289 			 */
290 			if (!ether_addr_equal(sdata->vif.addr,
291 					      nsdata->vif.addr))
292 				continue;
293 
294 			/*
295 			 * check whether it may have the same address
296 			 */
297 			if (!identical_mac_addr_allowed(iftype,
298 							nsdata->vif.type))
299 				return -ENOTUNIQ;
300 
301 			/*
302 			 * can only add VLANs to enabled APs
303 			 */
304 			if (iftype == NL80211_IFTYPE_AP_VLAN &&
305 			    nsdata->vif.type == NL80211_IFTYPE_AP)
306 				sdata->bss = &nsdata->u.ap;
307 		}
308 	}
309 
310 	mutex_lock(&local->chanctx_mtx);
311 	ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
312 	mutex_unlock(&local->chanctx_mtx);
313 	return ret;
314 }
315 
316 static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata,
317 				  enum nl80211_iftype iftype)
318 {
319 	int n_queues = sdata->local->hw.queues;
320 	int i;
321 
322 	if (iftype == NL80211_IFTYPE_NAN)
323 		return 0;
324 
325 	if (iftype != NL80211_IFTYPE_P2P_DEVICE) {
326 		for (i = 0; i < IEEE80211_NUM_ACS; i++) {
327 			if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==
328 					 IEEE80211_INVAL_HW_QUEUE))
329 				return -EINVAL;
330 			if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=
331 					 n_queues))
332 				return -EINVAL;
333 		}
334 	}
335 
336 	if ((iftype != NL80211_IFTYPE_AP &&
337 	     iftype != NL80211_IFTYPE_P2P_GO &&
338 	     iftype != NL80211_IFTYPE_MESH_POINT) ||
339 	    !ieee80211_hw_check(&sdata->local->hw, QUEUE_CONTROL)) {
340 		sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
341 		return 0;
342 	}
343 
344 	if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))
345 		return -EINVAL;
346 
347 	if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))
348 		return -EINVAL;
349 
350 	return 0;
351 }
352 
353 void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
354 				    const int offset)
355 {
356 	struct ieee80211_local *local = sdata->local;
357 	u32 flags = sdata->u.mntr.flags;
358 
359 #define ADJUST(_f, _s)	do {					\
360 	if (flags & MONITOR_FLAG_##_f)				\
361 		local->fif_##_s += offset;			\
362 	} while (0)
363 
364 	ADJUST(FCSFAIL, fcsfail);
365 	ADJUST(PLCPFAIL, plcpfail);
366 	ADJUST(CONTROL, control);
367 	ADJUST(CONTROL, pspoll);
368 	ADJUST(OTHER_BSS, other_bss);
369 
370 #undef ADJUST
371 }
372 
373 static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)
374 {
375 	struct ieee80211_local *local = sdata->local;
376 	int i;
377 
378 	for (i = 0; i < IEEE80211_NUM_ACS; i++) {
379 		if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
380 			sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
381 		else if (local->hw.queues >= IEEE80211_NUM_ACS)
382 			sdata->vif.hw_queue[i] = i;
383 		else
384 			sdata->vif.hw_queue[i] = 0;
385 	}
386 	sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
387 }
388 
389 int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
390 {
391 	struct ieee80211_sub_if_data *sdata;
392 	int ret;
393 
394 	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
395 		return 0;
396 
397 	ASSERT_RTNL();
398 
399 	if (local->monitor_sdata)
400 		return 0;
401 
402 	sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
403 	if (!sdata)
404 		return -ENOMEM;
405 
406 	/* set up data */
407 	sdata->local = local;
408 	sdata->vif.type = NL80211_IFTYPE_MONITOR;
409 	snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
410 		 wiphy_name(local->hw.wiphy));
411 	sdata->wdev.iftype = NL80211_IFTYPE_MONITOR;
412 
413 	sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
414 
415 	ieee80211_set_default_queues(sdata);
416 
417 	ret = drv_add_interface(local, sdata);
418 	if (WARN_ON(ret)) {
419 		/* ok .. stupid driver, it asked for this! */
420 		kfree(sdata);
421 		return ret;
422 	}
423 
424 	ret = ieee80211_check_queues(sdata, NL80211_IFTYPE_MONITOR);
425 	if (ret) {
426 		kfree(sdata);
427 		return ret;
428 	}
429 
430 	mutex_lock(&local->iflist_mtx);
431 	rcu_assign_pointer(local->monitor_sdata, sdata);
432 	mutex_unlock(&local->iflist_mtx);
433 
434 	mutex_lock(&local->mtx);
435 	ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,
436 					IEEE80211_CHANCTX_EXCLUSIVE);
437 	mutex_unlock(&local->mtx);
438 	if (ret) {
439 		mutex_lock(&local->iflist_mtx);
440 		RCU_INIT_POINTER(local->monitor_sdata, NULL);
441 		mutex_unlock(&local->iflist_mtx);
442 		synchronize_net();
443 		drv_remove_interface(local, sdata);
444 		kfree(sdata);
445 		return ret;
446 	}
447 
448 	skb_queue_head_init(&sdata->skb_queue);
449 	INIT_WORK(&sdata->work, ieee80211_iface_work);
450 
451 	return 0;
452 }
453 
454 void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
455 {
456 	struct ieee80211_sub_if_data *sdata;
457 
458 	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
459 		return;
460 
461 	ASSERT_RTNL();
462 
463 	mutex_lock(&local->iflist_mtx);
464 
465 	sdata = rcu_dereference_protected(local->monitor_sdata,
466 					  lockdep_is_held(&local->iflist_mtx));
467 	if (!sdata) {
468 		mutex_unlock(&local->iflist_mtx);
469 		return;
470 	}
471 
472 	RCU_INIT_POINTER(local->monitor_sdata, NULL);
473 	mutex_unlock(&local->iflist_mtx);
474 
475 	synchronize_net();
476 
477 	mutex_lock(&local->mtx);
478 	ieee80211_vif_release_channel(sdata);
479 	mutex_unlock(&local->mtx);
480 
481 	drv_remove_interface(local, sdata);
482 
483 	kfree(sdata);
484 }
485 
486 /*
487  * NOTE: Be very careful when changing this function, it must NOT return
488  * an error on interface type changes that have been pre-checked, so most
489  * checks should be in ieee80211_check_concurrent_iface.
490  */
491 int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
492 {
493 	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
494 	struct net_device *dev = wdev->netdev;
495 	struct ieee80211_local *local = sdata->local;
496 	struct sta_info *sta;
497 	u32 changed = 0;
498 	int res;
499 	u32 hw_reconf_flags = 0;
500 
501 	switch (sdata->vif.type) {
502 	case NL80211_IFTYPE_WDS:
503 		if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
504 			return -ENOLINK;
505 		break;
506 	case NL80211_IFTYPE_AP_VLAN: {
507 		struct ieee80211_sub_if_data *master;
508 
509 		if (!sdata->bss)
510 			return -ENOLINK;
511 
512 		mutex_lock(&local->mtx);
513 		list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
514 		mutex_unlock(&local->mtx);
515 
516 		master = container_of(sdata->bss,
517 				      struct ieee80211_sub_if_data, u.ap);
518 		sdata->control_port_protocol =
519 			master->control_port_protocol;
520 		sdata->control_port_no_encrypt =
521 			master->control_port_no_encrypt;
522 		sdata->vif.cab_queue = master->vif.cab_queue;
523 		memcpy(sdata->vif.hw_queue, master->vif.hw_queue,
524 		       sizeof(sdata->vif.hw_queue));
525 		sdata->vif.bss_conf.chandef = master->vif.bss_conf.chandef;
526 
527 		mutex_lock(&local->key_mtx);
528 		sdata->crypto_tx_tailroom_needed_cnt +=
529 			master->crypto_tx_tailroom_needed_cnt;
530 		mutex_unlock(&local->key_mtx);
531 
532 		break;
533 		}
534 	case NL80211_IFTYPE_AP:
535 		sdata->bss = &sdata->u.ap;
536 		break;
537 	case NL80211_IFTYPE_MESH_POINT:
538 	case NL80211_IFTYPE_STATION:
539 	case NL80211_IFTYPE_MONITOR:
540 	case NL80211_IFTYPE_ADHOC:
541 	case NL80211_IFTYPE_P2P_DEVICE:
542 	case NL80211_IFTYPE_OCB:
543 	case NL80211_IFTYPE_NAN:
544 		/* no special treatment */
545 		break;
546 	case NL80211_IFTYPE_UNSPECIFIED:
547 	case NUM_NL80211_IFTYPES:
548 	case NL80211_IFTYPE_P2P_CLIENT:
549 	case NL80211_IFTYPE_P2P_GO:
550 		/* cannot happen */
551 		WARN_ON(1);
552 		break;
553 	}
554 
555 	if (local->open_count == 0) {
556 		res = drv_start(local);
557 		if (res)
558 			goto err_del_bss;
559 		/* we're brought up, everything changes */
560 		hw_reconf_flags = ~0;
561 		ieee80211_led_radio(local, true);
562 		ieee80211_mod_tpt_led_trig(local,
563 					   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
564 	}
565 
566 	/*
567 	 * Copy the hopefully now-present MAC address to
568 	 * this interface, if it has the special null one.
569 	 */
570 	if (dev && is_zero_ether_addr(dev->dev_addr)) {
571 		memcpy(dev->dev_addr,
572 		       local->hw.wiphy->perm_addr,
573 		       ETH_ALEN);
574 		memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
575 
576 		if (!is_valid_ether_addr(dev->dev_addr)) {
577 			res = -EADDRNOTAVAIL;
578 			goto err_stop;
579 		}
580 	}
581 
582 	switch (sdata->vif.type) {
583 	case NL80211_IFTYPE_AP_VLAN:
584 		/* no need to tell driver, but set carrier and chanctx */
585 		if (rtnl_dereference(sdata->bss->beacon)) {
586 			ieee80211_vif_vlan_copy_chanctx(sdata);
587 			netif_carrier_on(dev);
588 		} else {
589 			netif_carrier_off(dev);
590 		}
591 		break;
592 	case NL80211_IFTYPE_MONITOR:
593 		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) {
594 			local->cooked_mntrs++;
595 			break;
596 		}
597 
598 		if (sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE) {
599 			res = drv_add_interface(local, sdata);
600 			if (res)
601 				goto err_stop;
602 		} else if (local->monitors == 0 && local->open_count == 0) {
603 			res = ieee80211_add_virtual_monitor(local);
604 			if (res)
605 				goto err_stop;
606 		}
607 
608 		/* must be before the call to ieee80211_configure_filter */
609 		local->monitors++;
610 		if (local->monitors == 1) {
611 			local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
612 			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
613 		}
614 
615 		ieee80211_adjust_monitor_flags(sdata, 1);
616 		ieee80211_configure_filter(local);
617 		mutex_lock(&local->mtx);
618 		ieee80211_recalc_idle(local);
619 		mutex_unlock(&local->mtx);
620 
621 		netif_carrier_on(dev);
622 		break;
623 	default:
624 		if (coming_up) {
625 			ieee80211_del_virtual_monitor(local);
626 
627 			res = drv_add_interface(local, sdata);
628 			if (res)
629 				goto err_stop;
630 			res = ieee80211_check_queues(sdata,
631 				ieee80211_vif_type_p2p(&sdata->vif));
632 			if (res)
633 				goto err_del_interface;
634 		}
635 
636 		if (sdata->vif.type == NL80211_IFTYPE_AP) {
637 			local->fif_pspoll++;
638 			local->fif_probe_req++;
639 
640 			ieee80211_configure_filter(local);
641 		} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
642 			local->fif_probe_req++;
643 		}
644 
645 		if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
646 		    sdata->vif.type != NL80211_IFTYPE_NAN)
647 			changed |= ieee80211_reset_erp_info(sdata);
648 		ieee80211_bss_info_change_notify(sdata, changed);
649 
650 		switch (sdata->vif.type) {
651 		case NL80211_IFTYPE_STATION:
652 		case NL80211_IFTYPE_ADHOC:
653 		case NL80211_IFTYPE_AP:
654 		case NL80211_IFTYPE_MESH_POINT:
655 		case NL80211_IFTYPE_OCB:
656 			netif_carrier_off(dev);
657 			break;
658 		case NL80211_IFTYPE_WDS:
659 		case NL80211_IFTYPE_P2P_DEVICE:
660 		case NL80211_IFTYPE_NAN:
661 			break;
662 		default:
663 			/* not reached */
664 			WARN_ON(1);
665 		}
666 
667 		/*
668 		 * Set default queue parameters so drivers don't
669 		 * need to initialise the hardware if the hardware
670 		 * doesn't start up with sane defaults.
671 		 * Enable QoS for anything but station interfaces.
672 		 */
673 		ieee80211_set_wmm_default(sdata, true,
674 			sdata->vif.type != NL80211_IFTYPE_STATION);
675 	}
676 
677 	set_bit(SDATA_STATE_RUNNING, &sdata->state);
678 
679 	switch (sdata->vif.type) {
680 	case NL80211_IFTYPE_WDS:
681 		/* Create STA entry for the WDS peer */
682 		sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
683 				     GFP_KERNEL);
684 		if (!sta) {
685 			res = -ENOMEM;
686 			goto err_del_interface;
687 		}
688 
689 		sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
690 		sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
691 		sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
692 
693 		res = sta_info_insert(sta);
694 		if (res) {
695 			/* STA has been freed */
696 			goto err_del_interface;
697 		}
698 
699 		rate_control_rate_init(sta);
700 		netif_carrier_on(dev);
701 		break;
702 	case NL80211_IFTYPE_P2P_DEVICE:
703 		rcu_assign_pointer(local->p2p_sdata, sdata);
704 		break;
705 	case NL80211_IFTYPE_MONITOR:
706 		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES)
707 			break;
708 		list_add_tail_rcu(&sdata->u.mntr.list, &local->mon_list);
709 		break;
710 	default:
711 		break;
712 	}
713 
714 	/*
715 	 * set_multicast_list will be invoked by the networking core
716 	 * which will check whether any increments here were done in
717 	 * error and sync them down to the hardware as filter flags.
718 	 */
719 	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
720 		atomic_inc(&local->iff_allmultis);
721 
722 	if (coming_up)
723 		local->open_count++;
724 
725 	if (hw_reconf_flags)
726 		ieee80211_hw_config(local, hw_reconf_flags);
727 
728 	ieee80211_recalc_ps(local);
729 
730 	if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
731 	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
732 	    local->ops->wake_tx_queue) {
733 		/* XXX: for AP_VLAN, actually track AP queues */
734 		netif_tx_start_all_queues(dev);
735 	} else if (dev) {
736 		unsigned long flags;
737 		int n_acs = IEEE80211_NUM_ACS;
738 		int ac;
739 
740 		if (local->hw.queues < IEEE80211_NUM_ACS)
741 			n_acs = 1;
742 
743 		spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
744 		if (sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE ||
745 		    (local->queue_stop_reasons[sdata->vif.cab_queue] == 0 &&
746 		     skb_queue_empty(&local->pending[sdata->vif.cab_queue]))) {
747 			for (ac = 0; ac < n_acs; ac++) {
748 				int ac_queue = sdata->vif.hw_queue[ac];
749 
750 				if (local->queue_stop_reasons[ac_queue] == 0 &&
751 				    skb_queue_empty(&local->pending[ac_queue]))
752 					netif_start_subqueue(dev, ac);
753 			}
754 		}
755 		spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
756 	}
757 
758 	return 0;
759  err_del_interface:
760 	drv_remove_interface(local, sdata);
761  err_stop:
762 	if (!local->open_count)
763 		drv_stop(local);
764  err_del_bss:
765 	sdata->bss = NULL;
766 	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
767 		mutex_lock(&local->mtx);
768 		list_del(&sdata->u.vlan.list);
769 		mutex_unlock(&local->mtx);
770 	}
771 	/* might already be clear but that doesn't matter */
772 	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
773 	return res;
774 }
775 
776 static int ieee80211_open(struct net_device *dev)
777 {
778 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
779 	int err;
780 
781 	/* fail early if user set an invalid address */
782 	if (!is_valid_ether_addr(dev->dev_addr))
783 		return -EADDRNOTAVAIL;
784 
785 	err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
786 	if (err)
787 		return err;
788 
789 	return ieee80211_do_open(&sdata->wdev, true);
790 }
791 
792 static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
793 			      bool going_down)
794 {
795 	struct ieee80211_local *local = sdata->local;
796 	struct fq *fq = &local->fq;
797 	unsigned long flags;
798 	struct sk_buff *skb, *tmp;
799 	u32 hw_reconf_flags = 0;
800 	int i, flushed;
801 	struct ps_data *ps;
802 	struct cfg80211_chan_def chandef;
803 	bool cancel_scan;
804 	struct cfg80211_nan_func *func;
805 
806 	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
807 
808 	cancel_scan = rcu_access_pointer(local->scan_sdata) == sdata;
809 	if (cancel_scan)
810 		ieee80211_scan_cancel(local);
811 
812 	/*
813 	 * Stop TX on this interface first.
814 	 */
815 	if (sdata->dev)
816 		netif_tx_stop_all_queues(sdata->dev);
817 
818 	ieee80211_roc_purge(local, sdata);
819 
820 	switch (sdata->vif.type) {
821 	case NL80211_IFTYPE_STATION:
822 		ieee80211_mgd_stop(sdata);
823 		break;
824 	case NL80211_IFTYPE_ADHOC:
825 		ieee80211_ibss_stop(sdata);
826 		break;
827 	case NL80211_IFTYPE_AP:
828 		cancel_work_sync(&sdata->u.ap.request_smps_work);
829 		break;
830 	case NL80211_IFTYPE_MONITOR:
831 		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES)
832 			break;
833 		list_del_rcu(&sdata->u.mntr.list);
834 		break;
835 	default:
836 		break;
837 	}
838 
839 	/*
840 	 * Remove all stations associated with this interface.
841 	 *
842 	 * This must be done before calling ops->remove_interface()
843 	 * because otherwise we can later invoke ops->sta_notify()
844 	 * whenever the STAs are removed, and that invalidates driver
845 	 * assumptions about always getting a vif pointer that is valid
846 	 * (because if we remove a STA after ops->remove_interface()
847 	 * the driver will have removed the vif info already!)
848 	 *
849 	 * In WDS mode a station must exist here and be flushed, for
850 	 * AP_VLANs stations may exist since there's nothing else that
851 	 * would have removed them, but in other modes there shouldn't
852 	 * be any stations.
853 	 */
854 	flushed = sta_info_flush(sdata);
855 	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
856 		     ((sdata->vif.type != NL80211_IFTYPE_WDS && flushed > 0) ||
857 		      (sdata->vif.type == NL80211_IFTYPE_WDS && flushed != 1)));
858 
859 	/* don't count this interface for allmulti while it is down */
860 	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
861 		atomic_dec(&local->iff_allmultis);
862 
863 	if (sdata->vif.type == NL80211_IFTYPE_AP) {
864 		local->fif_pspoll--;
865 		local->fif_probe_req--;
866 	} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
867 		local->fif_probe_req--;
868 	}
869 
870 	if (sdata->dev) {
871 		netif_addr_lock_bh(sdata->dev);
872 		spin_lock_bh(&local->filter_lock);
873 		__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
874 				 sdata->dev->addr_len);
875 		spin_unlock_bh(&local->filter_lock);
876 		netif_addr_unlock_bh(sdata->dev);
877 	}
878 
879 	del_timer_sync(&local->dynamic_ps_timer);
880 	cancel_work_sync(&local->dynamic_ps_enable_work);
881 
882 	cancel_work_sync(&sdata->recalc_smps);
883 	sdata_lock(sdata);
884 	mutex_lock(&local->mtx);
885 	sdata->vif.csa_active = false;
886 	if (sdata->vif.type == NL80211_IFTYPE_STATION)
887 		sdata->u.mgd.csa_waiting_bcn = false;
888 	if (sdata->csa_block_tx) {
889 		ieee80211_wake_vif_queues(local, sdata,
890 					  IEEE80211_QUEUE_STOP_REASON_CSA);
891 		sdata->csa_block_tx = false;
892 	}
893 	mutex_unlock(&local->mtx);
894 	sdata_unlock(sdata);
895 
896 	cancel_work_sync(&sdata->csa_finalize_work);
897 
898 	cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
899 
900 	if (sdata->wdev.cac_started) {
901 		chandef = sdata->vif.bss_conf.chandef;
902 		WARN_ON(local->suspended);
903 		mutex_lock(&local->mtx);
904 		ieee80211_vif_release_channel(sdata);
905 		mutex_unlock(&local->mtx);
906 		cfg80211_cac_event(sdata->dev, &chandef,
907 				   NL80211_RADAR_CAC_ABORTED,
908 				   GFP_KERNEL);
909 	}
910 
911 	/* APs need special treatment */
912 	if (sdata->vif.type == NL80211_IFTYPE_AP) {
913 		struct ieee80211_sub_if_data *vlan, *tmpsdata;
914 
915 		/* down all dependent devices, that is VLANs */
916 		list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
917 					 u.vlan.list)
918 			dev_close(vlan->dev);
919 		WARN_ON(!list_empty(&sdata->u.ap.vlans));
920 	} else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
921 		/* remove all packets in parent bc_buf pointing to this dev */
922 		ps = &sdata->bss->ps;
923 
924 		spin_lock_irqsave(&ps->bc_buf.lock, flags);
925 		skb_queue_walk_safe(&ps->bc_buf, skb, tmp) {
926 			if (skb->dev == sdata->dev) {
927 				__skb_unlink(skb, &ps->bc_buf);
928 				local->total_ps_buffered--;
929 				ieee80211_free_txskb(&local->hw, skb);
930 			}
931 		}
932 		spin_unlock_irqrestore(&ps->bc_buf.lock, flags);
933 	}
934 
935 	if (going_down)
936 		local->open_count--;
937 
938 	switch (sdata->vif.type) {
939 	case NL80211_IFTYPE_AP_VLAN:
940 		mutex_lock(&local->mtx);
941 		list_del(&sdata->u.vlan.list);
942 		mutex_unlock(&local->mtx);
943 		RCU_INIT_POINTER(sdata->vif.chanctx_conf, NULL);
944 		/* see comment in the default case below */
945 		ieee80211_free_keys(sdata, true);
946 		/* no need to tell driver */
947 		break;
948 	case NL80211_IFTYPE_MONITOR:
949 		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) {
950 			local->cooked_mntrs--;
951 			break;
952 		}
953 
954 		local->monitors--;
955 		if (local->monitors == 0) {
956 			local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
957 			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
958 		}
959 
960 		ieee80211_adjust_monitor_flags(sdata, -1);
961 		break;
962 	case NL80211_IFTYPE_NAN:
963 		/* clean all the functions */
964 		spin_lock_bh(&sdata->u.nan.func_lock);
965 
966 		idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, i) {
967 			idr_remove(&sdata->u.nan.function_inst_ids, i);
968 			cfg80211_free_nan_func(func);
969 		}
970 		idr_destroy(&sdata->u.nan.function_inst_ids);
971 
972 		spin_unlock_bh(&sdata->u.nan.func_lock);
973 		break;
974 	case NL80211_IFTYPE_P2P_DEVICE:
975 		/* relies on synchronize_rcu() below */
976 		RCU_INIT_POINTER(local->p2p_sdata, NULL);
977 		/* fall through */
978 	default:
979 		cancel_work_sync(&sdata->work);
980 		/*
981 		 * When we get here, the interface is marked down.
982 		 * Free the remaining keys, if there are any
983 		 * (which can happen in AP mode if userspace sets
984 		 * keys before the interface is operating, and maybe
985 		 * also in WDS mode)
986 		 *
987 		 * Force the key freeing to always synchronize_net()
988 		 * to wait for the RX path in case it is using this
989 		 * interface enqueuing frames at this very time on
990 		 * another CPU.
991 		 */
992 		ieee80211_free_keys(sdata, true);
993 		skb_queue_purge(&sdata->skb_queue);
994 	}
995 
996 	sdata->bss = NULL;
997 
998 	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
999 	for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
1000 		skb_queue_walk_safe(&local->pending[i], skb, tmp) {
1001 			struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1002 			if (info->control.vif == &sdata->vif) {
1003 				__skb_unlink(skb, &local->pending[i]);
1004 				ieee80211_free_txskb(&local->hw, skb);
1005 			}
1006 		}
1007 	}
1008 	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
1009 
1010 	if (sdata->vif.txq) {
1011 		struct txq_info *txqi = to_txq_info(sdata->vif.txq);
1012 
1013 		spin_lock_bh(&fq->lock);
1014 		ieee80211_txq_purge(local, txqi);
1015 		spin_unlock_bh(&fq->lock);
1016 	}
1017 
1018 	if (local->open_count == 0)
1019 		ieee80211_clear_tx_pending(local);
1020 
1021 	/*
1022 	 * If the interface goes down while suspended, presumably because
1023 	 * the device was unplugged and that happens before our resume,
1024 	 * then the driver is already unconfigured and the remainder of
1025 	 * this function isn't needed.
1026 	 * XXX: what about WoWLAN? If the device has software state, e.g.
1027 	 *	memory allocated, it might expect teardown commands from
1028 	 *	mac80211 here?
1029 	 */
1030 	if (local->suspended) {
1031 		WARN_ON(local->wowlan);
1032 		WARN_ON(rtnl_dereference(local->monitor_sdata));
1033 		return;
1034 	}
1035 
1036 	switch (sdata->vif.type) {
1037 	case NL80211_IFTYPE_AP_VLAN:
1038 		break;
1039 	case NL80211_IFTYPE_MONITOR:
1040 		if (local->monitors == 0)
1041 			ieee80211_del_virtual_monitor(local);
1042 
1043 		mutex_lock(&local->mtx);
1044 		ieee80211_recalc_idle(local);
1045 		mutex_unlock(&local->mtx);
1046 
1047 		if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
1048 			break;
1049 
1050 		/* fall through */
1051 	default:
1052 		if (going_down)
1053 			drv_remove_interface(local, sdata);
1054 	}
1055 
1056 	ieee80211_recalc_ps(local);
1057 
1058 	if (cancel_scan)
1059 		flush_delayed_work(&local->scan_work);
1060 
1061 	if (local->open_count == 0) {
1062 		ieee80211_stop_device(local);
1063 
1064 		/* no reconfiguring after stop! */
1065 		return;
1066 	}
1067 
1068 	/* do after stop to avoid reconfiguring when we stop anyway */
1069 	ieee80211_configure_filter(local);
1070 	ieee80211_hw_config(local, hw_reconf_flags);
1071 
1072 	if (local->monitors == local->open_count)
1073 		ieee80211_add_virtual_monitor(local);
1074 }
1075 
1076 static int ieee80211_stop(struct net_device *dev)
1077 {
1078 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1079 
1080 	ieee80211_do_stop(sdata, true);
1081 
1082 	return 0;
1083 }
1084 
1085 static void ieee80211_set_multicast_list(struct net_device *dev)
1086 {
1087 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1088 	struct ieee80211_local *local = sdata->local;
1089 	int allmulti, sdata_allmulti;
1090 
1091 	allmulti = !!(dev->flags & IFF_ALLMULTI);
1092 	sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
1093 
1094 	if (allmulti != sdata_allmulti) {
1095 		if (dev->flags & IFF_ALLMULTI)
1096 			atomic_inc(&local->iff_allmultis);
1097 		else
1098 			atomic_dec(&local->iff_allmultis);
1099 		sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
1100 	}
1101 
1102 	spin_lock_bh(&local->filter_lock);
1103 	__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
1104 	spin_unlock_bh(&local->filter_lock);
1105 	ieee80211_queue_work(&local->hw, &local->reconfig_filter);
1106 }
1107 
1108 /*
1109  * Called when the netdev is removed or, by the code below, before
1110  * the interface type changes.
1111  */
1112 static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
1113 {
1114 	int i;
1115 
1116 	/* free extra data */
1117 	ieee80211_free_keys(sdata, false);
1118 
1119 	ieee80211_debugfs_remove_netdev(sdata);
1120 
1121 	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
1122 		__skb_queue_purge(&sdata->fragments[i].skb_list);
1123 	sdata->fragment_next = 0;
1124 
1125 	if (ieee80211_vif_is_mesh(&sdata->vif))
1126 		ieee80211_mesh_teardown_sdata(sdata);
1127 }
1128 
1129 static void ieee80211_uninit(struct net_device *dev)
1130 {
1131 	ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
1132 }
1133 
1134 static u16 ieee80211_netdev_select_queue(struct net_device *dev,
1135 					 struct sk_buff *skb,
1136 					 void *accel_priv,
1137 					 select_queue_fallback_t fallback)
1138 {
1139 	return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
1140 }
1141 
1142 static void
1143 ieee80211_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
1144 {
1145 	int i;
1146 
1147 	for_each_possible_cpu(i) {
1148 		const struct pcpu_sw_netstats *tstats;
1149 		u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
1150 		unsigned int start;
1151 
1152 		tstats = per_cpu_ptr(dev->tstats, i);
1153 
1154 		do {
1155 			start = u64_stats_fetch_begin_irq(&tstats->syncp);
1156 			rx_packets = tstats->rx_packets;
1157 			tx_packets = tstats->tx_packets;
1158 			rx_bytes = tstats->rx_bytes;
1159 			tx_bytes = tstats->tx_bytes;
1160 		} while (u64_stats_fetch_retry_irq(&tstats->syncp, start));
1161 
1162 		stats->rx_packets += rx_packets;
1163 		stats->tx_packets += tx_packets;
1164 		stats->rx_bytes   += rx_bytes;
1165 		stats->tx_bytes   += tx_bytes;
1166 	}
1167 }
1168 
1169 static const struct net_device_ops ieee80211_dataif_ops = {
1170 	.ndo_open		= ieee80211_open,
1171 	.ndo_stop		= ieee80211_stop,
1172 	.ndo_uninit		= ieee80211_uninit,
1173 	.ndo_start_xmit		= ieee80211_subif_start_xmit,
1174 	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
1175 	.ndo_set_mac_address 	= ieee80211_change_mac,
1176 	.ndo_select_queue	= ieee80211_netdev_select_queue,
1177 	.ndo_get_stats64	= ieee80211_get_stats64,
1178 };
1179 
1180 static u16 ieee80211_monitor_select_queue(struct net_device *dev,
1181 					  struct sk_buff *skb,
1182 					  void *accel_priv,
1183 					  select_queue_fallback_t fallback)
1184 {
1185 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1186 	struct ieee80211_local *local = sdata->local;
1187 	struct ieee80211_hdr *hdr;
1188 	struct ieee80211_radiotap_header *rtap = (void *)skb->data;
1189 
1190 	if (local->hw.queues < IEEE80211_NUM_ACS)
1191 		return 0;
1192 
1193 	if (skb->len < 4 ||
1194 	    skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
1195 		return 0; /* doesn't matter, frame will be dropped */
1196 
1197 	hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
1198 
1199 	return ieee80211_select_queue_80211(sdata, skb, hdr);
1200 }
1201 
1202 static const struct net_device_ops ieee80211_monitorif_ops = {
1203 	.ndo_open		= ieee80211_open,
1204 	.ndo_stop		= ieee80211_stop,
1205 	.ndo_uninit		= ieee80211_uninit,
1206 	.ndo_start_xmit		= ieee80211_monitor_start_xmit,
1207 	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
1208 	.ndo_set_mac_address 	= ieee80211_change_mac,
1209 	.ndo_select_queue	= ieee80211_monitor_select_queue,
1210 	.ndo_get_stats64	= ieee80211_get_stats64,
1211 };
1212 
1213 static void ieee80211_if_free(struct net_device *dev)
1214 {
1215 	free_percpu(dev->tstats);
1216 }
1217 
1218 static void ieee80211_if_setup(struct net_device *dev)
1219 {
1220 	ether_setup(dev);
1221 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1222 	dev->netdev_ops = &ieee80211_dataif_ops;
1223 	dev->needs_free_netdev = true;
1224 	dev->priv_destructor = ieee80211_if_free;
1225 }
1226 
1227 static void ieee80211_if_setup_no_queue(struct net_device *dev)
1228 {
1229 	ieee80211_if_setup(dev);
1230 	dev->priv_flags |= IFF_NO_QUEUE;
1231 }
1232 
1233 static void ieee80211_iface_work(struct work_struct *work)
1234 {
1235 	struct ieee80211_sub_if_data *sdata =
1236 		container_of(work, struct ieee80211_sub_if_data, work);
1237 	struct ieee80211_local *local = sdata->local;
1238 	struct sk_buff *skb;
1239 	struct sta_info *sta;
1240 
1241 	if (!ieee80211_sdata_running(sdata))
1242 		return;
1243 
1244 	if (test_bit(SCAN_SW_SCANNING, &local->scanning))
1245 		return;
1246 
1247 	if (!ieee80211_can_run_worker(local))
1248 		return;
1249 
1250 	/* first process frames */
1251 	while ((skb = skb_dequeue(&sdata->skb_queue))) {
1252 		struct ieee80211_mgmt *mgmt = (void *)skb->data;
1253 
1254 		if (ieee80211_is_action(mgmt->frame_control) &&
1255 		    mgmt->u.action.category == WLAN_CATEGORY_BACK) {
1256 			int len = skb->len;
1257 
1258 			mutex_lock(&local->sta_mtx);
1259 			sta = sta_info_get_bss(sdata, mgmt->sa);
1260 			if (sta) {
1261 				switch (mgmt->u.action.u.addba_req.action_code) {
1262 				case WLAN_ACTION_ADDBA_REQ:
1263 					ieee80211_process_addba_request(
1264 							local, sta, mgmt, len);
1265 					break;
1266 				case WLAN_ACTION_ADDBA_RESP:
1267 					ieee80211_process_addba_resp(local, sta,
1268 								     mgmt, len);
1269 					break;
1270 				case WLAN_ACTION_DELBA:
1271 					ieee80211_process_delba(sdata, sta,
1272 								mgmt, len);
1273 					break;
1274 				default:
1275 					WARN_ON(1);
1276 					break;
1277 				}
1278 			}
1279 			mutex_unlock(&local->sta_mtx);
1280 		} else if (ieee80211_is_action(mgmt->frame_control) &&
1281 			   mgmt->u.action.category == WLAN_CATEGORY_VHT) {
1282 			switch (mgmt->u.action.u.vht_group_notif.action_code) {
1283 			case WLAN_VHT_ACTION_OPMODE_NOTIF: {
1284 				struct ieee80211_rx_status *status;
1285 				enum nl80211_band band;
1286 				u8 opmode;
1287 
1288 				status = IEEE80211_SKB_RXCB(skb);
1289 				band = status->band;
1290 				opmode = mgmt->u.action.u.vht_opmode_notif.operating_mode;
1291 
1292 				mutex_lock(&local->sta_mtx);
1293 				sta = sta_info_get_bss(sdata, mgmt->sa);
1294 
1295 				if (sta)
1296 					ieee80211_vht_handle_opmode(sdata, sta,
1297 								    opmode,
1298 								    band);
1299 
1300 				mutex_unlock(&local->sta_mtx);
1301 				break;
1302 			}
1303 			case WLAN_VHT_ACTION_GROUPID_MGMT:
1304 				ieee80211_process_mu_groups(sdata, mgmt);
1305 				break;
1306 			default:
1307 				WARN_ON(1);
1308 				break;
1309 			}
1310 		} else if (ieee80211_is_data_qos(mgmt->frame_control)) {
1311 			struct ieee80211_hdr *hdr = (void *)mgmt;
1312 			/*
1313 			 * So the frame isn't mgmt, but frame_control
1314 			 * is at the right place anyway, of course, so
1315 			 * the if statement is correct.
1316 			 *
1317 			 * Warn if we have other data frame types here,
1318 			 * they must not get here.
1319 			 */
1320 			WARN_ON(hdr->frame_control &
1321 					cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
1322 			WARN_ON(!(hdr->seq_ctrl &
1323 					cpu_to_le16(IEEE80211_SCTL_FRAG)));
1324 			/*
1325 			 * This was a fragment of a frame, received while
1326 			 * a block-ack session was active. That cannot be
1327 			 * right, so terminate the session.
1328 			 */
1329 			mutex_lock(&local->sta_mtx);
1330 			sta = sta_info_get_bss(sdata, mgmt->sa);
1331 			if (sta) {
1332 				u16 tid = *ieee80211_get_qos_ctl(hdr) &
1333 						IEEE80211_QOS_CTL_TID_MASK;
1334 
1335 				__ieee80211_stop_rx_ba_session(
1336 					sta, tid, WLAN_BACK_RECIPIENT,
1337 					WLAN_REASON_QSTA_REQUIRE_SETUP,
1338 					true);
1339 			}
1340 			mutex_unlock(&local->sta_mtx);
1341 		} else switch (sdata->vif.type) {
1342 		case NL80211_IFTYPE_STATION:
1343 			ieee80211_sta_rx_queued_mgmt(sdata, skb);
1344 			break;
1345 		case NL80211_IFTYPE_ADHOC:
1346 			ieee80211_ibss_rx_queued_mgmt(sdata, skb);
1347 			break;
1348 		case NL80211_IFTYPE_MESH_POINT:
1349 			if (!ieee80211_vif_is_mesh(&sdata->vif))
1350 				break;
1351 			ieee80211_mesh_rx_queued_mgmt(sdata, skb);
1352 			break;
1353 		default:
1354 			WARN(1, "frame for unexpected interface type");
1355 			break;
1356 		}
1357 
1358 		kfree_skb(skb);
1359 	}
1360 
1361 	/* then other type-dependent work */
1362 	switch (sdata->vif.type) {
1363 	case NL80211_IFTYPE_STATION:
1364 		ieee80211_sta_work(sdata);
1365 		break;
1366 	case NL80211_IFTYPE_ADHOC:
1367 		ieee80211_ibss_work(sdata);
1368 		break;
1369 	case NL80211_IFTYPE_MESH_POINT:
1370 		if (!ieee80211_vif_is_mesh(&sdata->vif))
1371 			break;
1372 		ieee80211_mesh_work(sdata);
1373 		break;
1374 	case NL80211_IFTYPE_OCB:
1375 		ieee80211_ocb_work(sdata);
1376 		break;
1377 	default:
1378 		break;
1379 	}
1380 }
1381 
1382 static void ieee80211_recalc_smps_work(struct work_struct *work)
1383 {
1384 	struct ieee80211_sub_if_data *sdata =
1385 		container_of(work, struct ieee80211_sub_if_data, recalc_smps);
1386 
1387 	ieee80211_recalc_smps(sdata);
1388 }
1389 
1390 /*
1391  * Helper function to initialise an interface to a specific type.
1392  */
1393 static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
1394 				  enum nl80211_iftype type)
1395 {
1396 	static const u8 bssid_wildcard[ETH_ALEN] = {0xff, 0xff, 0xff,
1397 						    0xff, 0xff, 0xff};
1398 
1399 	/* clear type-dependent union */
1400 	memset(&sdata->u, 0, sizeof(sdata->u));
1401 
1402 	/* and set some type-dependent values */
1403 	sdata->vif.type = type;
1404 	sdata->vif.p2p = false;
1405 	sdata->wdev.iftype = type;
1406 
1407 	sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
1408 	sdata->control_port_no_encrypt = false;
1409 	sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
1410 	sdata->vif.bss_conf.idle = true;
1411 
1412 	sdata->noack_map = 0;
1413 
1414 	/* only monitor/p2p-device differ */
1415 	if (sdata->dev) {
1416 		sdata->dev->netdev_ops = &ieee80211_dataif_ops;
1417 		sdata->dev->type = ARPHRD_ETHER;
1418 	}
1419 
1420 	skb_queue_head_init(&sdata->skb_queue);
1421 	INIT_WORK(&sdata->work, ieee80211_iface_work);
1422 	INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
1423 	INIT_WORK(&sdata->csa_finalize_work, ieee80211_csa_finalize_work);
1424 	INIT_LIST_HEAD(&sdata->assigned_chanctx_list);
1425 	INIT_LIST_HEAD(&sdata->reserved_chanctx_list);
1426 
1427 	switch (type) {
1428 	case NL80211_IFTYPE_P2P_GO:
1429 		type = NL80211_IFTYPE_AP;
1430 		sdata->vif.type = type;
1431 		sdata->vif.p2p = true;
1432 		/* fall through */
1433 	case NL80211_IFTYPE_AP:
1434 		skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
1435 		INIT_LIST_HEAD(&sdata->u.ap.vlans);
1436 		INIT_WORK(&sdata->u.ap.request_smps_work,
1437 			  ieee80211_request_smps_ap_work);
1438 		sdata->vif.bss_conf.bssid = sdata->vif.addr;
1439 		sdata->u.ap.req_smps = IEEE80211_SMPS_OFF;
1440 		break;
1441 	case NL80211_IFTYPE_P2P_CLIENT:
1442 		type = NL80211_IFTYPE_STATION;
1443 		sdata->vif.type = type;
1444 		sdata->vif.p2p = true;
1445 		/* fall through */
1446 	case NL80211_IFTYPE_STATION:
1447 		sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;
1448 		ieee80211_sta_setup_sdata(sdata);
1449 		break;
1450 	case NL80211_IFTYPE_OCB:
1451 		sdata->vif.bss_conf.bssid = bssid_wildcard;
1452 		ieee80211_ocb_setup_sdata(sdata);
1453 		break;
1454 	case NL80211_IFTYPE_ADHOC:
1455 		sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
1456 		ieee80211_ibss_setup_sdata(sdata);
1457 		break;
1458 	case NL80211_IFTYPE_MESH_POINT:
1459 		if (ieee80211_vif_is_mesh(&sdata->vif))
1460 			ieee80211_mesh_init_sdata(sdata);
1461 		break;
1462 	case NL80211_IFTYPE_MONITOR:
1463 		sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
1464 		sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
1465 		sdata->u.mntr.flags = MONITOR_FLAG_CONTROL |
1466 				      MONITOR_FLAG_OTHER_BSS;
1467 		break;
1468 	case NL80211_IFTYPE_WDS:
1469 		sdata->vif.bss_conf.bssid = NULL;
1470 		break;
1471 	case NL80211_IFTYPE_NAN:
1472 		idr_init(&sdata->u.nan.function_inst_ids);
1473 		spin_lock_init(&sdata->u.nan.func_lock);
1474 		sdata->vif.bss_conf.bssid = sdata->vif.addr;
1475 		break;
1476 	case NL80211_IFTYPE_AP_VLAN:
1477 	case NL80211_IFTYPE_P2P_DEVICE:
1478 		sdata->vif.bss_conf.bssid = sdata->vif.addr;
1479 		break;
1480 	case NL80211_IFTYPE_UNSPECIFIED:
1481 	case NUM_NL80211_IFTYPES:
1482 		BUG();
1483 		break;
1484 	}
1485 
1486 	ieee80211_debugfs_add_netdev(sdata);
1487 }
1488 
1489 static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
1490 					   enum nl80211_iftype type)
1491 {
1492 	struct ieee80211_local *local = sdata->local;
1493 	int ret, err;
1494 	enum nl80211_iftype internal_type = type;
1495 	bool p2p = false;
1496 
1497 	ASSERT_RTNL();
1498 
1499 	if (!local->ops->change_interface)
1500 		return -EBUSY;
1501 
1502 	switch (sdata->vif.type) {
1503 	case NL80211_IFTYPE_AP:
1504 	case NL80211_IFTYPE_STATION:
1505 	case NL80211_IFTYPE_ADHOC:
1506 	case NL80211_IFTYPE_OCB:
1507 		/*
1508 		 * Could maybe also all others here?
1509 		 * Just not sure how that interacts
1510 		 * with the RX/config path e.g. for
1511 		 * mesh.
1512 		 */
1513 		break;
1514 	default:
1515 		return -EBUSY;
1516 	}
1517 
1518 	switch (type) {
1519 	case NL80211_IFTYPE_AP:
1520 	case NL80211_IFTYPE_STATION:
1521 	case NL80211_IFTYPE_ADHOC:
1522 	case NL80211_IFTYPE_OCB:
1523 		/*
1524 		 * Could probably support everything
1525 		 * but WDS here (WDS do_open can fail
1526 		 * under memory pressure, which this
1527 		 * code isn't prepared to handle).
1528 		 */
1529 		break;
1530 	case NL80211_IFTYPE_P2P_CLIENT:
1531 		p2p = true;
1532 		internal_type = NL80211_IFTYPE_STATION;
1533 		break;
1534 	case NL80211_IFTYPE_P2P_GO:
1535 		p2p = true;
1536 		internal_type = NL80211_IFTYPE_AP;
1537 		break;
1538 	default:
1539 		return -EBUSY;
1540 	}
1541 
1542 	ret = ieee80211_check_concurrent_iface(sdata, internal_type);
1543 	if (ret)
1544 		return ret;
1545 
1546 	ieee80211_do_stop(sdata, false);
1547 
1548 	ieee80211_teardown_sdata(sdata);
1549 
1550 	ret = drv_change_interface(local, sdata, internal_type, p2p);
1551 	if (ret)
1552 		type = ieee80211_vif_type_p2p(&sdata->vif);
1553 
1554 	/*
1555 	 * Ignore return value here, there's not much we can do since
1556 	 * the driver changed the interface type internally already.
1557 	 * The warnings will hopefully make driver authors fix it :-)
1558 	 */
1559 	ieee80211_check_queues(sdata, type);
1560 
1561 	ieee80211_setup_sdata(sdata, type);
1562 
1563 	err = ieee80211_do_open(&sdata->wdev, false);
1564 	WARN(err, "type change: do_open returned %d", err);
1565 
1566 	return ret;
1567 }
1568 
1569 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
1570 			     enum nl80211_iftype type)
1571 {
1572 	int ret;
1573 
1574 	ASSERT_RTNL();
1575 
1576 	if (type == ieee80211_vif_type_p2p(&sdata->vif))
1577 		return 0;
1578 
1579 	if (ieee80211_sdata_running(sdata)) {
1580 		ret = ieee80211_runtime_change_iftype(sdata, type);
1581 		if (ret)
1582 			return ret;
1583 	} else {
1584 		/* Purge and reset type-dependent state. */
1585 		ieee80211_teardown_sdata(sdata);
1586 		ieee80211_setup_sdata(sdata, type);
1587 	}
1588 
1589 	/* reset some values that shouldn't be kept across type changes */
1590 	if (type == NL80211_IFTYPE_STATION)
1591 		sdata->u.mgd.use_4addr = false;
1592 
1593 	return 0;
1594 }
1595 
1596 static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
1597 				       u8 *perm_addr, enum nl80211_iftype type)
1598 {
1599 	struct ieee80211_sub_if_data *sdata;
1600 	u64 mask, start, addr, val, inc;
1601 	u8 *m;
1602 	u8 tmp_addr[ETH_ALEN];
1603 	int i;
1604 
1605 	/* default ... something at least */
1606 	memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
1607 
1608 	if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
1609 	    local->hw.wiphy->n_addresses <= 1)
1610 		return;
1611 
1612 	mutex_lock(&local->iflist_mtx);
1613 
1614 	switch (type) {
1615 	case NL80211_IFTYPE_MONITOR:
1616 		/* doesn't matter */
1617 		break;
1618 	case NL80211_IFTYPE_WDS:
1619 	case NL80211_IFTYPE_AP_VLAN:
1620 		/* match up with an AP interface */
1621 		list_for_each_entry(sdata, &local->interfaces, list) {
1622 			if (sdata->vif.type != NL80211_IFTYPE_AP)
1623 				continue;
1624 			memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
1625 			break;
1626 		}
1627 		/* keep default if no AP interface present */
1628 		break;
1629 	case NL80211_IFTYPE_P2P_CLIENT:
1630 	case NL80211_IFTYPE_P2P_GO:
1631 		if (ieee80211_hw_check(&local->hw, P2P_DEV_ADDR_FOR_INTF)) {
1632 			list_for_each_entry(sdata, &local->interfaces, list) {
1633 				if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
1634 					continue;
1635 				if (!ieee80211_sdata_running(sdata))
1636 					continue;
1637 				memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
1638 				goto out_unlock;
1639 			}
1640 		}
1641 		/* otherwise fall through */
1642 	default:
1643 		/* assign a new address if possible -- try n_addresses first */
1644 		for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
1645 			bool used = false;
1646 
1647 			list_for_each_entry(sdata, &local->interfaces, list) {
1648 				if (ether_addr_equal(local->hw.wiphy->addresses[i].addr,
1649 						     sdata->vif.addr)) {
1650 					used = true;
1651 					break;
1652 				}
1653 			}
1654 
1655 			if (!used) {
1656 				memcpy(perm_addr,
1657 				       local->hw.wiphy->addresses[i].addr,
1658 				       ETH_ALEN);
1659 				break;
1660 			}
1661 		}
1662 
1663 		/* try mask if available */
1664 		if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
1665 			break;
1666 
1667 		m = local->hw.wiphy->addr_mask;
1668 		mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1669 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1670 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1671 
1672 		if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
1673 			/* not a contiguous mask ... not handled now! */
1674 			pr_info("not contiguous\n");
1675 			break;
1676 		}
1677 
1678 		/*
1679 		 * Pick address of existing interface in case user changed
1680 		 * MAC address manually, default to perm_addr.
1681 		 */
1682 		m = local->hw.wiphy->perm_addr;
1683 		list_for_each_entry(sdata, &local->interfaces, list) {
1684 			if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
1685 				continue;
1686 			m = sdata->vif.addr;
1687 			break;
1688 		}
1689 		start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1690 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1691 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1692 
1693 		inc = 1ULL<<__ffs64(mask);
1694 		val = (start & mask);
1695 		addr = (start & ~mask) | (val & mask);
1696 		do {
1697 			bool used = false;
1698 
1699 			tmp_addr[5] = addr >> 0*8;
1700 			tmp_addr[4] = addr >> 1*8;
1701 			tmp_addr[3] = addr >> 2*8;
1702 			tmp_addr[2] = addr >> 3*8;
1703 			tmp_addr[1] = addr >> 4*8;
1704 			tmp_addr[0] = addr >> 5*8;
1705 
1706 			val += inc;
1707 
1708 			list_for_each_entry(sdata, &local->interfaces, list) {
1709 				if (ether_addr_equal(tmp_addr, sdata->vif.addr)) {
1710 					used = true;
1711 					break;
1712 				}
1713 			}
1714 
1715 			if (!used) {
1716 				memcpy(perm_addr, tmp_addr, ETH_ALEN);
1717 				break;
1718 			}
1719 			addr = (start & ~mask) | (val & mask);
1720 		} while (addr != start);
1721 
1722 		break;
1723 	}
1724 
1725  out_unlock:
1726 	mutex_unlock(&local->iflist_mtx);
1727 }
1728 
1729 int ieee80211_if_add(struct ieee80211_local *local, const char *name,
1730 		     unsigned char name_assign_type,
1731 		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
1732 		     struct vif_params *params)
1733 {
1734 	struct net_device *ndev = NULL;
1735 	struct ieee80211_sub_if_data *sdata = NULL;
1736 	struct txq_info *txqi;
1737 	void (*if_setup)(struct net_device *dev);
1738 	int ret, i;
1739 	int txqs = 1;
1740 
1741 	ASSERT_RTNL();
1742 
1743 	if (type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN) {
1744 		struct wireless_dev *wdev;
1745 
1746 		sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,
1747 				GFP_KERNEL);
1748 		if (!sdata)
1749 			return -ENOMEM;
1750 		wdev = &sdata->wdev;
1751 
1752 		sdata->dev = NULL;
1753 		strlcpy(sdata->name, name, IFNAMSIZ);
1754 		ieee80211_assign_perm_addr(local, wdev->address, type);
1755 		memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
1756 	} else {
1757 		int size = ALIGN(sizeof(*sdata) + local->hw.vif_data_size,
1758 				 sizeof(void *));
1759 		int txq_size = 0;
1760 
1761 		if (local->ops->wake_tx_queue)
1762 			txq_size += sizeof(struct txq_info) +
1763 				    local->hw.txq_data_size;
1764 
1765 		if (local->ops->wake_tx_queue)
1766 			if_setup = ieee80211_if_setup_no_queue;
1767 		else
1768 			if_setup = ieee80211_if_setup;
1769 
1770 		if (local->hw.queues >= IEEE80211_NUM_ACS)
1771 			txqs = IEEE80211_NUM_ACS;
1772 
1773 		ndev = alloc_netdev_mqs(size + txq_size,
1774 					name, name_assign_type,
1775 					if_setup, txqs, 1);
1776 		if (!ndev)
1777 			return -ENOMEM;
1778 		dev_net_set(ndev, wiphy_net(local->hw.wiphy));
1779 
1780 		ndev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1781 		if (!ndev->tstats) {
1782 			free_netdev(ndev);
1783 			return -ENOMEM;
1784 		}
1785 
1786 		ndev->needed_headroom = local->tx_headroom +
1787 					4*6 /* four MAC addresses */
1788 					+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
1789 					+ 6 /* mesh */
1790 					+ 8 /* rfc1042/bridge tunnel */
1791 					- ETH_HLEN /* ethernet hard_header_len */
1792 					+ IEEE80211_ENCRYPT_HEADROOM;
1793 		ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
1794 
1795 		ret = dev_alloc_name(ndev, ndev->name);
1796 		if (ret < 0) {
1797 			ieee80211_if_free(ndev);
1798 			free_netdev(ndev);
1799 			return ret;
1800 		}
1801 
1802 		ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
1803 		if (params && is_valid_ether_addr(params->macaddr))
1804 			memcpy(ndev->dev_addr, params->macaddr, ETH_ALEN);
1805 		else
1806 			memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
1807 		SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
1808 
1809 		/* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */
1810 		sdata = netdev_priv(ndev);
1811 		ndev->ieee80211_ptr = &sdata->wdev;
1812 		memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
1813 		memcpy(sdata->name, ndev->name, IFNAMSIZ);
1814 
1815 		if (txq_size) {
1816 			txqi = netdev_priv(ndev) + size;
1817 			ieee80211_txq_init(sdata, NULL, txqi, 0);
1818 		}
1819 
1820 		sdata->dev = ndev;
1821 	}
1822 
1823 	/* initialise type-independent data */
1824 	sdata->wdev.wiphy = local->hw.wiphy;
1825 	sdata->local = local;
1826 
1827 	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
1828 		skb_queue_head_init(&sdata->fragments[i].skb_list);
1829 
1830 	INIT_LIST_HEAD(&sdata->key_list);
1831 
1832 	INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work,
1833 			  ieee80211_dfs_cac_timer_work);
1834 	INIT_DELAYED_WORK(&sdata->dec_tailroom_needed_wk,
1835 			  ieee80211_delayed_tailroom_dec);
1836 
1837 	for (i = 0; i < NUM_NL80211_BANDS; i++) {
1838 		struct ieee80211_supported_band *sband;
1839 		sband = local->hw.wiphy->bands[i];
1840 		sdata->rc_rateidx_mask[i] =
1841 			sband ? (1 << sband->n_bitrates) - 1 : 0;
1842 		if (sband) {
1843 			__le16 cap;
1844 			u16 *vht_rate_mask;
1845 
1846 			memcpy(sdata->rc_rateidx_mcs_mask[i],
1847 			       sband->ht_cap.mcs.rx_mask,
1848 			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
1849 
1850 			cap = sband->vht_cap.vht_mcs.rx_mcs_map;
1851 			vht_rate_mask = sdata->rc_rateidx_vht_mcs_mask[i];
1852 			ieee80211_get_vht_mask_from_cap(cap, vht_rate_mask);
1853 		} else {
1854 			memset(sdata->rc_rateidx_mcs_mask[i], 0,
1855 			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
1856 			memset(sdata->rc_rateidx_vht_mcs_mask[i], 0,
1857 			       sizeof(sdata->rc_rateidx_vht_mcs_mask[i]));
1858 		}
1859 	}
1860 
1861 	ieee80211_set_default_queues(sdata);
1862 
1863 	sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
1864 	sdata->user_power_level = local->user_power_level;
1865 
1866 	sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
1867 
1868 	/* setup type-dependent data */
1869 	ieee80211_setup_sdata(sdata, type);
1870 
1871 	if (ndev) {
1872 		if (params) {
1873 			ndev->ieee80211_ptr->use_4addr = params->use_4addr;
1874 			if (type == NL80211_IFTYPE_STATION)
1875 				sdata->u.mgd.use_4addr = params->use_4addr;
1876 		}
1877 
1878 		ndev->features |= local->hw.netdev_features;
1879 
1880 		netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops);
1881 
1882 		/* MTU range: 256 - 2304 */
1883 		ndev->min_mtu = 256;
1884 		ndev->max_mtu = IEEE80211_MAX_DATA_LEN;
1885 
1886 		ret = register_netdevice(ndev);
1887 		if (ret) {
1888 			free_netdev(ndev);
1889 			return ret;
1890 		}
1891 	}
1892 
1893 	mutex_lock(&local->iflist_mtx);
1894 	list_add_tail_rcu(&sdata->list, &local->interfaces);
1895 	mutex_unlock(&local->iflist_mtx);
1896 
1897 	if (new_wdev)
1898 		*new_wdev = &sdata->wdev;
1899 
1900 	return 0;
1901 }
1902 
1903 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
1904 {
1905 	ASSERT_RTNL();
1906 
1907 	mutex_lock(&sdata->local->iflist_mtx);
1908 	list_del_rcu(&sdata->list);
1909 	mutex_unlock(&sdata->local->iflist_mtx);
1910 
1911 	synchronize_rcu();
1912 
1913 	if (sdata->dev) {
1914 		unregister_netdevice(sdata->dev);
1915 	} else {
1916 		cfg80211_unregister_wdev(&sdata->wdev);
1917 		ieee80211_teardown_sdata(sdata);
1918 		kfree(sdata);
1919 	}
1920 }
1921 
1922 void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)
1923 {
1924 	if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))
1925 		return;
1926 	ieee80211_do_stop(sdata, true);
1927 }
1928 
1929 void ieee80211_remove_interfaces(struct ieee80211_local *local)
1930 {
1931 	struct ieee80211_sub_if_data *sdata, *tmp;
1932 	LIST_HEAD(unreg_list);
1933 	LIST_HEAD(wdev_list);
1934 
1935 	ASSERT_RTNL();
1936 
1937 	/* Before destroying the interfaces, make sure they're all stopped so
1938 	 * that the hardware is stopped. Otherwise, the driver might still be
1939 	 * iterating the interfaces during the shutdown, e.g. from a worker
1940 	 * or from RX processing or similar, and if it does so (using atomic
1941 	 * iteration) while we're manipulating the list, the iteration will
1942 	 * crash.
1943 	 *
1944 	 * After this, the hardware should be stopped and the driver should
1945 	 * have stopped all of its activities, so that we can do RCU-unaware
1946 	 * manipulations of the interface list below.
1947 	 */
1948 	cfg80211_shutdown_all_interfaces(local->hw.wiphy);
1949 
1950 	WARN(local->open_count, "%s: open count remains %d\n",
1951 	     wiphy_name(local->hw.wiphy), local->open_count);
1952 
1953 	mutex_lock(&local->iflist_mtx);
1954 	list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
1955 		list_del(&sdata->list);
1956 
1957 		if (sdata->dev)
1958 			unregister_netdevice_queue(sdata->dev, &unreg_list);
1959 		else
1960 			list_add(&sdata->list, &wdev_list);
1961 	}
1962 	mutex_unlock(&local->iflist_mtx);
1963 	unregister_netdevice_many(&unreg_list);
1964 
1965 	list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {
1966 		list_del(&sdata->list);
1967 		cfg80211_unregister_wdev(&sdata->wdev);
1968 		kfree(sdata);
1969 	}
1970 }
1971 
1972 static int netdev_notify(struct notifier_block *nb,
1973 			 unsigned long state, void *ptr)
1974 {
1975 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1976 	struct ieee80211_sub_if_data *sdata;
1977 
1978 	if (state != NETDEV_CHANGENAME)
1979 		return NOTIFY_DONE;
1980 
1981 	if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
1982 		return NOTIFY_DONE;
1983 
1984 	if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
1985 		return NOTIFY_DONE;
1986 
1987 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1988 	memcpy(sdata->name, dev->name, IFNAMSIZ);
1989 	ieee80211_debugfs_rename_netdev(sdata);
1990 
1991 	return NOTIFY_OK;
1992 }
1993 
1994 static struct notifier_block mac80211_netdev_notifier = {
1995 	.notifier_call = netdev_notify,
1996 };
1997 
1998 int ieee80211_iface_init(void)
1999 {
2000 	return register_netdevice_notifier(&mac80211_netdev_notifier);
2001 }
2002 
2003 void ieee80211_iface_exit(void)
2004 {
2005 	unregister_netdevice_notifier(&mac80211_netdev_notifier);
2006 }
2007 
2008 void ieee80211_vif_inc_num_mcast(struct ieee80211_sub_if_data *sdata)
2009 {
2010 	if (sdata->vif.type == NL80211_IFTYPE_AP)
2011 		atomic_inc(&sdata->u.ap.num_mcast_sta);
2012 	else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
2013 		atomic_inc(&sdata->u.vlan.num_mcast_sta);
2014 }
2015 
2016 void ieee80211_vif_dec_num_mcast(struct ieee80211_sub_if_data *sdata)
2017 {
2018 	if (sdata->vif.type == NL80211_IFTYPE_AP)
2019 		atomic_dec(&sdata->u.ap.num_mcast_sta);
2020 	else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
2021 		atomic_dec(&sdata->u.vlan.num_mcast_sta);
2022 }
2023