mac80211_hwsim.c 84.8 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
static struct platform_driver mac80211_hwsim_driver = {
	.driver = {
		.name = "mac80211_hwsim",
	},
};
400

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

411
	struct mac_address addresses[2];
412
	int channels, idx;
413
	bool use_chanctx;
414 415 416
	bool destroy_on_close;
	struct work_struct destroy_work;
	u32 portid;
417 418
	char alpha2[2];
	const struct ieee80211_regdomain *regd;
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
	u8 scan_addr[ETH_ALEN];
427

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

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

	int power_level;
449 450

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

	/* Stats */
	u64 tx_pkts;
	u64 rx_pkts;
	u64 tx_bytes;
	u64 rx_bytes;
	u64 tx_dropped;
	u64 tx_failed;
463 464 465 466 467
};


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

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

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

492 493 494 495 496 497 498 499
enum hwsim_multicast_groups {
	HWSIM_MCGRP_CONFIG,
};

static const struct genl_multicast_group hwsim_mcgrps[] = {
	[HWSIM_MCGRP_CONFIG] = { .name = "config", },
};

500 501
/* MAC80211_HWSIM netlink policy */

502
static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
503 504
	[HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
	[HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
505 506 507 508 509 510
	[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,
511 512
				 .len = IEEE80211_TX_MAX_RATES *
					sizeof(struct hwsim_tx_rate)},
513
	[HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
514 515
	[HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 },
	[HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 },
516 517 518
	[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 },
519
	[HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG },
520
	[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE] = { .type = NLA_FLAG },
521 522 523
	[HWSIM_ATTR_RADIO_NAME] = { .type = NLA_STRING },
	[HWSIM_ATTR_NO_VIF] = { .type = NLA_FLAG },
	[HWSIM_ATTR_FREQ] = { .type = NLA_U32 },
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
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;

628
	local_bh_disable();
629
	if (val == PS_MANUAL_POLL) {
630 631 632
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_ps_poll, data);
633 634
		data->ps_poll_pending = true;
	} else if (old_ps == PS_DISABLED && val != PS_DISABLED) {
635 636 637
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_nullfunc_ps, data);
638
	} else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
639 640 641
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_nullfunc_no_ps, data);
642
	}
643
	local_bh_enable();
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680

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

681 682
static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
					struct net_device *dev)
683 684 685
{
	/* TODO: allow packet injection */
	dev_kfree_skb(skb);
686
	return NETDEV_TX_OK;
687 688
}

689 690 691 692 693
static inline u64 mac80211_hwsim_get_tsf_raw(void)
{
	return ktime_to_us(ktime_get_real());
}

694 695
static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
{
696
	u64 now = mac80211_hwsim_get_tsf_raw();
697 698
	return cpu_to_le64(now + data->tsf_offset);
}
699

700
static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
701
				  struct ieee80211_vif *vif)
702 703 704 705 706 707 708 709 710
{
	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;
711
	u64 now = mac80211_hwsim_get_tsf(hw, vif);
712
	u32 bcn_int = data->beacon_int;
713
	u64 delta = abs64(tsf - now);
714

715
	/* adjust after beaconing with new timestamp at old TBTT */
716 717 718 719 720 721 722
	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);
	}
723 724
}

725
static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
726 727
				      struct sk_buff *tx_skb,
				      struct ieee80211_channel *chan)
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
{
	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 已提交
747 748
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_RATE) |
749
					  (1 << IEEE80211_RADIOTAP_TSFT) |
J
Jouni Malinen 已提交
750
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
751
	hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
752 753
	hdr->rt_flags = 0;
	hdr->rt_rate = txrate->bitrate / 5;
754
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
755 756 757 758 759 760 761 762 763 764 765
	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 已提交
766
	skb->protocol = htons(ETH_P_802_2);
767 768 769 770 771
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}


772 773
static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
				       const u8 *addr)
774 775
{
	struct sk_buff *skb;
776
	struct hwsim_radiotap_ack_hdr *hdr;
777 778 779 780 781 782 783 784 785 786
	u16 flags;
	struct ieee80211_hdr *hdr11;

	if (!netif_running(hwsim_mon))
		return;

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

787
	hdr = (struct hwsim_radiotap_ack_hdr *) skb_put(skb, sizeof(*hdr));
788 789 790 791 792 793
	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;
794
	hdr->pad = 0;
795
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
	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);
}

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
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,
	};

835 836 837
	if (data->scanning && memcmp(addr, data->scan_addr, ETH_ALEN) == 0)
		return true;

838 839 840 841 842 843 844 845 846
	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;
}
847

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
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 &&
864
		    mac80211_hwsim_addr_match(data, skb->data + 4)) {
865 866 867 868 869 870 871 872 873
			data->ps_poll_pending = false;
			return true;
		}
		return false;
	}

	return true;
}

874 875
static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
				       struct sk_buff *my_skb,
876
				       int dst_portid)
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891
{
	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 */
892
		while (skb_queue_len(&data->pending) >= WARN_QUEUE) {
893
			ieee80211_free_txskb(hw, skb_dequeue(&data->pending));
894 895
			data->tx_dropped++;
		}
896 897
	}

898
	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
899 900 901 902 903 904 905 906 907 908
	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;
	}

909
	if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
910
		    ETH_ALEN, data->addresses[1].addr))
911
		goto nla_put_failure;
912

913
	/* We get the skb->data */
914 915
	if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
		goto nla_put_failure;
916 917 918 919 920 921 922 923 924 925

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

926 927
	if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
		goto nla_put_failure;
928

929 930 931
	if (nla_put_u32(skb, HWSIM_ATTR_FREQ, data->channel->center_freq))
		goto nla_put_failure;

932 933 934 935 936 937 938
	/* 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;
	}

939 940 941 942
	if (nla_put(skb, HWSIM_ATTR_TX_INFO,
		    sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
		    tx_attempts))
		goto nla_put_failure;
943 944

	/* We create a cookie to identify this skb */
945 946
	if (nla_put_u64(skb, HWSIM_ATTR_COOKIE, (unsigned long) my_skb))
		goto nla_put_failure;
947 948

	genlmsg_end(skb, msg_head);
949
	genlmsg_unicast(&init_net, skb, dst_portid);
950 951 952

	/* Enqueue the packet */
	skb_queue_tail(&data->pending, my_skb);
953 954
	data->tx_pkts++;
	data->tx_bytes += my_skb->len;
955 956 957
	return;

nla_put_failure:
958
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
959
	ieee80211_free_txskb(hw, my_skb);
960
	data->tx_failed++;
961 962
}

963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
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,
986
				rcu_dereference(vif->chanctx_conf)->def.chan))
987 988 989 990 991
		return;

	data->receive = true;
}

