mac80211_hwsim.c 76.4 KB
Newer Older
1 2 3
/*
 * mac80211_hwsim - software simulator of 802.11 radio(s) for mac80211
 * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
4
 * Copyright (c) 2011, Javier Lopez <jlopex@gmail.com>
5 6 7 8 9 10 11 12
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

/*
 * TODO:
13 14
 * - Add TSF sync and fix IBSS beacon transmission by adding
 *   competition for "air time" at TBTT
15 16 17
 * - RX filtering based on filter configuration (data->rx_filter)
 */

18
#include <linux/list.h>
19
#include <linux/slab.h>
20
#include <linux/spinlock.h>
21 22
#include <net/dst.h>
#include <net/xfrm.h>
23 24 25 26 27
#include <net/mac80211.h>
#include <net/ieee80211_radiotap.h>
#include <linux/if_arp.h>
#include <linux/rtnetlink.h>
#include <linux/etherdevice.h>
28
#include <linux/platform_device.h>
29
#include <linux/debugfs.h>
30
#include <linux/module.h>
31
#include <linux/ktime.h>
32 33 34 35 36
#include <net/genetlink.h>
#include "mac80211_hwsim.h"

#define WARN_QUEUE 100
#define MAX_QUEUE 200
37 38 39 40 41

MODULE_AUTHOR("Jouni Malinen");
MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211");
MODULE_LICENSE("GPL");

42
static u32 wmediumd_portid;
J
Johannes Berg 已提交
43

44 45 46 47
static int radios = 2;
module_param(radios, int, 0444);
MODULE_PARM_DESC(radios, "Number of simulated radios");

48 49 50
static int channels = 1;
module_param(channels, int, 0444);
MODULE_PARM_DESC(channels, "Number of concurrent channels");
51

52 53 54 55
static bool paged_rx = false;
module_param(paged_rx, bool, 0644);
MODULE_PARM_DESC(paged_rx, "Use paged SKBs for RX instead of linear ones");

56 57 58 59
static bool rctbl = false;
module_param(rctbl, bool, 0444);
MODULE_PARM_DESC(rctbl, "Handle rate control table");

60 61 62 63
static bool support_p2p_device = true;
module_param(support_p2p_device, bool, 0444);
MODULE_PARM_DESC(support_p2p_device, "Support P2P-Device interface type");

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
/**
 * enum hwsim_regtest - the type of regulatory tests we offer
 *
 * These are the different values you can use for the regtest
 * module parameter. This is useful to help test world roaming
 * and the driver regulatory_hint() call and combinations of these.
 * If you want to do specific alpha2 regulatory domain tests simply
 * use the userspace regulatory request as that will be respected as
 * well without the need of this module parameter. This is designed
 * only for testing the driver regulatory request, world roaming
 * and all possible combinations.
 *
 * @HWSIM_REGTEST_DISABLED: No regulatory tests are performed,
 * 	this is the default value.
 * @HWSIM_REGTEST_DRIVER_REG_FOLLOW: Used for testing the driver regulatory
 *	hint, only one driver regulatory hint will be sent as such the
 * 	secondary radios are expected to follow.
 * @HWSIM_REGTEST_DRIVER_REG_ALL: Used for testing the driver regulatory
 * 	request with all radios reporting the same regulatory domain.
 * @HWSIM_REGTEST_DIFF_COUNTRY: Used for testing the drivers calling
 * 	different regulatory domains requests. Expected behaviour is for
 * 	an intersection to occur but each device will still use their
 * 	respective regulatory requested domains. Subsequent radios will
 * 	use the resulting intersection.
L
Lucas De Marchi 已提交
88
 * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We accomplish
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
 *	this by using a custom beacon-capable regulatory domain for the first
 *	radio. All other device world roam.
 * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory
 * 	domain requests. All radios will adhere to this custom world regulatory
 * 	domain.
 * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory
 * 	domain requests. The first radio will adhere to the first custom world
 * 	regulatory domain, the second one to the second custom world regulatory
 * 	domain. All other devices will world roam.
 * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain
 *	settings, only the first radio will send a regulatory domain request
 *	and use strict settings. The rest of the radios are expected to follow.
 * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain
 *	settings. All radios will adhere to this.
 * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory
 *	domain settings, combined with secondary driver regulatory domain
 *	settings. The first radio will get a strict regulatory domain setting
 *	using the first driver regulatory request and the second radio will use
 *	non-strict settings using the second driver regulatory request. All
 *	other devices should follow the intersection created between the
 *	first two.
 * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need
 * 	at least 6 radios for a complete test. We will test in this order:
 * 	1 - driver custom world regulatory domain
 * 	2 - second custom world regulatory domain
 * 	3 - first driver regulatory domain request
 * 	4 - second driver regulatory domain request
 * 	5 - strict regulatory domain settings using the third driver regulatory
 * 	    domain request
 * 	6 and on - should follow the intersection of the 3rd, 4rth and 5th radio
 * 	           regulatory requests.
 */
enum hwsim_regtest {
	HWSIM_REGTEST_DISABLED = 0,
	HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
	HWSIM_REGTEST_DRIVER_REG_ALL = 2,
	HWSIM_REGTEST_DIFF_COUNTRY = 3,
	HWSIM_REGTEST_WORLD_ROAM = 4,
	HWSIM_REGTEST_CUSTOM_WORLD = 5,
	HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
	HWSIM_REGTEST_STRICT_FOLLOW = 7,
	HWSIM_REGTEST_STRICT_ALL = 8,
	HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
	HWSIM_REGTEST_ALL = 10,
};

/* Set to one of the HWSIM_REGTEST_* values above */
static int regtest = HWSIM_REGTEST_DISABLED;
module_param(regtest, int, 0444);
MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run");

static const char *hwsim_alpha2s[] = {
	"FI",
	"AL",
	"US",
	"DE",
	"JP",
	"AL",
};

static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = {
	.n_reg_rules = 4,
	.alpha2 =  "99",
	.reg_rules = {
		REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
		REG_RULE(2484-10, 2484+10, 40, 0, 20, 0),
		REG_RULE(5150-10, 5240+10, 40, 0, 30, 0),
		REG_RULE(5745-10, 5825+10, 40, 0, 30, 0),
	}
};

static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
	.n_reg_rules = 2,
	.alpha2 =  "99",
	.reg_rules = {
		REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
		REG_RULE(5725-10, 5850+10, 40, 0, 30,
166
			 NL80211_RRF_NO_IR),
167 168 169
	}
};

170 171 172 173 174
static const struct ieee80211_regdomain *hwsim_world_regdom_custom[] = {
	&hwsim_world_regdom_custom_01,
	&hwsim_world_regdom_custom_02,
};

175 176
struct hwsim_vif_priv {
	u32 magic;
177 178
	u8 bssid[ETH_ALEN];
	bool assoc;
179
	bool bcn_en;
180
	u16 aid;
181 182 183 184 185 186 187
};

#define HWSIM_VIF_MAGIC	0x69537748

static inline void hwsim_check_magic(struct ieee80211_vif *vif)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
188 189 190
	WARN(vp->magic != HWSIM_VIF_MAGIC,
	     "Invalid VIF (%p) magic %#x, %pM, %d/%d\n",
	     vif, vp->magic, vif->addr, vif->type, vif->p2p);
191 192 193 194 195 196 197 198 199 200 201 202 203
}

static inline void hwsim_set_magic(struct ieee80211_vif *vif)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	vp->magic = HWSIM_VIF_MAGIC;
}

static inline void hwsim_clear_magic(struct ieee80211_vif *vif)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	vp->magic = 0;
}
204

205 206 207 208
struct hwsim_sta_priv {
	u32 magic;
};

209
#define HWSIM_STA_MAGIC	0x6d537749
210 211 212 213

static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
214
	WARN_ON(sp->magic != HWSIM_STA_MAGIC);
215 216 217 218 219
}

static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
220
	sp->magic = HWSIM_STA_MAGIC;
221 222 223 224 225 226 227 228
}

static inline void hwsim_clear_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
	sp->magic = 0;
}

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
struct hwsim_chanctx_priv {
	u32 magic;
};

#define HWSIM_CHANCTX_MAGIC 0x6d53774a

static inline void hwsim_check_chanctx_magic(struct ieee80211_chanctx_conf *c)
{
	struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
	WARN_ON(cp->magic != HWSIM_CHANCTX_MAGIC);
}

static inline void hwsim_set_chanctx_magic(struct ieee80211_chanctx_conf *c)
{
	struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
	cp->magic = HWSIM_CHANCTX_MAGIC;
}

static inline void hwsim_clear_chanctx_magic(struct ieee80211_chanctx_conf *c)
{
	struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
	cp->magic = 0;
}

253 254 255 256
static struct class *hwsim_class;

static struct net_device *hwsim_mon; /* global monitor netdev */

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
#define CHAN2G(_freq)  { \
	.band = IEEE80211_BAND_2GHZ, \
	.center_freq = (_freq), \
	.hw_value = (_freq), \
	.max_power = 20, \
}

#define CHAN5G(_freq) { \
	.band = IEEE80211_BAND_5GHZ, \
	.center_freq = (_freq), \
	.hw_value = (_freq), \
	.max_power = 20, \
}

static const struct ieee80211_channel hwsim_channels_2ghz[] = {
	CHAN2G(2412), /* Channel 1 */
	CHAN2G(2417), /* Channel 2 */
	CHAN2G(2422), /* Channel 3 */
	CHAN2G(2427), /* Channel 4 */
	CHAN2G(2432), /* Channel 5 */
	CHAN2G(2437), /* Channel 6 */
	CHAN2G(2442), /* Channel 7 */
	CHAN2G(2447), /* Channel 8 */
	CHAN2G(2452), /* Channel 9 */
	CHAN2G(2457), /* Channel 10 */
	CHAN2G(2462), /* Channel 11 */
	CHAN2G(2467), /* Channel 12 */
	CHAN2G(2472), /* Channel 13 */
	CHAN2G(2484), /* Channel 14 */
};
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
static const struct ieee80211_channel hwsim_channels_5ghz[] = {
	CHAN5G(5180), /* Channel 36 */
	CHAN5G(5200), /* Channel 40 */
	CHAN5G(5220), /* Channel 44 */
	CHAN5G(5240), /* Channel 48 */

	CHAN5G(5260), /* Channel 52 */
	CHAN5G(5280), /* Channel 56 */
	CHAN5G(5300), /* Channel 60 */
	CHAN5G(5320), /* Channel 64 */

	CHAN5G(5500), /* Channel 100 */
	CHAN5G(5520), /* Channel 104 */
	CHAN5G(5540), /* Channel 108 */
	CHAN5G(5560), /* Channel 112 */
	CHAN5G(5580), /* Channel 116 */
	CHAN5G(5600), /* Channel 120 */
	CHAN5G(5620), /* Channel 124 */
	CHAN5G(5640), /* Channel 128 */
	CHAN5G(5660), /* Channel 132 */
	CHAN5G(5680), /* Channel 136 */
	CHAN5G(5700), /* Channel 140 */

	CHAN5G(5745), /* Channel 149 */
	CHAN5G(5765), /* Channel 153 */
	CHAN5G(5785), /* Channel 157 */
	CHAN5G(5805), /* Channel 161 */
	CHAN5G(5825), /* Channel 165 */
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
};

static const struct ieee80211_rate hwsim_rates[] = {
	{ .bitrate = 10 },
	{ .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 60 },
	{ .bitrate = 90 },
	{ .bitrate = 120 },
	{ .bitrate = 180 },
	{ .bitrate = 240 },
	{ .bitrate = 360 },
	{ .bitrate = 480 },
	{ .bitrate = 540 }
};

333 334 335 336 337 338 339 340 341
static const struct ieee80211_iface_limit hwsim_if_limits[] = {
	{ .max = 1, .types = BIT(NL80211_IFTYPE_ADHOC) },
	{ .max = 2048,  .types = BIT(NL80211_IFTYPE_STATION) |
				 BIT(NL80211_IFTYPE_P2P_CLIENT) |
#ifdef CONFIG_MAC80211_MESH
				 BIT(NL80211_IFTYPE_MESH_POINT) |
#endif
				 BIT(NL80211_IFTYPE_AP) |
				 BIT(NL80211_IFTYPE_P2P_GO) },
342 343
	/* must be last, see hwsim_if_comb */
	{ .max = 1, .types = BIT(NL80211_IFTYPE_P2P_DEVICE) }
344 345 346 347 348 349 350
};

