mac80211_hwsim.c 73.2 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 418 419 420 421 422
	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;

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

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

	int power_level;
444 445

	/* difference between this hw's clock and the real clock, in usecs */
446
	s64 tsf_offset;
447
	s64 bcn_delta;
448 449
	/* absolute beacon transmission time. Used to cover up "tx" delay. */
	u64 abs_bcn_ts;
450 451 452 453 454
};


struct hwsim_radiotap_hdr {
	struct ieee80211_radiotap_header hdr;
455
	__le64 rt_tsft;
456 457 458 459
	u8 rt_flags;
	u8 rt_rate;
	__le16 rt_channel;
	__le16 rt_chbitmask;
460
} __packed;
461

462 463 464 465 466 467 468 469
struct hwsim_radiotap_ack_hdr {
	struct ieee80211_radiotap_header hdr;
	u8 rt_flags;
	u8 pad;
	__le16 rt_channel;
	__le16 rt_chbitmask;
} __packed;

470 471 472 473 474 475 476 477 478 479 480
/* 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 */

481
static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
482 483
	[HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
	[HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
484 485 486 487 488 489
	[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,
490 491
				 .len = IEEE80211_TX_MAX_RATES *
					sizeof(struct hwsim_tx_rate)},
492
	[HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
493 494
	[HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 },
	[HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 },
495 496 497
	[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 },
498
	[HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG },
499
};
500

501 502 503 504 505 506 507 508 509 510 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
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");

656 657
static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
					struct net_device *dev)
658 659 660
{
	/* TODO: allow packet injection */
	dev_kfree_skb(skb);
661
	return NETDEV_TX_OK;
662 663
}

664 665 666 667 668
static inline u64 mac80211_hwsim_get_tsf_raw(void)
{
	return ktime_to_us(ktime_get_real());
}

669 670
static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
{
671
	u64 now = mac80211_hwsim_get_tsf_raw();
672 673
	return cpu_to_le64(now + data->tsf_offset);
}
674

675
static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
676
				  struct ieee80211_vif *vif)
677 678 679 680 681 682 683 684 685
{
	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;
686
	u64 now = mac80211_hwsim_get_tsf(hw, vif);
687
	u32 bcn_int = data->beacon_int;
688 689 690
	s64 delta = tsf - now;

	data->tsf_offset += delta;
691 692
	/* adjust after beaconing with new timestamp at old TBTT */
	data->bcn_delta = do_div(delta, bcn_int);
693 694
}

695
static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
696 697
				      struct sk_buff *tx_skb,
				      struct ieee80211_channel *chan)
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
{
	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 已提交
717 718
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_RATE) |
719
					  (1 << IEEE80211_RADIOTAP_TSFT) |
J
Jouni Malinen 已提交
720
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
721
	hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
722 723
	hdr->rt_flags = 0;
	hdr->rt_rate = txrate->bitrate / 5;
724
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
725 726 727 728 729 730 731 732 733 734 735
	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 已提交
736
	skb->protocol = htons(ETH_P_802_2);
737 738 739 740 741
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}


742 743
static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
				       const u8 *addr)
744 745
{
	struct sk_buff *skb;
746
	struct hwsim_radiotap_ack_hdr *hdr;
747 748 749 750 751 752 753 754 755 756
	u16 flags;
	struct ieee80211_hdr *hdr11;

	if (!netif_running(hwsim_mon))
		return;

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

757
	hdr = (struct hwsim_radiotap_ack_hdr *) skb_put(skb, sizeof(*hdr));
758 759 760 761 762 763
	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;
764
	hdr->pad = 0;
765
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
	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);
}

784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
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;
}
814

815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
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 &&
831
		    mac80211_hwsim_addr_match(data, skb->data + 4)) {
832 833 834 835 836 837 838 839 840
			data->ps_poll_pending = false;
			return true;
		}
		return false;
	}

	return true;
}

841 842
static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
				       struct sk_buff *my_skb,
843
				       int dst_portid)
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
{
	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 */
		while (skb_queue_len(&data->pending) >= WARN_QUEUE)
			skb_dequeue(&data->pending);
	}

863
	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
864 865 866 867 868 869 870 871 872 873
	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;
	}

874
	if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
875
		    ETH_ALEN, data->addresses[1].addr))
876
		goto nla_put_failure;
877

878
	/* We get the skb->data */
879 880
	if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
		goto nla_put_failure;
881 882 883 884 885 886 887 888 889 890

	/* 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;

891 892
	if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
		goto nla_put_failure;
893 894 895 896 897 898 899 900

	/* 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;
	}

901 902 903 904
	if (nla_put(skb, HWSIM_ATTR_TX_INFO,
		    sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
		    tx_attempts))
		goto nla_put_failure;
905 906

	/* We create a cookie to identify this skb */
907 908
	if (nla_put_u64(skb, HWSIM_ATTR_COOKIE, (unsigned long) my_skb))
		goto nla_put_failure;
909 910

	genlmsg_end(skb, msg_head);
911
	genlmsg_unicast(&init_net, skb, dst_portid);
912 913 914 915 916 917

	/* Enqueue the packet */
	skb_queue_tail(&data->pending, my_skb);
	return;