992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
static void mac80211_hwsim_add_vendor_rtap(struct sk_buff *skb)
{
	/*
	 * To enable this code, #define the HWSIM_RADIOTAP_OUI,
	 * e.g. like this:
	 * #define HWSIM_RADIOTAP_OUI "\x02\x00\x00"
	 * (but you should use a valid OUI, not that)
	 *
	 * If anyone wants to 'donate' a radiotap OUI/subns code
	 * please send a patch removing this #ifdef and changing
	 * the values accordingly.
	 */
#ifdef HWSIM_RADIOTAP_OUI
	struct ieee80211_vendor_radiotap *rtap;

	/*
	 * Note that this code requires the headroom in the SKB
	 * that was allocated earlier.
	 */
	rtap = (void *)skb_push(skb, sizeof(*rtap) + 8 + 4);
	rtap->oui[0] = HWSIM_RADIOTAP_OUI[0];
	rtap->oui[1] = HWSIM_RADIOTAP_OUI[1];
	rtap->oui[2] = HWSIM_RADIOTAP_OUI[2];
	rtap->subns = 127;

	/*
	 * Radiotap vendor namespaces can (and should) also be
	 * split into fields by using the standard radiotap
	 * presence bitmap mechanism. Use just BIT(0) here for
	 * the presence bitmap.
	 */
	rtap->present = BIT(0);
	/* We have 8 bytes of (dummy) data */
	rtap->len = 8;
	/* For testing, also require it to be aligned */
	rtap->align = 8;
	/* And also test that padding works, 4 bytes */
	rtap->pad = 4;
	/* push the data */
	memcpy(rtap->data, "ABCDEFGH", 8);
	/* make sure to clear padding, mac80211 doesn't */
	memset(rtap->data + 8, 0, 4);

	IEEE80211_SKB_RXCB(skb)->flag |= RX_FLAG_RADIOTAP_VENDOR_DATA;
#endif
}

1039
static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
1040 1041
					  struct sk_buff *skb,
					  struct ieee80211_channel *chan)
1042
{
1043 1044
	struct mac80211_hwsim_data *data = hw->priv, *data2;
	bool ack = false;
1045
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1046
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1047
	struct ieee80211_rx_status rx_status;
1048
	u64 now;
1049 1050

	memset(&rx_status, 0, sizeof(rx_status));
1051
	rx_status.flag |= RX_FLAG_MACTIME_START;
1052 1053
	rx_status.freq = chan->center_freq;
	rx_status.band = chan->band;
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	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;
	}
1065 1066 1067 1068
	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;
1069
	/* TODO: simulate real signal strength (and optional packet loss) */
1070
	rx_status.signal = data->power_level - 50;
1071

1072 1073 1074
	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);

1075 1076
	/* release the skb's source info */
	skb_orphan(skb);
1077
	skb_dst_drop(skb);
1078 1079 1080 1081
	skb->mark = 0;
	secpath_reset(skb);
	nf_reset(skb);

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
	/*
	 * 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();

1095
	/* Copy skb to all enabled radios that are on the current frequency */
1096 1097
	spin_lock(&hwsim_radio_lock);
	list_for_each_entry(data2, &hwsim_radios, list) {
1098
		struct sk_buff *nskb;
1099 1100 1101 1102
		struct tx_iter_data tx_iter_data = {
			.receive = false,
			.channel = chan,
		};
1103

1104
		if (data == data2)
1105
			continue;
1106

1107 1108
		if (!data2->started || (data2->idle && !data2->tmp_chan) ||
		    !hwsim_ps_rx_ok(data2, skb))
1109 1110
			continue;

1111 1112 1113 1114 1115 1116
		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(
1117 1118
				data2->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_tx_iter, &tx_iter_data);
1119 1120 1121 1122
			if (!tx_iter_data.receive)
				continue;
		}

1123 1124 1125 1126
		/*
		 * reserve some space for our vendor and the normal
		 * radiotap header, since we're copying anyway
		 */
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
		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;
		}
1146

1147
		if (mac80211_hwsim_addr_match(data2, hdr->addr1))
1148
			ack = true;
1149

1150
		rx_status.mactime = now + data2->tsf_offset;
1151

1152
		memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
1153 1154 1155

		mac80211_hwsim_add_vendor_rtap(nskb);

1156 1157
		data2->rx_pkts++;
		data2->rx_bytes += nskb->len;
1158
		ieee80211_rx_irqsafe(data2->hw, nskb);
1159
	}
1160
	spin_unlock(&hwsim_radio_lock);
1161

1162 1163 1164
	return ack;
}

1165 1166 1167
static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
			      struct ieee80211_tx_control *control,
			      struct sk_buff *skb)
1168
{
1169 1170 1171 1172
	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;
1173
	bool ack;
1174
	u32 _portid;
1175

1176
	if (WARN_ON(skb->len < 10)) {
1177
		/* Should not happen; just a sanity check for addr1 use */
1178
		ieee80211_free_txskb(hw, skb);
1179
		return;
1180 1181
	}

1182
	if (!data->use_chanctx) {
1183 1184 1185 1186 1187 1188
		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)
1189
			channel = chanctx_conf->def.chan;
1190 1191 1192 1193 1194
		else
			channel = NULL;
	}

	if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
1195
		ieee80211_free_txskb(hw, skb);
1196 1197 1198 1199 1200
		return;
	}

	if (data->idle && !data->tmp_chan) {
		wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
1201
		ieee80211_free_txskb(hw, skb);
1202 1203 1204 1205 1206 1207 1208 1209
		return;
	}

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

1210
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE)
1211 1212 1213
		ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
1214

1215
	txi->rate_driver_data[0] = channel;
1216 1217
	mac80211_hwsim_monitor_rx(hw, skb, channel);

1218
	/* wmediumd mode check */
1219
	_portid = ACCESS_ONCE(wmediumd_portid);
1220

1221 1222
	if (_portid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
1223 1224

	/* NO wmediumd detected, perfect medium simulation */
1225 1226
	data->tx_pkts++;
	data->tx_bytes += skb->len;
1227
	ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
1228

1229 1230
	if (ack && skb->len >= 16) {
		struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1231
		mac80211_hwsim_monitor_ack(channel, hdr->addr2);
1232
	}
1233

1234
	ieee80211_tx_info_clear_status(txi);
1235 1236 1237 1238 1239

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

1240 1241
	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
		txi->flags |= IEEE80211_TX_STAT_ACK;
1242 1243 1244 1245 1246 1247 1248
	ieee80211_tx_status_irqsafe(hw, skb);
}


static int mac80211_hwsim_start(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1249
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1250
	data->started = true;
1251 1252 1253 1254 1255 1256 1257
	return 0;
}


static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1258
	data->started = false;
T
Thomas Pedersen 已提交
1259
	tasklet_hrtimer_cancel(&data->beacon_timer);
1260
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1261 1262 1263 1264
}


static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1265
					struct ieee80211_vif *vif)
1266
{
1267
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1268 1269
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
1270
	hwsim_set_magic(vif);
1271 1272 1273 1274 1275 1276 1277

	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;

1278 1279 1280 1281
	return 0;
}


1282 1283
static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
					   struct ieee80211_vif *vif,
1284 1285
					   enum nl80211_iftype newtype,
					   bool newp2p)
1286
{
1287
	newtype = ieee80211_iftype_p2p(newtype, newp2p);
1288 1289
	wiphy_debug(hw->wiphy,
		    "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
1290 1291
		    __func__, ieee80211_vif_type_p2p(vif),
		    newtype, vif->addr);
1292 1293
	hwsim_check_magic(vif);

1294 1295 1296 1297 1298 1299
	/*
	 * interface may change from non-AP to AP in
	 * which case this needs to be set up again
	 */
	vif->cab_queue = 0;

1300 1301 1302
	return 0;
}

