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