nla_put_failure:
918
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
919 920
}

921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
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,
944
				rcu_dereference(vif->chanctx_conf)->def.chan))
945 946 947 948 949
		return;

	data->receive = true;
}

950
static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
951 952
					  struct sk_buff *skb,
					  struct ieee80211_channel *chan)
953
{
954 955
	struct mac80211_hwsim_data *data = hw->priv, *data2;
	bool ack = false;
956
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
957
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
958
	struct ieee80211_rx_status rx_status;
959
	u64 now;
960 961

	memset(&rx_status, 0, sizeof(rx_status));
962
	rx_status.flag |= RX_FLAG_MACTIME_START;
963 964
	rx_status.freq = chan->center_freq;
	rx_status.band = chan->band;
965 966 967 968 969 970 971 972 973 974 975
	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;
	}
976 977 978 979
	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;
980
	/* TODO: simulate real signal strength (and optional packet loss) */
981
	rx_status.signal = data->power_level - 50;
982

983 984 985
	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);

986 987
	/* release the skb's source info */
	skb_orphan(skb);
988
	skb_dst_drop(skb);
989 990 991 992
	skb->mark = 0;
	secpath_reset(skb);
	nf_reset(skb);

993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
	/*
	 * 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();

1006
	/* Copy skb to all enabled radios that are on the current frequency */
1007 1008
	spin_lock(&hwsim_radio_lock);
	list_for_each_entry(data2, &hwsim_radios, list) {
1009
		struct sk_buff *nskb;
1010 1011 1012 1013
		struct tx_iter_data tx_iter_data = {
			.receive = false,
			.channel = chan,
		};
1014

1015
		if (data == data2)
1016
			continue;
1017

1018 1019
		if (!data2->started || (data2->idle && !data2->tmp_chan) ||
		    !hwsim_ps_rx_ok(data2, skb))
1020 1021
			continue;

1022 1023 1024 1025 1026 1027
		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(
1028 1029
				data2->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_tx_iter, &tx_iter_data);
1030 1031 1032 1033
			if (!tx_iter_data.receive)
				continue;
		}

1034 1035 1036 1037
		/*
		 * reserve some space for our vendor and the normal
		 * radiotap header, since we're copying anyway
		 */
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
		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;
		}
1057

1058
		if (mac80211_hwsim_addr_match(data2, hdr->addr1))
1059
			ack = true;
1060

1061
		rx_status.mactime = now + data2->tsf_offset;
1062

1063 1064
		memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
		ieee80211_rx_irqsafe(data2->hw, nskb);
1065
	}
1066
	spin_unlock(&hwsim_radio_lock);
1067

1068 1069 1070
	return ack;
}

1071 1072 1073
static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
			      struct ieee80211_tx_control *control,
			      struct sk_buff *skb)
1074
{
1075 1076 1077 1078
	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;
1079
	bool ack;
1080
	u32 _portid;
1081

1082
	if (WARN_ON(skb->len < 10)) {
1083
		/* Should not happen; just a sanity check for addr1 use */
1084
		ieee80211_free_txskb(hw, skb);
1085
		return;
1086 1087
	}

1088
	if (!data->use_chanctx) {
1089 1090 1091 1092 1093 1094
		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)
1095
			channel = chanctx_conf->def.chan;
1096 1097 1098 1099 1100
		else
			channel = NULL;
	}

	if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
1101
		ieee80211_free_txskb(hw, skb);
1102 1103 1104 1105 1106
		return;
	}

	if (data->idle && !data->tmp_chan) {
		wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
1107
		ieee80211_free_txskb(hw, skb);
1108 1109 1110 1111 1112 1113 1114 1115
		return;
	}

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

1116
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE)
1117 1118 1119
		ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
1120

1121
	txi->rate_driver_data[0] = channel;
1122 1123
	mac80211_hwsim_monitor_rx(hw, skb, channel);

1124
	/* wmediumd mode check */
1125
	_portid = ACCESS_ONCE(wmediumd_portid);
1126

1127 1128
	if (_portid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
1129 1130

	/* NO wmediumd detected, perfect medium simulation */
1131
	ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
1132

1133 1134
	if (ack && skb->len >= 16) {
		struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1135
		mac80211_hwsim_monitor_ack(channel, hdr->addr2);
1136
	}
1137

1138
	ieee80211_tx_info_clear_status(txi);
1139 1140 1141 1142 1143

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

1144 1145
	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
		txi->flags |= IEEE80211_TX_STAT_ACK;
1146 1147 1148 1149 1150 1151 1152
	ieee80211_tx_status_irqsafe(hw, skb);
}


static int mac80211_hwsim_start(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1153
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1154
	data->started = true;
1155 1156 1157 1158 1159 1160 1161
	return 0;
}


static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1162
	data->started = false;
T
Thomas Pedersen 已提交
1163
	tasklet_hrtimer_cancel(&data->beacon_timer);
1164
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1165 1166 1167 1168
}


static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1169
					struct ieee80211_vif *vif)