1303
static void mac80211_hwsim_remove_interface(
1304
	struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1305
{
1306
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1307 1308
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
1309 1310
	hwsim_check_magic(vif);
	hwsim_clear_magic(vif);
1311 1312
}

1313 1314 1315 1316 1317 1318
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan)
{
	u32 _pid = ACCESS_ONCE(wmediumd_portid);

1319
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE) {
1320 1321 1322 1323 1324 1325
		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));
	}

1326 1327 1328 1329 1330 1331 1332 1333
	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);
}
1334 1335 1336 1337

static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
				     struct ieee80211_vif *vif)
{
1338 1339 1340 1341 1342
	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;
1343 1344
	struct sk_buff *skb;

1345 1346
	hwsim_check_magic(vif);

1347
	if (vif->type != NL80211_IFTYPE_AP &&
1348 1349
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_ADHOC)
1350 1351 1352 1353 1354
		return;

	skb = ieee80211_beacon_get(hw, vif);
	if (skb == NULL)
		return;
1355
	info = IEEE80211_SKB_CB(skb);
1356
	if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE)
1357 1358 1359 1360
		ieee80211_get_tx_rates(vif, NULL, skb,
				       info->control.rates,
				       ARRAY_SIZE(info->control.rates));

1361 1362 1363 1364 1365 1366 1367 1368
	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);
1369

1370
	mac80211_hwsim_tx_frame(hw, skb,
1371
				rcu_dereference(vif->chanctx_conf)->def.chan);
1372 1373 1374

	if (vif->csa_active && ieee80211_csa_is_complete(vif))
		ieee80211_csa_finish(vif);
1375 1376
}

T
Thomas Pedersen 已提交
1377 1378
static enum hrtimer_restart
mac80211_hwsim_beacon(struct hrtimer *timer)
1379
{
T
Thomas Pedersen 已提交
1380 1381 1382 1383 1384 1385
	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;
1386

1387
	if (!data->started)
T
Thomas Pedersen 已提交
1388
		goto out;
1389

J
Jouni Malinen 已提交
1390
	ieee80211_iterate_active_interfaces_atomic(
1391
		hw, IEEE80211_IFACE_ITER_NORMAL,
1392
		mac80211_hwsim_beacon_tx, data);
1393

1394 1395 1396 1397 1398 1399
	/* beacon at new TBTT + beacon interval */
	if (data->bcn_delta) {
		bcn_int -= data->bcn_delta;
		data->bcn_delta = 0;
	}

T
Thomas Pedersen 已提交
1400 1401 1402 1403 1404
	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;
1405 1406
}

1407 1408 1409 1410 1411 1412 1413
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",
1414
};
1415

1416
static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1417 1418
{
	struct mac80211_hwsim_data *data = hw->priv;
1419
	struct ieee80211_conf *conf = &hw->conf;
1420 1421 1422 1423 1424 1425 1426
	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",
	};

1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
	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]);
1445

1446 1447
	data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);

1448
	data->channel = conf->chandef.chan;
1449

1450
	WARN_ON(data->channel && data->use_chanctx);
1451

1452
	data->power_level = conf->power_level;
1453
	if (!data->started || !data->beacon_int)
T
Thomas Pedersen 已提交
1454 1455
		tasklet_hrtimer_cancel(&data->beacon_timer);
	else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
1456 1457 1458 1459
		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 已提交
1460
		tasklet_hrtimer_start(&data->beacon_timer,
1461
				      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1462 1463
				      HRTIMER_MODE_REL);
	}
1464 1465 1466 1467 1468 1469 1470

	return 0;
}


static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
					    unsigned int changed_flags,
1471
					    unsigned int *total_flags,u64 multicast)
1472 1473 1474
{
	struct mac80211_hwsim_data *data = hw->priv;

1475
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485

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

1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
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)++;
}

1496 1497 1498 1499 1500
static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif,
					    struct ieee80211_bss_conf *info,
					    u32 changed)
{
1501
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1502
	struct mac80211_hwsim_data *data = hw->priv;
1503

1504
	hwsim_check_magic(vif);
1505

1506 1507
	wiphy_debug(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n",
		    __func__, changed, vif->addr);
1508

1509
	if (changed & BSS_CHANGED_BSSID) {
1510 1511
		wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n",
			    __func__, info->bssid);
1512 1513 1514
		memcpy(vp->bssid, info->bssid, ETH_ALEN);
	}

1515
	if (changed & BSS_CHANGED_ASSOC) {
1516 1517
		wiphy_debug(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
			    info->assoc, info->aid);
1518 1519
		vp->assoc = info->assoc;
		vp->aid = info->aid;
1520 1521
	}

1522
	if (changed & BSS_CHANGED_BEACON_INT) {
1523
		wiphy_debug(hw->wiphy, "  BCNINT: %d\n", info->beacon_int);
T
Thomas Pedersen 已提交
1524 1525 1526 1527 1528
		data->beacon_int = info->beacon_int * 1024;
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED) {
		wiphy_debug(hw->wiphy, "  BCN EN: %d\n", info->enable_beacon);
1529
		vp->bcn_en = info->enable_beacon;
T
Thomas Pedersen 已提交
1530 1531 1532
		if (data->started &&
		    !hrtimer_is_queued(&data->beacon_timer.timer) &&
		    info->enable_beacon) {
1533 1534
			u64 tsf, until_tbtt;
			u32 bcn_int;
T
Thomas Pedersen 已提交
1535 1536
			if (WARN_ON(!data->beacon_int))
				data->beacon_int = 1000 * 1024;
1537 1538 1539
			tsf = mac80211_hwsim_get_tsf(hw, vif);
			bcn_int = data->beacon_int;
			until_tbtt = bcn_int - do_div(tsf, bcn_int);
T
Thomas Pedersen 已提交
1540
			tasklet_hrtimer_start(&data->beacon_timer,
1541
					      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1542
					      HRTIMER_MODE_REL);
1543 1544
		} else if (!info->enable_beacon) {
			unsigned int count = 0;
1545
			ieee80211_iterate_active_interfaces_atomic(
1546 1547 1548 1549 1550 1551 1552
				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);
		}
1553 1554
	}

1555
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1556 1557
		wiphy_debug(hw->wiphy, "  ERP_CTS_PROT: %d\n",
			    info->use_cts_prot);
1558 1559 1560
	}

	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1561 1562
		wiphy_debug(hw->wiphy, "  ERP_PREAMBLE: %d\n",
			    info->use_short_preamble);
1563 1564 1565
	}

	if (changed & BSS_CHANGED_ERP_SLOT) {
1566
		wiphy_debug(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
1567 1568 1569
	}

	if (changed & BSS_CHANGED_HT) {
1570 1571
		wiphy_debug(hw->wiphy, "  HT: op_mode=0x%x\n",
			    info->ht_operation_mode);
1572 1573 1574
	}

	if (changed & BSS_CHANGED_BASIC_RATES) {
1575 1576
		wiphy_debug(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
			    (unsigned long long) info->basic_rates);
1577
	}
1578 1579 1580

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

1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602
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;
}

1603 1604
static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
1605 1606
				      enum sta_notify_cmd cmd,
				      struct ieee80211_sta *sta)