static const struct ieee80211_iface_limit hwsim_if_dfs_limits[] = {
	{ .max = 8, .types = BIT(NL80211_IFTYPE_AP) },
};

static const struct ieee80211_iface_combination hwsim_if_comb[] = {
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
	{
		.limits = hwsim_if_limits,
		/* remove the last entry which is P2P_DEVICE */
		.n_limits = ARRAY_SIZE(hwsim_if_limits) - 1,
		.max_interfaces = 2048,
		.num_different_channels = 1,
	},
	{
		.limits = hwsim_if_dfs_limits,
		.n_limits = ARRAY_SIZE(hwsim_if_dfs_limits),
		.max_interfaces = 8,
		.num_different_channels = 1,
		.radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
				       BIT(NL80211_CHAN_WIDTH_20) |
				       BIT(NL80211_CHAN_WIDTH_40) |
				       BIT(NL80211_CHAN_WIDTH_80) |
				       BIT(NL80211_CHAN_WIDTH_160),
	}
};

static const struct ieee80211_iface_combination hwsim_if_comb_p2p_dev[] = {
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
	{
		.limits = hwsim_if_limits,
		.n_limits = ARRAY_SIZE(hwsim_if_limits),
		.max_interfaces = 2048,
		.num_different_channels = 1,
	},
	{
		.limits = hwsim_if_dfs_limits,
		.n_limits = ARRAY_SIZE(hwsim_if_dfs_limits),
		.max_interfaces = 8,
		.num_different_channels = 1,
		.radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
				       BIT(NL80211_CHAN_WIDTH_20) |
				       BIT(NL80211_CHAN_WIDTH_40) |
				       BIT(NL80211_CHAN_WIDTH_80) |
				       BIT(NL80211_CHAN_WIDTH_160),
	}
};

391 392
static spinlock_t hwsim_radio_lock;
static struct list_head hwsim_radios;
393
static int hwsim_radio_idx;
394

395 396 397 398 399 400
static struct platform_driver mac80211_hwsim_driver = {
	.driver = {
		.name = "mac80211_hwsim",
		.owner = THIS_MODULE,
	},
};
401

402
struct mac80211_hwsim_data {
403 404
	struct list_head list;
	struct ieee80211_hw *hw;
405
	struct device *dev;
406
	struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
407 408
	struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
	struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
409
	struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
410
	struct ieee80211_iface_combination if_combination;
411

412
	struct mac_address addresses[2];
413
	int channels, idx;
414
	bool use_chanctx;
415 416 417
	bool destroy_on_close;
	struct work_struct destroy_work;
	u32 portid;
418

419 420 421 422 423 424 425
	struct ieee80211_channel *tmp_chan;
	struct delayed_work roc_done;
	struct delayed_work hw_scan;
	struct cfg80211_scan_request *hw_scan_request;
	struct ieee80211_vif *hw_scan_vif;
	int scan_chan_idx;

426
	struct ieee80211_channel *channel;
T
Thomas Pedersen 已提交
427
	u64 beacon_int	/* beacon interval in us */;
428
	unsigned int rx_filter;
429 430
	bool started, idle, scanning;
	struct mutex mutex;
T
Thomas Pedersen 已提交
431
	struct tasklet_hrtimer beacon_timer;
432 433 434 435 436
	enum ps_mode {
		PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
	} ps;
	bool ps_poll_pending;
	struct dentry *debugfs;
D
Daniel Wagner 已提交
437

438
	struct sk_buff_head pending;	/* packets pending */
D
Daniel Wagner 已提交
439 440 441
	/*
	 * Only radios in the same group can communicate together (the
	 * channel has to match too). Each bit represents a group. A
442
	 * radio can be in more than one group.
D
Daniel Wagner 已提交
443 444
	 */
	u64 group;
445 446

	int power_level;
447 448

	/* difference between this hw's clock and the real clock, in usecs */
449
	s64 tsf_offset;
450
	s64 bcn_delta;
451 452
	/* absolute beacon transmission time. Used to cover up "tx" delay. */
	u64 abs_bcn_ts;
453 454 455 456 457 458 459 460

	/* Stats */
	u64 tx_pkts;
	u64 rx_pkts;
	u64 tx_bytes;
	u64 rx_bytes;
	u64 tx_dropped;
	u64 tx_failed;
461 462 463 464 465
};


struct hwsim_radiotap_hdr {
	struct ieee80211_radiotap_header hdr;
466
	__le64 rt_tsft;
467 468 469 470
	u8 rt_flags;
	u8 rt_rate;
	__le16 rt_channel;
	__le16 rt_chbitmask;
471
} __packed;
472

473 474 475 476 477 478 479 480
struct hwsim_radiotap_ack_hdr {
	struct ieee80211_radiotap_header hdr;
	u8 rt_flags;
	u8 pad;
	__le16 rt_channel;
	__le16 rt_chbitmask;
} __packed;

481 482 483 484 485 486 487 488 489 490 491
/* MAC80211_HWSIM netlinf family */
static struct genl_family hwsim_genl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = 0,
	.name = "MAC80211_HWSIM",
	.version = 1,
	.maxattr = HWSIM_ATTR_MAX,
};

/* MAC80211_HWSIM netlink policy */

492
static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
493 494
	[HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
	[HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
495 496 497 498 499 500
	[HWSIM_ATTR_FRAME] = { .type = NLA_BINARY,
			       .len = IEEE80211_MAX_DATA_LEN },
	[HWSIM_ATTR_FLAGS] = { .type = NLA_U32 },
	[HWSIM_ATTR_RX_RATE] = { .type = NLA_U32 },
	[HWSIM_ATTR_SIGNAL] = { .type = NLA_U32 },
	[HWSIM_ATTR_TX_INFO] = { .type = NLA_UNSPEC,
501 502
				 .len = IEEE80211_TX_MAX_RATES *
					sizeof(struct hwsim_tx_rate)},
503
	[HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
504 505
	[HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 },
	[HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 },
506 507 508
	[HWSIM_ATTR_REG_HINT_ALPHA2] = { .type = NLA_STRING, .len = 2 },
	[HWSIM_ATTR_REG_CUSTOM_REG] = { .type = NLA_U32 },
	[HWSIM_ATTR_REG_STRICT_REG] = { .type = NLA_FLAG },
509
	[HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG },
510
	[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE] = { .type = NLA_FLAG },
511
};
512

513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan);

/* sysfs attributes */
static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = dat;
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	struct sk_buff *skb;
	struct ieee80211_pspoll *pspoll;

	if (!vp->assoc)
		return;

	wiphy_debug(data->hw->wiphy,
		    "%s: send PS-Poll to %pM for aid %d\n",
		    __func__, vp->bssid, vp->aid);

	skb = dev_alloc_skb(sizeof(*pspoll));
	if (!skb)
		return;
	pspoll = (void *) skb_put(skb, sizeof(*pspoll));
	pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
					    IEEE80211_STYPE_PSPOLL |
					    IEEE80211_FCTL_PM);
	pspoll->aid = cpu_to_le16(0xc000 | vp->aid);
	memcpy(pspoll->bssid, vp->bssid, ETH_ALEN);
	memcpy(pspoll->ta, mac, ETH_ALEN);

	rcu_read_lock();
	mac80211_hwsim_tx_frame(data->hw, skb,
				rcu_dereference(vif->chanctx_conf)->def.chan);
	rcu_read_unlock();
}

static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
				struct ieee80211_vif *vif, int ps)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	struct sk_buff *skb;
	struct ieee80211_hdr *hdr;

	if (!vp->assoc)
		return;

	wiphy_debug(data->hw->wiphy,
		    "%s: send data::nullfunc to %pM ps=%d\n",
		    __func__, vp->bssid, ps);

	skb = dev_alloc_skb(sizeof(*hdr));
	if (!skb)
		return;
	hdr = (void *) skb_put(skb, sizeof(*hdr) - ETH_ALEN);
	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
					 IEEE80211_STYPE_NULLFUNC |
					 (ps ? IEEE80211_FCTL_PM : 0));
	hdr->duration_id = cpu_to_le16(0);
	memcpy(hdr->addr1, vp->bssid, ETH_ALEN);
	memcpy(hdr->addr2, mac, ETH_ALEN);
	memcpy(hdr->addr3, vp->bssid, ETH_ALEN);

	rcu_read_lock();
	mac80211_hwsim_tx_frame(data->hw, skb,
				rcu_dereference(vif->chanctx_conf)->def.chan);
	rcu_read_unlock();
}


static void hwsim_send_nullfunc_ps(void *dat, u8 *mac,
				   struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = dat;
	hwsim_send_nullfunc(data, mac, vif, 1);
}

static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac,
				      struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = dat;
	hwsim_send_nullfunc(data, mac, vif, 0);
}

static int hwsim_fops_ps_read(void *dat, u64 *val)
{
	struct mac80211_hwsim_data *data = dat;
	*val = data->ps;
	return 0;
}

static int hwsim_fops_ps_write(void *dat, u64 val)
{
	struct mac80211_hwsim_data *data = dat;
	enum ps_mode old_ps;

	if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL &&
	    val != PS_MANUAL_POLL)
		return -EINVAL;

	old_ps = data->ps;
	data->ps = val;

	if (val == PS_MANUAL_POLL) {
		ieee80211_iterate_active_interfaces(data->hw,
						    IEEE80211_IFACE_ITER_NORMAL,
						    hwsim_send_ps_poll, data);
		data->ps_poll_pending = true;
	} else if (old_ps == PS_DISABLED && val != PS_DISABLED) {
		ieee80211_iterate_active_interfaces(data->hw,
						    IEEE80211_IFACE_ITER_NORMAL,
						    hwsim_send_nullfunc_ps,
						    data);
	} else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
		ieee80211_iterate_active_interfaces(data->hw,
						    IEEE80211_IFACE_ITER_NORMAL,
						    hwsim_send_nullfunc_no_ps,
						    data);
	}

	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write,
			"%llu\n");

static int hwsim_write_simulate_radar(void *dat, u64 val)
{
	struct mac80211_hwsim_data *data = dat;

	ieee80211_radar_detected(data->hw);

	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(hwsim_simulate_radar, NULL,
			hwsim_write_simulate_radar, "%llu\n");

static int hwsim_fops_group_read(void *dat, u64 *val)
{
	struct mac80211_hwsim_data *data = dat;
	*val = data->group;
	return 0;
}

static int hwsim_fops_group_write(void *dat, u64 val)
{
	struct mac80211_hwsim_data *data = dat;
	data->group = val;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_group,
			hwsim_fops_group_read, hwsim_fops_group_write,
			"%llx\n");

668 669
static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
					struct net_device *dev)
670 671 672
{
	/* TODO: allow packet injection */
	dev_kfree_skb(skb);
673
	return NETDEV_TX_OK;
674 675
}

676 677 678 679 680
static inline u64 mac80211_hwsim_get_tsf_raw(void)
{
	return ktime_to_us(ktime_get_real());
}

681 682
static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
{
683
	u64 now = mac80211_hwsim_get_tsf_raw();
684 685
	return cpu_to_le64(now + data->tsf_offset);
}
686

687
static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
688
				  struct ieee80211_vif *vif)
689 690 691 692 693 694 695 696 697
{
	struct mac80211_hwsim_data *data = hw->priv;
	return le64_to_cpu(__mac80211_hwsim_get_tsf(data));
}

static void mac80211_hwsim_set_tsf(struct ieee80211_hw *hw,
		struct ieee80211_vif *vif, u64 tsf)
{
	struct mac80211_hwsim_data *data = hw->priv;
698
	u64 now = mac80211_hwsim_get_tsf(hw, vif);
699
	u32 bcn_int = data->beacon_int;
700
	u64 delta = abs64(tsf - now);
701

702
	/* adjust after beaconing with new timestamp at old TBTT */
703 704 705 706 707 708 709
	if (tsf > now) {
		data->tsf_offset += delta;
		data->bcn_delta = do_div(delta, bcn_int);
	} else {
		data->tsf_offset -= delta;
		data->bcn_delta = -do_div(delta, bcn_int);
	}
710 711
}

712
static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
713 714
				      struct sk_buff *tx_skb,
				      struct ieee80211_channel *chan)
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
{
	struct mac80211_hwsim_data *data = hw->priv;
	struct sk_buff *skb;
	struct hwsim_radiotap_hdr *hdr;
	u16 flags;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb);
	struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info);

	if (!netif_running(hwsim_mon))
		return;

	skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC);
	if (skb == NULL)
		return;

	hdr = (struct hwsim_radiotap_hdr *) skb_push(skb, sizeof(*hdr));
	hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
	hdr->hdr.it_pad = 0;
	hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
