core.c 28.9 KB
Newer Older
1 2 3
/*
 * This is the linux wireless configuration interface.
 *
4
 * Copyright 2006-2010		Johannes Berg <johannes@sipsolutions.net>
5
 * Copyright 2013-2014  Intel Mobile Communications GmbH
6 7
 */

8 9
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

10 11 12 13
#include <linux/if.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/list.h>
14
#include <linux/slab.h>
15 16 17 18
#include <linux/nl80211.h>
#include <linux/debugfs.h>
#include <linux/notifier.h>
#include <linux/device.h>
19
#include <linux/etherdevice.h>
Johannes Berg's avatar
Johannes Berg committed
20
#include <linux/rtnetlink.h>
21
#include <linux/sched.h>
22 23
#include <net/genetlink.h>
#include <net/cfg80211.h>
24
#include "nl80211.h"
25 26
#include "core.h"
#include "sysfs.h"
27
#include "debugfs.h"
28
#include "wext-compat.h"
29
#include "rdev-ops.h"
30 31 32 33 34 35 36

/* name for sysfs, %d is appended */
#define PHY_NAME "phy"

MODULE_AUTHOR("Johannes Berg");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("wireless configuration support");
37
MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
38

39
/* RCU-protected (and RTNL for writers) */
40
LIST_HEAD(cfg80211_rdev_list);
41
int cfg80211_rdev_list_generation;
42

43 44 45
/* for debugfs */
static struct dentry *ieee80211_debugfs_dir;

46 47 48
/* for the cleanup, scan and event works */
struct workqueue_struct *cfg80211_wq;

49 50 51 52 53
static bool cfg80211_disable_40mhz_24ghz;
module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
		 "Disable 40MHz support in the 2.4GHz band");

54
struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
55
{
56
	struct cfg80211_registered_device *result = NULL, *rdev;
57

58
	ASSERT_RTNL();
59

60 61 62
	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
		if (rdev->wiphy_idx == wiphy_idx) {
			result = rdev;
63 64 65 66 67 68 69
			break;
		}
	}

	return result;
}

70 71
int get_wiphy_idx(struct wiphy *wiphy)
{
72
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
73

74
	return rdev->wiphy_idx;
75 76 77 78
}

struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
{
79
	struct cfg80211_registered_device *rdev;
80

81
	ASSERT_RTNL();
82

83 84
	rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
	if (!rdev)
85
		return NULL;
86
	return &rdev->wiphy;
87 88
}

89 90
static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
				   const char *newname)
91
{
92
	struct cfg80211_registered_device *rdev2;
93
	int wiphy_idx, taken = -1, digits;
94

95
	ASSERT_RTNL();
96

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
	/* prohibit calling the thing phy%d when %d is not its number */
	sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
	if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
		/* count number of places needed to print wiphy_idx */
		digits = 1;
		while (wiphy_idx /= 10)
			digits++;
		/*
		 * deny the name if it is phy<idx> where <idx> is printed
		 * without leading zeroes. taken == strlen(newname) here
		 */
		if (taken == strlen(PHY_NAME) + digits)
			return -EINVAL;
	}

112 113 114 115 116 117 118 119 120 121 122 123 124 125
	/* Ensure another device does not already have this name. */
	list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
		if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
			return -EINVAL;

	return 0;
}

int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
			char *newname)
{
	int result;

	ASSERT_RTNL();
126

127
	/* Ignore nop renames */
128
	if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
129
		return 0;
130

131 132 133
	result = cfg80211_dev_check_name(rdev, newname);
	if (result < 0)
		return result;
134 135 136

	result = device_rename(&rdev->wiphy.dev, newname);
	if (result)
137
		return result;
138

139 140
	if (rdev->wiphy.debugfsdir &&
	    !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
141 142 143
			    rdev->wiphy.debugfsdir,
			    rdev->wiphy.debugfsdir->d_parent,
			    newname))