1607 1608
{
	hwsim_check_magic(vif);
1609

1610
	switch (cmd) {
1611 1612 1613 1614
	case STA_NOTIFY_SLEEP:
	case STA_NOTIFY_AWAKE:
		/* TODO: make good use of these flags */
		break;
1615 1616 1617
	default:
		WARN(1, "Invalid sta notify: %d\n", cmd);
		break;
1618 1619 1620 1621 1622 1623 1624 1625 1626
	}
}

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

1629
static int mac80211_hwsim_conf_tx(
1630 1631
	struct ieee80211_hw *hw,
	struct ieee80211_vif *vif, u16 queue,
1632 1633
	const struct ieee80211_tx_queue_params *params)
{
1634 1635 1636 1637 1638
	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);
1639 1640 1641
	return 0;
}

1642 1643 1644 1645 1646 1647
static int mac80211_hwsim_get_survey(
	struct ieee80211_hw *hw, int idx,
	struct survey_info *survey)
{
	struct ieee80211_conf *conf = &hw->conf;

1648
	wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx);
1649 1650 1651 1652 1653

	if (idx != 0)
		return -ENOENT;

	/* Current channel */
1654
	survey->channel = conf->chandef.chan;
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667

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

1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
#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,
1688 1689
	HWSIM_TM_CMD_STOP_QUEUES	= 2,
	HWSIM_TM_CMD_WAKE_QUEUES	= 3,
1690 1691 1692 1693 1694 1695 1696
};

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 已提交
1697
static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1698
				       struct ieee80211_vif *vif,
J
Johannes Berg 已提交
1699
				       void *data, int len)
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
{
	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;
1725 1726
		if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
			goto nla_put_failure;
1727
		return cfg80211_testmode_reply(skb);
1728 1729 1730 1731 1732 1733
	case HWSIM_TM_CMD_STOP_QUEUES:
		ieee80211_stop_queues(hw);
		return 0;
	case HWSIM_TM_CMD_WAKE_QUEUES:
		ieee80211_wake_queues(hw);
		return 0;
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
	default:
		return -EOPNOTSUPP;
	}

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

1744 1745 1746
static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
				       enum ieee80211_ampdu_mlme_action action,
1747 1748
				       struct ieee80211_sta *sta, u16 tid, u16 *ssn,
				       u8 buf_size)
1749 1750 1751 1752 1753
{
	switch (action) {
	case IEEE80211_AMPDU_TX_START:
		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
		break;
1754 1755 1756
	case IEEE80211_AMPDU_TX_STOP_CONT:
	case IEEE80211_AMPDU_TX_STOP_FLUSH:
	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
		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;
}

1771 1772 1773
static void mac80211_hwsim_flush(struct ieee80211_hw *hw,
				 struct ieee80211_vif *vif,
				 u32 queues, bool drop)
1774
{
1775
	/* Not implemented, queues only on kernel side */
1776 1777
}

1778
static void hw_scan_work(struct work_struct *work)
1779
{
1780 1781 1782 1783
	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;
1784

1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
	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];
1800
	if (hwsim->tmp_chan->flags & IEEE80211_CHAN_NO_IR ||
1801 1802 1803 1804 1805 1806 1807 1808 1809
	    !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,
1810
						       hwsim->scan_addr,
1811 1812
						       req->ssids[i].ssid,
						       req->ssids[i].ssid_len,
1813
						       req->ie_len);
1814 1815
			if (!probe)
				continue;
1816 1817 1818 1819 1820

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

1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
			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);
1831 1832 1833
}

static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
1834
				  struct ieee80211_vif *vif,
1835
				  struct ieee80211_scan_request *hw_req)
1836
{
1837
	struct mac80211_hwsim_data *hwsim = hw->priv;
1838
	struct cfg80211_scan_request *req = &hw_req->req;
1839

1840 1841 1842 1843 1844 1845 1846 1847
	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;
1848 1849 1850 1851 1852 1853
	if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)
		get_random_mask_addr(hwsim->scan_addr,
				     hw_req->req.mac_addr,
				     hw_req->req.mac_addr_mask);
	else
		memcpy(hwsim->scan_addr, vif->addr, ETH_ALEN);
1854
	mutex_unlock(&hwsim->mutex);
1855

1856
	wiphy_debug(hw->wiphy, "hwsim hw_scan request\n");
1857

1858
	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
1859 1860 1861 1862

	return 0;
}

1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
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);
}

1880 1881 1882
static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   const u8 *mac_addr)
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
{
	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");
1894 1895

	memcpy(hwsim->scan_addr, mac_addr, ETH_ALEN);
1896 1897 1898 1899 1900 1901
	hwsim->scanning = true;

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

1902 1903
static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif)
1904 1905 1906 1907 1908 1909
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);

	printk(KERN_DEBUG "hwsim sw_scan_complete\n");
1910
	hwsim->scanning = false;
1911
	memset(hwsim->scan_addr, 0, ETH_ALEN);
1912 1913 1914 1915

	mutex_unlock(&hwsim->mutex);
}

1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
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,
1930
			      struct ieee80211_vif *vif,
1931
			      struct ieee80211_channel *chan,
1932 1933
			      int duration,
			      enum ieee80211_roc_type type)
1934 1935 1936 1937 1938 1939 1940 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
{
	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);
1975 1976 1977 1978
	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);
1979 1980 1981 1982 1983 1984
	return 0;
}

static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
					  struct ieee80211_chanctx_conf *ctx)
{
1985 1986 1987 1988
	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);
1989 1990 1991 1992 1993 1994 1995 1996 1997
	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);
1998 1999 2000 2001
	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);
2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
}

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

2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
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);
}

2073
static const struct ieee80211_ops mac80211_hwsim_ops = {
2074 2075 2076 2077
	.tx = mac80211_hwsim_tx,
	.start = mac80211_hwsim_start,
	.stop = mac80211_hwsim_stop,
	.add_interface = mac80211_hwsim_add_interface,
2078
	.change_interface = mac80211_hwsim_change_interface,
2079 2080 2081
	.remove_interface = mac80211_hwsim_remove_interface,
	.config = mac80211_hwsim_config,
	.configure_filter = mac80211_hwsim_configure_filter,
2082
	.bss_info_changed = mac80211_hwsim_bss_info_changed,
2083 2084
	.sta_add = mac80211_hwsim_sta_add,
	.sta_remove = mac80211_hwsim_sta_remove,
2085
	.sta_notify = mac80211_hwsim_sta_notify,
2086
	.set_tim = mac80211_hwsim_set_tim,
2087
	.conf_tx = mac80211_hwsim_conf_tx,
2088
	.get_survey = mac80211_hwsim_get_survey,
2089
	CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)
2090
	.ampdu_action = mac80211_hwsim_ampdu_action,
2091 2092
	.sw_scan_start = mac80211_hwsim_sw_scan,
	.sw_scan_complete = mac80211_hwsim_sw_scan_complete,
2093
	.flush = mac80211_hwsim_flush,
2094 2095
	.get_tsf = mac80211_hwsim_get_tsf,
	.set_tsf = mac80211_hwsim_set_tsf,
2096 2097 2098
	.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,
2099 2100
};

2101
static struct ieee80211_ops mac80211_hwsim_mchan_ops;
2102