J
Jouni Malinen 已提交
734 735
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_RATE) |
736
					  (1 << IEEE80211_RADIOTAP_TSFT) |
J
Jouni Malinen 已提交
737
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
738
	hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
739 740
	hdr->rt_flags = 0;
	hdr->rt_rate = txrate->bitrate / 5;
741
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
742 743 744 745 746 747 748 749 750 751 752
	flags = IEEE80211_CHAN_2GHZ;
	if (txrate->flags & IEEE80211_RATE_ERP_G)
		flags |= IEEE80211_CHAN_OFDM;
	else
		flags |= IEEE80211_CHAN_CCK;
	hdr->rt_chbitmask = cpu_to_le16(flags);

	skb->dev = hwsim_mon;
	skb_set_mac_header(skb, 0);
	skb->ip_summed = CHECKSUM_UNNECESSARY;
	skb->pkt_type = PACKET_OTHERHOST;
J
Jouni Malinen 已提交
753
	skb->protocol = htons(ETH_P_802_2);
754 755 756 757 758
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}


759 760
static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
				       const u8 *addr)
761 762
{
	struct sk_buff *skb;
763
	struct hwsim_radiotap_ack_hdr *hdr;
764 765 766 767 768 769 770 771 772 773
	u16 flags;
	struct ieee80211_hdr *hdr11;

	if (!netif_running(hwsim_mon))
		return;

	skb = dev_alloc_skb(100);
	if (skb == NULL)
		return;

774
	hdr = (struct hwsim_radiotap_ack_hdr *) skb_put(skb, sizeof(*hdr));
775 776 777 778 779 780
	hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
	hdr->hdr.it_pad = 0;
	hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
	hdr->rt_flags = 0;
781
	hdr->pad = 0;
782
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
	flags = IEEE80211_CHAN_2GHZ;
	hdr->rt_chbitmask = cpu_to_le16(flags);

	hdr11 = (struct ieee80211_hdr *) skb_put(skb, 10);
	hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
					   IEEE80211_STYPE_ACK);
	hdr11->duration_id = cpu_to_le16(0);
	memcpy(hdr11->addr1, addr, ETH_ALEN);

	skb->dev = hwsim_mon;
	skb_set_mac_header(skb, 0);
	skb->ip_summed = CHECKSUM_UNNECESSARY;
	skb->pkt_type = PACKET_OTHERHOST;
	skb->protocol = htons(ETH_P_802_2);
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}

801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
struct mac80211_hwsim_addr_match_data {
	u8 addr[ETH_ALEN];
	bool ret;
};

static void mac80211_hwsim_addr_iter(void *data, u8 *mac,
				     struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_addr_match_data *md = data;

	if (memcmp(mac, md->addr, ETH_ALEN) == 0)
		md->ret = true;
}

static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data,
				      const u8 *addr)
{
	struct mac80211_hwsim_addr_match_data md = {
		.ret = false,
	};

	memcpy(md.addr, addr, ETH_ALEN);

	ieee80211_iterate_active_interfaces_atomic(data->hw,
						   IEEE80211_IFACE_ITER_NORMAL,
						   mac80211_hwsim_addr_iter,
						   &md);

	return md.ret;
}
831

832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
			   struct sk_buff *skb)
{
	switch (data->ps) {
	case PS_DISABLED:
		return true;
	case PS_ENABLED:
		return false;
	case PS_AUTO_POLL:
		/* TODO: accept (some) Beacons by default and other frames only
		 * if pending PS-Poll has been sent */
		return true;
	case PS_MANUAL_POLL:
		/* Allow unicast frames to own address if there is a pending
		 * PS-Poll */
		if (data->ps_poll_pending &&
848
		    mac80211_hwsim_addr_match(data, skb->data + 4)) {
849 850 851 852 853 854 855 856 857
			data->ps_poll_pending = false;
			return true;
		}
		return false;
	}

	return true;
}

858 859
static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
				       struct sk_buff *my_skb,
860
				       int dst_portid)
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
{
	struct sk_buff *skb;
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb);
	void *msg_head;
	unsigned int hwsim_flags = 0;
	int i;
	struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES];

	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
	/* If the queue contains MAX_QUEUE skb's drop some */
	if (skb_queue_len(&data->pending) >= MAX_QUEUE) {
		/* Droping until WARN_QUEUE level */
876
		while (skb_queue_len(&data->pending) >= WARN_QUEUE) {
877
			ieee80211_free_txskb(hw, skb_dequeue(&data->pending));
878 879
			data->tx_dropped++;
		}
880 881
	}

882
	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
883 884 885 886 887 888 889 890 891 892
	if (skb == NULL)
		goto nla_put_failure;

	msg_head = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
			       HWSIM_CMD_FRAME);
	if (msg_head == NULL) {
		printk(KERN_DEBUG "mac80211_hwsim: problem with msg_head\n");
		goto nla_put_failure;
	}

893
	if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
894
		    ETH_ALEN, data->addresses[1].addr))
895
		goto nla_put_failure;
896

897
	/* We get the skb->data */
898 899
	if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
		goto nla_put_failure;
900 901 902 903 904 905 906 907 908 909

	/* We get the flags for this transmission, and we translate them to
	   wmediumd flags  */

	if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
		hwsim_flags |= HWSIM_TX_CTL_REQ_TX_STATUS;

	if (info->flags & IEEE80211_TX_CTL_NO_ACK)
		hwsim_flags |= HWSIM_TX_CTL_NO_ACK;

910 911
	if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
		goto nla_put_failure;
912 913 914 915 916 917 918 919

	/* We get the tx control (rate and retries) info*/

	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
		tx_attempts[i].idx = info->status.rates[i].idx;
		tx_attempts[i].count = info->status.rates[i].count;
	}

920 921 922 923
	if (nla_put(skb, HWSIM_ATTR_TX_INFO,
		    sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
		    tx_attempts))
		goto nla_put_failure;
924 925

	/* We create a cookie to identify this skb */
926 927
	if (nla_put_u64(skb, HWSIM_ATTR_COOKIE, (unsigned long) my_skb))
		goto nla_put_failure;
928 929

	genlmsg_end(skb, msg_head);
930
	genlmsg_unicast(&init_net, skb, dst_portid);
931 932 933

	/* Enqueue the packet */
	skb_queue_tail(&data->pending, my_skb);
934 935
	data->tx_pkts++;
	data->tx_bytes += my_skb->len;
936 937 938
	return;

nla_put_failure:
939
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
940
	ieee80211_free_txskb(hw, my_skb);
941
	data->tx_failed++;
942 943
}

944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
static bool hwsim_chans_compat(struct ieee80211_channel *c1,
			       struct ieee80211_channel *c2)
{
	if (!c1 || !c2)
		return false;

	return c1->center_freq == c2->center_freq;
}

struct tx_iter_data {
	struct ieee80211_channel *channel;
	bool receive;
};

static void mac80211_hwsim_tx_iter(void *_data, u8 *addr,
				   struct ieee80211_vif *vif)
{
	struct tx_iter_data *data = _data;

	if (!vif->chanctx_conf)
		return;

	if (!hwsim_chans_compat(data->channel,
967
				rcu_dereference(vif->chanctx_conf)->def.chan))
968 969 970 971 972
		return;

	data->receive = true;
}

973
static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
974 975
					  struct sk_buff *skb,
					  struct ieee80211_channel *chan)
976
{
977 978
	struct mac80211_hwsim_data *data = hw->priv, *data2;
	bool ack = false;
979
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
980
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
981
	struct ieee80211_rx_status rx_status;
982
	u64 now;
983 984

	memset(&rx_status, 0, sizeof(rx_status));
985
	rx_status.flag |= RX_FLAG_MACTIME_START;
986 987
	rx_status.freq = chan->center_freq;
	rx_status.band = chan->band;
988 989 990 991 992 993 994 995 996 997 998
	if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
		rx_status.rate_idx =
			ieee80211_rate_get_vht_mcs(&info->control.rates[0]);
		rx_status.vht_nss =
			ieee80211_rate_get_vht_nss(&info->control.rates[0]);
		rx_status.flag |= RX_FLAG_VHT;
	} else {
		rx_status.rate_idx = info->control.rates[0].idx;
		if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
			rx_status.flag |= RX_FLAG_HT;
	}
999 1000 1001 1002
	if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		rx_status.flag |= RX_FLAG_40MHZ;
	if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
		rx_status.flag |= RX_FLAG_SHORT_GI;
1003
	/* TODO: simulate real signal strength (and optional packet loss) */
1004
	rx_status.signal = data->power_level - 50;
1005

1006 1007 1008
	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);

1009 1010
	/* release the skb's source info */
	skb_orphan(skb);
1011
	skb_dst_drop(skb);
1012 1013 1014 1015
	skb->mark = 0;
	secpath_reset(skb);
	nf_reset(skb);

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
	/*
	 * Get absolute mactime here so all HWs RX at the "same time", and
	 * absolute TX time for beacon mactime so the timestamp matches.
	 * Giving beacons a different mactime than non-beacons looks messy, but
	 * it helps the Toffset be exact and a ~10us mactime discrepancy
	 * probably doesn't really matter.
	 */
	if (ieee80211_is_beacon(hdr->frame_control) ||
	    ieee80211_is_probe_resp(hdr->frame_control))
		now = data->abs_bcn_ts;
	else
		now = mac80211_hwsim_get_tsf_raw();

1029
	/* Copy skb to all enabled radios that are on the current frequency */
1030 1031
	spin_lock(&hwsim_radio_lock);
	list_for_each_entry(data2, &hwsim_radios, list) {
1032
		struct sk_buff *nskb;
1033 1034 1035 1036
		struct tx_iter_data tx_iter_data = {
			.receive = false,
			.channel = chan,
		};
1037

1038
		if (data == data2)
1039
			continue;
1040

1041 1042
		if (!data2->started || (data2->idle && !data2->tmp_chan) ||
		    !hwsim_ps_rx_ok(data2, skb))
1043 1044
			continue;

1045 1046 1047 1048 1049 1050
		if (!(data->group & data2->group))
			continue;

		if (!hwsim_chans_compat(chan, data2->tmp_chan) &&
		    !hwsim_chans_compat(chan, data2->channel)) {
			ieee80211_iterate_active_interfaces_atomic(
1051 1052
				data2->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_tx_iter, &tx_iter_data);
1053 1054 1055 1056
			if (!tx_iter_data.receive)
				continue;
		}

1057 1058 1059 1060
		/*
		 * reserve some space for our vendor and the normal
		 * radiotap header, since we're copying anyway
		 */
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
		if (skb->len < PAGE_SIZE && paged_rx) {
			struct page *page = alloc_page(GFP_ATOMIC);

			if (!page)
				continue;

			nskb = dev_alloc_skb(128);
			if (!nskb) {
				__free_page(page);
				continue;
			}

			memcpy(page_address(page), skb->data, skb->len);
			skb_add_rx_frag(nskb, 0, page, 0, skb->len, skb->len);
		} else {
			nskb = skb_copy(skb, GFP_ATOMIC);
			if (!nskb)
				continue;
		}
1080

1081
		if (mac80211_hwsim_addr_match(data2, hdr->addr1))
1082
			ack = true;
1083

1084
		rx_status.mactime = now + data2->tsf_offset;
1085

1086
		memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
1087 1088
		data2->rx_pkts++;
		data2->rx_bytes += nskb->len;
1089
		ieee80211_rx_irqsafe(data2->hw, nskb);
1090
	}
1091
	spin_unlock(&hwsim_radio_lock);
1092

1093 1094 1095
	return ack;
}

1096 1097 1098
static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
			      struct ieee80211_tx_control *control,
			      struct sk_buff *skb)
1099
{
1100 1101 1102 1103
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_channel *channel;
1104
	bool ack;
1105
	u32 _portid;
1106

1107
	if (WARN_ON(skb->len < 10)) {
1108
		/* Should not happen; just a sanity check for addr1 use */
1109
		ieee80211_free_txskb(hw, skb);
1110
		return;
1111 1112
	}

1113
	if (!data->use_chanctx) {
1114 1115 1116 1117 1118 1119
		channel = data->channel;
	} else if (txi->hw_queue == 4) {
		channel = data->tmp_chan;
	} else {
		chanctx_conf = rcu_dereference(txi->control.vif->chanctx_conf);
		if (chanctx_conf)
1120
			channel = chanctx_conf->def.chan;
1121 1122 1123 1124 1125
		else
			channel = NULL;
	}

	if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
1126
		ieee80211_free_txskb(hw, skb);
1127 1128 1129 1130 1131
		return;
	}

	if (data->idle && !data->tmp_chan) {
		wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
1132
		ieee80211_free_txskb(hw, skb);
1133 1134 1135 1136 1137 1138 1139 1140
		return;
	}

	if (txi->control.vif)
		hwsim_check_magic(txi->control.vif);
	if (control->sta)
		hwsim_check_sta_magic(control->sta);