144
		pr_err("failed to rename debugfs dir to %s!\n", newname);
145

146
	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
147

148
	return 0;
149 150
}

151 152 153 154 155 156
int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
			  struct net *net)
{
	struct wireless_dev *wdev;
	int err = 0;

157
	if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
158 159
		return -EOPNOTSUPP;

160
	list_for_each_entry(wdev, &rdev->wdev_list, list) {
161 162
		if (!wdev->netdev)
			continue;
163 164 165 166 167 168 169 170 171 172 173
		wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
		err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
		if (err)
			break;
		wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
	}

	if (err) {
		/* failed -- clean up to old netns */
		net = wiphy_net(&rdev->wiphy);

174
		list_for_each_entry_continue_reverse(wdev, &rdev->wdev_list,
175
						     list) {
176 177
			if (!wdev->netdev)
				continue;
178 179 180 181 182 183
			wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
			err = dev_change_net_namespace(wdev->netdev, net,
							"wlan%d");
			WARN_ON(err);
			wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
		}
184 185

		return err;
186 187 188 189
	}

	wiphy_net_set(&rdev->wiphy, net);

190 191 192 193
	err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
	WARN_ON(err);

	return 0;
194 195
}

Johannes Berg's avatar
Johannes Berg committed
196 197
static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
{
198
	struct cfg80211_registered_device *rdev = data;
Johannes Berg's avatar
Johannes Berg committed
199

200
	rdev_rfkill_poll(rdev);
Johannes Berg's avatar
Johannes Berg committed
201 202
}

203 204 205
void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
			      struct wireless_dev *wdev)
{
206
	ASSERT_RTNL();
207 208 209 210 211 212 213 214 215 216 217 218

	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
		return;

	if (!wdev->p2p_started)
		return;

	rdev_stop_p2p_device(rdev, wdev);
	wdev->p2p_started = false;

	rdev->opencount--;

Johannes Berg's avatar
Johannes Berg committed
219 220 221
	if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
		if (WARN_ON(!rdev->scan_req->notified))
			rdev->scan_req->aborted = true;
222
		___cfg80211_scan_done(rdev, false);
Johannes Berg's avatar
Johannes Berg committed
223
	}
224 225
}

226
void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
Johannes Berg's avatar
Johannes Berg committed
227
{
228
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
229 230
	struct wireless_dev *wdev;

231
	ASSERT_RTNL();
232

233 234
	list_for_each_entry(wdev, &rdev->wdev_list, list) {
		if (wdev->netdev) {
235
			dev_close(wdev->netdev);
236 237 238 239 240
			continue;
		}
		/* otherwise, check iftype */
		switch (wdev->iftype) {
		case NL80211_IFTYPE_P2P_DEVICE:
241
			cfg80211_stop_p2p_device(rdev, wdev);
242 243 244 245 246
			break;
		default:
			break;
		}
	}
247 248
}
EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
Johannes Berg's avatar
Johannes Berg committed
249

250 251 252 253 254 255 256 257 258
static int cfg80211_rfkill_set_block(void *data, bool blocked)
{
	struct cfg80211_registered_device *rdev = data;

	if (!blocked)
		return 0;

	rtnl_lock();
	cfg80211_shutdown_all_interfaces(&rdev->wiphy);
Johannes Berg's avatar
Johannes Berg committed
259 260 261 262 263 264 265
	rtnl_unlock();

	return 0;
}

static void cfg80211_rfkill_sync_work(struct work_struct *work)
{
266
	struct cfg80211_registered_device *rdev;
Johannes Berg's avatar
Johannes Berg committed
267

268 269
	rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
	cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
Johannes Berg's avatar
Johannes Berg committed
270 271
}