2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
struct hwsim_new_radio_params {
	unsigned int channels;
	const char *reg_alpha2;
	const struct ieee80211_regdomain *regd;
	bool reg_strict;
	bool p2p_device;
	bool use_chanctx;
	bool destroy_on_close;
	const char *hwname;
	bool no_vif;
};

static void hwsim_mcast_config_msg(struct sk_buff *mcast_skb,
				   struct genl_info *info)
{
	if (info)
		genl_notify(&hwsim_genl_family, mcast_skb,
			    genl_info_net(info), info->snd_portid,
			    HWSIM_MCGRP_CONFIG, info->nlhdr, GFP_KERNEL);
	else
		genlmsg_multicast(&hwsim_genl_family, mcast_skb, 0,
				  HWSIM_MCGRP_CONFIG, GFP_KERNEL);
}

2127 2128
static int append_radio_msg(struct sk_buff *skb, int id,
			    struct hwsim_new_radio_params *param)
2129 2130 2131 2132 2133
{
	int ret;

	ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
	if (ret < 0)
2134
		return ret;
2135 2136 2137 2138

	if (param->channels) {
		ret = nla_put_u32(skb, HWSIM_ATTR_CHANNELS, param->channels);
		if (ret < 0)
2139
			return ret;
2140 2141 2142 2143 2144 2145
	}

	if (param->reg_alpha2) {
		ret = nla_put(skb, HWSIM_ATTR_REG_HINT_ALPHA2, 2,
			      param->reg_alpha2);
		if (ret < 0)
2146
			return ret;
2147 2148 2149 2150 2151
	}

	if (param->regd) {
		int i;

2152 2153 2154
		for (i = 0; i < ARRAY_SIZE(hwsim_world_regdom_custom); i++) {
			if (hwsim_world_regdom_custom[i] != param->regd)
				continue;
2155 2156 2157

			ret = nla_put_u32(skb, HWSIM_ATTR_REG_CUSTOM_REG, i);
			if (ret < 0)
2158
				return ret;
2159
			break;
2160 2161 2162 2163 2164 2165
		}
	}

	if (param->reg_strict) {
		ret = nla_put_flag(skb, HWSIM_ATTR_REG_STRICT_REG);
		if (ret < 0)
2166
			return ret;
2167 2168 2169 2170 2171
	}

	if (param->p2p_device) {
		ret = nla_put_flag(skb, HWSIM_ATTR_SUPPORT_P2P_DEVICE);
		if (ret < 0)
2172
			return ret;
2173 2174 2175 2176 2177
	}

	if (param->use_chanctx) {
		ret = nla_put_flag(skb, HWSIM_ATTR_USE_CHANCTX);
		if (ret < 0)
2178
			return ret;
2179 2180 2181 2182 2183 2184
	}

	if (param->hwname) {
		ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME,
			      strlen(param->hwname), param->hwname);
		if (ret < 0)
2185
			return ret;
2186 2187
	}

2188
	return 0;
2189 2190
}

2191
static void hwsim_mcast_new_radio(int id, struct genl_info *info,
2192 2193 2194
				  struct hwsim_new_radio_params *param)
{
	struct sk_buff *mcast_skb;
2195
	void *data;
2196

2197
	mcast_skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2198 2199 2200
	if (!mcast_skb)
		return;

2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
	data = genlmsg_put(mcast_skb, 0, 0, &hwsim_genl_family, 0,
			   HWSIM_CMD_NEW_RADIO);
	if (!data)
		goto out_err;

	if (append_radio_msg(mcast_skb, id, param) < 0)
		goto out_err;

	genlmsg_end(mcast_skb, data);

2211
	hwsim_mcast_config_msg(mcast_skb, info);
2212 2213 2214 2215 2216
	return;

out_err:
	genlmsg_cancel(mcast_skb, data);
	nlmsg_free(mcast_skb);
2217 2218 2219 2220
}

static int mac80211_hwsim_new_radio(struct genl_info *info,
				    struct hwsim_new_radio_params *param)
2221
{
2222 2223
	int err;
	u8 addr[ETH_ALEN];
2224
	struct mac80211_hwsim_data *data;
2225 2226 2227 2228
	struct ieee80211_hw *hw;
	enum ieee80211_band band;
	const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
	int idx;
2229

2230
	if (WARN_ON(param->channels > 1 && !param->use_chanctx))
2231 2232
		return -EINVAL;

2233
	spin_lock_bh(&hwsim_radio_lock);
2234
	idx = hwsim_radio_idx++;
2235 2236
	spin_unlock_bh(&hwsim_radio_lock);

2237
	if (param->use_chanctx)
2238
		ops = &mac80211_hwsim_mchan_ops;
2239
	hw = ieee80211_alloc_hw_nm(sizeof(*data), ops, param->hwname);
2240 2241 2242 2243 2244 2245 2246
	if (!hw) {
		printk(KERN_DEBUG "mac80211_hwsim: ieee80211_alloc_hw failed\n");
		err = -ENOMEM;
		goto failed;
	}
	data = hw->priv;
	data->hw = hw;
2247

2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
	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);
2261
		goto failed_bind;
2262 2263
	}

2264
	skb_queue_head_init(&data->pending);
2265

2266 2267 2268 2269 2270 2271 2272 2273 2274 2275
	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;
2276

2277 2278
	data->channels = param->channels;
	data->use_chanctx = param->use_chanctx;
2279
	data->idx = idx;
2280 2281 2282
	data->destroy_on_close = param->destroy_on_close;
	if (info)
		data->portid = info->snd_portid;
2283

2284
	if (data->use_chanctx) {
2285 2286 2287 2288 2289 2290
		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;
2291
		if (param->p2p_device)
2292 2293 2294
			data->if_combination = hwsim_if_comb_p2p_dev[0];
		else
			data->if_combination = hwsim_if_comb[0];
2295
		data->if_combination.num_different_channels = data->channels;
2296
	} else if (param->p2p_device) {
2297 2298 2299
		hw->wiphy->iface_combinations = hwsim_if_comb_p2p_dev;
		hw->wiphy->n_iface_combinations =
			ARRAY_SIZE(hwsim_if_comb_p2p_dev);
2300 2301 2302 2303
	} else {
		hw->wiphy->iface_combinations = hwsim_if_comb;
		hw->wiphy->n_iface_combinations = ARRAY_SIZE(hwsim_if_comb);
	}
2304

2305 2306
	INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
	INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2307

2308 2309 2310 2311 2312 2313 2314
	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) |
2315 2316
				     BIT(NL80211_IFTYPE_MESH_POINT);

2317
	if (param->p2p_device)
2318
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_DEVICE);
2319

2320 2321 2322 2323 2324
	hw->flags = IEEE80211_HW_MFP_CAPABLE |
		    IEEE80211_HW_SIGNAL_DBM |
		    IEEE80211_HW_AMPDU_AGGREGATION |
		    IEEE80211_HW_WANT_MONITOR_VIF |
		    IEEE80211_HW_QUEUE_CONTROL |
2325 2326
		    IEEE80211_HW_SUPPORTS_HT_CCK_RATES |
		    IEEE80211_HW_CHANCTX_STA_CSA;
2327 2328
	if (rctbl)
		hw->flags |= IEEE80211_HW_SUPPORTS_RC_TABLE;