1170
{
1171
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1172 1173
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
1174
	hwsim_set_magic(vif);
1175 1176 1177 1178 1179 1180 1181

	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;

1182 1183 1184 1185
	return 0;
}


1186 1187
static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
					   struct ieee80211_vif *vif,
1188 1189
					   enum nl80211_iftype newtype,
					   bool newp2p)
1190
{
1191
	newtype = ieee80211_iftype_p2p(newtype, newp2p);
1192 1193
	wiphy_debug(hw->wiphy,
		    "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
1194 1195
		    __func__, ieee80211_vif_type_p2p(vif),
		    newtype, vif->addr);
1196 1197
	hwsim_check_magic(vif);

1198 1199 1200 1201 1202 1203
	/*
	 * interface may change from non-AP to AP in
	 * which case this needs to be set up again
	 */
	vif->cab_queue = 0;

1204 1205 1206
	return 0;
}

1207
static void mac80211_hwsim_remove_interface(
1208
	struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1209
{
1210
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1211 1212
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
1213 1214
	hwsim_check_magic(vif);
	hwsim_clear_magic(vif);
1215 1216
}

1217 1218 1219 1220 1221 1222
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan)
{
	u32 _pid = ACCESS_ONCE(wmediumd_portid);

1223
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE) {
1224 1225 1226 1227 1228 1229
		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));
	}

1230 1231 1232 1233 1234 1235 1236 1237
	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);
}
1238 1239 1240 1241

static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
				     struct ieee80211_vif *vif)
{
1242 1243 1244 1245 1246
	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;
1247 1248
	struct sk_buff *skb;

1249 1250
	hwsim_check_magic(vif);

1251
	if (vif->type != NL80211_IFTYPE_AP &&
1252 1253
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_ADHOC)
1254 1255 1256 1257 1258
		return;

	skb = ieee80211_beacon_get(hw, vif);
	if (skb == NULL)
		return;
1259
	info = IEEE80211_SKB_CB(skb);
1260
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE)
1261 1262 1263 1264
		ieee80211_get_tx_rates(vif, NULL, skb,
				       info->control.rates,
				       ARRAY_SIZE(info->control.rates));

1265 1266 1267 1268 1269 1270 1271 1272
	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);
1273

1274
	mac80211_hwsim_tx_frame(hw, skb,
1275
				rcu_dereference(vif->chanctx_conf)->def.chan);
1276 1277 1278

	if (vif->csa_active && ieee80211_csa_is_complete(vif))
		ieee80211_csa_finish(vif);
1279 1280
}

T
Thomas Pedersen 已提交
1281 1282
static enum hrtimer_restart
mac80211_hwsim_beacon(struct hrtimer *timer)
1283
{
T
Thomas Pedersen 已提交
1284 1285 1286 1287 1288 1289
	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;
1290

1291
	if (!data->started)
T
Thomas Pedersen 已提交
1292
		goto out;
1293

J
Jouni Malinen 已提交
1294
	ieee80211_iterate_active_interfaces_atomic(
1295
		hw, IEEE80211_IFACE_ITER_NORMAL,
1296
		mac80211_hwsim_beacon_tx, data);
1297

1298 1299 1300 1301 1302 1303
	/* beacon at new TBTT + beacon interval */
	if (data->bcn_delta) {
		bcn_int -= data->bcn_delta;
		data->bcn_delta = 0;
	}

T
Thomas Pedersen 已提交
1304 1305 1306 1307 1308
	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;
1309 1310
}

1311 1312 1313 1314 1315 1316 1317
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",
1318
};
1319

1320
static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1321 1322
{
	struct mac80211_hwsim_data *data = hw->priv;
1323
	struct ieee80211_conf *conf = &hw->conf;
1324 1325 1326 1327 1328 1329 1330
	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",
	};

1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
	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]);
1349

1350 1351
	data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);

1352
	data->channel = conf->chandef.chan;
1353

1354
	WARN_ON(data->channel && data->use_chanctx);
1355

1356
	data->power_level = conf->power_level;
1357
	if (!data->started || !data->beacon_int)
T
Thomas Pedersen 已提交
1358 1359
		tasklet_hrtimer_cancel(&data->beacon_timer);
	else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
1360 1361 1362 1363
		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 已提交
1364
		tasklet_hrtimer_start(&data->beacon_timer,
1365
				      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1366 1367
				      HRTIMER_MODE_REL);
	}
1368 1369 1370 1371 1372 1373 1374

	return 0;
}


static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
					    unsigned int changed_flags,
1375
					    unsigned int *total_flags,u64 multicast)
1376 1377 1378
{
	struct mac80211_hwsim_data *data = hw->priv;

1379
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389

	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;
}

1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
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)++;
}

1400 1401 1402 1403 1404
static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif,
					    struct ieee80211_bss_conf *info,
					    u32 changed)
{
1405
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1406
	struct mac80211_hwsim_data *data = hw->priv;
1407

1408
	hwsim_check_magic(vif);
1409

1410 1411
	wiphy_debug(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n",
		    __func__, changed, vif->addr);
1412

1413
	if (changed & BSS_CHANGED_BSSID) {
1414 1415
		wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n",
			    __func__, info->bssid);
1416 1417 1418
		memcpy(vp->bssid, info->bssid, ETH_ALEN);
	}