1141
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE)
1142 1143 1144
		ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
1145

1146
	txi->rate_driver_data[0] = channel;
1147 1148
	mac80211_hwsim_monitor_rx(hw, skb, channel);

1149
	/* wmediumd mode check */
1150
	_portid = ACCESS_ONCE(wmediumd_portid);
1151

1152 1153
	if (_portid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
1154 1155

	/* NO wmediumd detected, perfect medium simulation */
1156 1157
	data->tx_pkts++;
	data->tx_bytes += skb->len;
1158
	ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
1159

1160 1161
	if (ack && skb->len >= 16) {
		struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1162
		mac80211_hwsim_monitor_ack(channel, hdr->addr2);
1163
	}
1164

1165
	ieee80211_tx_info_clear_status(txi);
1166 1167 1168 1169 1170

	/* frame was transmitted at most favorable rate at first attempt */
	txi->control.rates[0].count = 1;
	txi->control.rates[1].idx = -1;

1171 1172
	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
		txi->flags |= IEEE80211_TX_STAT_ACK;
1173 1174 1175 1176 1177 1178 1179
	ieee80211_tx_status_irqsafe(hw, skb);
}


static int mac80211_hwsim_start(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1180
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1181
	data->started = true;
1182 1183 1184 1185 1186 1187 1188
	return 0;
}


static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1189
	data->started = false;
T
Thomas Pedersen 已提交
1190
	tasklet_hrtimer_cancel(&data->beacon_timer);
1191
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1192 1193 1194 1195
}


static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1196
					struct ieee80211_vif *vif)
1197
{
1198
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1199 1200
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
1201
	hwsim_set_magic(vif);
1202 1203 1204 1205 1206 1207 1208

	vif->cab_queue = 0;
	vif->hw_queue[IEEE80211_AC_VO] = 0;
	vif->hw_queue[IEEE80211_AC_VI] = 1;
	vif->hw_queue[IEEE80211_AC_BE] = 2;
	vif->hw_queue[IEEE80211_AC_BK] = 3;

1209 1210 1211 1212
	return 0;
}


1213 1214
static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
					   struct ieee80211_vif *vif,
1215 1216
					   enum nl80211_iftype newtype,
					   bool newp2p)
1217
{
1218
	newtype = ieee80211_iftype_p2p(newtype, newp2p);
1219 1220
	wiphy_debug(hw->wiphy,
		    "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
1221 1222
		    __func__, ieee80211_vif_type_p2p(vif),
		    newtype, vif->addr);
1223 1224
	hwsim_check_magic(vif);

1225 1226 1227 1228 1229 1230
	/*
	 * interface may change from non-AP to AP in
	 * which case this needs to be set up again
	 */
	vif->cab_queue = 0;

1231 1232 1233
	return 0;
}

1234
static void mac80211_hwsim_remove_interface(
1235
	struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1236
{
1237
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1238 1239
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
1240 1241
	hwsim_check_magic(vif);
	hwsim_clear_magic(vif);
1242 1243
}

1244 1245 1246 1247 1248 1249
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan)
{
	u32 _pid = ACCESS_ONCE(wmediumd_portid);

1250
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE) {
1251 1252 1253 1254 1255 1256
		struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
		ieee80211_get_tx_rates(txi->control.vif, NULL, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
	}

1257 1258 1259 1260 1261 1262 1263 1264
	mac80211_hwsim_monitor_rx(hw, skb, chan);

	if (_pid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _pid);

	mac80211_hwsim_tx_frame_no_nl(hw, skb, chan);
	dev_kfree_skb(skb);
}
1265 1266 1267 1268

static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
				     struct ieee80211_vif *vif)
{
1269 1270 1271 1272 1273
	struct mac80211_hwsim_data *data = arg;
	struct ieee80211_hw *hw = data->hw;
	struct ieee80211_tx_info *info;
	struct ieee80211_rate *txrate;
	struct ieee80211_mgmt *mgmt;
1274 1275
	struct sk_buff *skb;

1276 1277
	hwsim_check_magic(vif);

1278
	if (vif->type != NL80211_IFTYPE_AP &&
1279 1280
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_ADHOC)
1281 1282 1283 1284 1285
		return;

	skb = ieee80211_beacon_get(hw, vif);
	if (skb == NULL)
		return;
1286
	info = IEEE80211_SKB_CB(skb);
1287
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE)
1288 1289 1290 1291
		ieee80211_get_tx_rates(vif, NULL, skb,
				       info->control.rates,
				       ARRAY_SIZE(info->control.rates));

1292 1293 1294 1295 1296 1297 1298 1299
	txrate = ieee80211_get_tx_rate(hw, info);

	mgmt = (struct ieee80211_mgmt *) skb->data;
	/* fake header transmission time */
	data->abs_bcn_ts = mac80211_hwsim_get_tsf_raw();
	mgmt->u.beacon.timestamp = cpu_to_le64(data->abs_bcn_ts +
					       data->tsf_offset +
					       24 * 8 * 10 / txrate->bitrate);
1300

1301
	mac80211_hwsim_tx_frame(hw, skb,
1302
				rcu_dereference(vif->chanctx_conf)->def.chan);
1303 1304 1305

	if (vif->csa_active && ieee80211_csa_is_complete(vif))
		ieee80211_csa_finish(vif);
1306 1307
}

T
Thomas Pedersen 已提交
1308 1309
static enum hrtimer_restart
mac80211_hwsim_beacon(struct hrtimer *timer)
1310
{
T
Thomas Pedersen 已提交
1311 1312 1313 1314 1315 1316
	struct mac80211_hwsim_data *data =
		container_of(timer, struct mac80211_hwsim_data,
			     beacon_timer.timer);
	struct ieee80211_hw *hw = data->hw;
	u64 bcn_int = data->beacon_int;
	ktime_t next_bcn;
1317

1318
	if (!data->started)
T
Thomas Pedersen 已提交
1319
		goto out;
1320

J
Jouni Malinen 已提交
1321
	ieee80211_iterate_active_interfaces_atomic(
1322
		hw, IEEE80211_IFACE_ITER_NORMAL,
1323
		mac80211_hwsim_beacon_tx, data);
1324

1325 1326 1327 1328 1329 1330
	/* beacon at new TBTT + beacon interval */
	if (data->bcn_delta) {
		bcn_int -= data->bcn_delta;
		data->bcn_delta = 0;
	}

T
Thomas Pedersen 已提交
1331 1332 1333 1334 1335
	next_bcn = ktime_add(hrtimer_get_expires(timer),
			     ns_to_ktime(bcn_int * 1000));
	tasklet_hrtimer_start(&data->beacon_timer, next_bcn, HRTIMER_MODE_ABS);
out:
	return HRTIMER_NORESTART;
1336 1337
}

1338 1339 1340 1341 1342 1343 1344
static const char * const hwsim_chanwidths[] = {
	[NL80211_CHAN_WIDTH_20_NOHT] = "noht",
	[NL80211_CHAN_WIDTH_20] = "ht20",
	[NL80211_CHAN_WIDTH_40] = "ht40",
	[NL80211_CHAN_WIDTH_80] = "vht80",
	[NL80211_CHAN_WIDTH_80P80] = "vht80p80",
	[NL80211_CHAN_WIDTH_160] = "vht160",
1345
};
1346

1347
static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1348 1349
{
	struct mac80211_hwsim_data *data = hw->priv;
1350
	struct ieee80211_conf *conf = &hw->conf;
1351 1352 1353 1354 1355 1356 1357
	static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
		[IEEE80211_SMPS_AUTOMATIC] = "auto",
		[IEEE80211_SMPS_OFF] = "off",
		[IEEE80211_SMPS_STATIC] = "static",
		[IEEE80211_SMPS_DYNAMIC] = "dynamic",
	};

1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
	if (conf->chandef.chan)
		wiphy_debug(hw->wiphy,
			    "%s (freq=%d(%d - %d)/%s idle=%d ps=%d smps=%s)\n",
			    __func__,
			    conf->chandef.chan->center_freq,
			    conf->chandef.center_freq1,
			    conf->chandef.center_freq2,
			    hwsim_chanwidths[conf->chandef.width],
			    !!(conf->flags & IEEE80211_CONF_IDLE),
			    !!(conf->flags & IEEE80211_CONF_PS),
			    smps_modes[conf->smps_mode]);
	else
		wiphy_debug(hw->wiphy,
			    "%s (freq=0 idle=%d ps=%d smps=%s)\n",
			    __func__,
			    !!(conf->flags & IEEE80211_CONF_IDLE),
			    !!(conf->flags & IEEE80211_CONF_PS),
			    smps_modes[conf->smps_mode]);
1376

1377 1378
	data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);

1379
	data->channel = conf->chandef.chan;
1380

1381
	WARN_ON(data->channel && data->use_chanctx);
1382

1383
	data->power_level = conf->power_level;
1384
	if (!data->started || !data->beacon_int)
T
Thomas Pedersen 已提交
1385 1386
		tasklet_hrtimer_cancel(&data->beacon_timer);
	else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
1387 1388 1389 1390
		u64 tsf = mac80211_hwsim_get_tsf(hw, NULL);
		u32 bcn_int = data->beacon_int;
		u64 until_tbtt = bcn_int - do_div(tsf, bcn_int);

T
Thomas Pedersen 已提交
1391
		tasklet_hrtimer_start(&data->beacon_timer,
1392
				      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1393 1394
				      HRTIMER_MODE_REL);
	}
1395 1396 1397 1398 1399 1400 1401

	return 0;
}


static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
					    unsigned int changed_flags,
1402
					    unsigned int *total_flags,u64 multicast)
1403 1404 1405
{
	struct mac80211_hwsim_data *data = hw->priv;

1406
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416

	data->rx_filter = 0;
	if (*total_flags & FIF_PROMISC_IN_BSS)
		data->rx_filter |= FIF_PROMISC_IN_BSS;
	if (*total_flags & FIF_ALLMULTI)
		data->rx_filter |= FIF_ALLMULTI;

	*total_flags = data->rx_filter;
}

1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
static void mac80211_hwsim_bcn_en_iter(void *data, u8 *mac,
				       struct ieee80211_vif *vif)
{
	unsigned int *count = data;
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;

	if (vp->bcn_en)
		(*count)++;
}

1427 1428 1429 1430 1431
static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif,
					    struct ieee80211_bss_conf *info,
					    u32 changed)
{
1432
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1433
	struct mac80211_hwsim_data *data = hw->priv;
1434

1435
	hwsim_check_magic(vif);
1436

1437 1438
	wiphy_debug(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n",
		    __func__, changed, vif->addr);
1439

1440
	if (changed & BSS_CHANGED_BSSID) {
1441 1442
		wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n",
			    __func__, info->bssid);
1443 1444 1445
		memcpy(vp->bssid, info->bssid, ETH_ALEN);
	}

1446
	if (changed & BSS_CHANGED_ASSOC) {
1447 1448
		wiphy_debug(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
			    info->assoc, info->aid);
1449 1450
		vp->assoc = info->assoc;
		vp->aid = info->aid;
1451 1452
	}