Johannes Berg's avatar
Johannes Berg committed
272 273 274 275 276 277 278 279
static void cfg80211_event_work(struct work_struct *work)
{
	struct cfg80211_registered_device *rdev;

	rdev = container_of(work, struct cfg80211_registered_device,
			    event_work);

	rtnl_lock();
280
	cfg80211_process_rdev_events(rdev);
Johannes Berg's avatar
Johannes Berg committed
281 282 283
	rtnl_unlock();
}

284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
{
	struct cfg80211_iface_destroy *item;

	ASSERT_RTNL();

	spin_lock_irq(&rdev->destroy_list_lock);
	while ((item = list_first_entry_or_null(&rdev->destroy_list,
						struct cfg80211_iface_destroy,
						list))) {
		struct wireless_dev *wdev, *tmp;
		u32 nlportid = item->nlportid;

		list_del(&item->list);
		kfree(item);
		spin_unlock_irq(&rdev->destroy_list_lock);

		list_for_each_entry_safe(wdev, tmp, &rdev->wdev_list, list) {
			if (nlportid == wdev->owner_nlportid)
				rdev_del_virtual_intf(rdev, wdev);
		}

		spin_lock_irq(&rdev->destroy_list_lock);
	}
	spin_unlock_irq(&rdev->destroy_list_lock);
}

static void cfg80211_destroy_iface_wk(struct work_struct *work)
{
	struct cfg80211_registered_device *rdev;

	rdev = container_of(work, struct cfg80211_registered_device,
			    destroy_work);

	rtnl_lock();
	cfg80211_destroy_ifaces(rdev);
	rtnl_unlock();
}

323 324
/* exported functions */

325 326
struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
			   const char *requested_name)
327
{
328
	static atomic_t wiphy_counter = ATOMIC_INIT(0);
329 330

	struct cfg80211_registered_device *rdev;
331 332
	int alloc_size;

333 334 335 336 337 338 339
	WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
	WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
	WARN_ON(ops->connect && !ops->disconnect);
	WARN_ON(ops->join_ibss && !ops->leave_ibss);
	WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
	WARN_ON(ops->add_station && !ops->del_station);
	WARN_ON(ops->add_mpath && !ops->del_mpath);
340
	WARN_ON(ops->join_mesh && !ops->leave_mesh);
341

342
	alloc_size = sizeof(*rdev) + sizeof_priv;
343

344 345
	rdev = kzalloc(alloc_size, GFP_KERNEL);
	if (!rdev)
346 347
		return NULL;

348
	rdev->ops = ops;
349

350
	rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
351

352
	if (unlikely(rdev->wiphy_idx < 0)) {
353
		/* ugh, wrapped! */
354
		atomic_dec(&wiphy_counter);
355
		kfree(rdev);
356 357 358
		return NULL;
	}

359 360 361
	/* atomic_inc_return makes it start at 1, make it start at 0 */
	rdev->wiphy_idx--;

362
	/* give it a proper name */
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
	if (requested_name && requested_name[0]) {
		int rv;

		rtnl_lock();
		rv = cfg80211_dev_check_name(rdev, requested_name);

		if (rv < 0) {
			rtnl_unlock();
			goto use_default_name;
		}

		rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
		rtnl_unlock();
		if (rv)
			goto use_default_name;
	} else {
use_default_name:
		/* NOTE:  This is *probably* safe w/out holding rtnl because of
		 * the restrictions on phy names.  Probably this call could
		 * fail if some other part of the kernel (re)named a device
		 * phyX.  But, might should add some locking and check return
		 * value, and use a different name if this one exists?
		 */
		dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
	}
388

389
	INIT_LIST_HEAD(&rdev->wdev_list);
390 391
	INIT_LIST_HEAD(&rdev->beacon_registrations);
	spin_lock_init(&rdev->beacon_registrations_lock);
392 393 394
	spin_lock_init(&rdev->bss_lock);
	INIT_LIST_HEAD(&rdev->bss_list);
	INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
395
	INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results);
396 397
	INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
			  cfg80211_dfs_channels_update_work);