1419
	if (changed & BSS_CHANGED_ASSOC) {
1420 1421
		wiphy_debug(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
			    info->assoc, info->aid);
1422 1423
		vp->assoc = info->assoc;
		vp->aid = info->aid;
1424 1425
	}

1426
	if (changed & BSS_CHANGED_BEACON_INT) {
1427
		wiphy_debug(hw->wiphy, "  BCNINT: %d\n", info->beacon_int);
T
Thomas Pedersen 已提交
1428 1429 1430 1431 1432
		data->beacon_int = info->beacon_int * 1024;
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED) {
		wiphy_debug(hw->wiphy, "  BCN EN: %d\n", info->enable_beacon);
1433
		vp->bcn_en = info->enable_beacon;
T
Thomas Pedersen 已提交
1434 1435 1436
		if (data->started &&
		    !hrtimer_is_queued(&data->beacon_timer.timer) &&
		    info->enable_beacon) {
1437 1438
			u64 tsf, until_tbtt;
			u32 bcn_int;
T
Thomas Pedersen 已提交
1439 1440
			if (WARN_ON(!data->beacon_int))
				data->beacon_int = 1000 * 1024;
1441 1442 1443
			tsf = mac80211_hwsim_get_tsf(hw, vif);
			bcn_int = data->beacon_int;
			until_tbtt = bcn_int - do_div(tsf, bcn_int);
T
Thomas Pedersen 已提交
1444
			tasklet_hrtimer_start(&data->beacon_timer,
1445
					      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1446
					      HRTIMER_MODE_REL);
1447 1448
		} else if (!info->enable_beacon) {
			unsigned int count = 0;
1449
			ieee80211_iterate_active_interfaces_atomic(
1450 1451 1452 1453 1454 1455 1456
				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);
		}
1457 1458
	}

1459
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1460 1461
		wiphy_debug(hw->wiphy, "  ERP_CTS_PROT: %d\n",
			    info->use_cts_prot);
1462 1463 1464
	}

	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1465 1466
		wiphy_debug(hw->wiphy, "  ERP_PREAMBLE: %d\n",
			    info->use_short_preamble);
1467 1468 1469
	}

	if (changed & BSS_CHANGED_ERP_SLOT) {
1470
		wiphy_debug(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
1471 1472 1473
	}

	if (changed & BSS_CHANGED_HT) {
1474 1475
		wiphy_debug(hw->wiphy, "  HT: op_mode=0x%x\n",
			    info->ht_operation_mode);
1476 1477 1478
	}

	if (changed & BSS_CHANGED_BASIC_RATES) {
1479 1480
		wiphy_debug(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
			    (unsigned long long) info->basic_rates);
1481
	}
1482 1483 1484

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

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
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;
}

1507 1508
static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
1509 1510
				      enum sta_notify_cmd cmd,
				      struct ieee80211_sta *sta)
1511 1512
{
	hwsim_check_magic(vif);
1513

1514
	switch (cmd) {
1515 1516 1517 1518
	case STA_NOTIFY_SLEEP:
	case STA_NOTIFY_AWAKE:
		/* TODO: make good use of these flags */
		break;
1519 1520 1521
	default:
		WARN(1, "Invalid sta notify: %d\n", cmd);
		break;
1522 1523 1524 1525 1526 1527 1528 1529 1530
	}
}

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

1533
static int mac80211_hwsim_conf_tx(
1534 1535
	struct ieee80211_hw *hw,
	struct ieee80211_vif *vif, u16 queue,
1536 1537
	const struct ieee80211_tx_queue_params *params)
{
1538 1539 1540 1541 1542
	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);
1543 1544 1545
	return 0;
}

1546 1547 1548 1549 1550 1551
static int mac80211_hwsim_get_survey(
	struct ieee80211_hw *hw, int idx,
	struct survey_info *survey)
{
	struct ieee80211_conf *conf = &hw->conf;

1552
	wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx);
1553 1554 1555 1556 1557

	if (idx != 0)
		return -ENOENT;

	/* Current channel */
1558
	survey->channel = conf->chandef.chan;
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571

	/*
	 * 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;
}

1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
#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,
1592 1593
	HWSIM_TM_CMD_STOP_QUEUES	= 2,
	HWSIM_TM_CMD_WAKE_QUEUES	= 3,
1594 1595 1596 1597 1598 1599 1600
};

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 已提交
1601
static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1602
				       struct ieee80211_vif *vif,
J
Johannes Berg 已提交
1603
				       void *data, int len)
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
{
	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;
1629 1630
		if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
			goto nla_put_failure;
1631
		return cfg80211_testmode_reply(skb);
1632 1633 1634 1635 1636 1637
	case HWSIM_TM_CMD_STOP_QUEUES:
		ieee80211_stop_queues(hw);
		return 0;
	case HWSIM_TM_CMD_WAKE_QUEUES:
		ieee80211_wake_queues(hw);
		return 0;
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
	default:
		return -EOPNOTSUPP;
	}

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

1648 1649 1650
static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
				       enum ieee80211_ampdu_mlme_action action,
1651 1652
				       struct ieee80211_sta *sta, u16 tid, u16 *ssn,
				       u8 buf_size)
1653 1654 1655 1656 1657
{
	switch (action) {
	case IEEE80211_AMPDU_TX_START:
		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
		break;
1658 1659 1660
	case IEEE80211_AMPDU_TX_STOP_CONT:
	case IEEE80211_AMPDU_TX_STOP_FLUSH:
	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
		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;
}

1675 1676 1677
static void mac80211_hwsim_flush(struct ieee80211_hw *hw,
				 struct ieee80211_vif *vif,
				 u32 queues, bool drop)
1678
{
1679
	/* Not implemented, queues only on kernel side */