1453
	if (changed & BSS_CHANGED_BEACON_INT) {
1454
		wiphy_debug(hw->wiphy, "  BCNINT: %d\n", info->beacon_int);
T
Thomas Pedersen 已提交
1455 1456 1457 1458 1459
		data->beacon_int = info->beacon_int * 1024;
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED) {
		wiphy_debug(hw->wiphy, "  BCN EN: %d\n", info->enable_beacon);
1460
		vp->bcn_en = info->enable_beacon;
T
Thomas Pedersen 已提交
1461 1462 1463
		if (data->started &&
		    !hrtimer_is_queued(&data->beacon_timer.timer) &&
		    info->enable_beacon) {
1464 1465
			u64 tsf, until_tbtt;
			u32 bcn_int;
T
Thomas Pedersen 已提交
1466 1467
			if (WARN_ON(!data->beacon_int))
				data->beacon_int = 1000 * 1024;
1468 1469 1470
			tsf = mac80211_hwsim_get_tsf(hw, vif);
			bcn_int = data->beacon_int;
			until_tbtt = bcn_int - do_div(tsf, bcn_int);
T
Thomas Pedersen 已提交
1471
			tasklet_hrtimer_start(&data->beacon_timer,
1472
					      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1473
					      HRTIMER_MODE_REL);
1474 1475
		} else if (!info->enable_beacon) {
			unsigned int count = 0;
1476
			ieee80211_iterate_active_interfaces_atomic(
1477 1478 1479 1480 1481 1482 1483
				data->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_bcn_en_iter, &count);
			wiphy_debug(hw->wiphy, "  beaconing vifs remaining: %u",
				    count);
			if (count == 0)
				tasklet_hrtimer_cancel(&data->beacon_timer);
		}
1484 1485
	}

1486
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1487 1488
		wiphy_debug(hw->wiphy, "  ERP_CTS_PROT: %d\n",
			    info->use_cts_prot);
1489 1490 1491
	}

	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1492 1493
		wiphy_debug(hw->wiphy, "  ERP_PREAMBLE: %d\n",
			    info->use_short_preamble);
1494 1495 1496
	}

	if (changed & BSS_CHANGED_ERP_SLOT) {
1497
		wiphy_debug(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
1498 1499 1500
	}

	if (changed & BSS_CHANGED_HT) {
1501 1502
		wiphy_debug(hw->wiphy, "  HT: op_mode=0x%x\n",
			    info->ht_operation_mode);
1503 1504 1505
	}

	if (changed & BSS_CHANGED_BASIC_RATES) {
1506 1507
		wiphy_debug(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
			    (unsigned long long) info->basic_rates);
1508
	}
1509 1510 1511

	if (changed & BSS_CHANGED_TXPOWER)
		wiphy_debug(hw->wiphy, "  TX Power: %d dBm\n", info->txpower);
1512 1513
}

1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif,
				  struct ieee80211_sta *sta)
{
	hwsim_check_magic(vif);
	hwsim_set_sta_magic(sta);

	return 0;
}

static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct ieee80211_sta *sta)
{
	hwsim_check_magic(vif);
	hwsim_clear_sta_magic(sta);

	return 0;
}

1534 1535
static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
1536 1537
				      enum sta_notify_cmd cmd,
				      struct ieee80211_sta *sta)
1538 1539
{
	hwsim_check_magic(vif);
1540

1541
	switch (cmd) {
1542 1543 1544 1545
	case STA_NOTIFY_SLEEP:
	case STA_NOTIFY_AWAKE:
		/* TODO: make good use of these flags */
		break;
1546 1547 1548
	default:
		WARN(1, "Invalid sta notify: %d\n", cmd);
		break;
1549 1550 1551 1552 1553 1554 1555 1556 1557
	}
}

static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw,
				  struct ieee80211_sta *sta,
				  bool set)
{
	hwsim_check_sta_magic(sta);
	return 0;
1558
}
1559

1560
static int mac80211_hwsim_conf_tx(
1561 1562
	struct ieee80211_hw *hw,
	struct ieee80211_vif *vif, u16 queue,
1563 1564
	const struct ieee80211_tx_queue_params *params)
{
1565 1566 1567 1568 1569
	wiphy_debug(hw->wiphy,
		    "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n",
		    __func__, queue,
		    params->txop, params->cw_min,
		    params->cw_max, params->aifs);
1570 1571 1572
	return 0;
}

1573 1574 1575 1576 1577 1578
static int mac80211_hwsim_get_survey(
	struct ieee80211_hw *hw, int idx,
	struct survey_info *survey)
{
	struct ieee80211_conf *conf = &hw->conf;

1579
	wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx);
1580 1581 1582 1583 1584

	if (idx != 0)
		return -ENOENT;

	/* Current channel */
1585
	survey->channel = conf->chandef.chan;
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598

	/*
	 * Magically conjured noise level --- this is only ok for simulated hardware.
	 *
	 * A real driver which cannot determine the real channel noise MUST NOT
	 * report any noise, especially not a magically conjured one :-)
	 */
	survey->filled = SURVEY_INFO_NOISE_DBM;
	survey->noise = -92;

	return 0;
}

1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
#ifdef CONFIG_NL80211_TESTMODE
/*
 * This section contains example code for using netlink
 * attributes with the testmode command in nl80211.
 */

/* These enums need to be kept in sync with userspace */
enum hwsim_testmode_attr {
	__HWSIM_TM_ATTR_INVALID	= 0,
	HWSIM_TM_ATTR_CMD	= 1,
	HWSIM_TM_ATTR_PS	= 2,

	/* keep last */
	__HWSIM_TM_ATTR_AFTER_LAST,
	HWSIM_TM_ATTR_MAX	= __HWSIM_TM_ATTR_AFTER_LAST - 1
};

enum hwsim_testmode_cmd {
	HWSIM_TM_CMD_SET_PS		= 0,
	HWSIM_TM_CMD_GET_PS		= 1,
1619 1620
	HWSIM_TM_CMD_STOP_QUEUES	= 2,
	HWSIM_TM_CMD_WAKE_QUEUES	= 3,
1621 1622 1623 1624 1625 1626 1627
};

static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = {
	[HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 },
	[HWSIM_TM_ATTR_PS] = { .type = NLA_U32 },
};

J
Johannes Berg 已提交
1628
static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1629
				       struct ieee80211_vif *vif,
J
Johannes Berg 已提交
1630
				       void *data, int len)
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
{
	struct mac80211_hwsim_data *hwsim = hw->priv;
	struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1];
	struct sk_buff *skb;
	int err, ps;

	err = nla_parse(tb, HWSIM_TM_ATTR_MAX, data, len,
			hwsim_testmode_policy);
	if (err)
		return err;

	if (!tb[HWSIM_TM_ATTR_CMD])
		return -EINVAL;

	switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) {
	case HWSIM_TM_CMD_SET_PS:
		if (!tb[HWSIM_TM_ATTR_PS])
			return -EINVAL;
		ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]);
		return hwsim_fops_ps_write(hwsim, ps);
	case HWSIM_TM_CMD_GET_PS:
		skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
						nla_total_size(sizeof(u32)));
		if (!skb)
			return -ENOMEM;
1656 1657
		if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
			goto nla_put_failure;
1658
		return cfg80211_testmode_reply(skb);
1659 1660 1661 1662 1663 1664
	case HWSIM_TM_CMD_STOP_QUEUES:
		ieee80211_stop_queues(hw);
		return 0;
	case HWSIM_TM_CMD_WAKE_QUEUES:
		ieee80211_wake_queues(hw);
		return 0;
1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
	default:
		return -EOPNOTSUPP;
	}

 nla_put_failure:
	kfree_skb(skb);
	return -ENOBUFS;
}
#endif

1675 1676 1677
static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
				       enum ieee80211_ampdu_mlme_action action,
1678 1679
				       struct ieee80211_sta *sta, u16 tid, u16 *ssn,
				       u8 buf_size)
1680 1681 1682 1683 1684
{
	switch (action) {
	case IEEE80211_AMPDU_TX_START:
		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
		break;
1685 1686 1687
	case IEEE80211_AMPDU_TX_STOP_CONT:
	case IEEE80211_AMPDU_TX_STOP_FLUSH:
	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
		break;
	case IEEE80211_AMPDU_TX_OPERATIONAL:
		break;
	case IEEE80211_AMPDU_RX_START:
	case IEEE80211_AMPDU_RX_STOP:
		break;
	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

1702 1703 1704
static void mac80211_hwsim_flush(struct ieee80211_hw *hw,
				 struct ieee80211_vif *vif,
				 u32 queues, bool drop)
1705
{
1706
	/* Not implemented, queues only on kernel side */
1707 1708
}

1709
static void hw_scan_work(struct work_struct *work)
1710
{
1711 1712 1713 1714
	struct mac80211_hwsim_data *hwsim =
		container_of(work, struct mac80211_hwsim_data, hw_scan.work);
	struct cfg80211_scan_request *req = hwsim->hw_scan_request;
	int dwell, i;
1715

1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
	mutex_lock(&hwsim->mutex);
	if (hwsim->scan_chan_idx >= req->n_channels) {
		wiphy_debug(hwsim->hw->wiphy, "hw scan complete\n");
		ieee80211_scan_completed(hwsim->hw, false);
		hwsim->hw_scan_request = NULL;
		hwsim->hw_scan_vif = NULL;
		hwsim->tmp_chan = NULL;
		mutex_unlock(&hwsim->mutex);
		return;
	}

	wiphy_debug(hwsim->hw->wiphy, "hw scan %d MHz\n",
		    req->channels[hwsim->scan_chan_idx]->center_freq);

	hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx];
1731
	if (hwsim->tmp_chan->flags & IEEE80211_CHAN_NO_IR ||
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
	    !req->n_ssids) {
		dwell = 120;
	} else {
		dwell = 30;
		/* send probes */
		for (i = 0; i < req->n_ssids; i++) {
			struct sk_buff *probe;

			probe = ieee80211_probereq_get(hwsim->hw,
						       hwsim->hw_scan_vif,
						       req->ssids[i].ssid,
						       req->ssids[i].ssid_len,
1744
						       req->ie_len);
1745 1746
			if (!probe)
				continue;
1747 1748 1749 1750 1751

			if (req->ie_len)
				memcpy(skb_put(probe, req->ie_len), req->ie,
				       req->ie_len);

1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
			local_bh_disable();
			mac80211_hwsim_tx_frame(hwsim->hw, probe,
						hwsim->tmp_chan);
			local_bh_enable();
		}
	}
	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan,
				     msecs_to_jiffies(dwell));
	hwsim->scan_chan_idx++;
	mutex_unlock(&hwsim->mutex);
1762 1763 1764
}

static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
1765
				  struct ieee80211_vif *vif,
1766
				  struct ieee80211_scan_request *hw_req)
1767
{
1768
	struct mac80211_hwsim_data *hwsim = hw->priv;
1769
	struct cfg80211_scan_request *req = &hw_req->req;
1770

1771 1772 1773 1774 1775 1776 1777 1778 1779
	mutex_lock(&hwsim->mutex);
	if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
		mutex_unlock(&hwsim->mutex);
		return -EBUSY;
	}
	hwsim->hw_scan_request = req;
	hwsim->hw_scan_vif = vif;
	hwsim->scan_chan_idx = 0;
	mutex_unlock(&hwsim->mutex);
1780

1781
	wiphy_debug(hw->wiphy, "hwsim hw_scan request\n");
1782

1783
	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
1784 1785 1786 1787

	return 0;
}

1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804
static void mac80211_hwsim_cancel_hw_scan(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	wiphy_debug(hw->wiphy, "hwsim cancel_hw_scan\n");

	cancel_delayed_work_sync(&hwsim->hw_scan);

	mutex_lock(&hwsim->mutex);
	ieee80211_scan_completed(hwsim->hw, true);
	hwsim->tmp_chan = NULL;
	hwsim->hw_scan_request = NULL;
	hwsim->hw_scan_vif = NULL;
	mutex_unlock(&hwsim->mutex);
}

1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);

	if (hwsim->scanning) {
		printk(KERN_DEBUG "two hwsim sw_scans detected!\n");
		goto out;
	}

	printk(KERN_DEBUG "hwsim sw_scan request, prepping stuff\n");
	hwsim->scanning = true;

out:
	mutex_unlock(&hwsim->mutex);
}

static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);

	printk(KERN_DEBUG "hwsim sw_scan_complete\n");
1830
	hwsim->scanning = false;
1831 1832 1833 1834

	mutex_unlock(&hwsim->mutex);
}

1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
static void hw_roc_done(struct work_struct *work)
{
	struct mac80211_hwsim_data *hwsim =
		container_of(work, struct mac80211_hwsim_data, roc_done.work);

	mutex_lock(&hwsim->mutex);
	ieee80211_remain_on_channel_expired(hwsim->hw);
	hwsim->tmp_chan = NULL;
	mutex_unlock(&hwsim->mutex);

	wiphy_debug(hwsim->hw->wiphy, "hwsim ROC expired\n");
}