2329

2330 2331
	hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
			    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
2332 2333
			    WIPHY_FLAG_AP_UAPSD |
			    WIPHY_FLAG_HAS_CHANNEL_SWITCH;
2334 2335 2336
	hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR |
			       NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
			       NL80211_FEATURE_STATIC_SMPS |
2337 2338
			       NL80211_FEATURE_DYNAMIC_SMPS |
			       NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
2339

2340 2341 2342 2343
	/* 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);
2344

2345 2346 2347 2348 2349
	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));
2350

2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
	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;
		}
2369

2370 2371 2372
		sband->ht_cap.ht_supported = true;
		sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
				    IEEE80211_HT_CAP_GRN_FLD |
B
Ben Greear 已提交
2373
				    IEEE80211_HT_CAP_SGI_20 |
2374 2375 2376 2377 2378 2379 2380 2381 2382
				    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;
2383

2384
		hw->wiphy->bands[band] = sband;
2385

2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
		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_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;
	}
2411

2412 2413 2414
	/* By default all radios belong to the first group */
	data->group = 1;
	mutex_init(&data->mutex);
2415

2416 2417 2418
	/* Enable frame retransmissions for lossy channels */
	hw->max_rates = 4;
	hw->max_rate_tries = 11;
2419

2420
	if (param->reg_strict)
2421
		hw->wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
2422
	if (param->regd) {
2423
		data->regd = param->regd;
2424
		hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2425
		wiphy_apply_custom_regulatory(hw->wiphy, param->regd);
2426 2427 2428
		/* give the regulatory workqueue a chance to run */
		schedule_timeout_interruptible(1);
	}
2429

2430
	if (param->no_vif)
2431 2432
		hw->flags |= IEEE80211_HW_NO_AUTO_VIF;

2433 2434 2435 2436 2437 2438
	err = ieee80211_register_hw(hw);
	if (err < 0) {
		printk(KERN_DEBUG "mac80211_hwsim: ieee80211_register_hw failed (%d)\n",
		       err);
		goto failed_hw;
	}
2439

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

2442 2443 2444
	if (param->reg_alpha2) {
		data->alpha2[0] = param->reg_alpha2[0];
		data->alpha2[1] = param->reg_alpha2[1];
2445
		regulatory_hint(hw->wiphy, param->reg_alpha2);
2446
	}
2447

2448 2449 2450 2451
	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);
2452
	if (!data->use_chanctx)
2453 2454 2455
		debugfs_create_file("dfs_simulate_radar", 0222,
				    data->debugfs,
				    data, &hwsim_simulate_radar);
2456

2457 2458 2459
	tasklet_hrtimer_init(&data->beacon_timer,
			     mac80211_hwsim_beacon,
			     CLOCK_MONOTONIC_RAW, HRTIMER_MODE_ABS);
2460

2461 2462 2463
	spin_lock_bh(&hwsim_radio_lock);
	list_add_tail(&data->list, &hwsim_radios);
	spin_unlock_bh(&hwsim_radio_lock);
2464

2465
	if (idx > 0)
2466
		hwsim_mcast_new_radio(idx, info, param);
2467

2468
	return idx;
2469

2470
failed_hw:
2471 2472
	device_release_driver(data->dev);
failed_bind:
2473 2474 2475 2476 2477
	device_unregister(data->dev);
failed_drvdata:
	ieee80211_free_hw(hw);
failed:
	return err;
2478 2479
}

2480 2481
static void hwsim_mcast_del_radio(int id, const char *hwname,
				  struct genl_info *info)
2482
{
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499
	struct sk_buff *skb;
	void *data;
	int ret;

	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (!skb)
		return;

	data = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
			   HWSIM_CMD_DEL_RADIO);
	if (!data)
		goto error;

	ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
	if (ret < 0)
		goto error;

2500 2501 2502 2503
	ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME, strlen(hwname),
		      hwname);
	if (ret < 0)
		goto error;
2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519

	genlmsg_end(skb, data);

	hwsim_mcast_config_msg(skb, info);

	return;

error:
	nlmsg_free(skb);
}

static void mac80211_hwsim_del_radio(struct mac80211_hwsim_data *data,
				     const char *hwname,
				     struct genl_info *info)
{
	hwsim_mcast_del_radio(data->idx, hwname, info);
2520 2521 2522 2523 2524
	debugfs_remove_recursive(data->debugfs);
	ieee80211_unregister_hw(data->hw);
	device_release_driver(data->dev);
	device_unregister(data->dev);
	ieee80211_free_hw(data->hw);
2525 2526
}

2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543
static int mac80211_hwsim_get_radio(struct sk_buff *skb,
				    struct mac80211_hwsim_data *data,
				    u32 portid, u32 seq,
				    struct netlink_callback *cb, int flags)
{
	void *hdr;
	struct hwsim_new_radio_params param = { };
	int res = -EMSGSIZE;

	hdr = genlmsg_put(skb, portid, seq, &hwsim_genl_family, flags,
			  HWSIM_CMD_GET_RADIO);
	if (!hdr)
		return -EMSGSIZE;

	if (cb)
		genl_dump_check_consistent(cb, hdr, &hwsim_genl_family);

2544 2545 2546
	if (data->alpha2[0] && data->alpha2[1])
		param.reg_alpha2 = data->alpha2;

2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559
	param.reg_strict = !!(data->hw->wiphy->regulatory_flags &
					REGULATORY_STRICT_REG);
	param.p2p_device = !!(data->hw->wiphy->interface_modes &
					BIT(NL80211_IFTYPE_P2P_DEVICE));
	param.use_chanctx = data->use_chanctx;
	param.regd = data->regd;
	param.channels = data->channels;
	param.hwname = wiphy_name(data->hw->wiphy);

	res = append_radio_msg(skb, data->idx, &param);
	if (res < 0)
		goto out_err;

2560 2561
	genlmsg_end(skb, hdr);
	return 0;
2562 2563 2564 2565 2566 2567

out_err:
	genlmsg_cancel(skb, hdr);
	return res;
}

2568
static void mac80211_hwsim_free(void)
2569
{
2570
	struct mac80211_hwsim_data *data;
2571

2572 2573 2574 2575 2576 2577
	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);
2578 2579
		mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
					 NULL);
2580
		spin_lock_bh(&hwsim_radio_lock);
2581
	}
2582 2583
	spin_unlock_bh(&hwsim_radio_lock);
	class_destroy(hwsim_class);
2584 2585
}

2586 2587 2588 2589 2590 2591
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 已提交
2592

2593
static void hwsim_mon_setup(struct net_device *dev)
D
Daniel Wagner 已提交
2594
{
2595 2596 2597 2598 2599 2600 2601
	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 已提交
2602 2603
}