1680 1681
}

1682
static void hw_scan_work(struct work_struct *work)
1683
{
1684 1685 1686 1687
	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;
1688

1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
	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];
1704
	if (hwsim->tmp_chan->flags & IEEE80211_CHAN_NO_IR ||
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
	    !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,
1717
						       req->ie_len);
1718 1719
			if (!probe)
				continue;
1720 1721 1722 1723 1724

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

1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
			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);
1735 1736 1737
}

static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
1738
				  struct ieee80211_vif *vif,
1739 1740
				  struct cfg80211_scan_request *req)
{
1741
	struct mac80211_hwsim_data *hwsim = hw->priv;
1742

1743 1744 1745 1746 1747 1748 1749 1750 1751
	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);
1752

1753
	wiphy_debug(hw->wiphy, "hwsim hw_scan request\n");
1754

1755
	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
1756 1757 1758 1759

	return 0;
}

1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776
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);
}

1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
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");
1802
	hwsim->scanning = false;
1803 1804 1805 1806

	mutex_unlock(&hwsim->mutex);
}

1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
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,
1821
			      struct ieee80211_vif *vif,
1822
			      struct ieee80211_channel *chan,
1823 1824
			      int duration,
			      enum ieee80211_roc_type type)
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
{
	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);
1866 1867 1868 1869
	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);
1870 1871 1872 1873 1874 1875
	return 0;
}

static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
					  struct ieee80211_chanctx_conf *ctx)
{
1876 1877 1878 1879
	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);
1880 1881 1882 1883 1884 1885 1886 1887 1888
	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);
1889 1890 1891 1892
	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);
1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912
}

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);
}

1913
static const struct ieee80211_ops mac80211_hwsim_ops = {
1914 1915 1916 1917
	.tx = mac80211_hwsim_tx,
	.start = mac80211_hwsim_start,
	.stop = mac80211_hwsim_stop,
	.add_interface = mac80211_hwsim_add_interface,
1918
	.change_interface = mac80211_hwsim_change_interface,
1919 1920 1921
	.remove_interface = mac80211_hwsim_remove_interface,
	.config = mac80211_hwsim_config,
	.configure_filter = mac80211_hwsim_configure_filter,
1922
	.bss_info_changed = mac80211_hwsim_bss_info_changed,
1923 1924
	.sta_add = mac80211_hwsim_sta_add,
	.sta_remove = mac80211_hwsim_sta_remove,
1925
	.sta_notify = mac80211_hwsim_sta_notify,
1926
	.set_tim = mac80211_hwsim_set_tim,
1927
	.conf_tx = mac80211_hwsim_conf_tx,
1928
	.get_survey = mac80211_hwsim_get_survey,
1929
	CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)
1930
	.ampdu_action = mac80211_hwsim_ampdu_action,
1931 1932
	.sw_scan_start = mac80211_hwsim_sw_scan,
	.sw_scan_complete = mac80211_hwsim_sw_scan_complete,
1933
	.flush = mac80211_hwsim_flush,
1934 1935
	.get_tsf = mac80211_hwsim_get_tsf,
	.set_tsf = mac80211_hwsim_set_tsf,
1936 1937
};

1938
static struct ieee80211_ops mac80211_hwsim_mchan_ops;
1939

1940 1941
static int mac80211_hwsim_create_radio(int channels, const char *reg_alpha2,
				       const struct ieee80211_regdomain *regd,
1942 1943
				       bool reg_strict, bool p2p_device,
				       bool use_chanctx)
1944
{
1945 1946
	int err;
	u8 addr[ETH_ALEN];
1947
	struct mac80211_hwsim_data *data;
1948 1949 1950 1951
	struct ieee80211_hw *hw;
	enum ieee80211_band band;
	const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
	int idx;
1952

1953 1954 1955
	if (WARN_ON(channels > 1 && !use_chanctx))
		return -EINVAL;

1956
	spin_lock_bh(&hwsim_radio_lock);
1957
	idx = hwsim_radio_idx++;
1958 1959
	spin_unlock_bh(&hwsim_radio_lock);

1960
	if (use_chanctx)
1961 1962 1963 1964 1965 1966 1967 1968 1969
		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;
1970

1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
	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;
1985 1986
	}

1987
	skb_queue_head_init(&data->pending);
1988

1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
	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;
1999

2000
	data->channels = channels;
2001
	data->use_chanctx = use_chanctx;
2002
	data->idx = idx;
2003