static int mac80211_hwsim_roc(struct ieee80211_hw *hw,
1849
			      struct ieee80211_vif *vif,
1850
			      struct ieee80211_channel *chan,
1851 1852
			      int duration,
			      enum ieee80211_roc_type type)
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);
	if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
		mutex_unlock(&hwsim->mutex);
		return -EBUSY;
	}

	hwsim->tmp_chan = chan;
	mutex_unlock(&hwsim->mutex);

	wiphy_debug(hw->wiphy, "hwsim ROC (%d MHz, %d ms)\n",
		    chan->center_freq, duration);

	ieee80211_ready_on_channel(hw);

	ieee80211_queue_delayed_work(hw, &hwsim->roc_done,
				     msecs_to_jiffies(duration));
	return 0;
}

static int mac80211_hwsim_croc(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	cancel_delayed_work_sync(&hwsim->roc_done);

	mutex_lock(&hwsim->mutex);
	hwsim->tmp_chan = NULL;
	mutex_unlock(&hwsim->mutex);

	wiphy_debug(hw->wiphy, "hwsim ROC canceled\n");

	return 0;
}

static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw,
				      struct ieee80211_chanctx_conf *ctx)
{
	hwsim_set_chanctx_magic(ctx);
1894 1895 1896 1897
	wiphy_debug(hw->wiphy,
		    "add channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
		    ctx->def.chan->center_freq, ctx->def.width,
		    ctx->def.center_freq1, ctx->def.center_freq2);
1898 1899 1900 1901 1902 1903
	return 0;
}

static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
					  struct ieee80211_chanctx_conf *ctx)
{
1904 1905 1906 1907
	wiphy_debug(hw->wiphy,
		    "remove channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
		    ctx->def.chan->center_freq, ctx->def.width,
		    ctx->def.center_freq1, ctx->def.center_freq2);
1908 1909 1910 1911 1912 1913 1914 1915 1916
	hwsim_check_chanctx_magic(ctx);
	hwsim_clear_chanctx_magic(ctx);
}

static void mac80211_hwsim_change_chanctx(struct ieee80211_hw *hw,
					  struct ieee80211_chanctx_conf *ctx,
					  u32 changed)
{
	hwsim_check_chanctx_magic(ctx);
1917 1918 1919 1920
	wiphy_debug(hw->wiphy,
		    "change channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
		    ctx->def.chan->center_freq, ctx->def.width,
		    ctx->def.center_freq1, ctx->def.center_freq2);
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
}

static int mac80211_hwsim_assign_vif_chanctx(struct ieee80211_hw *hw,
					     struct ieee80211_vif *vif,
					     struct ieee80211_chanctx_conf *ctx)
{
	hwsim_check_magic(vif);
	hwsim_check_chanctx_magic(ctx);

	return 0;
}

static void mac80211_hwsim_unassign_vif_chanctx(struct ieee80211_hw *hw,
						struct ieee80211_vif *vif,
						struct ieee80211_chanctx_conf *ctx)
{
	hwsim_check_magic(vif);
	hwsim_check_chanctx_magic(ctx);
}

1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
static const char mac80211_hwsim_gstrings_stats[][ETH_GSTRING_LEN] = {
	"tx_pkts_nic",
	"tx_bytes_nic",
	"rx_pkts_nic",
	"rx_bytes_nic",
	"d_tx_dropped",
	"d_tx_failed",
	"d_ps_mode",
	"d_group",
	"d_tx_power",
};

#define MAC80211_HWSIM_SSTATS_LEN ARRAY_SIZE(mac80211_hwsim_gstrings_stats)

static void mac80211_hwsim_get_et_strings(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif,
					  u32 sset, u8 *data)
{
	if (sset == ETH_SS_STATS)
		memcpy(data, *mac80211_hwsim_gstrings_stats,
		       sizeof(mac80211_hwsim_gstrings_stats));
}

static int mac80211_hwsim_get_et_sset_count(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif, int sset)
{
	if (sset == ETH_SS_STATS)
		return MAC80211_HWSIM_SSTATS_LEN;
	return 0;
}

static void mac80211_hwsim_get_et_stats(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
					struct ethtool_stats *stats, u64 *data)
{
	struct mac80211_hwsim_data *ar = hw->priv;
	int i = 0;

	data[i++] = ar->tx_pkts;
	data[i++] = ar->tx_bytes;
	data[i++] = ar->rx_pkts;
	data[i++] = ar->rx_bytes;
	data[i++] = ar->tx_dropped;
	data[i++] = ar->tx_failed;
	data[i++] = ar->ps;
	data[i++] = ar->group;
	data[i++] = ar->power_level;

	WARN_ON(i != MAC80211_HWSIM_SSTATS_LEN);
}

1992
static const struct ieee80211_ops mac80211_hwsim_ops = {
1993 1994 1995 1996
	.tx = mac80211_hwsim_tx,
	.start = mac80211_hwsim_start,
	.stop = mac80211_hwsim_stop,
	.add_interface = mac80211_hwsim_add_interface,
1997
	.change_interface = mac80211_hwsim_change_interface,
1998 1999 2000
	.remove_interface = mac80211_hwsim_remove_interface,
	.config = mac80211_hwsim_config,
	.configure_filter = mac80211_hwsim_configure_filter,
2001
	.bss_info_changed = mac80211_hwsim_bss_info_changed,
2002 2003
	.sta_add = mac80211_hwsim_sta_add,
	.sta_remove = mac80211_hwsim_sta_remove,
2004
	.sta_notify = mac80211_hwsim_sta_notify,
2005
	.set_tim = mac80211_hwsim_set_tim,
2006
	.conf_tx = mac80211_hwsim_conf_tx,
2007
	.get_survey = mac80211_hwsim_get_survey,
2008
	CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)
2009
	.ampdu_action = mac80211_hwsim_ampdu_action,
2010 2011
	.sw_scan_start = mac80211_hwsim_sw_scan,
	.sw_scan_complete = mac80211_hwsim_sw_scan_complete,
2012
	.flush = mac80211_hwsim_flush,
2013 2014
	.get_tsf = mac80211_hwsim_get_tsf,
	.set_tsf = mac80211_hwsim_set_tsf,
2015 2016 2017
	.get_et_sset_count = mac80211_hwsim_get_et_sset_count,
	.get_et_stats = mac80211_hwsim_get_et_stats,
	.get_et_strings = mac80211_hwsim_get_et_strings,
2018 2019
};

2020
static struct ieee80211_ops mac80211_hwsim_mchan_ops;
2021

2022 2023
static int mac80211_hwsim_create_radio(int channels, const char *reg_alpha2,
				       const struct ieee80211_regdomain *regd,
2024
				       bool reg_strict, bool p2p_device,
2025 2026
				       bool use_chanctx, bool destroy_on_close,
				       u32 portid)
2027
{
2028 2029
	int err;
	u8 addr[ETH_ALEN];
2030
	struct mac80211_hwsim_data *data;
2031 2032 2033 2034
	struct ieee80211_hw *hw;
	enum ieee80211_band band;
	const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
	int idx;
2035

2036 2037 2038
	if (WARN_ON(channels > 1 && !use_chanctx))
		return -EINVAL;

2039
	spin_lock_bh(&hwsim_radio_lock);
2040
	idx = hwsim_radio_idx++;
2041 2042
	spin_unlock_bh(&hwsim_radio_lock);

2043
	if (use_chanctx)
2044 2045 2046 2047 2048 2049 2050 2051 2052
		ops = &mac80211_hwsim_mchan_ops;
	hw = ieee80211_alloc_hw(sizeof(*data), ops);
	if (!hw) {
		printk(KERN_DEBUG "mac80211_hwsim: ieee80211_alloc_hw failed\n");
		err = -ENOMEM;
		goto failed;
	}
	data = hw->priv;
	data->hw = hw;
2053

2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
	data->dev = device_create(hwsim_class, NULL, 0, hw, "hwsim%d", idx);
	if (IS_ERR(data->dev)) {
		printk(KERN_DEBUG
		       "mac80211_hwsim: device_create failed (%ld)\n",
		       PTR_ERR(data->dev));
		err = -ENOMEM;
		goto failed_drvdata;
	}
	data->dev->driver = &mac80211_hwsim_driver.driver;
	err = device_bind_driver(data->dev);
	if (err != 0) {
		printk(KERN_DEBUG "mac80211_hwsim: device_bind_driver failed (%d)\n",
		       err);
		goto failed_hw;
2068 2069
	}

2070
	skb_queue_head_init(&data->pending);
2071

2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
	SET_IEEE80211_DEV(hw, data->dev);
	memset(addr, 0, ETH_ALEN);
	addr[0] = 0x02;
	addr[3] = idx >> 8;
	addr[4] = idx;
	memcpy(data->addresses[0].addr, addr, ETH_ALEN);
	memcpy(data->addresses[1].addr, addr, ETH_ALEN);
	data->addresses[1].addr[0] |= 0x40;
	hw->wiphy->n_addresses = 2;
	hw->wiphy->addresses = data->addresses;
2082

2083
	data->channels = channels;
2084
	data->use_chanctx = use_chanctx;
2085
	data->idx = idx;
2086 2087
	data->destroy_on_close = destroy_on_close;
	data->portid = portid;
2088

2089
	if (data->use_chanctx) {
2090 2091 2092 2093 2094 2095
		hw->wiphy->max_scan_ssids = 255;
		hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
		hw->wiphy->max_remain_on_channel_duration = 1000;
		/* For channels > 1 DFS is not allowed */
		hw->wiphy->n_iface_combinations = 1;
		hw->wiphy->iface_combinations = &data->if_combination;
2096 2097 2098 2099
		if (p2p_device)
			data->if_combination = hwsim_if_comb_p2p_dev[0];
		else
			data->if_combination = hwsim_if_comb[0];
2100
		data->if_combination.num_different_channels = data->channels;
2101 2102 2103 2104
	} else if (p2p_device) {
		hw->wiphy->iface_combinations = hwsim_if_comb_p2p_dev;
		hw->wiphy->n_iface_combinations =
			ARRAY_SIZE(hwsim_if_comb_p2p_dev);
2105 2106 2107 2108
	} else {
		hw->wiphy->iface_combinations = hwsim_if_comb;
		hw->wiphy->n_iface_combinations = ARRAY_SIZE(hwsim_if_comb);
	}
2109

2110 2111
	INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
	INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2112

2113 2114 2115 2116 2117 2118 2119
	hw->queues = 5;
	hw->offchannel_tx_hw_queue = 4;
	hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
				     BIT(NL80211_IFTYPE_AP) |
				     BIT(NL80211_IFTYPE_P2P_CLIENT) |
				     BIT(NL80211_IFTYPE_P2P_GO) |
				     BIT(NL80211_IFTYPE_ADHOC) |
2120 2121 2122 2123
				     BIT(NL80211_IFTYPE_MESH_POINT);

	if (p2p_device)
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_DEVICE);
2124

2125 2126 2127 2128 2129
	hw->flags = IEEE80211_HW_MFP_CAPABLE |
		    IEEE80211_HW_SIGNAL_DBM |
		    IEEE80211_HW_AMPDU_AGGREGATION |
		    IEEE80211_HW_WANT_MONITOR_VIF |
		    IEEE80211_HW_QUEUE_CONTROL |
2130 2131
		    IEEE80211_HW_SUPPORTS_HT_CCK_RATES |
		    IEEE80211_HW_CHANCTX_STA_CSA;
2132 2133
	if (rctbl)
		hw->flags |= IEEE80211_HW_SUPPORTS_RC_TABLE;
2134

2135 2136
	hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
			    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
2137 2138
			    WIPHY_FLAG_AP_UAPSD |
			    WIPHY_FLAG_HAS_CHANNEL_SWITCH;
2139 2140 2141 2142
	hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR |
			       NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
			       NL80211_FEATURE_STATIC_SMPS |
			       NL80211_FEATURE_DYNAMIC_SMPS;
2143

2144 2145 2146 2147
	/* ask mac80211 to reserve space for magic */
	hw->vif_data_size = sizeof(struct hwsim_vif_priv);
	hw->sta_data_size = sizeof(struct hwsim_sta_priv);
	hw->chanctx_data_size = sizeof(struct hwsim_chanctx_priv);
2148

2149 2150 2151 2152 2153
	memcpy(data->channels_2ghz, hwsim_channels_2ghz,
		sizeof(hwsim_channels_2ghz));
	memcpy(data->channels_5ghz, hwsim_channels_5ghz,
		sizeof(hwsim_channels_5ghz));
	memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
2154