Johannes Berg's avatar
Johannes Berg committed
398 399 400 401
#ifdef CONFIG_CFG80211_WEXT
	rdev->wiphy.wext = &cfg80211_wext_handler;
#endif

402 403 404 405
	device_initialize(&rdev->wiphy.dev);
	rdev->wiphy.dev.class = &ieee80211_class;
	rdev->wiphy.dev.platform_data = rdev;

406 407 408 409
	INIT_LIST_HEAD(&rdev->destroy_list);
	spin_lock_init(&rdev->destroy_list_lock);
	INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);

410 411 412
#ifdef CONFIG_CFG80211_DEFAULT_PS
	rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
#endif
413

414 415
	wiphy_net_set(&rdev->wiphy, &init_net);

416 417 418 419 420 421 422
	rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
	rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
				   &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
				   &rdev->rfkill_ops, rdev);

	if (!rdev->rfkill) {
		kfree(rdev);
Johannes Berg's avatar
Johannes Berg committed
423 424 425
		return NULL;
	}

426 427 428
	INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
	INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
	INIT_WORK(&rdev->event_work, cfg80211_event_work);
Johannes Berg's avatar
Johannes Berg committed
429

430 431
	init_waitqueue_head(&rdev->dev_wait);

432 433 434 435 436
	/*
	 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
	 * Fragmentation and RTS threshold are disabled by default with the
	 * special -1 value.
	 */
437 438 439 440
	rdev->wiphy.retry_short = 7;
	rdev->wiphy.retry_long = 4;
	rdev->wiphy.frag_threshold = (u32) -1;
	rdev->wiphy.rts_threshold = (u32) -1;
441
	rdev->wiphy.coverage_class = 0;
442

443 444
	rdev->wiphy.max_num_csa_counters = 1;

445
	return &rdev->wiphy;
446
}
447
EXPORT_SYMBOL(wiphy_new_nm);
448

449 450 451 452 453 454 455 456 457 458 459
static int wiphy_verify_combinations(struct wiphy *wiphy)
{
	const struct ieee80211_iface_combination *c;
	int i, j;

	for (i = 0; i < wiphy->n_iface_combinations; i++) {
		u32 cnt = 0;
		u16 all_iftypes = 0;

		c = &wiphy->iface_combinations[i];

460 461 462 463 464
		/*
		 * Combinations with just one interface aren't real,
		 * however we make an exception for DFS.
		 */
		if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
465 466 467 468 469 470
			return -EINVAL;

		/* Need at least one channel */
		if (WARN_ON(!c->num_different_channels))
			return -EINVAL;

471 472 473 474 475 476 477 478
		/*
		 * Put a sane limit on maximum number of different
		 * channels to simplify channel accounting code.
		 */
		if (WARN_ON(c->num_different_channels >
				CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
			return -EINVAL;

479 480 481 482 483
		/* DFS only works on one channel. */
		if (WARN_ON(c->radar_detect_widths &&
			    (c->num_different_channels > 1)))
			return -EINVAL;

484 485 486 487 488 489
		if (WARN_ON(!c->n_limits))
			return -EINVAL;

		for (j = 0; j < c->n_limits; j++) {
			u16 types = c->limits[j].types;

490
			/* interface types shouldn't overlap */
491 492 493 494 495 496 497 498 499 500 501
			if (WARN_ON(types & all_iftypes))
				return -EINVAL;
			all_iftypes |= types;

			if (WARN_ON(!c->limits[j].max))
				return -EINVAL;

			/* Shouldn't list software iftypes in combinations! */
			if (WARN_ON(wiphy->software_iftypes & types))
				return -EINVAL;

502 503 504 505 506
			/* Only a single P2P_DEVICE can be allowed */
			if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
				    c->limits[j].max > 1))
				return -EINVAL;

507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
			cnt += c->limits[j].max;
			/*
			 * Don't advertise an unsupported type
			 * in a combination.
			 */
			if (WARN_ON((wiphy->interface_modes & types) != types))
				return -EINVAL;
		}

		/* You can't even choose that many! */
		if (WARN_ON(cnt < c->max_interfaces))
			return -EINVAL;
	}

	return 0;
}