2004
	if (data->use_chanctx) {
2005 2006 2007 2008 2009 2010
		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;
2011 2012 2013 2014
		if (p2p_device)
			data->if_combination = hwsim_if_comb_p2p_dev[0];
		else
			data->if_combination = hwsim_if_comb[0];
2015
		data->if_combination.num_different_channels = data->channels;
2016 2017 2018 2019
	} 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);
2020 2021 2022 2023
	} else {
		hw->wiphy->iface_combinations = hwsim_if_comb;
		hw->wiphy->n_iface_combinations = ARRAY_SIZE(hwsim_if_comb);
	}
2024

2025 2026
	INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
	INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2027

2028 2029 2030 2031 2032 2033 2034
	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) |
2035 2036 2037 2038
				     BIT(NL80211_IFTYPE_MESH_POINT);

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

2040 2041 2042 2043 2044 2045 2046
	hw->flags = IEEE80211_HW_MFP_CAPABLE |
		    IEEE80211_HW_SIGNAL_DBM |
		    IEEE80211_HW_SUPPORTS_STATIC_SMPS |
		    IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
		    IEEE80211_HW_AMPDU_AGGREGATION |
		    IEEE80211_HW_WANT_MONITOR_VIF |
		    IEEE80211_HW_QUEUE_CONTROL |
2047 2048
		    IEEE80211_HW_SUPPORTS_HT_CCK_RATES |
		    IEEE80211_HW_CHANCTX_STA_CSA;
2049 2050
	if (rctbl)
		hw->flags |= IEEE80211_HW_SUPPORTS_RC_TABLE;
2051

2052 2053
	hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
			    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
2054 2055
			    WIPHY_FLAG_AP_UAPSD |
			    WIPHY_FLAG_HAS_CHANNEL_SWITCH;
2056
	hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR;
2057
	hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
2058

2059 2060 2061 2062
	/* 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);
2063

2064 2065 2066 2067 2068
	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));
2069

2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
	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;
		}
2088

2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
		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;
2101

2102
		hw->wiphy->bands[band] = sband;
2103

2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
		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;
	}
2130

2131 2132 2133
	/* By default all radios belong to the first group */
	data->group = 1;
	mutex_init(&data->mutex);
2134

2135 2136 2137
	/* Enable frame retransmissions for lossy channels */
	hw->max_rates = 4;
	hw->max_rate_tries = 11;
2138

2139 2140 2141 2142 2143 2144 2145 2146
	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);
	}
2147

2148 2149 2150 2151 2152 2153
	err = ieee80211_register_hw(hw);
	if (err < 0) {
		printk(KERN_DEBUG "mac80211_hwsim: ieee80211_register_hw failed (%d)\n",
		       err);
		goto failed_hw;
	}
2154

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

2157 2158
	if (reg_alpha2)
		regulatory_hint(hw->wiphy, reg_alpha2);
2159

2160 2161 2162 2163
	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);
2164
	if (!data->use_chanctx)
2165 2166 2167
		debugfs_create_file("dfs_simulate_radar", 0222,
				    data->debugfs,
				    data, &hwsim_simulate_radar);
2168

2169 2170 2171
	tasklet_hrtimer_init(&data->beacon_timer,
			     mac80211_hwsim_beacon,
			     CLOCK_MONOTONIC_RAW, HRTIMER_MODE_ABS);
2172

2173 2174 2175
	spin_lock_bh(&hwsim_radio_lock);
	list_add_tail(&data->list, &hwsim_radios);
	spin_unlock_bh(&hwsim_radio_lock);
2176

2177
	return idx;
2178

2179 2180 2181 2182 2183 2184
failed_hw:
	device_unregister(data->dev);
failed_drvdata:
	ieee80211_free_hw(hw);
failed:
	return err;
2185 2186
}

2187
static void mac80211_hwsim_destroy_radio(struct mac80211_hwsim_data *data)
2188
{
2189 2190 2191 2192 2193
	debugfs_remove_recursive(data->debugfs);
	ieee80211_unregister_hw(data->hw);
	device_release_driver(data->dev);
	device_unregister(data->dev);
	ieee80211_free_hw(data->hw);
2194 2195
}

2196
static void mac80211_hwsim_free(void)
2197
{
2198
	struct mac80211_hwsim_data *data;
2199

2200 2201 2202 2203 2204 2205 2206 2207
	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);
2208
	}
2209 2210
	spin_unlock_bh(&hwsim_radio_lock);
	class_destroy(hwsim_class);
2211 2212
}

2213 2214 2215 2216 2217 2218
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 已提交
2219

2220
static void hwsim_mon_setup(struct net_device *dev)
D
Daniel Wagner 已提交
2221
{
2222 2223 2224 2225 2226 2227 2228
	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 已提交
2229 2230
}

