xref: /openbmc/linux/net/wireless/core.c (revision f97769fd)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * This is the linux wireless configuration interface.
4  *
5  * Copyright 2006-2010		Johannes Berg <johannes@sipsolutions.net>
6  * Copyright 2013-2014  Intel Mobile Communications GmbH
7  * Copyright 2015-2017	Intel Deutschland GmbH
8  * Copyright (C) 2018-2020 Intel Corporation
9  */
10 
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 
13 #include <linux/if.h>
14 #include <linux/module.h>
15 #include <linux/err.h>
16 #include <linux/list.h>
17 #include <linux/slab.h>
18 #include <linux/nl80211.h>
19 #include <linux/debugfs.h>
20 #include <linux/notifier.h>
21 #include <linux/device.h>
22 #include <linux/etherdevice.h>
23 #include <linux/rtnetlink.h>
24 #include <linux/sched.h>
25 #include <net/genetlink.h>
26 #include <net/cfg80211.h>
27 #include "nl80211.h"
28 #include "core.h"
29 #include "sysfs.h"
30 #include "debugfs.h"
31 #include "wext-compat.h"
32 #include "rdev-ops.h"
33 
34 /* name for sysfs, %d is appended */
35 #define PHY_NAME "phy"
36 
37 MODULE_AUTHOR("Johannes Berg");
38 MODULE_LICENSE("GPL");
39 MODULE_DESCRIPTION("wireless configuration support");
40 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
41 
42 /* RCU-protected (and RTNL for writers) */
43 LIST_HEAD(cfg80211_rdev_list);
44 int cfg80211_rdev_list_generation;
45 
46 /* for debugfs */
47 static struct dentry *ieee80211_debugfs_dir;
48 
49 /* for the cleanup, scan and event works */
50 struct workqueue_struct *cfg80211_wq;
51 
52 static bool cfg80211_disable_40mhz_24ghz;
53 module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
54 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
55 		 "Disable 40MHz support in the 2.4GHz band");
56 
57 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
58 {
59 	struct cfg80211_registered_device *result = NULL, *rdev;
60 
61 	ASSERT_RTNL();
62 
63 	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
64 		if (rdev->wiphy_idx == wiphy_idx) {
65 			result = rdev;
66 			break;
67 		}
68 	}
69 
70 	return result;
71 }
72 
73 int get_wiphy_idx(struct wiphy *wiphy)
74 {
75 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
76 
77 	return rdev->wiphy_idx;
78 }
79 
80 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
81 {
82 	struct cfg80211_registered_device *rdev;
83 
84 	ASSERT_RTNL();
85 
86 	rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
87 	if (!rdev)
88 		return NULL;
89 	return &rdev->wiphy;
90 }
91 
92 static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
93 				   const char *newname)
94 {
95 	struct cfg80211_registered_device *rdev2;
96 	int wiphy_idx, taken = -1, digits;
97 
98 	ASSERT_RTNL();
99 
100 	if (strlen(newname) > NL80211_WIPHY_NAME_MAXLEN)
101 		return -EINVAL;
102 
103 	/* prohibit calling the thing phy%d when %d is not its number */
104 	sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
105 	if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
106 		/* count number of places needed to print wiphy_idx */
107 		digits = 1;
108 		while (wiphy_idx /= 10)
109 			digits++;
110 		/*
111 		 * deny the name if it is phy<idx> where <idx> is printed
112 		 * without leading zeroes. taken == strlen(newname) here
113 		 */
114 		if (taken == strlen(PHY_NAME) + digits)
115 			return -EINVAL;
116 	}
117 
118 	/* Ensure another device does not already have this name. */
119 	list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
120 		if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
121 			return -EINVAL;
122 
123 	return 0;
124 }
125 
126 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
127 			char *newname)
128 {
129 	int result;
130 
131 	ASSERT_RTNL();
132 
133 	/* Ignore nop renames */
134 	if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
135 		return 0;
136 
137 	result = cfg80211_dev_check_name(rdev, newname);
138 	if (result < 0)
139 		return result;
140 
141 	result = device_rename(&rdev->wiphy.dev, newname);
142 	if (result)
143 		return result;
144 
145 	if (!IS_ERR_OR_NULL(rdev->wiphy.debugfsdir))
146 		debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
147 			       rdev->wiphy.debugfsdir,
148 			       rdev->wiphy.debugfsdir->d_parent, newname);
149 
150 	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
151 
152 	return 0;
153 }
154 
155 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
156 			  struct net *net)
157 {
158 	struct wireless_dev *wdev;
159 	int err = 0;
160 
161 	if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
162 		return -EOPNOTSUPP;
163 
164 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
165 		if (!wdev->netdev)
166 			continue;
167 		wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
168 		err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
169 		if (err)
170 			break;
171 		wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
172 	}
173 
174 	if (err) {
175 		/* failed -- clean up to old netns */
176 		net = wiphy_net(&rdev->wiphy);
177 
178 		list_for_each_entry_continue_reverse(wdev,
179 						     &rdev->wiphy.wdev_list,
180 						     list) {
181 			if (!wdev->netdev)
182 				continue;
183 			wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
184 			err = dev_change_net_namespace(wdev->netdev, net,
185 							"wlan%d");
186 			WARN_ON(err);
187 			wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
188 		}
189 
190 		return err;
191 	}
192 
193 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
194 		if (!wdev->netdev)
195 			continue;
196 		nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
197 	}
198 	nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
199 
200 	wiphy_net_set(&rdev->wiphy, net);
201 
202 	err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
203 	WARN_ON(err);
204 
205 	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
206 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
207 		if (!wdev->netdev)
208 			continue;
209 		nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
210 	}
211 
212 	return 0;
213 }
214 
215 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
216 {
217 	struct cfg80211_registered_device *rdev = data;
218 
219 	rdev_rfkill_poll(rdev);
220 }
221 
222 void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
223 			      struct wireless_dev *wdev)
224 {
225 	ASSERT_RTNL();
226 
227 	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
228 		return;
229 
230 	if (!wdev_running(wdev))
231 		return;
232 
233 	rdev_stop_p2p_device(rdev, wdev);
234 	wdev->is_running = false;
235 
236 	rdev->opencount--;
237 
238 	if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
239 		if (WARN_ON(!rdev->scan_req->notified))
240 			rdev->scan_req->info.aborted = true;
241 		___cfg80211_scan_done(rdev, false);
242 	}
243 }
244 
245 void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
246 		       struct wireless_dev *wdev)
247 {
248 	ASSERT_RTNL();
249 
250 	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_NAN))
251 		return;
252 
253 	if (!wdev_running(wdev))
254 		return;
255 
256 	rdev_stop_nan(rdev, wdev);
257 	wdev->is_running = false;
258 
259 	rdev->opencount--;
260 }
261 
262 void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
263 {
264 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
265 	struct wireless_dev *wdev;
266 
267 	ASSERT_RTNL();
268 
269 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
270 		if (wdev->netdev) {
271 			dev_close(wdev->netdev);
272 			continue;
273 		}
274 		/* otherwise, check iftype */
275 		switch (wdev->iftype) {
276 		case NL80211_IFTYPE_P2P_DEVICE:
277 			cfg80211_stop_p2p_device(rdev, wdev);
278 			break;
279 		case NL80211_IFTYPE_NAN:
280 			cfg80211_stop_nan(rdev, wdev);
281 			break;
282 		default:
283 			break;
284 		}
285 	}
286 }
287 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
288 
289 static int cfg80211_rfkill_set_block(void *data, bool blocked)
290 {
291 	struct cfg80211_registered_device *rdev = data;
292 
293 	if (!blocked)
294 		return 0;
295 
296 	rtnl_lock();
297 	cfg80211_shutdown_all_interfaces(&rdev->wiphy);
298 	rtnl_unlock();
299 
300 	return 0;
301 }
302 
303 static void cfg80211_rfkill_block_work(struct work_struct *work)
304 {
305 	struct cfg80211_registered_device *rdev;
306 
307 	rdev = container_of(work, struct cfg80211_registered_device,
308 			    rfkill_block);
309 	cfg80211_rfkill_set_block(rdev, true);
310 }
311 
312 static void cfg80211_event_work(struct work_struct *work)
313 {
314 	struct cfg80211_registered_device *rdev;
315 
316 	rdev = container_of(work, struct cfg80211_registered_device,
317 			    event_work);
318 
319 	rtnl_lock();
320 	cfg80211_process_rdev_events(rdev);
321 	rtnl_unlock();
322 }
323 
324 void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
325 {
326 	struct wireless_dev *wdev, *tmp;
327 
328 	ASSERT_RTNL();
329 
330 	list_for_each_entry_safe(wdev, tmp, &rdev->wiphy.wdev_list, list) {
331 		if (wdev->nl_owner_dead)
332 			rdev_del_virtual_intf(rdev, wdev);
333 	}
334 }
335 
336 static void cfg80211_destroy_iface_wk(struct work_struct *work)
337 {
338 	struct cfg80211_registered_device *rdev;
339 
340 	rdev = container_of(work, struct cfg80211_registered_device,
341 			    destroy_work);
342 
343 	rtnl_lock();
344 	cfg80211_destroy_ifaces(rdev);
345 	rtnl_unlock();
346 }
347 
348 static void cfg80211_sched_scan_stop_wk(struct work_struct *work)
349 {
350 	struct cfg80211_registered_device *rdev;
351 	struct cfg80211_sched_scan_request *req, *tmp;
352 
353 	rdev = container_of(work, struct cfg80211_registered_device,
354 			   sched_scan_stop_wk);
355 
356 	rtnl_lock();
357 	list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
358 		if (req->nl_owner_dead)
359 			cfg80211_stop_sched_scan_req(rdev, req, false);
360 	}
361 	rtnl_unlock();
362 }
363 
364 static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
365 {
366 	struct cfg80211_registered_device *rdev;
367 
368 	rdev = container_of(work, struct cfg80211_registered_device,
369 			    propagate_radar_detect_wk);
370 
371 	rtnl_lock();
372 
373 	regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->radar_chandef,
374 				       NL80211_DFS_UNAVAILABLE,
375 				       NL80211_RADAR_DETECTED);
376 
377 	rtnl_unlock();
378 }
379 
380 static void cfg80211_propagate_cac_done_wk(struct work_struct *work)
381 {
382 	struct cfg80211_registered_device *rdev;
383 
384 	rdev = container_of(work, struct cfg80211_registered_device,
385 			    propagate_cac_done_wk);
386 
387 	rtnl_lock();
388 
389 	regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
390 				       NL80211_DFS_AVAILABLE,
391 				       NL80211_RADAR_CAC_FINISHED);
392 
393 	rtnl_unlock();
394 }
395 
396 /* exported functions */
397 
398 struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
399 			   const char *requested_name)
400 {
401 	static atomic_t wiphy_counter = ATOMIC_INIT(0);
402 
403 	struct cfg80211_registered_device *rdev;
404 	int alloc_size;
405 
406 	WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
407 	WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
408 	WARN_ON(ops->connect && !ops->disconnect);
409 	WARN_ON(ops->join_ibss && !ops->leave_ibss);
410 	WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
411 	WARN_ON(ops->add_station && !ops->del_station);
412 	WARN_ON(ops->add_mpath && !ops->del_mpath);
413 	WARN_ON(ops->join_mesh && !ops->leave_mesh);
414 	WARN_ON(ops->start_p2p_device && !ops->stop_p2p_device);
415 	WARN_ON(ops->start_ap && !ops->stop_ap);
416 	WARN_ON(ops->join_ocb && !ops->leave_ocb);
417 	WARN_ON(ops->suspend && !ops->resume);
418 	WARN_ON(ops->sched_scan_start && !ops->sched_scan_stop);
419 	WARN_ON(ops->remain_on_channel && !ops->cancel_remain_on_channel);
420 	WARN_ON(ops->tdls_channel_switch && !ops->tdls_cancel_channel_switch);
421 	WARN_ON(ops->add_tx_ts && !ops->del_tx_ts);
422 
423 	alloc_size = sizeof(*rdev) + sizeof_priv;
424 
425 	rdev = kzalloc(alloc_size, GFP_KERNEL);
426 	if (!rdev)
427 		return NULL;
428 
429 	rdev->ops = ops;
430 
431 	rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
432 
433 	if (unlikely(rdev->wiphy_idx < 0)) {
434 		/* ugh, wrapped! */
435 		atomic_dec(&wiphy_counter);
436 		kfree(rdev);
437 		return NULL;
438 	}
439 
440 	/* atomic_inc_return makes it start at 1, make it start at 0 */
441 	rdev->wiphy_idx--;
442 
443 	/* give it a proper name */
444 	if (requested_name && requested_name[0]) {
445 		int rv;
446 
447 		rtnl_lock();
448 		rv = cfg80211_dev_check_name(rdev, requested_name);
449 
450 		if (rv < 0) {
451 			rtnl_unlock();
452 			goto use_default_name;
453 		}
454 
455 		rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
456 		rtnl_unlock();
457 		if (rv)
458 			goto use_default_name;
459 	} else {
460 		int rv;
461 
462 use_default_name:
463 		/* NOTE:  This is *probably* safe w/out holding rtnl because of
464 		 * the restrictions on phy names.  Probably this call could
465 		 * fail if some other part of the kernel (re)named a device
466 		 * phyX.  But, might should add some locking and check return
467 		 * value, and use a different name if this one exists?
468 		 */
469 		rv = dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
470 		if (rv < 0) {
471 			kfree(rdev);
472 			return NULL;
473 		}
474 	}
475 
476 	INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
477 	INIT_LIST_HEAD(&rdev->beacon_registrations);
478 	spin_lock_init(&rdev->beacon_registrations_lock);
479 	spin_lock_init(&rdev->bss_lock);
480 	INIT_LIST_HEAD(&rdev->bss_list);
481 	INIT_LIST_HEAD(&rdev->sched_scan_req_list);
482 	INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
483 	INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
484 			  cfg80211_dfs_channels_update_work);
485 #ifdef CONFIG_CFG80211_WEXT
486 	rdev->wiphy.wext = &cfg80211_wext_handler;
487 #endif
488 
489 	device_initialize(&rdev->wiphy.dev);
490 	rdev->wiphy.dev.class = &ieee80211_class;
491 	rdev->wiphy.dev.platform_data = rdev;
492 	device_enable_async_suspend(&rdev->wiphy.dev);
493 
494 	INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
495 	INIT_WORK(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
496 	INIT_WORK(&rdev->sched_scan_res_wk, cfg80211_sched_scan_results_wk);
497 	INIT_WORK(&rdev->propagate_radar_detect_wk,
498 		  cfg80211_propagate_radar_detect_wk);
499 	INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
500 	INIT_WORK(&rdev->mgmt_registrations_update_wk,
501 		  cfg80211_mgmt_registrations_update_wk);
502 
503 #ifdef CONFIG_CFG80211_DEFAULT_PS
504 	rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
505 #endif
506 
507 	wiphy_net_set(&rdev->wiphy, &init_net);
508 
509 	rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
510 	rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
511 				   &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
512 				   &rdev->rfkill_ops, rdev);
513 
514 	if (!rdev->rfkill) {
515 		wiphy_free(&rdev->wiphy);
516 		return NULL;
517 	}
518 
519 	INIT_WORK(&rdev->rfkill_block, cfg80211_rfkill_block_work);
520 	INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
521 	INIT_WORK(&rdev->event_work, cfg80211_event_work);
522 
523 	init_waitqueue_head(&rdev->dev_wait);
524 
525 	/*
526 	 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
527 	 * Fragmentation and RTS threshold are disabled by default with the
528 	 * special -1 value.
529 	 */
530 	rdev->wiphy.retry_short = 7;
531 	rdev->wiphy.retry_long = 4;
532 	rdev->wiphy.frag_threshold = (u32) -1;
533 	rdev->wiphy.rts_threshold = (u32) -1;
534 	rdev->wiphy.coverage_class = 0;
535 
536 	rdev->wiphy.max_num_csa_counters = 1;
537 
538 	rdev->wiphy.max_sched_scan_plans = 1;
539 	rdev->wiphy.max_sched_scan_plan_interval = U32_MAX;
540 
541 	return &rdev->wiphy;
542 }
543 EXPORT_SYMBOL(wiphy_new_nm);
544 
545 static int wiphy_verify_combinations(struct wiphy *wiphy)
546 {
547 	const struct ieee80211_iface_combination *c;
548 	int i, j;
549 
550 	for (i = 0; i < wiphy->n_iface_combinations; i++) {
551 		u32 cnt = 0;
552 		u16 all_iftypes = 0;
553 
554 		c = &wiphy->iface_combinations[i];
555 
556 		/*
557 		 * Combinations with just one interface aren't real,
558 		 * however we make an exception for DFS.
559 		 */
560 		if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
561 			return -EINVAL;
562 
563 		/* Need at least one channel */
564 		if (WARN_ON(!c->num_different_channels))
565 			return -EINVAL;
566 
567 		/*
568 		 * Put a sane limit on maximum number of different
569 		 * channels to simplify channel accounting code.
570 		 */
571 		if (WARN_ON(c->num_different_channels >
572 				CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
573 			return -EINVAL;
574 
575 		/* DFS only works on one channel. */
576 		if (WARN_ON(c->radar_detect_widths &&
577 			    (c->num_different_channels > 1)))
578 			return -EINVAL;
579 
580 		if (WARN_ON(!c->n_limits))
581 			return -EINVAL;
582 
583 		for (j = 0; j < c->n_limits; j++) {
584 			u16 types = c->limits[j].types;
585 
586 			/* interface types shouldn't overlap */
587 			if (WARN_ON(types & all_iftypes))
588 				return -EINVAL;
589 			all_iftypes |= types;
590 
591 			if (WARN_ON(!c->limits[j].max))
592 				return -EINVAL;
593 
594 			/* Shouldn't list software iftypes in combinations! */
595 			if (WARN_ON(wiphy->software_iftypes & types))
596 				return -EINVAL;
597 
598 			/* Only a single P2P_DEVICE can be allowed */
599 			if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
600 				    c->limits[j].max > 1))
601 				return -EINVAL;
602 
603 			/* Only a single NAN can be allowed */
604 			if (WARN_ON(types & BIT(NL80211_IFTYPE_NAN) &&
605 				    c->limits[j].max > 1))
606 				return -EINVAL;
607 
608 			/*
609 			 * This isn't well-defined right now. If you have an
610 			 * IBSS interface, then its beacon interval may change
611 			 * by joining other networks, and nothing prevents it
612 			 * from doing that.
613 			 * So technically we probably shouldn't even allow AP
614 			 * and IBSS in the same interface, but it seems that
615 			 * some drivers support that, possibly only with fixed
616 			 * beacon intervals for IBSS.
617 			 */
618 			if (WARN_ON(types & BIT(NL80211_IFTYPE_ADHOC) &&
619 				    c->beacon_int_min_gcd)) {
620 				return -EINVAL;
621 			}
622 
623 			cnt += c->limits[j].max;
624 			/*
625 			 * Don't advertise an unsupported type
626 			 * in a combination.
627 			 */
628 			if (WARN_ON((wiphy->interface_modes & types) != types))
629 				return -EINVAL;
630 		}
631 
632 #ifndef CONFIG_WIRELESS_WDS
633 		if (WARN_ON(all_iftypes & BIT(NL80211_IFTYPE_WDS)))
634 			return -EINVAL;
635 #endif
636 
637 		/* You can't even choose that many! */
638 		if (WARN_ON(cnt < c->max_interfaces))
639 			return -EINVAL;
640 	}
641 
642 	return 0;
643 }
644 
645 int wiphy_register(struct wiphy *wiphy)
646 {
647 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
648 	int res;
649 	enum nl80211_band band;
650 	struct ieee80211_supported_band *sband;
651 	bool have_band = false;
652 	int i;
653 	u16 ifmodes = wiphy->interface_modes;
654 
655 #ifdef CONFIG_PM
656 	if (WARN_ON(wiphy->wowlan &&
657 		    (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
658 		    !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
659 		return -EINVAL;
660 	if (WARN_ON(wiphy->wowlan &&
661 		    !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
662 		    !wiphy->wowlan->tcp))
663 		return -EINVAL;
664 #endif
665 	if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
666 		    (!rdev->ops->tdls_channel_switch ||
667 		     !rdev->ops->tdls_cancel_channel_switch)))
668 		return -EINVAL;
669 
670 	if (WARN_ON((wiphy->interface_modes & BIT(NL80211_IFTYPE_NAN)) &&
671 		    (!rdev->ops->start_nan || !rdev->ops->stop_nan ||
672 		     !rdev->ops->add_nan_func || !rdev->ops->del_nan_func ||
673 		     !(wiphy->nan_supported_bands & BIT(NL80211_BAND_2GHZ)))))
674 		return -EINVAL;
675 
676 #ifndef CONFIG_WIRELESS_WDS
677 	if (WARN_ON(wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)))
678 		return -EINVAL;
679 #endif
680 
681 	if (WARN_ON(wiphy->pmsr_capa && !wiphy->pmsr_capa->ftm.supported))
682 		return -EINVAL;
683 
684 	if (wiphy->pmsr_capa && wiphy->pmsr_capa->ftm.supported) {
685 		if (WARN_ON(!wiphy->pmsr_capa->ftm.asap &&
686 			    !wiphy->pmsr_capa->ftm.non_asap))
687 			return -EINVAL;
688 		if (WARN_ON(!wiphy->pmsr_capa->ftm.preambles ||
689 			    !wiphy->pmsr_capa->ftm.bandwidths))
690 			return -EINVAL;
691 		if (WARN_ON(wiphy->pmsr_capa->ftm.preambles &
692 				~(BIT(NL80211_PREAMBLE_LEGACY) |
693 				  BIT(NL80211_PREAMBLE_HT) |
694 				  BIT(NL80211_PREAMBLE_VHT) |
695 				  BIT(NL80211_PREAMBLE_HE) |
696 				  BIT(NL80211_PREAMBLE_DMG))))
697 			return -EINVAL;
698 		if (WARN_ON((wiphy->pmsr_capa->ftm.trigger_based ||
699 			     wiphy->pmsr_capa->ftm.non_trigger_based) &&
700 			    !(wiphy->pmsr_capa->ftm.preambles &
701 			      BIT(NL80211_PREAMBLE_HE))))
702 			return -EINVAL;
703 		if (WARN_ON(wiphy->pmsr_capa->ftm.bandwidths &
704 				~(BIT(NL80211_CHAN_WIDTH_20_NOHT) |
705 				  BIT(NL80211_CHAN_WIDTH_20) |
706 				  BIT(NL80211_CHAN_WIDTH_40) |
707 				  BIT(NL80211_CHAN_WIDTH_80) |
708 				  BIT(NL80211_CHAN_WIDTH_80P80) |
709 				  BIT(NL80211_CHAN_WIDTH_160) |
710 				  BIT(NL80211_CHAN_WIDTH_5) |
711 				  BIT(NL80211_CHAN_WIDTH_10))))
712 			return -EINVAL;
713 	}
714 
715 	/*
716 	 * if a wiphy has unsupported modes for regulatory channel enforcement,
717 	 * opt-out of enforcement checking
718 	 */
719 	if (wiphy->interface_modes & ~(BIT(NL80211_IFTYPE_STATION) |
720 				       BIT(NL80211_IFTYPE_P2P_CLIENT) |
721 				       BIT(NL80211_IFTYPE_AP) |
722 				       BIT(NL80211_IFTYPE_P2P_GO) |
723 				       BIT(NL80211_IFTYPE_ADHOC) |
724 				       BIT(NL80211_IFTYPE_P2P_DEVICE) |
725 				       BIT(NL80211_IFTYPE_NAN) |
726 				       BIT(NL80211_IFTYPE_AP_VLAN) |
727 				       BIT(NL80211_IFTYPE_MONITOR)))
728 		wiphy->regulatory_flags |= REGULATORY_IGNORE_STALE_KICKOFF;
729 
730 	if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
731 		    (wiphy->regulatory_flags &
732 					(REGULATORY_CUSTOM_REG |
733 					 REGULATORY_STRICT_REG |
734 					 REGULATORY_COUNTRY_IE_FOLLOW_POWER |
735 					 REGULATORY_COUNTRY_IE_IGNORE))))
736 		return -EINVAL;
737 
738 	if (WARN_ON(wiphy->coalesce &&
739 		    (!wiphy->coalesce->n_rules ||
740 		     !wiphy->coalesce->n_patterns) &&
741 		    (!wiphy->coalesce->pattern_min_len ||
742 		     wiphy->coalesce->pattern_min_len >
743 			wiphy->coalesce->pattern_max_len)))
744 		return -EINVAL;
745 
746 	if (WARN_ON(wiphy->ap_sme_capa &&
747 		    !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
748 		return -EINVAL;
749 
750 	if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
751 		return -EINVAL;
752 
753 	if (WARN_ON(wiphy->addresses &&
754 		    !is_zero_ether_addr(wiphy->perm_addr) &&
755 		    memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
756 			   ETH_ALEN)))
757 		return -EINVAL;
758 
759 	if (WARN_ON(wiphy->max_acl_mac_addrs &&
760 		    (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
761 		     !rdev->ops->set_mac_acl)))
762 		return -EINVAL;
763 
764 	/* assure only valid behaviours are flagged by driver
765 	 * hence subtract 2 as bit 0 is invalid.
766 	 */
767 	if (WARN_ON(wiphy->bss_select_support &&
768 		    (wiphy->bss_select_support & ~(BIT(__NL80211_BSS_SELECT_ATTR_AFTER_LAST) - 2))))
769 		return -EINVAL;
770 
771 	if (WARN_ON(wiphy_ext_feature_isset(&rdev->wiphy,
772 					    NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X) &&
773 		    (!rdev->ops->set_pmk || !rdev->ops->del_pmk)))
774 		return -EINVAL;
775 
776 	if (WARN_ON(!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
777 		    rdev->ops->update_connect_params))
778 		return -EINVAL;
779 
780 	if (wiphy->addresses)
781 		memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
782 
783 	/* sanity check ifmodes */
784 	WARN_ON(!ifmodes);
785 	ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
786 	if (WARN_ON(ifmodes != wiphy->interface_modes))
787 		wiphy->interface_modes = ifmodes;
788 
789 	res = wiphy_verify_combinations(wiphy);
790 	if (res)
791 		return res;
792 
793 	/* sanity check supported bands/channels */
794 	for (band = 0; band < NUM_NL80211_BANDS; band++) {
795 		u16 types = 0;
796 		bool have_he = false;
797 
798 		sband = wiphy->bands[band];
799 		if (!sband)
800 			continue;
801 
802 		sband->band = band;
803 		if (WARN_ON(!sband->n_channels))
804 			return -EINVAL;
805 		/*
806 		 * on 60GHz or sub-1Ghz band, there are no legacy rates, so
807 		 * n_bitrates is 0
808 		 */
809 		if (WARN_ON((band != NL80211_BAND_60GHZ &&
810 			     band != NL80211_BAND_S1GHZ) &&
811 			    !sband->n_bitrates))
812 			return -EINVAL;
813 
814 		if (WARN_ON(band == NL80211_BAND_6GHZ &&
815 			    (sband->ht_cap.ht_supported ||
816 			     sband->vht_cap.vht_supported)))
817 			return -EINVAL;
818 
819 		/*
820 		 * Since cfg80211_disable_40mhz_24ghz is global, we can
821 		 * modify the sband's ht data even if the driver uses a
822 		 * global structure for that.
823 		 */
824 		if (cfg80211_disable_40mhz_24ghz &&
825 		    band == NL80211_BAND_2GHZ &&
826 		    sband->ht_cap.ht_supported) {
827 			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
828 			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
829 		}
830 
831 		/*
832 		 * Since we use a u32 for rate bitmaps in
833 		 * ieee80211_get_response_rate, we cannot
834 		 * have more than 32 legacy rates.
835 		 */
836 		if (WARN_ON(sband->n_bitrates > 32))
837 			return -EINVAL;
838 
839 		for (i = 0; i < sband->n_channels; i++) {
840 			sband->channels[i].orig_flags =
841 				sband->channels[i].flags;
842 			sband->channels[i].orig_mag = INT_MAX;
843 			sband->channels[i].orig_mpwr =
844 				sband->channels[i].max_power;
845 			sband->channels[i].band = band;
846 
847 			if (WARN_ON(sband->channels[i].freq_offset >= 1000))
848 				return -EINVAL;
849 		}
850 
851 		for (i = 0; i < sband->n_iftype_data; i++) {
852 			const struct ieee80211_sband_iftype_data *iftd;
853 
854 			iftd = &sband->iftype_data[i];
855 
856 			if (WARN_ON(!iftd->types_mask))
857 				return -EINVAL;
858 			if (WARN_ON(types & iftd->types_mask))
859 				return -EINVAL;
860 
861 			/* at least one piece of information must be present */
862 			if (WARN_ON(!iftd->he_cap.has_he))
863 				return -EINVAL;
864 
865 			types |= iftd->types_mask;
866 
867 			if (i == 0)
868 				have_he = iftd->he_cap.has_he;
869 			else
870 				have_he = have_he &&
871 					  iftd->he_cap.has_he;
872 		}
873 
874 		if (WARN_ON(!have_he && band == NL80211_BAND_6GHZ))
875 			return -EINVAL;
876 
877 		have_band = true;
878 	}
879 
880 	if (!have_band) {
881 		WARN_ON(1);
882 		return -EINVAL;
883 	}
884 
885 	for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
886 		/*
887 		 * Validate we have a policy (can be explicitly set to
888 		 * VENDOR_CMD_RAW_DATA which is non-NULL) and also that
889 		 * we have at least one of doit/dumpit.
890 		 */
891 		if (WARN_ON(!rdev->wiphy.vendor_commands[i].policy))
892 			return -EINVAL;
893 		if (WARN_ON(!rdev->wiphy.vendor_commands[i].doit &&
894 			    !rdev->wiphy.vendor_commands[i].dumpit))
895 			return -EINVAL;
896 	}
897 
898 #ifdef CONFIG_PM
899 	if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
900 		    (!rdev->wiphy.wowlan->pattern_min_len ||
901 		     rdev->wiphy.wowlan->pattern_min_len >
902 				rdev->wiphy.wowlan->pattern_max_len)))
903 		return -EINVAL;
904 #endif
905 
906 	/* check and set up bitrates */
907 	ieee80211_set_bitrate_flags(wiphy);
908 
909 	rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
910 
911 	rtnl_lock();
912 	res = device_add(&rdev->wiphy.dev);
913 	if (res) {
914 		rtnl_unlock();
915 		return res;
916 	}
917 
918 	/* set up regulatory info */
919 	wiphy_regulatory_register(wiphy);
920 
921 	list_add_rcu(&rdev->list, &cfg80211_rdev_list);
922 	cfg80211_rdev_list_generation++;
923 
924 	/* add to debugfs */
925 	rdev->wiphy.debugfsdir = debugfs_create_dir(wiphy_name(&rdev->wiphy),
926 						    ieee80211_debugfs_dir);
927 
928 	cfg80211_debugfs_rdev_add(rdev);
929 	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
930 
931 	if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
932 		struct regulatory_request request;
933 
934 		request.wiphy_idx = get_wiphy_idx(wiphy);
935 		request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
936 		request.alpha2[0] = '9';
937 		request.alpha2[1] = '9';
938 
939 		nl80211_send_reg_change_event(&request);
940 	}
941 
942 	/* Check that nobody globally advertises any capabilities they do not
943 	 * advertise on all possible interface types.
944 	 */
945 	if (wiphy->extended_capabilities_len &&
946 	    wiphy->num_iftype_ext_capab &&
947 	    wiphy->iftype_ext_capab) {
948 		u8 supported_on_all, j;
949 		const struct wiphy_iftype_ext_capab *capab;
950 
951 		capab = wiphy->iftype_ext_capab;
952 		for (j = 0; j < wiphy->extended_capabilities_len; j++) {
953 			if (capab[0].extended_capabilities_len > j)
954 				supported_on_all =
955 					capab[0].extended_capabilities[j];
956 			else
957 				supported_on_all = 0x00;
958 			for (i = 1; i < wiphy->num_iftype_ext_capab; i++) {
959 				if (j >= capab[i].extended_capabilities_len) {
960 					supported_on_all = 0x00;
961 					break;
962 				}
963 				supported_on_all &=
964 					capab[i].extended_capabilities[j];
965 			}
966 			if (WARN_ON(wiphy->extended_capabilities[j] &
967 				    ~supported_on_all))
968 				break;
969 		}
970 	}
971 
972 	rdev->wiphy.registered = true;
973 	rtnl_unlock();
974 
975 	res = rfkill_register(rdev->rfkill);
976 	if (res) {
977 		rfkill_destroy(rdev->rfkill);
978 		rdev->rfkill = NULL;
979 		wiphy_unregister(&rdev->wiphy);
980 		return res;
981 	}
982 
983 	return 0;
984 }
985 EXPORT_SYMBOL(wiphy_register);
986 
987 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
988 {
989 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
990 
991 	if (!rdev->ops->rfkill_poll)
992 		return;
993 	rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
994 	rfkill_resume_polling(rdev->rfkill);
995 }
996 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
997 
998 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
999 {
1000 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1001 
1002 	rfkill_pause_polling(rdev->rfkill);
1003 }
1004 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
1005 
1006 void wiphy_unregister(struct wiphy *wiphy)
1007 {
1008 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1009 
1010 	wait_event(rdev->dev_wait, ({
1011 		int __count;
1012 		rtnl_lock();
1013 		__count = rdev->opencount;
1014 		rtnl_unlock();
1015 		__count == 0; }));
1016 
1017 	if (rdev->rfkill)
1018 		rfkill_unregister(rdev->rfkill);
1019 
1020 	rtnl_lock();
1021 	nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
1022 	rdev->wiphy.registered = false;
1023 
1024 	WARN_ON(!list_empty(&rdev->wiphy.wdev_list));
1025 
1026 	/*
1027 	 * First remove the hardware from everywhere, this makes
1028 	 * it impossible to find from userspace.
1029 	 */
1030 	debugfs_remove_recursive(rdev->wiphy.debugfsdir);
1031 	list_del_rcu(&rdev->list);
1032 	synchronize_rcu();
1033 
1034 	/*
1035 	 * If this device got a regulatory hint tell core its
1036 	 * free to listen now to a new shiny device regulatory hint
1037 	 */
1038 	wiphy_regulatory_deregister(wiphy);
1039 
1040 	cfg80211_rdev_list_generation++;
1041 	device_del(&rdev->wiphy.dev);
1042 
1043 	rtnl_unlock();
1044 
1045 	flush_work(&rdev->scan_done_wk);
1046 	cancel_work_sync(&rdev->conn_work);
1047 	flush_work(&rdev->event_work);
1048 	cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
1049 	flush_work(&rdev->destroy_work);
1050 	flush_work(&rdev->sched_scan_stop_wk);
1051 	flush_work(&rdev->propagate_radar_detect_wk);
1052 	flush_work(&rdev->propagate_cac_done_wk);
1053 	flush_work(&rdev->mgmt_registrations_update_wk);
1054 
1055 #ifdef CONFIG_PM
1056 	if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
1057 		rdev_set_wakeup(rdev, false);
1058 #endif
1059 	cfg80211_rdev_free_wowlan(rdev);
1060 	cfg80211_rdev_free_coalesce(rdev);
1061 }
1062 EXPORT_SYMBOL(wiphy_unregister);
1063 
1064 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
1065 {
1066 	struct cfg80211_internal_bss *scan, *tmp;
1067 	struct cfg80211_beacon_registration *reg, *treg;
1068 	rfkill_destroy(rdev->rfkill);
1069 	list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
1070 		list_del(&reg->list);
1071 		kfree(reg);
1072 	}
1073 	list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
1074 		cfg80211_put_bss(&rdev->wiphy, &scan->pub);
1075 	kfree(rdev);
1076 }
1077 
1078 void wiphy_free(struct wiphy *wiphy)
1079 {
1080 	put_device(&wiphy->dev);
1081 }
1082 EXPORT_SYMBOL(wiphy_free);
1083 
1084 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
1085 {
1086 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1087 
1088 	if (rfkill_set_hw_state(rdev->rfkill, blocked))
1089 		schedule_work(&rdev->rfkill_block);
1090 }
1091 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
1092 
1093 void cfg80211_cqm_config_free(struct wireless_dev *wdev)
1094 {
1095 	kfree(wdev->cqm_config);
1096 	wdev->cqm_config = NULL;
1097 }
1098 
1099 static void __cfg80211_unregister_wdev(struct wireless_dev *wdev, bool sync)
1100 {
1101 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1102 
1103 	ASSERT_RTNL();
1104 
1105 	flush_work(&wdev->pmsr_free_wk);
1106 
1107 	nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
1108 
1109 	list_del_rcu(&wdev->list);
1110 	if (sync)
1111 		synchronize_rcu();
1112 	rdev->devlist_generation++;
1113 
1114 	cfg80211_mlme_purge_registrations(wdev);
1115 
1116 	switch (wdev->iftype) {
1117 	case NL80211_IFTYPE_P2P_DEVICE:
1118 		cfg80211_stop_p2p_device(rdev, wdev);
1119 		break;
1120 	case NL80211_IFTYPE_NAN:
1121 		cfg80211_stop_nan(rdev, wdev);
1122 		break;
1123 	default:
1124 		break;
1125 	}
1126 
1127 #ifdef CONFIG_CFG80211_WEXT
1128 	kfree_sensitive(wdev->wext.keys);
1129 	wdev->wext.keys = NULL;
1130 #endif
1131 	/* only initialized if we have a netdev */
1132 	if (wdev->netdev)
1133 		flush_work(&wdev->disconnect_wk);
1134 
1135 	cfg80211_cqm_config_free(wdev);
1136 }
1137 
1138 void cfg80211_unregister_wdev(struct wireless_dev *wdev)
1139 {
1140 	if (WARN_ON(wdev->netdev))
1141 		return;
1142 
1143 	__cfg80211_unregister_wdev(wdev, true);
1144 }
1145 EXPORT_SYMBOL(cfg80211_unregister_wdev);
1146 
1147 static const struct device_type wiphy_type = {
1148 	.name	= "wlan",
1149 };
1150 
1151 void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
1152 			       enum nl80211_iftype iftype, int num)
1153 {
1154 	ASSERT_RTNL();
1155 
1156 	rdev->num_running_ifaces += num;
1157 	if (iftype == NL80211_IFTYPE_MONITOR)
1158 		rdev->num_running_monitor_ifaces += num;
1159 }
1160 
1161 void __cfg80211_leave(struct cfg80211_registered_device *rdev,
1162 		      struct wireless_dev *wdev)
1163 {
1164 	struct net_device *dev = wdev->netdev;
1165 	struct cfg80211_sched_scan_request *pos, *tmp;
1166 
1167 	ASSERT_RTNL();
1168 	ASSERT_WDEV_LOCK(wdev);
1169 
1170 	cfg80211_pmsr_wdev_down(wdev);
1171 
1172 	switch (wdev->iftype) {
1173 	case NL80211_IFTYPE_ADHOC:
1174 		__cfg80211_leave_ibss(rdev, dev, true);
1175 		break;
1176 	case NL80211_IFTYPE_P2P_CLIENT:
1177 	case NL80211_IFTYPE_STATION:
1178 		list_for_each_entry_safe(pos, tmp, &rdev->sched_scan_req_list,
1179 					 list) {
1180 			if (dev == pos->dev)
1181 				cfg80211_stop_sched_scan_req(rdev, pos, false);
1182 		}
1183 
1184 #ifdef CONFIG_CFG80211_WEXT
1185 		kfree(wdev->wext.ie);
1186 		wdev->wext.ie = NULL;
1187 		wdev->wext.ie_len = 0;
1188 		wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1189 #endif
1190 		cfg80211_disconnect(rdev, dev,
1191 				    WLAN_REASON_DEAUTH_LEAVING, true);
1192 		break;
1193 	case NL80211_IFTYPE_MESH_POINT:
1194 		__cfg80211_leave_mesh(rdev, dev);
1195 		break;
1196 	case NL80211_IFTYPE_AP:
1197 	case NL80211_IFTYPE_P2P_GO:
1198 		__cfg80211_stop_ap(rdev, dev, true);
1199 		break;
1200 	case NL80211_IFTYPE_OCB:
1201 		__cfg80211_leave_ocb(rdev, dev);
1202 		break;
1203 	case NL80211_IFTYPE_WDS:
1204 		/* must be handled by mac80211/driver, has no APIs */
1205 		break;
1206 	case NL80211_IFTYPE_P2P_DEVICE:
1207 	case NL80211_IFTYPE_NAN:
1208 		/* cannot happen, has no netdev */
1209 		break;
1210 	case NL80211_IFTYPE_AP_VLAN:
1211 	case NL80211_IFTYPE_MONITOR:
1212 		/* nothing to do */
1213 		break;
1214 	case NL80211_IFTYPE_UNSPECIFIED:
1215 	case NUM_NL80211_IFTYPES:
1216 		/* invalid */
1217 		break;
1218 	}
1219 }
1220 
1221 void cfg80211_leave(struct cfg80211_registered_device *rdev,
1222 		    struct wireless_dev *wdev)
1223 {
1224 	wdev_lock(wdev);
1225 	__cfg80211_leave(rdev, wdev);
1226 	wdev_unlock(wdev);
1227 }
1228 
1229 void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
1230 			 gfp_t gfp)
1231 {
1232 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1233 	struct cfg80211_event *ev;
1234 	unsigned long flags;
1235 
1236 	trace_cfg80211_stop_iface(wiphy, wdev);
1237 
1238 	ev = kzalloc(sizeof(*ev), gfp);
1239 	if (!ev)
1240 		return;
1241 
1242 	ev->type = EVENT_STOPPED;
1243 
1244 	spin_lock_irqsave(&wdev->event_lock, flags);
1245 	list_add_tail(&ev->list, &wdev->event_list);
1246 	spin_unlock_irqrestore(&wdev->event_lock, flags);
1247 	queue_work(cfg80211_wq, &rdev->event_work);
1248 }
1249 EXPORT_SYMBOL(cfg80211_stop_iface);
1250 
1251 void cfg80211_init_wdev(struct cfg80211_registered_device *rdev,
1252 			struct wireless_dev *wdev)
1253 {
1254 	mutex_init(&wdev->mtx);
1255 	INIT_LIST_HEAD(&wdev->event_list);
1256 	spin_lock_init(&wdev->event_lock);
1257 	INIT_LIST_HEAD(&wdev->mgmt_registrations);
1258 	spin_lock_init(&wdev->mgmt_registrations_lock);
1259 	INIT_LIST_HEAD(&wdev->pmsr_list);
1260 	spin_lock_init(&wdev->pmsr_lock);
1261 	INIT_WORK(&wdev->pmsr_free_wk, cfg80211_pmsr_free_wk);
1262 
1263 	/*
1264 	 * We get here also when the interface changes network namespaces,
1265 	 * as it's registered into the new one, but we don't want it to
1266 	 * change ID in that case. Checking if the ID is already assigned
1267 	 * works, because 0 isn't considered a valid ID and the memory is
1268 	 * 0-initialized.
1269 	 */
1270 	if (!wdev->identifier)
1271 		wdev->identifier = ++rdev->wdev_id;
1272 	list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
1273 	rdev->devlist_generation++;
1274 
1275 	nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
1276 }
1277 
1278 static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
1279 					 unsigned long state, void *ptr)
1280 {
1281 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1282 	struct wireless_dev *wdev = dev->ieee80211_ptr;
1283 	struct cfg80211_registered_device *rdev;
1284 	struct cfg80211_sched_scan_request *pos, *tmp;
1285 
1286 	if (!wdev)
1287 		return NOTIFY_DONE;
1288 
1289 	rdev = wiphy_to_rdev(wdev->wiphy);
1290 
1291 	WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
1292 
1293 	switch (state) {
1294 	case NETDEV_POST_INIT:
1295 		SET_NETDEV_DEVTYPE(dev, &wiphy_type);
1296 		break;
1297 	case NETDEV_REGISTER:
1298 		/*
1299 		 * NB: cannot take rdev->mtx here because this may be
1300 		 * called within code protected by it when interfaces
1301 		 * are added with nl80211.
1302 		 */
1303 		/* can only change netns with wiphy */
1304 		dev->features |= NETIF_F_NETNS_LOCAL;
1305 
1306 		if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
1307 				      "phy80211")) {
1308 			pr_err("failed to add phy80211 symlink to netdev!\n");
1309 		}
1310 		wdev->netdev = dev;
1311 #ifdef CONFIG_CFG80211_WEXT
1312 		wdev->wext.default_key = -1;
1313 		wdev->wext.default_mgmt_key = -1;
1314 		wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1315 #endif
1316 
1317 		if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
1318 			wdev->ps = true;
1319 		else
1320 			wdev->ps = false;
1321 		/* allow mac80211 to determine the timeout */
1322 		wdev->ps_timeout = -1;
1323 
1324 		if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1325 		     wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
1326 		     wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
1327 			dev->priv_flags |= IFF_DONT_BRIDGE;
1328 
1329 		INIT_WORK(&wdev->disconnect_wk, cfg80211_autodisconnect_wk);
1330 
1331 		cfg80211_init_wdev(rdev, wdev);
1332 		break;
1333 	case NETDEV_GOING_DOWN:
1334 		cfg80211_leave(rdev, wdev);
1335 		break;
1336 	case NETDEV_DOWN:
1337 		cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1338 		if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1339 			if (WARN_ON(!rdev->scan_req->notified))
1340 				rdev->scan_req->info.aborted = true;
1341 			___cfg80211_scan_done(rdev, false);
1342 		}
1343 
1344 		list_for_each_entry_safe(pos, tmp,
1345 					 &rdev->sched_scan_req_list, list) {
1346 			if (WARN_ON(pos->dev == wdev->netdev))
1347 				cfg80211_stop_sched_scan_req(rdev, pos, false);
1348 		}
1349 
1350 		rdev->opencount--;
1351 		wake_up(&rdev->dev_wait);
1352 		break;
1353 	case NETDEV_UP:
1354 		cfg80211_update_iface_num(rdev, wdev->iftype, 1);
1355 		wdev_lock(wdev);
1356 		switch (wdev->iftype) {
1357 #ifdef CONFIG_CFG80211_WEXT
1358 		case NL80211_IFTYPE_ADHOC:
1359 			cfg80211_ibss_wext_join(rdev, wdev);
1360 			break;
1361 		case NL80211_IFTYPE_STATION:
1362 			cfg80211_mgd_wext_connect(rdev, wdev);
1363 			break;
1364 #endif
1365 #ifdef CONFIG_MAC80211_MESH
1366 		case NL80211_IFTYPE_MESH_POINT:
1367 			{
1368 				/* backward compat code... */
1369 				struct mesh_setup setup;
1370 				memcpy(&setup, &default_mesh_setup,
1371 						sizeof(setup));
1372 				 /* back compat only needed for mesh_id */
1373 				setup.mesh_id = wdev->ssid;
1374 				setup.mesh_id_len = wdev->mesh_id_up_len;
1375 				if (wdev->mesh_id_up_len)
1376 					__cfg80211_join_mesh(rdev, dev,
1377 							&setup,
1378 							&default_mesh_config);
1379 				break;
1380 			}
1381 #endif
1382 		default:
1383 			break;
1384 		}
1385 		wdev_unlock(wdev);
1386 		rdev->opencount++;
1387 
1388 		/*
1389 		 * Configure power management to the driver here so that its
1390 		 * correctly set also after interface type changes etc.
1391 		 */
1392 		if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1393 		     wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
1394 		    rdev->ops->set_power_mgmt &&
1395 		    rdev_set_power_mgmt(rdev, dev, wdev->ps,
1396 					wdev->ps_timeout)) {
1397 			/* assume this means it's off */
1398 			wdev->ps = false;
1399 		}
1400 		break;
1401 	case NETDEV_UNREGISTER:
1402 		/*
1403 		 * It is possible to get NETDEV_UNREGISTER
1404 		 * multiple times. To detect that, check
1405 		 * that the interface is still on the list
1406 		 * of registered interfaces, and only then
1407 		 * remove and clean it up.
1408 		 */
1409 		if (!list_empty(&wdev->list)) {
1410 			__cfg80211_unregister_wdev(wdev, false);
1411 			sysfs_remove_link(&dev->dev.kobj, "phy80211");
1412 		}
1413 		/*
1414 		 * synchronise (so that we won't find this netdev
1415 		 * from other code any more) and then clear the list
1416 		 * head so that the above code can safely check for
1417 		 * !list_empty() to avoid double-cleanup.
1418 		 */
1419 		synchronize_rcu();
1420 		INIT_LIST_HEAD(&wdev->list);
1421 		/*
1422 		 * Ensure that all events have been processed and
1423 		 * freed.
1424 		 */
1425 		cfg80211_process_wdev_events(wdev);
1426 
1427 		if (WARN_ON(wdev->current_bss)) {
1428 			cfg80211_unhold_bss(wdev->current_bss);
1429 			cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
1430 			wdev->current_bss = NULL;
1431 		}
1432 		break;
1433 	case NETDEV_PRE_UP:
1434 		if (!cfg80211_iftype_allowed(wdev->wiphy, wdev->iftype,
1435 					     wdev->use_4addr, 0))
1436 			return notifier_from_errno(-EOPNOTSUPP);
1437 
1438 		if (rfkill_blocked(rdev->rfkill))
1439 			return notifier_from_errno(-ERFKILL);
1440 		break;
1441 	default:
1442 		return NOTIFY_DONE;
1443 	}
1444 
1445 	wireless_nlevent_flush();
1446 
1447 	return NOTIFY_OK;
1448 }
1449 
1450 static struct notifier_block cfg80211_netdev_notifier = {
1451 	.notifier_call = cfg80211_netdev_notifier_call,
1452 };
1453 
1454 static void __net_exit cfg80211_pernet_exit(struct net *net)
1455 {
1456 	struct cfg80211_registered_device *rdev;
1457 
1458 	rtnl_lock();
1459 	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1460 		if (net_eq(wiphy_net(&rdev->wiphy), net))
1461 			WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1462 	}
1463 	rtnl_unlock();
1464 }
1465 
1466 static struct pernet_operations cfg80211_pernet_ops = {
1467 	.exit = cfg80211_pernet_exit,
1468 };
1469 
1470 static int __init cfg80211_init(void)
1471 {
1472 	int err;
1473 
1474 	err = register_pernet_device(&cfg80211_pernet_ops);
1475 	if (err)
1476 		goto out_fail_pernet;
1477 
1478 	err = wiphy_sysfs_init();
1479 	if (err)
1480 		goto out_fail_sysfs;
1481 
1482 	err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1483 	if (err)
1484 		goto out_fail_notifier;
1485 
1486 	err = nl80211_init();
1487 	if (err)
1488 		goto out_fail_nl80211;
1489 
1490 	ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1491 
1492 	err = regulatory_init();
1493 	if (err)
1494 		goto out_fail_reg;
1495 
1496 	cfg80211_wq = alloc_ordered_workqueue("cfg80211", WQ_MEM_RECLAIM);
1497 	if (!cfg80211_wq) {
1498 		err = -ENOMEM;
1499 		goto out_fail_wq;
1500 	}
1501 
1502 	return 0;
1503 
1504 out_fail_wq:
1505 	regulatory_exit();
1506 out_fail_reg:
1507 	debugfs_remove(ieee80211_debugfs_dir);
1508 	nl80211_exit();
1509 out_fail_nl80211:
1510 	unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1511 out_fail_notifier:
1512 	wiphy_sysfs_exit();
1513 out_fail_sysfs:
1514 	unregister_pernet_device(&cfg80211_pernet_ops);
1515 out_fail_pernet:
1516 	return err;
1517 }
1518 fs_initcall(cfg80211_init);
1519 
1520 static void __exit cfg80211_exit(void)
1521 {
1522 	debugfs_remove(ieee80211_debugfs_dir);
1523 	nl80211_exit();
1524 	unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1525 	wiphy_sysfs_exit();
1526 	regulatory_exit();
1527 	unregister_pernet_device(&cfg80211_pernet_ops);
1528 	destroy_workqueue(cfg80211_wq);
1529 }
1530 module_exit(cfg80211_exit);
1531