524 525
int wiphy_register(struct wiphy *wiphy)
{
526
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
527
	int res;
528 529 530 531
	enum ieee80211_band band;
	struct ieee80211_supported_band *sband;
	bool have_band = false;
	int i;
532 533
	u16 ifmodes = wiphy->interface_modes;

534
#ifdef CONFIG_PM
535 536 537 538 539 540 541
	if (WARN_ON(wiphy->wowlan &&
		    (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
		    !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
		return -EINVAL;
	if (WARN_ON(wiphy->wowlan &&
		    !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
		    !wiphy->wowlan->tcp))
542
		return -EINVAL;
543
#endif
544 545 546 547
	if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
		    (!rdev->ops->tdls_channel_switch ||
		     !rdev->ops->tdls_cancel_channel_switch)))
		return -EINVAL;
548

549 550 551 552 553 554 555 556
	if (WARN_ON(wiphy->coalesce &&
		    (!wiphy->coalesce->n_rules ||
		     !wiphy->coalesce->n_patterns) &&
		    (!wiphy->coalesce->pattern_min_len ||
		     wiphy->coalesce->pattern_min_len >
			wiphy->coalesce->pattern_max_len)))
		return -EINVAL;

557 558 559 560
	if (WARN_ON(wiphy->ap_sme_capa &&
		    !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
		return -EINVAL;

561 562 563 564 565 566 567 568 569
	if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
		return -EINVAL;

	if (WARN_ON(wiphy->addresses &&
		    !is_zero_ether_addr(wiphy->perm_addr) &&
		    memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
			   ETH_ALEN)))
		return -EINVAL;

570 571 572 573 574
	if (WARN_ON(wiphy->max_acl_mac_addrs &&
		    (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
		     !rdev->ops->set_mac_acl)))
		return -EINVAL;

575 576 577
	if (wiphy->addresses)
		memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);

578 579
	/* sanity check ifmodes */
	WARN_ON(!ifmodes);
580
	ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
581 582
	if (WARN_ON(ifmodes != wiphy->interface_modes))
		wiphy->interface_modes = ifmodes;
583

584 585 586 587
	res = wiphy_verify_combinations(wiphy);
	if (res)
		return res;

588 589 590 591 592 593 594
	/* sanity check supported bands/channels */
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
		sband = wiphy->bands[band];
		if (!sband)
			continue;

		sband->band = band;
595 596 597 598 599 600 601 602
		if (WARN_ON(!sband->n_channels))
			return -EINVAL;
		/*
		 * on 60gHz band, there are no legacy rates, so
		 * n_bitrates is 0
		 */
		if (WARN_ON(band != IEEE80211_BAND_60GHZ &&
			    !sband->n_bitrates))
603 604
			return -EINVAL;

605 606 607 608 609 610 611 612 613 614 615 616
		/*
		 * Since cfg80211_disable_40mhz_24ghz is global, we can
		 * modify the sband's ht data even if the driver uses a
		 * global structure for that.
		 */
		if (cfg80211_disable_40mhz_24ghz &&
		    band == IEEE80211_BAND_2GHZ &&
		    sband->ht_cap.ht_supported) {
			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
		}

617 618 619 620 621 622
		/*
		 * Since we use a u32 for rate bitmaps in
		 * ieee80211_get_response_rate, we cannot
		 * have more than 32 legacy rates.
		 */
		if (WARN_ON(sband->n_bitrates > 32))
623 624 625 626 627
			return -EINVAL;

		for (i = 0; i < sband->n_channels; i++) {
			sband->channels[i].orig_flags =
				sband->channels[i].flags;
628
			sband->channels[i].orig_mag = INT_MAX;
629 630 631 632 633 634 635 636 637 638 639 640 641
			sband->channels[i].orig_mpwr =
				sband->channels[i].max_power;
			sband->channels[i].band = band;
		}

		have_band = true;
	}

	if (!have_band) {
		WARN_ON(1);
		return -EINVAL;
	}

642
#ifdef CONFIG_PM
643 644 645 646 647
	if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
		    (!rdev->wiphy.wowlan->pattern_min_len ||
		     rdev->wiphy.wowlan->pattern_min_len >
				rdev->wiphy.wowlan->pattern_max_len)))
		return -EINVAL;