2231
static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr)
2232 2233 2234 2235 2236 2237
{
	struct mac80211_hwsim_data *data;
	bool _found = false;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
2238
		if (memcmp(data->addresses[1].addr, addr, ETH_ALEN) == 0) {
2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258
			_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;
2259
	unsigned long ret_skb_ptr;
2260
	struct sk_buff *skb, *tmp;
2261
	const u8 *src;
2262 2263 2264 2265
	unsigned int hwsim_flags;
	int i;
	bool found = false;

2266 2267 2268
	if (info->snd_portid != wmediumd_portid)
		return -EINVAL;

2269
	if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
2270 2271 2272
	    !info->attrs[HWSIM_ATTR_FLAGS] ||
	    !info->attrs[HWSIM_ATTR_COOKIE] ||
	    !info->attrs[HWSIM_ATTR_TX_INFO])
2273 2274
		goto out;

2275
	src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
2276
	hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
2277
	ret_skb_ptr = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
2278 2279

	data2 = get_hwsim_data_ref_from_addr(src);
2280
	if (!data2)
2281 2282 2283 2284
		goto out;

	/* look for the skb matching the cookie passed back from user */
	skb_queue_walk_safe(&data2->pending, skb, tmp) {
2285
		if ((unsigned long)skb == ret_skb_ptr) {
2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
			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;
2319
			mac80211_hwsim_monitor_ack(data2->channel,
2320
						   hdr->addr2);
2321
		}
2322
		txi->flags |= IEEE80211_TX_STAT_ACK;
2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334
	}
	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)
{

2335
	struct mac80211_hwsim_data *data2;
2336
	struct ieee80211_rx_status rx_status;
2337
	const u8 *dst;
2338
	int frame_data_len;
2339
	void *frame_data;
2340 2341
	struct sk_buff *skb = NULL;

2342 2343 2344
	if (info->snd_portid != wmediumd_portid)
		return -EINVAL;

2345
	if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
2346 2347 2348
	    !info->attrs[HWSIM_ATTR_FRAME] ||
	    !info->attrs[HWSIM_ATTR_RX_RATE] ||
	    !info->attrs[HWSIM_ATTR_SIGNAL])
2349 2350
		goto out;

2351
	dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
2352
	frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
2353
	frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
2354 2355 2356 2357 2358 2359

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

2360
	if (frame_data_len > IEEE80211_MAX_DATA_LEN)
2361 2362
		goto err;

2363 2364
	/* Copy the data */
	memcpy(skb_put(skb, frame_data_len), frame_data, frame_data_len);
2365

2366 2367
	data2 = get_hwsim_data_ref_from_addr(dst);
	if (!data2)
2368 2369 2370 2371
		goto out;

	/* check if radio is configured properly */

2372
	if (data2->idle || !data2->started)
2373 2374
		goto out;

2375
	/* A frame is received from user space */
2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386
	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));
	ieee80211_rx_irqsafe(data2->hw, skb);

	return 0;
err:
2387
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
2388 2389 2390 2391 2392 2393 2394 2395 2396
	goto out;
out:
	dev_kfree_skb(skb);
	return -EINVAL;
}

static int hwsim_register_received_nl(struct sk_buff *skb_2,
				      struct genl_info *info)
{
2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
	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;

2413 2414
	if (wmediumd_portid)
		return -EBUSY;
2415

2416
	wmediumd_portid = info->snd_portid;
2417 2418

	printk(KERN_DEBUG "mac80211_hwsim: received a REGISTER, "
2419
	       "switching to wmediumd mode with pid %d\n", info->snd_portid);
2420 2421 2422 2423

	return 0;
}

2424 2425 2426
static int hwsim_create_radio_nl(struct sk_buff *msg, struct genl_info *info)
{
	unsigned int chans = channels;
2427 2428 2429
	const char *alpha2 = NULL;
	const struct ieee80211_regdomain *regd = NULL;
	bool reg_strict = info->attrs[HWSIM_ATTR_REG_STRICT_REG];
2430
	bool p2p_device = info->attrs[HWSIM_ATTR_SUPPORT_P2P_DEVICE];
2431
	bool use_chanctx;
2432 2433 2434 2435

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

2436 2437 2438 2439 2440
	if (info->attrs[HWSIM_ATTR_USE_CHANCTX])
		use_chanctx = true;
	else
		use_chanctx = (chans > 1);

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451
	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];
	}

2452
	return mac80211_hwsim_create_radio(chans, alpha2, regd, reg_strict,
2453
					   p2p_device, use_chanctx);
2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
}

static int hwsim_destroy_radio_nl(struct sk_buff *msg, struct genl_info *info)
{
	struct mac80211_hwsim_data *data;
	int idx;

	if (!info->attrs[HWSIM_ATTR_RADIO_ID])
		return -EINVAL;
	idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
		if (data->idx != idx)
			continue;
		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;
2477 2478 2479
}

/* Generic Netlink operations array */
2480
static const struct genl_ops hwsim_ops[] = {
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496
	{
		.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,
	},
2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508
	{
		.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,
	},
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
};

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;

2520
	if (notify->portid == wmediumd_portid) {
2521 2522
		printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
		       " socket, switching to perfect channel medium\n");
2523
		wmediumd_portid = 0;
2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
	}
	return NOTIFY_DONE;

}

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