2604
static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr)
2605 2606 2607 2608 2609 2610
{
	struct mac80211_hwsim_data *data;
	bool _found = false;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
2611
		if (memcmp(data->addresses[1].addr, addr, ETH_ALEN) == 0) {
2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
			_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;
2632
	unsigned long ret_skb_ptr;
2633
	struct sk_buff *skb, *tmp;
2634
	const u8 *src;
2635 2636 2637 2638
	unsigned int hwsim_flags;
	int i;
	bool found = false;

2639 2640 2641
	if (info->snd_portid != wmediumd_portid)
		return -EINVAL;

2642
	if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
2643 2644 2645
	    !info->attrs[HWSIM_ATTR_FLAGS] ||
	    !info->attrs[HWSIM_ATTR_COOKIE] ||
	    !info->attrs[HWSIM_ATTR_TX_INFO])
2646 2647
		goto out;

2648
	src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
2649
	hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
2650
	ret_skb_ptr = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
2651 2652

	data2 = get_hwsim_data_ref_from_addr(src);
2653
	if (!data2)
2654 2655 2656 2657
		goto out;

	/* look for the skb matching the cookie passed back from user */
	skb_queue_walk_safe(&data2->pending, skb, tmp) {
2658
		if ((unsigned long)skb == ret_skb_ptr) {
2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691
			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;
2692
			mac80211_hwsim_monitor_ack(data2->channel,
2693
						   hdr->addr2);
2694
		}
2695
		txi->flags |= IEEE80211_TX_STAT_ACK;
2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
	}
	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)
{
2707
	struct mac80211_hwsim_data *data2;
2708
	struct ieee80211_rx_status rx_status;
2709
	const u8 *dst;
2710
	int frame_data_len;
2711
	void *frame_data;
2712 2713
	struct sk_buff *skb = NULL;

2714 2715 2716
	if (info->snd_portid != wmediumd_portid)
		return -EINVAL;

2717
	if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
2718 2719 2720
	    !info->attrs[HWSIM_ATTR_FRAME] ||
	    !info->attrs[HWSIM_ATTR_RX_RATE] ||
	    !info->attrs[HWSIM_ATTR_SIGNAL])
2721 2722
		goto out;

2723
	dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
2724
	frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
2725
	frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
2726 2727 2728 2729 2730 2731

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

2732
	if (frame_data_len > IEEE80211_MAX_DATA_LEN)
2733 2734
		goto err;

2735 2736
	/* Copy the data */
	memcpy(skb_put(skb, frame_data_len), frame_data, frame_data_len);
2737

2738 2739
	data2 = get_hwsim_data_ref_from_addr(dst);
	if (!data2)
2740 2741 2742 2743
		goto out;

	/* check if radio is configured properly */

2744
	if (data2->idle || !data2->started)
2745 2746
		goto out;

2747
	/* A frame is received from user space */
2748
	memset(&rx_status, 0, sizeof(rx_status));
2749 2750 2751
	/* TODO: Check ATTR_FREQ if it exists, and maybe throw away off-channel
	 * packets?
	 */
2752 2753 2754 2755 2756 2757
	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));
2758 2759
	data2->rx_pkts++;
	data2->rx_bytes += skb->len;
2760 2761 2762 2763
	ieee80211_rx_irqsafe(data2->hw, skb);

	return 0;
err:
2764
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
2765 2766 2767 2768 2769 2770 2771 2772
out:
	dev_kfree_skb(skb);
	return -EINVAL;
}

static int hwsim_register_received_nl(struct sk_buff *skb_2,
				      struct genl_info *info)
{
2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788
	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;

2789 2790
	if (wmediumd_portid)
		return -EBUSY;
2791

2792
	wmediumd_portid = info->snd_portid;
2793 2794

	printk(KERN_DEBUG "mac80211_hwsim: received a REGISTER, "
2795
	       "switching to wmediumd mode with pid %d\n", info->snd_portid);
2796 2797 2798 2799

	return 0;
}

2800
static int hwsim_new_radio_nl(struct sk_buff *msg, struct genl_info *info)
2801
{
2802 2803 2804 2805 2806 2807 2808
	struct hwsim_new_radio_params param = { 0 };

	param.reg_strict = info->attrs[HWSIM_ATTR_REG_STRICT_REG];
	param.p2p_device = info->attrs[HWSIM_ATTR_SUPPORT_P2P_DEVICE];
	param.channels = channels;
	param.destroy_on_close =
		info->attrs[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE];
2809 2810

	if (info->attrs[HWSIM_ATTR_CHANNELS])
2811
		param.channels = nla_get_u32(info->attrs[HWSIM_ATTR_CHANNELS]);
2812

2813
	if (info->attrs[HWSIM_ATTR_NO_VIF])
2814
		param.no_vif = true;
2815

2816
	if (info->attrs[HWSIM_ATTR_RADIO_NAME])
2817
		param.hwname = nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]);
2818

2819
	if (info->attrs[HWSIM_ATTR_USE_CHANCTX])
2820
		param.use_chanctx = true;
2821
	else
2822
		param.use_chanctx = (param.channels > 1);
2823

2824
	if (info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2])
2825 2826
		param.reg_alpha2 =
			nla_data(info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]);
2827 2828 2829 2830 2831 2832

	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;
2833
		param.regd = hwsim_world_regdom_custom[idx];
2834 2835
	}

2836
	return mac80211_hwsim_new_radio(info, &param);
2837 2838
}

2839
static int hwsim_del_radio_nl(struct sk_buff *msg, struct genl_info *info)
2840 2841
{
	struct mac80211_hwsim_data *data;
2842 2843
	s64 idx = -1;
	const char *hwname = NULL;
2844

2845 2846 2847 2848 2849
	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
2850 2851 2852 2853
		return -EINVAL;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
2854 2855 2856 2857
		if (idx >= 0) {
			if (data->idx != idx)
				continue;
		} else {
2858
			if (strcmp(hwname, wiphy_name(data->hw->wiphy)))
2859 2860 2861
				continue;
		}

2862 2863
		list_del(&data->list);
		spin_unlock_bh(&hwsim_radio_lock);
2864 2865
		mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
					 info);
2866 2867 2868 2869 2870
		return 0;
	}
	spin_unlock_bh(&hwsim_radio_lock);

	return -ENODEV;
2871 2872
}

2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
static int hwsim_get_radio_nl(struct sk_buff *msg, struct genl_info *info)
{
	struct mac80211_hwsim_data *data;
	struct sk_buff *skb;
	int idx, res = -ENODEV;

	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;

		skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
		if (!skb) {
			res = -ENOMEM;
			goto out_err;
		}

		res = mac80211_hwsim_get_radio(skb, data, info->snd_portid,
					       info->snd_seq, NULL, 0);
		if (res < 0) {
			nlmsg_free(skb);
			goto out_err;
		}

		genlmsg_reply(skb, info);
		break;
	}

out_err:
	spin_unlock_bh(&hwsim_radio_lock);

	return res;
}

static int hwsim_dump_radio_nl(struct sk_buff *skb,
			       struct netlink_callback *cb)
{
	int idx = cb->args[0];
	struct mac80211_hwsim_data *data = NULL;
	int res;

	spin_lock_bh(&hwsim_radio_lock);

	if (idx == hwsim_radio_idx)
		goto done;

	list_for_each_entry(data, &hwsim_radios, list) {
		if (data->idx < idx)
			continue;

		res = mac80211_hwsim_get_radio(skb, data,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq, cb,
					       NLM_F_MULTI);
		if (res < 0)
			break;

		idx = data->idx + 1;
	}

	cb->args[0] = idx;

done:
	spin_unlock_bh(&hwsim_radio_lock);
	return skb->len;
}