648
#endif
649

650 651 652
	/* check and set up bitrates */
	ieee80211_set_bitrate_flags(wiphy);

653 654
	rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;

655
	rtnl_lock();
656
	res = device_add(&rdev->wiphy.dev);
657
	if (res) {
658
		rtnl_unlock();
659 660
		return res;
	}
Johannes Berg's avatar
Johannes Berg committed
661

662
	/* set up regulatory info */
663
	wiphy_regulatory_register(wiphy);
664

665
	list_add_rcu(&rdev->list, &cfg80211_rdev_list);
666
	cfg80211_rdev_list_generation++;
667 668

	/* add to debugfs */
669 670
	rdev->wiphy.debugfsdir =
		debugfs_create_dir(wiphy_name(&rdev->wiphy),
671
				   ieee80211_debugfs_dir);
672 673
	if (IS_ERR(rdev->wiphy.debugfsdir))
		rdev->wiphy.debugfsdir = NULL;
674

675 676 677
	cfg80211_debugfs_rdev_add(rdev);
	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);

678
	if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
679 680 681 682 683 684 685 686 687 688
		struct regulatory_request request;

		request.wiphy_idx = get_wiphy_idx(wiphy);
		request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
		request.alpha2[0] = '9';
		request.alpha2[1] = '9';

		nl80211_send_reg_change_event(&request);
	}

689 690
	rdev->wiphy.registered = true;
	rtnl_unlock();
691 692 693 694 695 696 697 698 699

	res = rfkill_register(rdev->rfkill);
	if (res) {
		rfkill_destroy(rdev->rfkill);
		rdev->rfkill = NULL;
		wiphy_unregister(&rdev->wiphy);
		return res;
	}

700
	return 0;
701 702 703
}
EXPORT_SYMBOL(wiphy_register);

Johannes Berg's avatar
Johannes Berg committed
704 705
void wiphy_rfkill_start_polling(struct wiphy *wiphy)
{
706
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
707

708
	if (!rdev->ops->rfkill_poll)
Johannes Berg's avatar
Johannes Berg committed
709
		return;
710 711
	rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
	rfkill_resume_polling(rdev->rfkill);
Johannes Berg's avatar
Johannes Berg committed
712 713 714 715 716
}
EXPORT_SYMBOL(wiphy_rfkill_start_polling);

void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
{
717
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
718

719
	rfkill_pause_polling(rdev->rfkill);
Johannes Berg's avatar
Johannes Berg committed
720 721 722
}
EXPORT_SYMBOL(wiphy_rfkill_stop_polling);