2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
	for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) {
		struct ieee80211_supported_band *sband = &data->bands[band];
		switch (band) {
		case IEEE80211_BAND_2GHZ:
			sband->channels = data->channels_2ghz;
			sband->n_channels = ARRAY_SIZE(hwsim_channels_2ghz);
			sband->bitrates = data->rates;
			sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
			break;
		case IEEE80211_BAND_5GHZ:
			sband->channels = data->channels_5ghz;
			sband->n_channels = ARRAY_SIZE(hwsim_channels_5ghz);
			sband->bitrates = data->rates + 4;
			sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4;
			break;
		default:
			continue;
		}
2173

2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185
		sband->ht_cap.ht_supported = true;
		sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
				    IEEE80211_HT_CAP_GRN_FLD |
				    IEEE80211_HT_CAP_SGI_40 |
				    IEEE80211_HT_CAP_DSSSCCK40;
		sband->ht_cap.ampdu_factor = 0x3;
		sband->ht_cap.ampdu_density = 0x6;
		memset(&sband->ht_cap.mcs, 0,
		       sizeof(sband->ht_cap.mcs));
		sband->ht_cap.mcs.rx_mask[0] = 0xff;
		sband->ht_cap.mcs.rx_mask[1] = 0xff;
		sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
2186

2187
		hw->wiphy->bands[band] = sband;
2188

2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214
		sband->vht_cap.vht_supported = true;
		sband->vht_cap.cap =
			IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
			IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ |
			IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
			IEEE80211_VHT_CAP_RXLDPC |
			IEEE80211_VHT_CAP_SHORT_GI_80 |
			IEEE80211_VHT_CAP_SHORT_GI_160 |
			IEEE80211_VHT_CAP_TXSTBC |
			IEEE80211_VHT_CAP_RXSTBC_1 |
			IEEE80211_VHT_CAP_RXSTBC_2 |
			IEEE80211_VHT_CAP_RXSTBC_3 |
			IEEE80211_VHT_CAP_RXSTBC_4 |
			IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
		sband->vht_cap.vht_mcs.rx_mcs_map =
			cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_8 << 0 |
				    IEEE80211_VHT_MCS_SUPPORT_0_8 << 2 |
				    IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
				    IEEE80211_VHT_MCS_SUPPORT_0_8 << 6 |
				    IEEE80211_VHT_MCS_SUPPORT_0_8 << 8 |
				    IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 |
				    IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 |
				    IEEE80211_VHT_MCS_SUPPORT_0_8 << 14);
		sband->vht_cap.vht_mcs.tx_mcs_map =
			sband->vht_cap.vht_mcs.rx_mcs_map;
	}
2215

2216 2217 2218
	/* By default all radios belong to the first group */
	data->group = 1;
	mutex_init(&data->mutex);
2219

2220 2221 2222
	/* Enable frame retransmissions for lossy channels */
	hw->max_rates = 4;
	hw->max_rate_tries = 11;
2223

2224 2225 2226 2227 2228 2229 2230 2231
	if (reg_strict)
		hw->wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
	if (regd) {
		hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
		wiphy_apply_custom_regulatory(hw->wiphy, regd);
		/* give the regulatory workqueue a chance to run */
		schedule_timeout_interruptible(1);
	}
2232

2233 2234 2235 2236 2237 2238
	err = ieee80211_register_hw(hw);
	if (err < 0) {
		printk(KERN_DEBUG "mac80211_hwsim: ieee80211_register_hw failed (%d)\n",
		       err);
		goto failed_hw;
	}
2239

2240
	wiphy_debug(hw->wiphy, "hwaddr %pM registered\n", hw->wiphy->perm_addr);
2241

2242 2243
	if (reg_alpha2)
		regulatory_hint(hw->wiphy, reg_alpha2);
2244

2245 2246 2247 2248
	data->debugfs = debugfs_create_dir("hwsim", hw->wiphy->debugfsdir);
	debugfs_create_file("ps", 0666, data->debugfs, data, &hwsim_fops_ps);
	debugfs_create_file("group", 0666, data->debugfs, data,
			    &hwsim_fops_group);
2249
	if (!data->use_chanctx)
2250 2251 2252
		debugfs_create_file("dfs_simulate_radar", 0222,
				    data->debugfs,
				    data, &hwsim_simulate_radar);
2253

2254 2255 2256
	tasklet_hrtimer_init(&data->beacon_timer,
			     mac80211_hwsim_beacon,
			     CLOCK_MONOTONIC_RAW, HRTIMER_MODE_ABS);
2257

2258 2259 2260
	spin_lock_bh(&hwsim_radio_lock);
	list_add_tail(&data->list, &hwsim_radios);
	spin_unlock_bh(&hwsim_radio_lock);
2261

2262
	return idx;
2263

2264 2265 2266 2267 2268 2269
failed_hw:
	device_unregister(data->dev);
failed_drvdata:
	ieee80211_free_hw(hw);
failed:
	return err;
2270 2271
}

2272
static void mac80211_hwsim_destroy_radio(struct mac80211_hwsim_data *data)
2273
{
2274 2275 2276 2277 2278
	debugfs_remove_recursive(data->debugfs);
	ieee80211_unregister_hw(data->hw);
	device_release_driver(data->dev);
	device_unregister(data->dev);
	ieee80211_free_hw(data->hw);
2279 2280
}

2281
static void mac80211_hwsim_free(void)
2282
{
2283
	struct mac80211_hwsim_data *data;
2284

2285 2286 2287 2288 2289 2290 2291 2292
	spin_lock_bh(&hwsim_radio_lock);
	while ((data = list_first_entry_or_null(&hwsim_radios,
						struct mac80211_hwsim_data,
						list))) {
		list_del(&data->list);
		spin_unlock_bh(&hwsim_radio_lock);
		mac80211_hwsim_destroy_radio(data);
		spin_lock_bh(&hwsim_radio_lock);
2293
	}
2294 2295
	spin_unlock_bh(&hwsim_radio_lock);
	class_destroy(hwsim_class);
2296 2297
}

2298 2299 2300 2301 2302 2303
static const struct net_device_ops hwsim_netdev_ops = {
	.ndo_start_xmit 	= hwsim_mon_xmit,
	.ndo_change_mtu		= eth_change_mtu,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
};
D
Daniel Wagner 已提交
2304

2305
static void hwsim_mon_setup(struct net_device *dev)
D
Daniel Wagner 已提交
2306
{
2307 2308 2309 2310 2311 2312 2313
	dev->netdev_ops = &hwsim_netdev_ops;
	dev->destructor = free_netdev;
	ether_setup(dev);
	dev->tx_queue_len = 0;
	dev->type = ARPHRD_IEEE80211_RADIOTAP;
	memset(dev->dev_addr, 0, ETH_ALEN);
	dev->dev_addr[0] = 0x12;
D
Daniel Wagner 已提交
2314 2315
}

2316
static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr)
2317 2318 2319 2320 2321 2322
{
	struct mac80211_hwsim_data *data;
	bool _found = false;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
2323
		if (memcmp(data->addresses[1].addr, addr, ETH_ALEN) == 0) {
2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
			_found = true;
			break;
		}
	}
	spin_unlock_bh(&hwsim_radio_lock);

	if (!_found)
		return NULL;

	return data;
}

static int hwsim_tx_info_frame_received_nl(struct sk_buff *skb_2,
					   struct genl_info *info)
{

	struct ieee80211_hdr *hdr;
	struct mac80211_hwsim_data *data2;
	struct ieee80211_tx_info *txi;
	struct hwsim_tx_rate *tx_attempts;
2344
	unsigned long ret_skb_ptr;
2345
	struct sk_buff *skb, *tmp;
2346
	const u8 *src;
2347 2348 2349 2350
	unsigned int hwsim_flags;
	int i;
	bool found = false;

2351 2352 2353
	if (info->snd_portid != wmediumd_portid)
		return -EINVAL;

2354
	if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
2355 2356 2357
	    !info->attrs[HWSIM_ATTR_FLAGS] ||
	    !info->attrs[HWSIM_ATTR_COOKIE] ||
	    !info->attrs[HWSIM_ATTR_TX_INFO])
2358 2359
		goto out;

2360
	src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
2361
	hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
2362
	ret_skb_ptr = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
2363 2364

	data2 = get_hwsim_data_ref_from_addr(src);
2365
	if (!data2)
2366 2367 2368 2369
		goto out;

	/* look for the skb matching the cookie passed back from user */
	skb_queue_walk_safe(&data2->pending, skb, tmp) {
2370
		if ((unsigned long)skb == ret_skb_ptr) {
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
			skb_unlink(skb, &data2->pending);
			found = true;
			break;
		}
	}

	/* not found */
	if (!found)
		goto out;

	/* Tx info received because the frame was broadcasted on user space,
	 so we get all the necessary info: tx attempts and skb control buff */

	tx_attempts = (struct hwsim_tx_rate *)nla_data(
		       info->attrs[HWSIM_ATTR_TX_INFO]);

	/* now send back TX status */
	txi = IEEE80211_SKB_CB(skb);

	ieee80211_tx_info_clear_status(txi);

	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
		txi->status.rates[i].idx = tx_attempts[i].idx;
		txi->status.rates[i].count = tx_attempts[i].count;
		/*txi->status.rates[i].flags = 0;*/
	}

	txi->status.ack_signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);

	if (!(hwsim_flags & HWSIM_TX_CTL_NO_ACK) &&
	   (hwsim_flags & HWSIM_TX_STAT_ACK)) {
		if (skb->len >= 16) {
			hdr = (struct ieee80211_hdr *) skb->data;
2404
			mac80211_hwsim_monitor_ack(data2->channel,
2405
						   hdr->addr2);
2406
		}
2407
		txi->flags |= IEEE80211_TX_STAT_ACK;
2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
	}
	ieee80211_tx_status_irqsafe(data2->hw, skb);
	return 0;
out:
	return -EINVAL;

}

static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2,
					  struct genl_info *info)
{

2420
	struct mac80211_hwsim_data *data2;
2421
	struct ieee80211_rx_status rx_status;
2422
	const u8 *dst;
2423
	int frame_data_len;
2424
	void *frame_data;
2425 2426
	struct sk_buff *skb = NULL;

2427 2428 2429
	if (info->snd_portid != wmediumd_portid)
		return -EINVAL;

2430
	if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
2431 2432 2433
	    !info->attrs[HWSIM_ATTR_FRAME] ||
	    !info->attrs[HWSIM_ATTR_RX_RATE] ||
	    !info->attrs[HWSIM_ATTR_SIGNAL])
2434 2435
		goto out;

2436
	dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
2437
	frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
2438
	frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
2439 2440 2441 2442 2443 2444

	/* Allocate new skb here */
	skb = alloc_skb(frame_data_len, GFP_KERNEL);
	if (skb == NULL)
		goto err;

2445
	if (frame_data_len > IEEE80211_MAX_DATA_LEN)
2446 2447
		goto err;

2448 2449
	/* Copy the data */
	memcpy(skb_put(skb, frame_data_len), frame_data, frame_data_len);
2450

2451 2452
	data2 = get_hwsim_data_ref_from_addr(dst);
	if (!data2)
2453 2454 2455 2456
		goto out;

	/* check if radio is configured properly */

2457
	if (data2->idle || !data2->started)
2458 2459
		goto out;

2460
	/* A frame is received from user space */
2461 2462 2463 2464 2465 2466 2467
	memset(&rx_status, 0, sizeof(rx_status));
	rx_status.freq = data2->channel->center_freq;
	rx_status.band = data2->channel->band;
	rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]);
	rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);

	memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
2468 2469
	data2->rx_pkts++;
	data2->rx_bytes += skb->len;
2470 2471 2472 2473
	ieee80211_rx_irqsafe(data2->hw, skb);

	return 0;
err:
2474
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
2475 2476 2477 2478 2479 2480 2481 2482
out:
	dev_kfree_skb(skb);
	return -EINVAL;
}

static int hwsim_register_received_nl(struct sk_buff *skb_2,
				      struct genl_info *info)
{
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498
	struct mac80211_hwsim_data *data;
	int chans = 1;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list)
		chans = max(chans, data->channels);
	spin_unlock_bh(&hwsim_radio_lock);

	/* In the future we should revise the userspace API and allow it
	 * to set a flag that it does support multi-channel, then we can
	 * let this pass conditionally on the flag.
	 * For current userspace, prohibit it since it won't work right.
	 */
	if (chans > 1)
		return -EOPNOTSUPP;

2499 2500
	if (wmediumd_portid)
		return -EBUSY;
2501

2502
	wmediumd_portid = info->snd_portid;
2503 2504

	printk(KERN_DEBUG "mac80211_hwsim: received a REGISTER, "
2505
	       "switching to wmediumd mode with pid %d\n", info->snd_portid);