2944
/* Generic Netlink operations array */
2945
static const struct genl_ops hwsim_ops[] = {
2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
	{
		.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,
	},
2962
	{
2963
		.cmd = HWSIM_CMD_NEW_RADIO,
2964
		.policy = hwsim_genl_policy,
2965
		.doit = hwsim_new_radio_nl,
2966 2967 2968
		.flags = GENL_ADMIN_PERM,
	},
	{
2969
		.cmd = HWSIM_CMD_DEL_RADIO,
2970
		.policy = hwsim_genl_policy,
2971
		.doit = hwsim_del_radio_nl,
2972 2973
		.flags = GENL_ADMIN_PERM,
	},
2974 2975 2976 2977 2978 2979
	{
		.cmd = HWSIM_CMD_GET_RADIO,
		.policy = hwsim_genl_policy,
		.doit = hwsim_get_radio_nl,
		.dumpit = hwsim_dump_radio_nl,
	},
2980 2981
};

2982 2983 2984 2985 2986
static void destroy_radio(struct work_struct *work)
{
	struct mac80211_hwsim_data *data =
		container_of(work, struct mac80211_hwsim_data, destroy_work);

2987
	mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy), NULL);
2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004
}

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

3005 3006 3007 3008 3009 3010 3011 3012 3013
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;

3014 3015
	remove_user_radios(notify->portid);

3016
	if (notify->portid == wmediumd_portid) {
3017 3018
		printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
		       " socket, switching to perfect channel medium\n");
3019
		wmediumd_portid = 0;
3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031
	}
	return NOTIFY_DONE;

}

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

static int hwsim_init_netlink(void)
{
	int rc;
3032

3033 3034
	printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");

3035 3036 3037
	rc = genl_register_family_with_ops_groups(&hwsim_genl_family,
						  hwsim_ops,
						  hwsim_mcgrps);
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047
	if (rc)
		goto failure;

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

	return 0;

failure:
3048
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
3049 3050 3051 3052 3053 3054 3055 3056
	return -EINVAL;
}

static void hwsim_exit_netlink(void)
{
	/* unregister the notifier */
	netlink_unregister_notifier(&hwsim_netlink_notifier);
	/* unregister the family */
3057
	genl_unregister_family(&hwsim_genl_family);
3058 3059
}

3060 3061
static int __init init_mac80211_hwsim(void)
{
3062
	int i, err;
3063

3064
	if (radios < 0 || radios > 100)
3065 3066
		return -EINVAL;

3067 3068 3069
	if (channels < 1)
		return -EINVAL;

3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083
	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;
3084

3085 3086
	spin_lock_init(&hwsim_radio_lock);
	INIT_LIST_HEAD(&hwsim_radios);
3087

3088
	err = platform_driver_register(&mac80211_hwsim_driver);
3089 3090 3091
	if (err)
		return err;

3092
	hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
3093 3094
	if (IS_ERR(hwsim_class)) {
		err = PTR_ERR(hwsim_class);
3095
		goto out_unregister_driver;
3096
	}
3097

3098 3099 3100 3101
	err = hwsim_init_netlink();
	if (err < 0)
		goto out_unregister_driver;

3102
	for (i = 0; i < radios; i++) {
3103 3104 3105
		struct hwsim_new_radio_params param = { 0 };

		param.channels = channels;
3106

3107 3108
		switch (regtest) {
		case HWSIM_REGTEST_DIFF_COUNTRY:
3109
			if (i < ARRAY_SIZE(hwsim_alpha2s))
3110
				param.reg_alpha2 = hwsim_alpha2s[i];
3111 3112 3113
			break;
		case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
			if (!i)
3114
				param.reg_alpha2 = hwsim_alpha2s[0];
3115 3116
			break;
		case HWSIM_REGTEST_STRICT_ALL:
3117
			param.reg_strict = true;
3118
		case HWSIM_REGTEST_DRIVER_REG_ALL:
3119
			param.reg_alpha2 = hwsim_alpha2s[0];
3120
			break;
3121 3122
		case HWSIM_REGTEST_WORLD_ROAM:
			if (i == 0)
3123
				param.regd = &hwsim_world_regdom_custom_01;
3124 3125
			break;
		case HWSIM_REGTEST_CUSTOM_WORLD:
3126
			param.regd = &hwsim_world_regdom_custom_01;
3127
			break;
3128
		case HWSIM_REGTEST_CUSTOM_WORLD_2:
3129
			if (i == 0)
3130
				param.regd = &hwsim_world_regdom_custom_01;
3131
			else if (i == 1)
3132
				param.regd = &hwsim_world_regdom_custom_02;
3133 3134
			break;
		case HWSIM_REGTEST_STRICT_FOLLOW:
3135
			if (i == 0) {
3136 3137
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[0];
3138
			}
3139 3140
			break;
		case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
3141
			if (i == 0) {
3142 3143
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[0];
3144
			} else if (i == 1) {
3145
				param.reg_alpha2 = hwsim_alpha2s[1];
3146
			}
3147 3148
			break;
		case HWSIM_REGTEST_ALL:
3149 3150
			switch (i) {
			case 0:
3151
				param.regd = &hwsim_world_regdom_custom_01;
3152 3153
				break;
			case 1:
3154
				param.regd = &hwsim_world_regdom_custom_02;
3155 3156
				break;
			case 2:
3157
				param.reg_alpha2 = hwsim_alpha2s[0];
3158 3159
				break;
			case 3:
3160
				param.reg_alpha2 = hwsim_alpha2s[1];
3161 3162
				break;
			case 4:
3163 3164
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[2];
3165 3166
				break;
			}
3167 3168 3169 3170 3171
			break;
		default:
			break;
		}

3172 3173 3174 3175
		param.p2p_device = support_p2p_device;
		param.use_chanctx = channels > 1;

		err = mac80211_hwsim_new_radio(NULL, &param);
3176
		if (err < 0)
3177
			goto out_free_radios;
3178 3179
	}

3180 3181
	hwsim_mon = alloc_netdev(0, "hwsim%d", NET_NAME_UNKNOWN,
				 hwsim_mon_setup);
3182 3183
	if (hwsim_mon == NULL) {
		err = -ENOMEM;
3184
		goto out_free_radios;
3185
	}
3186

3187 3188
	rtnl_lock();
	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
3189 3190 3191 3192
	if (err < 0) {
		rtnl_unlock();
		goto out_free_radios;
	}
3193 3194

	err = register_netdevice(hwsim_mon);
3195 3196 3197 3198
	if (err < 0) {
		rtnl_unlock();
		goto out_free_mon;
	}
3199 3200
	rtnl_unlock();

3201 3202
	return 0;

3203
out_free_mon:
3204
	free_netdev(hwsim_mon);
3205
out_free_radios:
3206
	mac80211_hwsim_free();
3207
out_unregister_driver:
3208
	platform_driver_unregister(&mac80211_hwsim_driver);
3209 3210
	return err;
}
3211
module_init(init_mac80211_hwsim);
3212 3213 3214

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

3217 3218
	hwsim_exit_netlink();

3219
	mac80211_hwsim_free();
3220
	unregister_netdev(hwsim_mon);
3221
	platform_driver_unregister(&mac80211_hwsim_driver);
3222 3223
}
module_exit(exit_mac80211_hwsim);