static int hwsim_init_netlink(void)
{
	int rc;
2536

2537 2538
	printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");

2539
	rc = genl_register_family_with_ops(&hwsim_genl_family, hwsim_ops);
2540 2541 2542 2543 2544 2545 2546 2547 2548 2549
	if (rc)
		goto failure;

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

	return 0;

failure:
2550
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
2551 2552 2553 2554 2555 2556 2557 2558
	return -EINVAL;
}

static void hwsim_exit_netlink(void)
{
	/* unregister the notifier */
	netlink_unregister_notifier(&hwsim_netlink_notifier);
	/* unregister the family */
2559
	genl_unregister_family(&hwsim_genl_family);
2560 2561
}

2562 2563
static int __init init_mac80211_hwsim(void)
{
2564
	int i, err;
2565

2566
	if (radios < 0 || radios > 100)
2567 2568
		return -EINVAL;

2569 2570 2571
	if (channels < 1)
		return -EINVAL;

2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585
	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;
2586

2587 2588
	spin_lock_init(&hwsim_radio_lock);
	INIT_LIST_HEAD(&hwsim_radios);
2589

2590
	err = platform_driver_register(&mac80211_hwsim_driver);
2591 2592 2593
	if (err)
		return err;

2594
	hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
2595 2596
	if (IS_ERR(hwsim_class)) {
		err = PTR_ERR(hwsim_class);
2597
		goto out_unregister_driver;
2598
	}
2599

2600
	for (i = 0; i < radios; i++) {
2601 2602 2603
		const char *reg_alpha2 = NULL;
		const struct ieee80211_regdomain *regd = NULL;
		bool reg_strict = false;
2604

2605 2606
		switch (regtest) {
		case HWSIM_REGTEST_DIFF_COUNTRY:
2607 2608
			if (i < ARRAY_SIZE(hwsim_alpha2s))
				reg_alpha2 = hwsim_alpha2s[i];
2609 2610 2611
			break;
		case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
			if (!i)
2612
				reg_alpha2 = hwsim_alpha2s[0];
2613 2614
			break;
		case HWSIM_REGTEST_STRICT_ALL:
2615 2616 2617
			reg_strict = true;
		case HWSIM_REGTEST_DRIVER_REG_ALL:
			reg_alpha2 = hwsim_alpha2s[0];
2618
			break;
2619 2620 2621
		case HWSIM_REGTEST_WORLD_ROAM:
			if (i == 0)
				regd = &hwsim_world_regdom_custom_01;
2622 2623
			break;
		case HWSIM_REGTEST_CUSTOM_WORLD:
2624 2625
			regd = &hwsim_world_regdom_custom_01;
			break;
2626
		case HWSIM_REGTEST_CUSTOM_WORLD_2:
2627 2628 2629 2630
			if (i == 0)
				regd = &hwsim_world_regdom_custom_01;
			else if (i == 1)
				regd = &hwsim_world_regdom_custom_02;
2631 2632
			break;
		case HWSIM_REGTEST_STRICT_FOLLOW:
2633 2634 2635 2636
			if (i == 0) {
				reg_strict = true;
				reg_alpha2 = hwsim_alpha2s[0];
			}
2637 2638
			break;
		case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
2639 2640 2641 2642 2643 2644
			if (i == 0) {
				reg_strict = true;
				reg_alpha2 = hwsim_alpha2s[0];
			} else if (i == 1) {
				reg_alpha2 = hwsim_alpha2s[1];
			}
2645 2646
			break;
		case HWSIM_REGTEST_ALL:
2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664
			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;
			}
2665 2666 2667 2668 2669
			break;
		default:
			break;
		}

2670
		err = mac80211_hwsim_create_radio(channels, reg_alpha2,
2671
						  regd, reg_strict,
2672 2673
						  support_p2p_device,
						  channels > 1);
2674
		if (err < 0)
2675
			goto out_free_radios;
2676 2677 2678
	}

	hwsim_mon = alloc_netdev(0, "hwsim%d", hwsim_mon_setup);
2679 2680
	if (hwsim_mon == NULL) {
		err = -ENOMEM;
2681
		goto out_free_radios;
2682
	}
2683

2684 2685
	rtnl_lock();
	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
2686 2687 2688 2689
	if (err < 0) {
		rtnl_unlock();
		goto out_free_radios;
	}
2690 2691

	err = register_netdevice(hwsim_mon);
2692 2693 2694 2695
	if (err < 0) {
		rtnl_unlock();
		goto out_free_mon;
	}
2696 2697 2698 2699
	rtnl_unlock();

	err = hwsim_init_netlink();
	if (err < 0)
2700
		goto out_free_mon;
2701

2702 2703
	return 0;

2704
out_free_mon:
2705
	free_netdev(hwsim_mon);
2706
out_free_radios:
2707
	mac80211_hwsim_free();
2708
out_unregister_driver:
2709
	platform_driver_unregister(&mac80211_hwsim_driver);
2710 2711
	return err;
}
2712
module_init(init_mac80211_hwsim);
2713 2714 2715

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

2718 2719
	hwsim_exit_netlink();

2720
	mac80211_hwsim_free();
2721
	unregister_netdev(hwsim_mon);
2722
	platform_driver_unregister(&mac80211_hwsim_driver);
2723 2724
}
module_exit(exit_mac80211_hwsim);