723 724
void wiphy_unregister(struct wiphy *wiphy)
{
725
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
726

727 728
	wait_event(rdev->dev_wait, ({
		int __count;
729
		rtnl_lock();
730
		__count = rdev->opencount;
731
		rtnl_unlock();
732
		__count == 0; }));
733

734 735
	if (rdev->rfkill)
		rfkill_unregister(rdev->rfkill);
736

737
	rtnl_lock();
738
	nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
739 740
	rdev->wiphy.registered = false;

Johannes Berg's avatar
Johannes Berg committed
741
	WARN_ON(!list_empty(&rdev->wdev_list));
742 743 744 745 746

	/*
	 * First remove the hardware from everywhere, this makes
	 * it impossible to find from userspace.
	 */
747
	debugfs_remove_recursive(rdev->wiphy.debugfsdir);
748 749
	list_del_rcu(&rdev->list);
	synchronize_rcu();
750

751 752 753 754 755
	/*
	 * If this device got a regulatory hint tell core its
	 * free to listen now to a new shiny device regulatory hint
	 */
	wiphy_regulatory_deregister(wiphy);
756

757
	cfg80211_rdev_list_generation++;
758
	device_del(&rdev->wiphy.dev);
759

760
	rtnl_unlock();
Johannes Berg's avatar
Johannes Berg committed
761

762
	flush_work(&rdev->scan_done_wk);
Johannes Berg's avatar
Johannes Berg committed
763 764
	cancel_work_sync(&rdev->conn_work);
	flush_work(&rdev->event_work);
765
	cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
766
	flush_work(&rdev->destroy_work);
767

768 769
#ifdef CONFIG_PM
	if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
770
		rdev_set_wakeup(rdev, false);
771
#endif
772
	cfg80211_rdev_free_wowlan(rdev);
773
	cfg80211_rdev_free_coalesce(rdev);
774 775 776
}
EXPORT_SYMBOL(wiphy_unregister);

777
void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
778
{
779
	struct cfg80211_internal_bss *scan, *tmp;
780
	struct cfg80211_beacon_registration *reg, *treg;
781
	rfkill_destroy(rdev->rfkill);
782 783 784 785
	list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
		list_del(&reg->list);
		kfree(reg);
	}
786
	list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
787
		cfg80211_put_bss(&rdev->wiphy, &scan->pub);
788
	kfree(rdev);
789 790 791 792 793 794 795 796
}

void wiphy_free(struct wiphy *wiphy)
{
	put_device(&wiphy->dev);
}
EXPORT_SYMBOL(wiphy_free);

Johannes Berg's avatar
Johannes Berg committed
797 798
void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
{
799
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
800

801 802
	if (rfkill_set_hw_state(rdev->rfkill, blocked))
		schedule_work(&rdev->rfkill_sync);
Johannes Berg's avatar
Johannes Berg committed
803 804 805
}
EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);

806 807
void cfg80211_unregister_wdev(struct wireless_dev *wdev)
{
808
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
809 810 811 812 813 814 815 816 817 818 819

	ASSERT_RTNL();

	if (WARN_ON(wdev->netdev))
		return;

	list_del_rcu(&wdev->list);
	rdev->devlist_generation++;

	switch (wdev->iftype) {
	case NL80211_IFTYPE_P2P_DEVICE:
820
		cfg80211_stop_p2p_device(rdev, wdev);
821 822 823 824 825 826 827 828
		break;
	default:
		WARN_ON_ONCE(1);
		break;
	}
}
EXPORT_SYMBOL(cfg80211_unregister_wdev);

829
static const struct device_type wiphy_type = {
830 831 832
	.name	= "wlan",
};

833 834 835
void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
			       enum nl80211_iftype iftype, int num)
{
836
	ASSERT_RTNL();
837 838 839 840 841 842

	rdev->num_running_ifaces += num;
	if (iftype == NL80211_IFTYPE_MONITOR)
		rdev->num_running_monitor_ifaces += num;
}

843 844
void __cfg80211_leave(struct cfg80211_registered_device *rdev,
		      struct wireless_dev *wdev)