2506 2507 2508 2509

	return 0;
}

2510 2511 2512
static int hwsim_create_radio_nl(struct sk_buff *msg, struct genl_info *info)
{
	unsigned int chans = channels;
2513 2514 2515
	const char *alpha2 = NULL;
	const struct ieee80211_regdomain *regd = NULL;
	bool reg_strict = info->attrs[HWSIM_ATTR_REG_STRICT_REG];
2516
	bool p2p_device = info->attrs[HWSIM_ATTR_SUPPORT_P2P_DEVICE];
2517
	bool destroy_on_close = info->attrs[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE];
2518
	bool use_chanctx;
2519 2520 2521 2522

	if (info->attrs[HWSIM_ATTR_CHANNELS])
		chans = nla_get_u32(info->attrs[HWSIM_ATTR_CHANNELS]);

2523 2524 2525 2526 2527
	if (info->attrs[HWSIM_ATTR_USE_CHANCTX])
		use_chanctx = true;
	else
		use_chanctx = (chans > 1);

2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
	if (info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2])
		alpha2 = nla_data(info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]);

	if (info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]) {
		u32 idx = nla_get_u32(info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]);

		if (idx >= ARRAY_SIZE(hwsim_world_regdom_custom))
			return -EINVAL;
		regd = hwsim_world_regdom_custom[idx];
	}

2539
	return mac80211_hwsim_create_radio(chans, alpha2, regd, reg_strict,
2540 2541
					   p2p_device, use_chanctx,
					   destroy_on_close, info->snd_portid);
2542 2543 2544 2545 2546
}

static int hwsim_destroy_radio_nl(struct sk_buff *msg, struct genl_info *info)
{
	struct mac80211_hwsim_data *data;
2547 2548
	s64 idx = -1;
	const char *hwname = NULL;
2549

2550 2551 2552 2553 2554
	if (info->attrs[HWSIM_ATTR_RADIO_ID])
		idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);
	else if (info->attrs[HWSIM_ATTR_RADIO_NAME])
		hwname = (void *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]);
	else
2555 2556 2557 2558
		return -EINVAL;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
2559 2560 2561 2562 2563 2564 2565 2566 2567
		if (idx >= 0) {
			if (data->idx != idx)
				continue;
		} else {
			if (hwname &&
			    strcmp(hwname, wiphy_name(data->hw->wiphy)))
				continue;
		}

2568 2569 2570 2571 2572 2573 2574 2575
		list_del(&data->list);
		spin_unlock_bh(&hwsim_radio_lock);
		mac80211_hwsim_destroy_radio(data);
		return 0;
	}
	spin_unlock_bh(&hwsim_radio_lock);

	return -ENODEV;
2576 2577 2578
}

/* Generic Netlink operations array */
2579
static const struct genl_ops hwsim_ops[] = {
2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
	{
		.cmd = HWSIM_CMD_REGISTER,
		.policy = hwsim_genl_policy,
		.doit = hwsim_register_received_nl,
		.flags = GENL_ADMIN_PERM,
	},
	{
		.cmd = HWSIM_CMD_FRAME,
		.policy = hwsim_genl_policy,
		.doit = hwsim_cloned_frame_received_nl,
	},
	{
		.cmd = HWSIM_CMD_TX_INFO_FRAME,
		.policy = hwsim_genl_policy,
		.doit = hwsim_tx_info_frame_received_nl,
	},
2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607
	{
		.cmd = HWSIM_CMD_CREATE_RADIO,
		.policy = hwsim_genl_policy,
		.doit = hwsim_create_radio_nl,
		.flags = GENL_ADMIN_PERM,
	},
	{
		.cmd = HWSIM_CMD_DESTROY_RADIO,
		.policy = hwsim_genl_policy,
		.doit = hwsim_destroy_radio_nl,
		.flags = GENL_ADMIN_PERM,
	},
2608 2609
};

2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632
static void destroy_radio(struct work_struct *work)
{
	struct mac80211_hwsim_data *data =
		container_of(work, struct mac80211_hwsim_data, destroy_work);

	mac80211_hwsim_destroy_radio(data);
}

static void remove_user_radios(u32 portid)
{
	struct mac80211_hwsim_data *entry, *tmp;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry_safe(entry, tmp, &hwsim_radios, list) {
		if (entry->destroy_on_close && entry->portid == portid) {
			list_del(&entry->list);
			INIT_WORK(&entry->destroy_work, destroy_radio);
			schedule_work(&entry->destroy_work);
		}
	}
	spin_unlock_bh(&hwsim_radio_lock);
}

2633 2634 2635 2636 2637 2638 2639 2640 2641
static int mac80211_hwsim_netlink_notify(struct notifier_block *nb,
					 unsigned long state,
					 void *_notify)
{
	struct netlink_notify *notify = _notify;

	if (state != NETLINK_URELEASE)
		return NOTIFY_DONE;

2642 2643
	remove_user_radios(notify->portid);

2644
	if (notify->portid == wmediumd_portid) {
2645 2646
		printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
		       " socket, switching to perfect channel medium\n");
2647
		wmediumd_portid = 0;
2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659
	}
	return NOTIFY_DONE;

}

static struct notifier_block hwsim_netlink_notifier = {
	.notifier_call = mac80211_hwsim_netlink_notify,
};

static int hwsim_init_netlink(void)
{
	int rc;
2660

2661 2662
	printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");

2663
	rc = genl_register_family_with_ops(&hwsim_genl_family, hwsim_ops);
2664 2665 2666 2667 2668 2669 2670 2671 2672 2673
	if (rc)
		goto failure;

	rc = netlink_register_notifier(&hwsim_netlink_notifier);
	if (rc)
		goto failure;

	return 0;

failure:
2674
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
2675 2676 2677 2678 2679 2680 2681 2682
	return -EINVAL;
}

static void hwsim_exit_netlink(void)
{
	/* unregister the notifier */
	netlink_unregister_notifier(&hwsim_netlink_notifier);
	/* unregister the family */
2683
	genl_unregister_family(&hwsim_genl_family);
2684 2685
}

2686 2687
static int __init init_mac80211_hwsim(void)
{
2688
	int i, err;
2689

2690
	if (radios < 0 || radios > 100)
2691 2692
		return -EINVAL;

2693 2694 2695
	if (channels < 1)
		return -EINVAL;

2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
	mac80211_hwsim_mchan_ops = mac80211_hwsim_ops;
	mac80211_hwsim_mchan_ops.hw_scan = mac80211_hwsim_hw_scan;
	mac80211_hwsim_mchan_ops.cancel_hw_scan = mac80211_hwsim_cancel_hw_scan;
	mac80211_hwsim_mchan_ops.sw_scan_start = NULL;
	mac80211_hwsim_mchan_ops.sw_scan_complete = NULL;
	mac80211_hwsim_mchan_ops.remain_on_channel = mac80211_hwsim_roc;
	mac80211_hwsim_mchan_ops.cancel_remain_on_channel = mac80211_hwsim_croc;
	mac80211_hwsim_mchan_ops.add_chanctx = mac80211_hwsim_add_chanctx;
	mac80211_hwsim_mchan_ops.remove_chanctx = mac80211_hwsim_remove_chanctx;
	mac80211_hwsim_mchan_ops.change_chanctx = mac80211_hwsim_change_chanctx;
	mac80211_hwsim_mchan_ops.assign_vif_chanctx =
		mac80211_hwsim_assign_vif_chanctx;
	mac80211_hwsim_mchan_ops.unassign_vif_chanctx =
		mac80211_hwsim_unassign_vif_chanctx;
2710

2711 2712
	spin_lock_init(&hwsim_radio_lock);
	INIT_LIST_HEAD(&hwsim_radios);
2713

2714
	err = platform_driver_register(&mac80211_hwsim_driver);
2715 2716 2717
	if (err)
		return err;

2718
	hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
2719 2720
	if (IS_ERR(hwsim_class)) {
		err = PTR_ERR(hwsim_class);
2721
		goto out_unregister_driver;
2722
	}
2723

2724
	for (i = 0; i < radios; i++) {
2725 2726 2727
		const char *reg_alpha2 = NULL;
		const struct ieee80211_regdomain *regd = NULL;
		bool reg_strict = false;
2728

2729 2730
		switch (regtest) {
		case HWSIM_REGTEST_DIFF_COUNTRY:
2731 2732
			if (i < ARRAY_SIZE(hwsim_alpha2s))
				reg_alpha2 = hwsim_alpha2s[i];
2733 2734 2735
			break;
		case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
			if (!i)
2736
				reg_alpha2 = hwsim_alpha2s[0];
2737 2738
			break;
		case HWSIM_REGTEST_STRICT_ALL:
2739 2740 2741
			reg_strict = true;
		case HWSIM_REGTEST_DRIVER_REG_ALL:
			reg_alpha2 = hwsim_alpha2s[0];
2742
			break;
2743 2744 2745
		case HWSIM_REGTEST_WORLD_ROAM:
			if (i == 0)
				regd = &hwsim_world_regdom_custom_01;
2746 2747
			break;
		case HWSIM_REGTEST_CUSTOM_WORLD:
2748 2749
			regd = &hwsim_world_regdom_custom_01;
			break;
2750
		case HWSIM_REGTEST_CUSTOM_WORLD_2:
2751 2752 2753 2754
			if (i == 0)
				regd = &hwsim_world_regdom_custom_01;
			else if (i == 1)
				regd = &hwsim_world_regdom_custom_02;
2755 2756
			break;
		case HWSIM_REGTEST_STRICT_FOLLOW:
2757 2758 2759 2760
			if (i == 0) {
				reg_strict = true;
				reg_alpha2 = hwsim_alpha2s[0];
			}
2761 2762
			break;
		case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
2763 2764 2765 2766 2767 2768
			if (i == 0) {
				reg_strict = true;
				reg_alpha2 = hwsim_alpha2s[0];
			} else if (i == 1) {
				reg_alpha2 = hwsim_alpha2s[1];
			}
2769 2770
			break;
		case HWSIM_REGTEST_ALL:
2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788
			switch (i) {
			case 0:
				regd = &hwsim_world_regdom_custom_01;
				break;
			case 1:
				regd = &hwsim_world_regdom_custom_02;
				break;
			case 2:
				reg_alpha2 = hwsim_alpha2s[0];
				break;
			case 3:
				reg_alpha2 = hwsim_alpha2s[1];
				break;
			case 4:
				reg_strict = true;
				reg_alpha2 = hwsim_alpha2s[2];
				break;
			}
2789 2790 2791 2792 2793
			break;
		default:
			break;
		}

2794
		err = mac80211_hwsim_create_radio(channels, reg_alpha2,
2795
						  regd, reg_strict,
2796
						  support_p2p_device,
2797
						  channels > 1, false, 0);
2798
		if (err < 0)
2799
			goto out_free_radios;
2800 2801
	}

2802 2803
	hwsim_mon = alloc_netdev(0, "hwsim%d", NET_NAME_UNKNOWN,
				 hwsim_mon_setup);
2804 2805
	if (hwsim_mon == NULL) {
		err = -ENOMEM;
2806
		goto out_free_radios;
2807
	}
2808

2809 2810
	rtnl_lock();
	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
2811 2812 2813 2814
	if (err < 0) {
		rtnl_unlock();
		goto out_free_radios;
	}
2815 2816

	err = register_netdevice(hwsim_mon);
2817 2818 2819 2820
	if (err < 0) {
		rtnl_unlock();
		goto out_free_mon;
	}
2821 2822 2823 2824
	rtnl_unlock();

	err = hwsim_init_netlink();
	if (err < 0)
2825
		goto out_free_mon;
2826

2827 2828
	return 0;

2829
out_free_mon:
2830
	free_netdev(hwsim_mon);
2831
out_free_radios:
2832
	mac80211_hwsim_free();
2833
out_unregister_driver:
2834
	platform_driver_unregister(&mac80211_hwsim_driver);
2835 2836
	return err;
}
2837
module_init(init_mac80211_hwsim);
2838 2839 2840

static void __exit exit_mac80211_hwsim(void)
{
2841
	printk(KERN_DEBUG "mac80211_hwsim: unregister radios\n");
2842

2843 2844
	hwsim_exit_netlink();

2845
	mac80211_hwsim_free();
2846
	unregister_netdev(hwsim_mon);
2847
	platform_driver_unregister(&mac80211_hwsim_driver);
2848 2849
}
module_exit(exit_mac80211_hwsim);