845 846 847
{
	struct net_device *dev = wdev->netdev;

848
	ASSERT_RTNL();
849
	ASSERT_WDEV_LOCK(wdev);
850

851 852
	switch (wdev->iftype) {
	case NL80211_IFTYPE_ADHOC:
853
		__cfg80211_leave_ibss(rdev, dev, true);
854 855 856
		break;
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_STATION:
857 858
		if (rdev->sched_scan_req && dev == rdev->sched_scan_req->dev)
			__cfg80211_stop_sched_scan(rdev, false);
859 860 861 862 863 864 865

#ifdef CONFIG_CFG80211_WEXT
		kfree(wdev->wext.ie);
		wdev->wext.ie = NULL;
		wdev->wext.ie_len = 0;
		wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
#endif
866 867
		cfg80211_disconnect(rdev, dev,
				    WLAN_REASON_DEAUTH_LEAVING, true);
868 869
		break;
	case NL80211_IFTYPE_MESH_POINT:
870
		__cfg80211_leave_mesh(rdev, dev);
871 872
		break;
	case NL80211_IFTYPE_AP:
873
	case NL80211_IFTYPE_P2P_GO:
874
		__cfg80211_stop_ap(rdev, dev, true);
875
		break;
876 877 878
	case NL80211_IFTYPE_OCB:
		__cfg80211_leave_ocb(rdev, dev);
		break;
879 880 881 882 883 884 885 886 887 888 889 890 891
	case NL80211_IFTYPE_WDS:
		/* must be handled by mac80211/driver, has no APIs */
		break;
	case NL80211_IFTYPE_P2P_DEVICE:
		/* cannot happen, has no netdev */
		break;
	case NL80211_IFTYPE_AP_VLAN:
	case NL80211_IFTYPE_MONITOR:
		/* nothing to do */
		break;
	case NL80211_IFTYPE_UNSPECIFIED:
	case NUM_NL80211_IFTYPES:
		/* invalid */
892 893 894 895
		break;
	}
}

896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
void cfg80211_leave(struct cfg80211_registered_device *rdev,
		    struct wireless_dev *wdev)
{
	wdev_lock(wdev);
	__cfg80211_leave(rdev, wdev);
	wdev_unlock(wdev);
}

void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
			 gfp_t gfp)
{
	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
	struct cfg80211_event *ev;
	unsigned long flags;

	trace_cfg80211_stop_iface(wiphy, wdev);

	ev = kzalloc(sizeof(*ev), gfp);
	if (!ev)
		return;

	ev->type = EVENT_STOPPED;

	spin_lock_irqsave(&wdev->event_lock, flags);
	list_add_tail(&ev->list, &wdev->event_list);
	spin_unlock_irqrestore(&wdev->event_lock, flags);
	queue_work(cfg80211_wq, &rdev->event_work);
}
EXPORT_SYMBOL(cfg80211_stop_iface);

926
static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
927
					 unsigned long state, void *ptr)
928
{
929
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
930
	struct wireless_dev *wdev = dev->ieee80211_ptr;
931 932
	struct cfg80211_registered_device *rdev;

933
	if (!wdev)
Johannes Berg's avatar
Johannes Berg committed
934
		return NOTIFY_DONE;
935

936
	rdev = wiphy_to_rdev(wdev->wiphy);
937

938
	WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
Johannes Berg's avatar
Johannes Berg committed
939

940
	switch (state) {
941 942 943
	case NETDEV_POST_INIT:
		SET_NETDEV_DEVTYPE(dev, &wiphy_type);
		break;
944
	case NETDEV_REGISTER:
Johannes Berg's avatar
Johannes Berg committed
945 946 947 948 949
		/*
		 * NB: cannot take rdev->mtx here because this may be
		 * called within code protected by it when interfaces
		 * are added with nl80211.
		 */
Johannes Berg's avatar
Johannes Berg committed
950 951 952
		mutex_init(&wdev->mtx);
		INIT_LIST_HEAD(&wdev->event_list);
		spin_lock_init(&wdev->event_lock);
953 954
		INIT_LIST_HEAD(&wdev->mgmt_registrations);
		spin_lock_init(&wdev->mgmt_registrations_lock);
955

956 957
		wdev->identifier = ++rdev->wdev_id;
		list_add_rcu(&wdev->list, &rdev->wdev_list);
958
		rdev->devlist_generation++;
959