mac80211_hwsim.c 103.0 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>
I
Ilan Peer 已提交
5
 * Copyright (c) 2016 - 2017 Intel Deutschland GmbH
6 7 8 9 10 11 12 13
 *
 * 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:
14 15
 * - Add TSF sync and fix IBSS beacon transmission by adding
 *   competition for "air time" at TBTT
16 17 18
 * - RX filtering based on filter configuration (data->rx_filter)
 */

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

#define WARN_QUEUE 100
#define MAX_QUEUE 200
42 43 44 45 46 47 48 49 50

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

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

51 52 53
static int channels = 1;
module_param(channels, int, 0444);
MODULE_PARM_DESC(channels, "Number of concurrent channels");
54

55 56 57 58
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");

59 60 61 62
static bool rctbl = false;
module_param(rctbl, bool, 0444);
MODULE_PARM_DESC(rctbl, "Handle rate control table");

63 64 65 66
static bool support_p2p_device = true;
module_param(support_p2p_device, bool, 0444);
MODULE_PARM_DESC(support_p2p_device, "Support P2P-Device interface type");

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
/**
 * 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 已提交
91
 * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We accomplish
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 166 167 168
 *	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,
169
			 NL80211_RRF_NO_IR),
170 171 172
	}
};

173 174 175 176 177
static const struct ieee80211_regdomain *hwsim_world_regdom_custom[] = {
	&hwsim_world_regdom_custom_01,
	&hwsim_world_regdom_custom_02,
};

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

#define HWSIM_VIF_MAGIC	0x69537748

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

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

208 209 210 211
struct hwsim_sta_priv {
	u32 magic;
};

212
#define HWSIM_STA_MAGIC	0x6d537749
213 214 215 216

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

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

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

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
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;
}

256
static unsigned int hwsim_net_id;
257

M
Matthew Wilcox 已提交
258
static DEFINE_IDA(hwsim_netgroup_ida);
259 260 261

struct hwsim_net {
	int netgroup;
262
	u32 wmediumd;
263 264 265 266 267 268 269 270 271
};

static inline int hwsim_net_get_netgroup(struct net *net)
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

	return hwsim_net->netgroup;
}

272
static inline int hwsim_net_set_netgroup(struct net *net)
273 274 275
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

276 277 278
	hwsim_net->netgroup = ida_simple_get(&hwsim_netgroup_ida,
					     0, 0, GFP_KERNEL);
	return hwsim_net->netgroup >= 0 ? 0 : -ENOMEM;
279 280
}

281 282 283 284 285 286 287 288 289 290 291 292 293 294
static inline u32 hwsim_net_get_wmediumd(struct net *net)
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

	return hwsim_net->wmediumd;
}

static inline void hwsim_net_set_wmediumd(struct net *net, u32 portid)
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

	hwsim_net->wmediumd = portid;
}

295 296 297 298
static struct class *hwsim_class;

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

299
#define CHAN2G(_freq)  { \
300
	.band = NL80211_BAND_2GHZ, \
301 302 303 304 305 306
	.center_freq = (_freq), \
	.hw_value = (_freq), \
	.max_power = 20, \
}

#define CHAN5G(_freq) { \
307
	.band = NL80211_BAND_5GHZ, \
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
	.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 */
};
329

330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
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 */
358
	CHAN5G(5845), /* Channel 169 */
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
};

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

376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
#define OUI_QCA 0x001374
#define QCA_NL80211_SUBCMD_TEST 1
enum qca_nl80211_vendor_subcmds {
	QCA_WLAN_VENDOR_ATTR_TEST = 8,
	QCA_WLAN_VENDOR_ATTR_MAX = QCA_WLAN_VENDOR_ATTR_TEST
};

static const struct nla_policy
hwsim_vendor_test_policy[QCA_WLAN_VENDOR_ATTR_MAX + 1] = {
	[QCA_WLAN_VENDOR_ATTR_MAX] = { .type = NLA_U32 },
};

static int mac80211_hwsim_vendor_cmd_test(struct wiphy *wiphy,
					  struct wireless_dev *wdev,
					  const void *data, int data_len)
{
	struct sk_buff *skb;
	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_MAX + 1];
	int err;
	u32 val;

	err = nla_parse(tb, QCA_WLAN_VENDOR_ATTR_MAX, data, data_len,
398
			hwsim_vendor_test_policy, NULL);
399 400 401 402 403
	if (err)
		return err;
	if (!tb[QCA_WLAN_VENDOR_ATTR_TEST])
		return -EINVAL;
	val = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_TEST]);
404
	wiphy_dbg(wiphy, "%s: test=%u\n", __func__, val);
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452

	/* Send a vendor event as a test. Note that this would not normally be
	 * done within a command handler, but rather, based on some other
	 * trigger. For simplicity, this command is used to trigger the event
	 * here.
	 *
	 * event_idx = 0 (index in mac80211_hwsim_vendor_commands)
	 */
	skb = cfg80211_vendor_event_alloc(wiphy, wdev, 100, 0, GFP_KERNEL);
	if (skb) {
		/* skb_put() or nla_put() will fill up data within
		 * NL80211_ATTR_VENDOR_DATA.
		 */

		/* Add vendor data */
		nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 1);

		/* Send the event - this will call nla_nest_end() */
		cfg80211_vendor_event(skb, GFP_KERNEL);
	}

	/* Send a response to the command */
	skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 10);
	if (!skb)
		return -ENOMEM;

	/* skb_put() or nla_put() will fill up data within
	 * NL80211_ATTR_VENDOR_DATA
	 */
	nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 2);

	return cfg80211_vendor_cmd_reply(skb);
}

static struct wiphy_vendor_command mac80211_hwsim_vendor_commands[] = {
	{
		.info = { .vendor_id = OUI_QCA,
			  .subcmd = QCA_NL80211_SUBCMD_TEST },
		.flags = WIPHY_VENDOR_CMD_NEED_NETDEV,
		.doit = mac80211_hwsim_vendor_cmd_test,
	}
};

/* Advertise support vendor specific events */
static const struct nl80211_vendor_cmd_info mac80211_hwsim_vendor_events[] = {
	{ .vendor_id = OUI_QCA, .subcmd = 1 },
};

453 454 455 456 457 458 459 460 461
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) },
462 463
	/* must be last, see hwsim_if_comb */
	{ .max = 1, .types = BIT(NL80211_IFTYPE_P2P_DEVICE) }
464 465 466
};

static const struct ieee80211_iface_combination hwsim_if_comb[] = {
467 468 469 470 471 472 473 474 475 476 477
	{
		.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,
		.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),
478
	},
479 480 481
};

static const struct ieee80211_iface_combination hwsim_if_comb_p2p_dev[] = {
482 483 484 485 486 487 488 489 490 491
	{
		.limits = hwsim_if_limits,
		.n_limits = ARRAY_SIZE(hwsim_if_limits),
		.max_interfaces = 2048,
		.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),
492
	},
493 494
};

495
static spinlock_t hwsim_radio_lock;
496
static LIST_HEAD(hwsim_radios);
497
static struct workqueue_struct *hwsim_wq;
498
static struct rhashtable hwsim_radios_rht;
499
static int hwsim_radio_idx;
500
static int hwsim_radios_generation = 1;
501

502 503 504 505 506
static struct platform_driver mac80211_hwsim_driver = {
	.driver = {
		.name = "mac80211_hwsim",
	},
};
507

508
struct mac80211_hwsim_data {
509
	struct list_head list;
510
	struct rhash_head rht;
511
	struct ieee80211_hw *hw;
512
	struct device *dev;
513
	struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
514 515
	struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
	struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
516
	struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
517
	struct ieee80211_iface_combination if_combination;
518

519
	struct mac_address addresses[2];
520
	int channels, idx;
521
	bool use_chanctx;
522 523 524
	bool destroy_on_close;
	struct work_struct destroy_work;
	u32 portid;
525 526
	char alpha2[2];
	const struct ieee80211_regdomain *regd;
527

528
	struct ieee80211_channel *tmp_chan;
529 530 531
	struct ieee80211_channel *roc_chan;
	u32 roc_duration;
	struct delayed_work roc_start;
532 533 534 535 536
	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;
537
	u8 scan_addr[ETH_ALEN];
538 539 540 541 542
	struct {
		struct ieee80211_channel *channel;
		unsigned long next_start, start, end;
	} survey_data[ARRAY_SIZE(hwsim_channels_2ghz) +
		      ARRAY_SIZE(hwsim_channels_5ghz)];
543

544
	struct ieee80211_channel *channel;
T
Thomas Pedersen 已提交
545
	u64 beacon_int	/* beacon interval in us */;
546
	unsigned int rx_filter;
547 548
	bool started, idle, scanning;
	struct mutex mutex;
T
Thomas Pedersen 已提交
549
	struct tasklet_hrtimer beacon_timer;
550 551 552 553 554
	enum ps_mode {
		PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
	} ps;
	bool ps_poll_pending;
	struct dentry *debugfs;
D
Daniel Wagner 已提交
555

556
	uintptr_t pending_cookie;
557
	struct sk_buff_head pending;	/* packets pending */
D
Daniel Wagner 已提交
558 559 560
	/*
	 * Only radios in the same group can communicate together (the
	 * channel has to match too). Each bit represents a group. A
561
	 * radio can be in more than one group.
D
Daniel Wagner 已提交
562 563
	 */
	u64 group;
564

565 566
	/* group shared by radios created in the same netns */
	int netgroup;
567 568
	/* wmediumd portid responsible for netgroup of this radio */
	u32 wmediumd;
569

570
	/* difference between this hw's clock and the real clock, in usecs */
571
	s64 tsf_offset;
572
	s64 bcn_delta;
573 574
	/* absolute beacon transmission time. Used to cover up "tx" delay. */
	u64 abs_bcn_ts;
575 576 577 578 579 580 581 582

	/* Stats */
	u64 tx_pkts;
	u64 rx_pkts;
	u64 tx_bytes;
	u64 rx_bytes;
	u64 tx_dropped;
	u64 tx_failed;
583 584
};

585 586 587 588 589 590 591
static const struct rhashtable_params hwsim_rht_params = {
	.nelem_hint = 2,
	.automatic_shrinking = true,
	.key_len = ETH_ALEN,
	.key_offset = offsetof(struct mac80211_hwsim_data, addresses[1]),
	.head_offset = offsetof(struct mac80211_hwsim_data, rht),
};
592 593 594

struct hwsim_radiotap_hdr {
	struct ieee80211_radiotap_header hdr;
595
	__le64 rt_tsft;
596 597 598 599
	u8 rt_flags;
	u8 rt_rate;
	__le16 rt_channel;
	__le16 rt_chbitmask;
600
} __packed;
601

602 603 604 605 606 607 608 609
struct hwsim_radiotap_ack_hdr {
	struct ieee80211_radiotap_header hdr;
	u8 rt_flags;
	u8 pad;
	__le16 rt_channel;
	__le16 rt_chbitmask;
} __packed;

610 611
/* MAC80211_HWSIM netlink family */
static struct genl_family hwsim_genl_family;
612

613 614 615 616 617 618 619 620
enum hwsim_multicast_groups {
	HWSIM_MCGRP_CONFIG,
};

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

621 622
/* MAC80211_HWSIM netlink policy */

623
static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
624 625
	[HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
	[HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
626 627 628 629 630 631
	[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,
632 633
				 .len = IEEE80211_TX_MAX_RATES *
					sizeof(struct hwsim_tx_rate)},
634
	[HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
635 636
	[HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 },
	[HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 },
637 638 639
	[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 },
640
	[HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG },
641
	[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE] = { .type = NLA_FLAG },
642 643 644
	[HWSIM_ATTR_RADIO_NAME] = { .type = NLA_STRING },
	[HWSIM_ATTR_NO_VIF] = { .type = NLA_FLAG },
	[HWSIM_ATTR_FREQ] = { .type = NLA_U32 },
645
	[HWSIM_ATTR_PERM_ADDR] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
646
};
647

648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
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;

663 664 665
	wiphy_dbg(data->hw->wiphy,
		  "%s: send PS-Poll to %pM for aid %d\n",
		  __func__, vp->bssid, vp->aid);
666 667 668 669

	skb = dev_alloc_skb(sizeof(*pspoll));
	if (!skb)
		return;
670
	pspoll = skb_put(skb, sizeof(*pspoll));
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
	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;

694 695 696
	wiphy_dbg(data->hw->wiphy,
		  "%s: send data::nullfunc to %pM ps=%d\n",
		  __func__, vp->bssid, ps);
697 698 699 700

	skb = dev_alloc_skb(sizeof(*hdr));
	if (!skb)
		return;
701
	hdr = skb_put(skb, sizeof(*hdr) - ETH_ALEN);
702 703
	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
					 IEEE80211_STYPE_NULLFUNC |
704
					 IEEE80211_FCTL_TODS |
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
					 (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;

	if (val == PS_MANUAL_POLL) {
749 750 751
		if (data->ps != PS_ENABLED)
			return -EINVAL;
		local_bh_disable();
752 753 754
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_ps_poll, data);
755 756 757 758 759 760 761 762
		local_bh_enable();
		return 0;
	}
	old_ps = data->ps;
	data->ps = val;

	local_bh_disable();
	if (old_ps == PS_DISABLED && val != PS_DISABLED) {
763 764 765
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_nullfunc_ps, data);
766
	} else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
767 768 769
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_nullfunc_no_ps, data);
770
	}
771
	local_bh_enable();
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808

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

809 810
static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
					struct net_device *dev)
811 812 813
{
	/* TODO: allow packet injection */
	dev_kfree_skb(skb);
814
	return NETDEV_TX_OK;
815 816
}

817 818 819 820 821
static inline u64 mac80211_hwsim_get_tsf_raw(void)
{
	return ktime_to_us(ktime_get_real());
}

822 823
static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
{
824
	u64 now = mac80211_hwsim_get_tsf_raw();
825 826
	return cpu_to_le64(now + data->tsf_offset);
}
827

828
static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
829
				  struct ieee80211_vif *vif)
830 831 832 833 834 835 836 837 838
{
	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;
839
	u64 now = mac80211_hwsim_get_tsf(hw, vif);
840
	u32 bcn_int = data->beacon_int;
A
Andrew Morton 已提交
841
	u64 delta = abs(tsf - now);
842

843
	/* adjust after beaconing with new timestamp at old TBTT */
844 845 846 847 848
	if (tsf > now) {
		data->tsf_offset += delta;
		data->bcn_delta = do_div(delta, bcn_int);
	} else {
		data->tsf_offset -= delta;
849
		data->bcn_delta = -(s64)do_div(delta, bcn_int);
850
	}
851 852
}

853
static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
854 855
				      struct sk_buff *tx_skb,
				      struct ieee80211_channel *chan)
856 857 858 859 860 861 862 863
{
	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);

864 865 866
	if (WARN_ON(!txrate))
		return;

867 868 869 870 871 872 873
	if (!netif_running(hwsim_mon))
		return;

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

874
	hdr = skb_push(skb, sizeof(*hdr));
875 876 877
	hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
	hdr->hdr.it_pad = 0;
	hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
J
Jouni Malinen 已提交
878 879
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_RATE) |
880
					  (1 << IEEE80211_RADIOTAP_TSFT) |
J
Jouni Malinen 已提交
881
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
882
	hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
883 884
	hdr->rt_flags = 0;
	hdr->rt_rate = txrate->bitrate / 5;
885
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
886 887 888 889 890 891 892 893
	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;
894
	skb_reset_mac_header(skb);
895 896
	skb->ip_summed = CHECKSUM_UNNECESSARY;
	skb->pkt_type = PACKET_OTHERHOST;
J
Jouni Malinen 已提交
897
	skb->protocol = htons(ETH_P_802_2);
898 899 900 901 902
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}


903 904
static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
				       const u8 *addr)
905 906
{
	struct sk_buff *skb;
907
	struct hwsim_radiotap_ack_hdr *hdr;
908 909 910 911 912 913 914 915 916 917
	u16 flags;
	struct ieee80211_hdr *hdr11;

	if (!netif_running(hwsim_mon))
		return;

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

918
	hdr = skb_put(skb, sizeof(*hdr));
919 920 921 922 923 924
	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;
925
	hdr->pad = 0;
926
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
927 928 929
	flags = IEEE80211_CHAN_2GHZ;
	hdr->rt_chbitmask = cpu_to_le16(flags);

930
	hdr11 = skb_put(skb, 10);
931 932 933 934 935 936
	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;
937
	skb_reset_mac_header(skb);
938 939 940 941 942 943 944
	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);
}

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
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,
	};

966 967 968
	if (data->scanning && memcmp(addr, data->scan_addr, ETH_ALEN) == 0)
		return true;

969 970 971 972 973 974 975 976 977
	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;
}
978

979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
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 &&
995
		    mac80211_hwsim_addr_match(data, skb->data + 4)) {
996 997 998 999 1000 1001 1002 1003 1004
			data->ps_poll_pending = false;
			return true;
		}
		return false;
	}

	return true;
}

1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
static int hwsim_unicast_netgroup(struct mac80211_hwsim_data *data,
				  struct sk_buff *skb, int portid)
{
	struct net *net;
	bool found = false;
	int res = -ENOENT;

	rcu_read_lock();
	for_each_net_rcu(net) {
		if (data->netgroup == hwsim_net_get_netgroup(net)) {
			res = genlmsg_unicast(net, skb, portid);
			found = true;
			break;
		}
	}
	rcu_read_unlock();

	if (!found)
		nlmsg_free(skb);

	return res;
}

1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
static inline u16 trans_tx_rate_flags_ieee2hwsim(struct ieee80211_tx_rate *rate)
{
	u16 result = 0;

	if (rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
		result |= MAC80211_HWSIM_TX_RC_USE_RTS_CTS;
	if (rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
		result |= MAC80211_HWSIM_TX_RC_USE_CTS_PROTECT;
	if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
		result |= MAC80211_HWSIM_TX_RC_USE_SHORT_PREAMBLE;
	if (rate->flags & IEEE80211_TX_RC_MCS)
		result |= MAC80211_HWSIM_TX_RC_MCS;
	if (rate->flags & IEEE80211_TX_RC_GREEN_FIELD)
		result |= MAC80211_HWSIM_TX_RC_GREEN_FIELD;
	if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		result |= MAC80211_HWSIM_TX_RC_40_MHZ_WIDTH;
	if (rate->flags & IEEE80211_TX_RC_DUP_DATA)
		result |= MAC80211_HWSIM_TX_RC_DUP_DATA;
	if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
		result |= MAC80211_HWSIM_TX_RC_SHORT_GI;
	if (rate->flags & IEEE80211_TX_RC_VHT_MCS)
		result |= MAC80211_HWSIM_TX_RC_VHT_MCS;
	if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
		result |= MAC80211_HWSIM_TX_RC_80_MHZ_WIDTH;
	if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
		result |= MAC80211_HWSIM_TX_RC_160_MHZ_WIDTH;

	return result;
}

1058 1059
static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
				       struct sk_buff *my_skb,
1060
				       int dst_portid)
1061 1062 1063 1064 1065 1066 1067 1068 1069
{
	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];
1070
	struct hwsim_tx_rate_flag tx_attempts_flags[IEEE80211_TX_MAX_RATES];
1071
	uintptr_t cookie;
1072 1073 1074 1075 1076 1077

	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 */
1078
		while (skb_queue_len(&data->pending) >= WARN_QUEUE) {
1079
			ieee80211_free_txskb(hw, skb_dequeue(&data->pending));
1080 1081
			data->tx_dropped++;
		}
1082 1083
	}

1084
	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1085 1086 1087 1088 1089 1090
	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) {
1091
		pr_debug("mac80211_hwsim: problem with msg_head\n");
1092 1093 1094
		goto nla_put_failure;
	}

1095 1096
	if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
		    ETH_ALEN, data->addresses[1].addr))
1097
		goto nla_put_failure;
1098

1099
	/* We get the skb->data */
1100 1101
	if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
		goto nla_put_failure;
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111

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

1112 1113
	if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
		goto nla_put_failure;
1114

1115 1116 1117
	if (nla_put_u32(skb, HWSIM_ATTR_FREQ, data->channel->center_freq))
		goto nla_put_failure;

1118 1119 1120 1121
	/* 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;
1122
		tx_attempts_flags[i].idx = info->status.rates[i].idx;
1123
		tx_attempts[i].count = info->status.rates[i].count;
1124 1125 1126
		tx_attempts_flags[i].flags =
				trans_tx_rate_flags_ieee2hwsim(
						&info->status.rates[i]);
1127 1128
	}

1129 1130 1131 1132
	if (nla_put(skb, HWSIM_ATTR_TX_INFO,
		    sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
		    tx_attempts))
		goto nla_put_failure;
1133

1134 1135 1136 1137 1138
	if (nla_put(skb, HWSIM_ATTR_TX_INFO_FLAGS,
		    sizeof(struct hwsim_tx_rate_flag) * IEEE80211_TX_MAX_RATES,
		    tx_attempts_flags))
		goto nla_put_failure;

1139
	/* We create a cookie to identify this skb */
1140 1141 1142
	data->pending_cookie++;
	cookie = data->pending_cookie;
	info->rate_driver_data[0] = (void *)cookie;
1143
	if (nla_put_u64_64bit(skb, HWSIM_ATTR_COOKIE, cookie, HWSIM_ATTR_PAD))
1144
		goto nla_put_failure;
1145 1146

	genlmsg_end(skb, msg_head);
1147
	if (hwsim_unicast_netgroup(data, skb, dst_portid))
1148
		goto err_free_txskb;
1149 1150 1151

	/* Enqueue the packet */
	skb_queue_tail(&data->pending, my_skb);
1152 1153
	data->tx_pkts++;
	data->tx_bytes += my_skb->len;
1154 1155 1156
	return;

nla_put_failure:
1157 1158
	nlmsg_free(skb);
err_free_txskb:
1159
	pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
1160
	ieee80211_free_txskb(hw, my_skb);
1161
	data->tx_failed++;
1162 1163
}

1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
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,
1187
				rcu_dereference(vif->chanctx_conf)->def.chan))
1188 1189 1190 1191 1192
		return;

	data->receive = true;
}

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
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.
	 */
1212
	rtap = skb_push(skb, sizeof(*rtap) + 8 + 4);
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
	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
}

1240
static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
1241 1242
					  struct sk_buff *skb,
					  struct ieee80211_channel *chan)
1243
{
1244 1245
	struct mac80211_hwsim_data *data = hw->priv, *data2;
	bool ack = false;
1246
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1247
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1248
	struct ieee80211_rx_status rx_status;
1249
	u64 now;
1250 1251

	memset(&rx_status, 0, sizeof(rx_status));
1252
	rx_status.flag |= RX_FLAG_MACTIME_START;
1253 1254
	rx_status.freq = chan->center_freq;
	rx_status.band = chan->band;
1255 1256 1257
	if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
		rx_status.rate_idx =
			ieee80211_rate_get_vht_mcs(&info->control.rates[0]);
1258
		rx_status.nss =
1259
			ieee80211_rate_get_vht_nss(&info->control.rates[0]);
1260
		rx_status.encoding = RX_ENC_VHT;
1261 1262 1263
	} else {
		rx_status.rate_idx = info->control.rates[0].idx;
		if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
1264
			rx_status.encoding = RX_ENC_HT;
1265
	}
1266
	if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
1267 1268 1269 1270 1271 1272 1273
		rx_status.bw = RATE_INFO_BW_40;
	else if (info->control.rates[0].flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
		rx_status.bw = RATE_INFO_BW_80;
	else if (info->control.rates[0].flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
		rx_status.bw = RATE_INFO_BW_160;
	else
		rx_status.bw = RATE_INFO_BW_20;
1274
	if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
1275
		rx_status.enc_flags |= RX_ENC_FLAG_SHORT_GI;
1276
	/* TODO: simulate real signal strength (and optional packet loss) */
1277 1278 1279
	rx_status.signal = -50;
	if (info->control.vif)
		rx_status.signal += info->control.vif->bss_conf.txpower;
1280

1281 1282 1283
	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);

1284 1285
	/* release the skb's source info */
	skb_orphan(skb);
1286
	skb_dst_drop(skb);
1287 1288 1289 1290
	skb->mark = 0;
	secpath_reset(skb);
	nf_reset(skb);

1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
	/*
	 * 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();

1304
	/* Copy skb to all enabled radios that are on the current frequency */
1305 1306
	spin_lock(&hwsim_radio_lock);
	list_for_each_entry(data2, &hwsim_radios, list) {
1307
		struct sk_buff *nskb;
1308 1309 1310 1311
		struct tx_iter_data tx_iter_data = {
			.receive = false,
			.channel = chan,
		};
1312

1313
		if (data == data2)
1314
			continue;
1315

1316 1317
		if (!data2->started || (data2->idle && !data2->tmp_chan) ||
		    !hwsim_ps_rx_ok(data2, skb))
1318 1319
			continue;

1320 1321 1322
		if (!(data->group & data2->group))
			continue;

1323 1324 1325
		if (data->netgroup != data2->netgroup)
			continue;

1326 1327 1328
		if (!hwsim_chans_compat(chan, data2->tmp_chan) &&
		    !hwsim_chans_compat(chan, data2->channel)) {
			ieee80211_iterate_active_interfaces_atomic(
1329 1330
				data2->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_tx_iter, &tx_iter_data);
1331 1332 1333 1334
			if (!tx_iter_data.receive)
				continue;
		}

1335 1336 1337 1338
		/*
		 * reserve some space for our vendor and the normal
		 * radiotap header, since we're copying anyway
		 */
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
		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;
		}
1358

1359
		if (mac80211_hwsim_addr_match(data2, hdr->addr1))
1360
			ack = true;
1361

1362
		rx_status.mactime = now + data2->tsf_offset;
1363

1364
		memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
1365 1366 1367

		mac80211_hwsim_add_vendor_rtap(nskb);

1368 1369
		data2->rx_pkts++;
		data2->rx_bytes += nskb->len;
1370
		ieee80211_rx_irqsafe(data2->hw, nskb);
1371
	}
1372
	spin_unlock(&hwsim_radio_lock);
1373

1374 1375 1376
	return ack;
}

1377 1378 1379
static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
			      struct ieee80211_tx_control *control,
			      struct sk_buff *skb)
1380
{
1381 1382
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
1383
	struct ieee80211_hdr *hdr = (void *)skb->data;
1384 1385
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_channel *channel;
1386
	bool ack;
1387
	u32 _portid;
1388

1389
	if (WARN_ON(skb->len < 10)) {
1390
		/* Should not happen; just a sanity check for addr1 use */
1391
		ieee80211_free_txskb(hw, skb);
1392
		return;
1393 1394
	}

1395
	if (!data->use_chanctx) {
1396 1397 1398 1399 1400 1401
		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)
1402
			channel = chanctx_conf->def.chan;
1403 1404 1405 1406 1407
		else
			channel = NULL;
	}

	if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
1408
		ieee80211_free_txskb(hw, skb);
1409 1410 1411 1412
		return;
	}

	if (data->idle && !data->tmp_chan) {
1413
		wiphy_dbg(hw->wiphy, "Trying to TX when idle - reject\n");
1414
		ieee80211_free_txskb(hw, skb);
1415 1416 1417 1418 1419 1420 1421 1422
		return;
	}

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

1423
	if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1424 1425 1426
		ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
1427

1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
	if (skb->len >= 24 + 8 &&
	    ieee80211_is_probe_resp(hdr->frame_control)) {
		/* fake header transmission time */
		struct ieee80211_mgmt *mgmt;
		struct ieee80211_rate *txrate;
		u64 ts;

		mgmt = (struct ieee80211_mgmt *)skb->data;
		txrate = ieee80211_get_tx_rate(hw, txi);
		ts = mac80211_hwsim_get_tsf_raw();
		mgmt->u.probe_resp.timestamp =
			cpu_to_le64(ts + data->tsf_offset +
				    24 * 8 * 10 / txrate->bitrate);
	}

1443 1444
	mac80211_hwsim_monitor_rx(hw, skb, channel);

1445
	/* wmediumd mode check */
1446
	_portid = READ_ONCE(data->wmediumd);
1447

1448 1449
	if (_portid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
1450 1451

	/* NO wmediumd detected, perfect medium simulation */
1452 1453
	data->tx_pkts++;
	data->tx_bytes += skb->len;
1454
	ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
1455

1456
	if (ack && skb->len >= 16)
1457
		mac80211_hwsim_monitor_ack(channel, hdr->addr2);
1458

1459
	ieee80211_tx_info_clear_status(txi);
1460 1461 1462 1463 1464

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

1465 1466
	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
		txi->flags |= IEEE80211_TX_STAT_ACK;
1467 1468 1469 1470 1471 1472 1473
	ieee80211_tx_status_irqsafe(hw, skb);
}


static int mac80211_hwsim_start(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1474
	wiphy_dbg(hw->wiphy, "%s\n", __func__);
1475
	data->started = true;
1476 1477 1478 1479 1480 1481 1482
	return 0;
}


static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1483
	data->started = false;
T
Thomas Pedersen 已提交
1484
	tasklet_hrtimer_cancel(&data->beacon_timer);
1485
	wiphy_dbg(hw->wiphy, "%s\n", __func__);
1486 1487 1488 1489
}


static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1490
					struct ieee80211_vif *vif)
1491
{
1492 1493 1494
	wiphy_dbg(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
		  __func__, ieee80211_vif_type_p2p(vif),
		  vif->addr);
1495
	hwsim_set_magic(vif);
1496 1497 1498 1499 1500 1501 1502

	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;

1503 1504 1505 1506
	return 0;
}


1507 1508
static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
					   struct ieee80211_vif *vif,
1509 1510
					   enum nl80211_iftype newtype,
					   bool newp2p)
1511
{
1512
	newtype = ieee80211_iftype_p2p(newtype, newp2p);
1513 1514 1515
	wiphy_dbg(hw->wiphy,
		  "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
		  __func__, ieee80211_vif_type_p2p(vif),
1516
		    newtype, vif->addr);
1517 1518
	hwsim_check_magic(vif);

1519 1520 1521 1522 1523 1524
	/*
	 * interface may change from non-AP to AP in
	 * which case this needs to be set up again
	 */
	vif->cab_queue = 0;

1525 1526 1527
	return 0;
}

1528
static void mac80211_hwsim_remove_interface(
1529
	struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1530
{
1531 1532 1533
	wiphy_dbg(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
		  __func__, ieee80211_vif_type_p2p(vif),
		  vif->addr);
1534 1535
	hwsim_check_magic(vif);
	hwsim_clear_magic(vif);
1536 1537
}

1538 1539 1540 1541
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan)
{
1542
	struct mac80211_hwsim_data *data = hw->priv;
1543
	u32 _pid = READ_ONCE(data->wmediumd);
1544

1545
	if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE)) {
1546 1547 1548 1549 1550 1551
		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));
	}

1552 1553 1554 1555 1556 1557 1558 1559
	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);
}
1560 1561 1562 1563

static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
				     struct ieee80211_vif *vif)
{
1564 1565 1566 1567 1568
	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;
1569 1570
	struct sk_buff *skb;

1571 1572
	hwsim_check_magic(vif);

1573
	if (vif->type != NL80211_IFTYPE_AP &&
1574 1575
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_ADHOC)
1576 1577 1578 1579 1580
		return;

	skb = ieee80211_beacon_get(hw, vif);
	if (skb == NULL)
		return;
1581
	info = IEEE80211_SKB_CB(skb);
1582
	if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1583 1584 1585 1586
		ieee80211_get_tx_rates(vif, NULL, skb,
				       info->control.rates,
				       ARRAY_SIZE(info->control.rates));

1587 1588 1589 1590 1591 1592 1593 1594
	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);
1595

1596
	mac80211_hwsim_tx_frame(hw, skb,
1597
				rcu_dereference(vif->chanctx_conf)->def.chan);
1598 1599 1600

	if (vif->csa_active && ieee80211_csa_is_complete(vif))
		ieee80211_csa_finish(vif);
1601 1602
}

T
Thomas Pedersen 已提交
1603 1604
static enum hrtimer_restart
mac80211_hwsim_beacon(struct hrtimer *timer)
1605
{
T
Thomas Pedersen 已提交
1606 1607 1608 1609 1610 1611
	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;
1612

1613
	if (!data->started)
T
Thomas Pedersen 已提交
1614
		goto out;
1615

J
Jouni Malinen 已提交
1616
	ieee80211_iterate_active_interfaces_atomic(
1617
		hw, IEEE80211_IFACE_ITER_NORMAL,
1618
		mac80211_hwsim_beacon_tx, data);
1619

1620 1621 1622 1623 1624 1625
	/* beacon at new TBTT + beacon interval */
	if (data->bcn_delta) {
		bcn_int -= data->bcn_delta;
		data->bcn_delta = 0;
	}

T
Thomas Pedersen 已提交
1626 1627 1628 1629 1630
	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;
1631 1632
}

1633 1634 1635 1636 1637 1638 1639
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",
1640
};
1641

1642
static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1643 1644
{
	struct mac80211_hwsim_data *data = hw->priv;
1645
	struct ieee80211_conf *conf = &hw->conf;
1646 1647 1648 1649 1650 1651
	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",
	};
1652
	int idx;
1653

1654
	if (conf->chandef.chan)
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
		wiphy_dbg(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]);
1665
	else
1666 1667 1668 1669 1670 1671
		wiphy_dbg(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]);
1672

1673 1674
	data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);

1675
	WARN_ON(conf->chandef.chan && data->use_chanctx);
1676

1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
	mutex_lock(&data->mutex);
	if (data->scanning && conf->chandef.chan) {
		for (idx = 0; idx < ARRAY_SIZE(data->survey_data); idx++) {
			if (data->survey_data[idx].channel == data->channel) {
				data->survey_data[idx].start =
					data->survey_data[idx].next_start;
				data->survey_data[idx].end = jiffies;
				break;
			}
		}

		data->channel = conf->chandef.chan;
1689

1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
		for (idx = 0; idx < ARRAY_SIZE(data->survey_data); idx++) {
			if (data->survey_data[idx].channel &&
			    data->survey_data[idx].channel != data->channel)
				continue;
			data->survey_data[idx].channel = data->channel;
			data->survey_data[idx].next_start = jiffies;
			break;
		}
	} else {
		data->channel = conf->chandef.chan;
	}
	mutex_unlock(&data->mutex);
1702

1703
	if (!data->started || !data->beacon_int)
T
Thomas Pedersen 已提交
1704 1705
		tasklet_hrtimer_cancel(&data->beacon_timer);
	else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
1706 1707 1708 1709
		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 已提交
1710
		tasklet_hrtimer_start(&data->beacon_timer,
1711
				      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1712 1713
				      HRTIMER_MODE_REL);
	}
1714 1715 1716 1717 1718 1719 1720

	return 0;
}


static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
					    unsigned int changed_flags,
1721
					    unsigned int *total_flags,u64 multicast)
1722 1723 1724
{
	struct mac80211_hwsim_data *data = hw->priv;

1725
	wiphy_dbg(hw->wiphy, "%s\n", __func__);
1726 1727 1728 1729 1730 1731 1732 1733

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

	*total_flags = data->rx_filter;
}

1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
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)++;
}

1744 1745 1746 1747 1748
static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif,
					    struct ieee80211_bss_conf *info,
					    u32 changed)
{
1749
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1750
	struct mac80211_hwsim_data *data = hw->priv;
1751

1752
	hwsim_check_magic(vif);
1753

1754 1755
	wiphy_dbg(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n",
		  __func__, changed, vif->addr);
1756

1757
	if (changed & BSS_CHANGED_BSSID) {
1758 1759
		wiphy_dbg(hw->wiphy, "%s: BSSID changed: %pM\n",
			  __func__, info->bssid);
1760 1761 1762
		memcpy(vp->bssid, info->bssid, ETH_ALEN);
	}

1763
	if (changed & BSS_CHANGED_ASSOC) {
1764 1765
		wiphy_dbg(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
			  info->assoc, info->aid);
1766 1767
		vp->assoc = info->assoc;
		vp->aid = info->aid;
1768 1769
	}

T
Thomas Pedersen 已提交
1770
	if (changed & BSS_CHANGED_BEACON_ENABLED) {
1771 1772
		wiphy_dbg(hw->wiphy, "  BCN EN: %d (BI=%u)\n",
			  info->enable_beacon, info->beacon_int);
1773
		vp->bcn_en = info->enable_beacon;
T
Thomas Pedersen 已提交
1774 1775 1776
		if (data->started &&
		    !hrtimer_is_queued(&data->beacon_timer.timer) &&
		    info->enable_beacon) {
1777 1778
			u64 tsf, until_tbtt;
			u32 bcn_int;
1779
			data->beacon_int = info->beacon_int * 1024;
1780 1781 1782
			tsf = mac80211_hwsim_get_tsf(hw, vif);
			bcn_int = data->beacon_int;
			until_tbtt = bcn_int - do_div(tsf, bcn_int);
T
Thomas Pedersen 已提交
1783
			tasklet_hrtimer_start(&data->beacon_timer,
1784
					      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1785
					      HRTIMER_MODE_REL);
1786 1787
		} else if (!info->enable_beacon) {
			unsigned int count = 0;
1788
			ieee80211_iterate_active_interfaces_atomic(
1789 1790
				data->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_bcn_en_iter, &count);
1791 1792
			wiphy_dbg(hw->wiphy, "  beaconing vifs remaining: %u",
				  count);
1793
			if (count == 0) {
1794
				tasklet_hrtimer_cancel(&data->beacon_timer);
1795 1796
				data->beacon_int = 0;
			}
1797
		}
1798 1799
	}

1800
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1801 1802
		wiphy_dbg(hw->wiphy, "  ERP_CTS_PROT: %d\n",
			  info->use_cts_prot);
1803 1804 1805
	}

	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1806 1807
		wiphy_dbg(hw->wiphy, "  ERP_PREAMBLE: %d\n",
			  info->use_short_preamble);
1808 1809 1810
	}

	if (changed & BSS_CHANGED_ERP_SLOT) {
1811
		wiphy_dbg(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
1812 1813 1814
	}

	if (changed & BSS_CHANGED_HT) {
1815 1816
		wiphy_dbg(hw->wiphy, "  HT: op_mode=0x%x\n",
			  info->ht_operation_mode);
1817 1818 1819
	}

	if (changed & BSS_CHANGED_BASIC_RATES) {
1820 1821
		wiphy_dbg(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
			  (unsigned long long) info->basic_rates);
1822
	}
1823 1824

	if (changed & BSS_CHANGED_TXPOWER)
1825
		wiphy_dbg(hw->wiphy, "  TX Power: %d dBm\n", info->txpower);
1826 1827
}

1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
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;
}

1848 1849
static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
1850 1851
				      enum sta_notify_cmd cmd,
				      struct ieee80211_sta *sta)
1852 1853
{
	hwsim_check_magic(vif);
1854

1855
	switch (cmd) {
1856 1857 1858 1859
	case STA_NOTIFY_SLEEP:
	case STA_NOTIFY_AWAKE:
		/* TODO: make good use of these flags */
		break;
1860 1861 1862
	default:
		WARN(1, "Invalid sta notify: %d\n", cmd);
		break;
1863 1864 1865 1866 1867 1868 1869 1870 1871
	}
}

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

1874
static int mac80211_hwsim_conf_tx(
1875 1876
	struct ieee80211_hw *hw,
	struct ieee80211_vif *vif, u16 queue,
1877 1878
	const struct ieee80211_tx_queue_params *params)
{
1879 1880 1881 1882 1883
	wiphy_dbg(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);
1884 1885 1886
	return 0;
}

1887 1888
static int mac80211_hwsim_get_survey(struct ieee80211_hw *hw, int idx,
				     struct survey_info *survey)
1889
{
1890
	struct mac80211_hwsim_data *hwsim = hw->priv;
1891

1892
	if (idx < 0 || idx >= ARRAY_SIZE(hwsim->survey_data))
1893 1894
		return -ENOENT;

1895 1896 1897 1898 1899 1900
	mutex_lock(&hwsim->mutex);
	survey->channel = hwsim->survey_data[idx].channel;
	if (!survey->channel) {
		mutex_unlock(&hwsim->mutex);
		return -ENOENT;
	}
1901 1902

	/*
1903
	 * Magically conjured dummy values --- this is only ok for simulated hardware.
1904
	 *
1905 1906
	 * A real driver which cannot determine real values noise MUST NOT
	 * report any, especially not a magically conjured ones :-)
1907
	 */
1908 1909 1910
	survey->filled = SURVEY_INFO_NOISE_DBM |
			 SURVEY_INFO_TIME |
			 SURVEY_INFO_TIME_BUSY;
1911
	survey->noise = -92;
1912 1913 1914 1915 1916 1917
	survey->time =
		jiffies_to_msecs(hwsim->survey_data[idx].end -
				 hwsim->survey_data[idx].start);
	/* report 12.5% of channel time is used */
	survey->time_busy = survey->time/8;
	mutex_unlock(&hwsim->mutex);
1918 1919 1920 1921

	return 0;
}

1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
#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,
1942 1943
	HWSIM_TM_CMD_STOP_QUEUES	= 2,
	HWSIM_TM_CMD_WAKE_QUEUES	= 3,
1944 1945 1946 1947 1948 1949 1950
};

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 已提交
1951
static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1952
				       struct ieee80211_vif *vif,
J
Johannes Berg 已提交
1953
				       void *data, int len)
1954 1955 1956 1957 1958 1959 1960
{
	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,
1961
			hwsim_testmode_policy, NULL);
1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
	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;
1979 1980
		if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
			goto nla_put_failure;
1981
		return cfg80211_testmode_reply(skb);
1982 1983 1984 1985 1986 1987
	case HWSIM_TM_CMD_STOP_QUEUES:
		ieee80211_stop_queues(hw);
		return 0;
	case HWSIM_TM_CMD_WAKE_QUEUES:
		ieee80211_wake_queues(hw);
		return 0;
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
	default:
		return -EOPNOTSUPP;
	}

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

1998 1999
static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
2000
				       struct ieee80211_ampdu_params *params)
2001
{
2002 2003 2004 2005
	struct ieee80211_sta *sta = params->sta;
	enum ieee80211_ampdu_mlme_action action = params->action;
	u16 tid = params->tid;

2006 2007 2008 2009
	switch (action) {
	case IEEE80211_AMPDU_TX_START:
		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
		break;
2010 2011 2012
	case IEEE80211_AMPDU_TX_STOP_CONT:
	case IEEE80211_AMPDU_TX_STOP_FLUSH:
	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
		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;
}

2027 2028 2029
static void mac80211_hwsim_flush(struct ieee80211_hw *hw,
				 struct ieee80211_vif *vif,
				 u32 queues, bool drop)
2030
{
2031
	/* Not implemented, queues only on kernel side */
2032 2033
}

2034
static void hw_scan_work(struct work_struct *work)
2035
{
2036 2037 2038 2039
	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;
2040

2041 2042
	mutex_lock(&hwsim->mutex);
	if (hwsim->scan_chan_idx >= req->n_channels) {
2043 2044 2045 2046
		struct cfg80211_scan_info info = {
			.aborted = false,
		};

2047
		wiphy_dbg(hwsim->hw->wiphy, "hw scan complete\n");
2048
		ieee80211_scan_completed(hwsim->hw, &info);
2049 2050 2051 2052 2053 2054 2055
		hwsim->hw_scan_request = NULL;
		hwsim->hw_scan_vif = NULL;
		hwsim->tmp_chan = NULL;
		mutex_unlock(&hwsim->mutex);
		return;
	}

2056 2057
	wiphy_dbg(hwsim->hw->wiphy, "hw scan %d MHz\n",
		  req->channels[hwsim->scan_chan_idx]->center_freq);
2058 2059

	hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx];
2060 2061
	if (hwsim->tmp_chan->flags & (IEEE80211_CHAN_NO_IR |
				      IEEE80211_CHAN_RADAR) ||
2062 2063 2064 2065 2066 2067 2068
	    !req->n_ssids) {
		dwell = 120;
	} else {
		dwell = 30;
		/* send probes */
		for (i = 0; i < req->n_ssids; i++) {
			struct sk_buff *probe;
2069
			struct ieee80211_mgmt *mgmt;
2070 2071

			probe = ieee80211_probereq_get(hwsim->hw,
2072
						       hwsim->scan_addr,
2073 2074
						       req->ssids[i].ssid,
						       req->ssids[i].ssid_len,
2075
						       req->ie_len);
2076 2077
			if (!probe)
				continue;
2078

2079 2080 2081 2082
			mgmt = (struct ieee80211_mgmt *) probe->data;
			memcpy(mgmt->da, req->bssid, ETH_ALEN);
			memcpy(mgmt->bssid, req->bssid, ETH_ALEN);

2083
			if (req->ie_len)
2084
				skb_put_data(probe, req->ie, req->ie_len);
2085

2086 2087 2088 2089 2090 2091 2092 2093
			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));
2094 2095 2096 2097
	hwsim->survey_data[hwsim->scan_chan_idx].channel = hwsim->tmp_chan;
	hwsim->survey_data[hwsim->scan_chan_idx].start = jiffies;
	hwsim->survey_data[hwsim->scan_chan_idx].end =
		jiffies + msecs_to_jiffies(dwell);
2098 2099
	hwsim->scan_chan_idx++;
	mutex_unlock(&hwsim->mutex);
2100 2101 2102
}

static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
2103
				  struct ieee80211_vif *vif,
2104
				  struct ieee80211_scan_request *hw_req)
2105
{
2106
	struct mac80211_hwsim_data *hwsim = hw->priv;
2107
	struct cfg80211_scan_request *req = &hw_req->req;
2108

2109 2110 2111 2112 2113 2114 2115 2116
	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;
2117 2118 2119 2120 2121 2122
	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);
2123
	memset(hwsim->survey_data, 0, sizeof(hwsim->survey_data));
2124
	mutex_unlock(&hwsim->mutex);
2125

2126
	wiphy_dbg(hw->wiphy, "hwsim hw_scan request\n");
2127

2128
	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
2129 2130 2131 2132

	return 0;
}

2133 2134 2135 2136
static void mac80211_hwsim_cancel_hw_scan(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *hwsim = hw->priv;
2137 2138 2139
	struct cfg80211_scan_info info = {
		.aborted = true,
	};
2140

2141
	wiphy_dbg(hw->wiphy, "hwsim cancel_hw_scan\n");
2142 2143 2144 2145

	cancel_delayed_work_sync(&hwsim->hw_scan);

	mutex_lock(&hwsim->mutex);
2146
	ieee80211_scan_completed(hwsim->hw, &info);
2147 2148 2149 2150 2151 2152
	hwsim->tmp_chan = NULL;
	hwsim->hw_scan_request = NULL;
	hwsim->hw_scan_vif = NULL;
	mutex_unlock(&hwsim->mutex);
}

2153 2154 2155
static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   const u8 *mac_addr)
2156 2157 2158 2159 2160 2161
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);

	if (hwsim->scanning) {
2162
		pr_debug("two hwsim sw_scans detected!\n");
2163 2164 2165
		goto out;
	}

2166
	pr_debug("hwsim sw_scan request, prepping stuff\n");
2167 2168

	memcpy(hwsim->scan_addr, mac_addr, ETH_ALEN);
2169
	hwsim->scanning = true;
2170
	memset(hwsim->survey_data, 0, sizeof(hwsim->survey_data));
2171 2172 2173 2174 2175

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

2176 2177
static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif)
2178 2179 2180 2181 2182
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);

2183
	pr_debug("hwsim sw_scan_complete\n");
2184
	hwsim->scanning = false;
2185
	eth_zero_addr(hwsim->scan_addr);
2186 2187 2188 2189

	mutex_unlock(&hwsim->mutex);
}

2190 2191 2192 2193 2194 2195 2196
static void hw_roc_start(struct work_struct *work)
{
	struct mac80211_hwsim_data *hwsim =
		container_of(work, struct mac80211_hwsim_data, roc_start.work);

	mutex_lock(&hwsim->mutex);

2197
	wiphy_dbg(hwsim->hw->wiphy, "hwsim ROC begins\n");
2198 2199 2200 2201 2202 2203 2204 2205 2206
	hwsim->tmp_chan = hwsim->roc_chan;
	ieee80211_ready_on_channel(hwsim->hw);

	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->roc_done,
				     msecs_to_jiffies(hwsim->roc_duration));

	mutex_unlock(&hwsim->mutex);
}

2207 2208 2209 2210 2211 2212 2213 2214 2215 2216
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);

2217
	wiphy_dbg(hwsim->hw->wiphy, "hwsim ROC expired\n");
2218 2219 2220
}

static int mac80211_hwsim_roc(struct ieee80211_hw *hw,
2221
			      struct ieee80211_vif *vif,
2222
			      struct ieee80211_channel *chan,
2223 2224
			      int duration,
			      enum ieee80211_roc_type type)
2225 2226 2227 2228 2229 2230 2231 2232 2233
{
	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;
	}

2234 2235
	hwsim->roc_chan = chan;
	hwsim->roc_duration = duration;
2236 2237
	mutex_unlock(&hwsim->mutex);

2238 2239
	wiphy_dbg(hw->wiphy, "hwsim ROC (%d MHz, %d ms)\n",
		  chan->center_freq, duration);
2240
	ieee80211_queue_delayed_work(hw, &hwsim->roc_start, HZ/50);
2241 2242 2243 2244 2245 2246 2247 2248

	return 0;
}

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

2249
	cancel_delayed_work_sync(&hwsim->roc_start);
2250 2251 2252 2253 2254 2255
	cancel_delayed_work_sync(&hwsim->roc_done);

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

2256
	wiphy_dbg(hw->wiphy, "hwsim ROC canceled\n");
2257 2258 2259 2260 2261 2262 2263 2264

	return 0;
}

static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw,
				      struct ieee80211_chanctx_conf *ctx)
{
	hwsim_set_chanctx_magic(ctx);
2265 2266 2267 2268
	wiphy_dbg(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);
2269 2270 2271 2272 2273 2274
	return 0;
}

static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
					  struct ieee80211_chanctx_conf *ctx)
{
2275 2276 2277 2278
	wiphy_dbg(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);
2279 2280 2281 2282 2283 2284 2285 2286 2287
	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);
2288 2289 2290 2291
	wiphy_dbg(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);
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311
}

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

2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360
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",
};

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

	WARN_ON(i != MAC80211_HWSIM_SSTATS_LEN);
}

2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
#define HWSIM_COMMON_OPS					\
	.tx = mac80211_hwsim_tx,				\
	.start = mac80211_hwsim_start,				\
	.stop = mac80211_hwsim_stop,				\
	.add_interface = mac80211_hwsim_add_interface,		\
	.change_interface = mac80211_hwsim_change_interface,	\
	.remove_interface = mac80211_hwsim_remove_interface,	\
	.config = mac80211_hwsim_config,			\
	.configure_filter = mac80211_hwsim_configure_filter,	\
	.bss_info_changed = mac80211_hwsim_bss_info_changed,	\
	.sta_add = mac80211_hwsim_sta_add,			\
	.sta_remove = mac80211_hwsim_sta_remove,		\
	.sta_notify = mac80211_hwsim_sta_notify,		\
	.set_tim = mac80211_hwsim_set_tim,			\
	.conf_tx = mac80211_hwsim_conf_tx,			\
	.get_survey = mac80211_hwsim_get_survey,		\
	CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)	\
	.ampdu_action = mac80211_hwsim_ampdu_action,		\
	.flush = mac80211_hwsim_flush,				\
	.get_tsf = mac80211_hwsim_get_tsf,			\
	.set_tsf = mac80211_hwsim_set_tsf,			\
	.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,

2386
static const struct ieee80211_ops mac80211_hwsim_ops = {
2387
	HWSIM_COMMON_OPS
2388 2389
	.sw_scan_start = mac80211_hwsim_sw_scan,
	.sw_scan_complete = mac80211_hwsim_sw_scan_complete,
2390 2391
};

2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405
static const struct ieee80211_ops mac80211_hwsim_mchan_ops = {
	HWSIM_COMMON_OPS
	.hw_scan = mac80211_hwsim_hw_scan,
	.cancel_hw_scan = mac80211_hwsim_cancel_hw_scan,
	.sw_scan_start = NULL,
	.sw_scan_complete = NULL,
	.remain_on_channel = mac80211_hwsim_roc,
	.cancel_remain_on_channel = mac80211_hwsim_croc,
	.add_chanctx = mac80211_hwsim_add_chanctx,
	.remove_chanctx = mac80211_hwsim_remove_chanctx,
	.change_chanctx = mac80211_hwsim_change_chanctx,
	.assign_vif_chanctx = mac80211_hwsim_assign_vif_chanctx,
	.unassign_vif_chanctx = mac80211_hwsim_unassign_vif_chanctx,
};
2406

2407 2408 2409 2410 2411 2412 2413 2414 2415 2416
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;
2417
	const u8 *perm_addr;
2418 2419 2420 2421 2422 2423
};

static void hwsim_mcast_config_msg(struct sk_buff *mcast_skb,
				   struct genl_info *info)
{
	if (info)
J
Jiri Benc 已提交
2424 2425
		genl_notify(&hwsim_genl_family, mcast_skb, info,
			    HWSIM_MCGRP_CONFIG, GFP_KERNEL);
2426 2427 2428 2429 2430
	else
		genlmsg_multicast(&hwsim_genl_family, mcast_skb, 0,
				  HWSIM_MCGRP_CONFIG, GFP_KERNEL);
}

2431 2432
static int append_radio_msg(struct sk_buff *skb, int id,
			    struct hwsim_new_radio_params *param)
2433 2434 2435 2436 2437
{
	int ret;

	ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
	if (ret < 0)
2438
		return ret;
2439 2440 2441 2442

	if (param->channels) {
		ret = nla_put_u32(skb, HWSIM_ATTR_CHANNELS, param->channels);
		if (ret < 0)
2443
			return ret;
2444 2445 2446 2447 2448 2449
	}

	if (param->reg_alpha2) {
		ret = nla_put(skb, HWSIM_ATTR_REG_HINT_ALPHA2, 2,
			      param->reg_alpha2);
		if (ret < 0)
2450
			return ret;
2451 2452 2453 2454 2455
	}

	if (param->regd) {
		int i;

2456 2457 2458
		for (i = 0; i < ARRAY_SIZE(hwsim_world_regdom_custom); i++) {
			if (hwsim_world_regdom_custom[i] != param->regd)
				continue;
2459 2460 2461

			ret = nla_put_u32(skb, HWSIM_ATTR_REG_CUSTOM_REG, i);
			if (ret < 0)
2462
				return ret;
2463
			break;
2464 2465 2466 2467 2468 2469
		}
	}

	if (param->reg_strict) {
		ret = nla_put_flag(skb, HWSIM_ATTR_REG_STRICT_REG);
		if (ret < 0)
2470
			return ret;
2471 2472 2473 2474 2475
	}

	if (param->p2p_device) {
		ret = nla_put_flag(skb, HWSIM_ATTR_SUPPORT_P2P_DEVICE);
		if (ret < 0)
2476
			return ret;
2477 2478 2479 2480 2481
	}

	if (param->use_chanctx) {
		ret = nla_put_flag(skb, HWSIM_ATTR_USE_CHANCTX);
		if (ret < 0)
2482
			return ret;
2483 2484 2485 2486 2487 2488
	}

	if (param->hwname) {
		ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME,
			      strlen(param->hwname), param->hwname);
		if (ret < 0)
2489
			return ret;
2490 2491
	}

2492
	return 0;
2493 2494
}

2495
static void hwsim_mcast_new_radio(int id, struct genl_info *info,
2496 2497 2498
				  struct hwsim_new_radio_params *param)
{
	struct sk_buff *mcast_skb;
2499
	void *data;
2500

2501
	mcast_skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2502 2503 2504
	if (!mcast_skb)
		return;

2505 2506 2507 2508 2509 2510 2511 2512 2513 2514
	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);

2515
	hwsim_mcast_config_msg(mcast_skb, info);
2516 2517 2518 2519
	return;

out_err:
	nlmsg_free(mcast_skb);
2520 2521
}

I
Ilan Peer 已提交
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638
static const struct ieee80211_sband_iftype_data he_capa_2ghz = {
	/* TODO: should we support other types, e.g., P2P?*/
	.types_mask = BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP),
	.he_cap = {
		.has_he = true,
		.he_cap_elem = {
			.mac_cap_info[0] =
				IEEE80211_HE_MAC_CAP0_HTC_HE,
			.mac_cap_info[1] =
				IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US |
				IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_8,
			.mac_cap_info[2] =
				IEEE80211_HE_MAC_CAP2_BSR |
				IEEE80211_HE_MAC_CAP2_MU_CASCADING |
				IEEE80211_HE_MAC_CAP2_ACK_EN,
			.mac_cap_info[3] =
				IEEE80211_HE_MAC_CAP3_GRP_ADDR_MULTI_STA_BA_DL_MU |
				IEEE80211_HE_MAC_CAP3_OMI_CONTROL |
				IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_VHT_2,
			.mac_cap_info[4] = IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU,
			.phy_cap_info[0] =
				IEEE80211_HE_PHY_CAP0_DUAL_BAND,
			.phy_cap_info[1] =
				IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK |
				IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A |
				IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD |
				IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_MAX_NSTS,
			.phy_cap_info[2] =
				IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US |
				IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ |
				IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ |
				IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
				IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO,

			/* Leave all the other PHY capability bytes unset, as
			 * DCM, beam forming, RU and PPE threshold information
			 * are not supported
			 */
		},
		.he_mcs_nss_supp = {
			.rx_mcs_80 = cpu_to_le16(0xfffa),
			.tx_mcs_80 = cpu_to_le16(0xfffa),
			.rx_mcs_160 = cpu_to_le16(0xffff),
			.tx_mcs_160 = cpu_to_le16(0xffff),
			.rx_mcs_80p80 = cpu_to_le16(0xffff),
			.tx_mcs_80p80 = cpu_to_le16(0xffff),
		},
	},
};

static const struct ieee80211_sband_iftype_data he_capa_5ghz = {
	/* TODO: should we support other types, e.g., P2P?*/
	.types_mask = BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP),
	.he_cap = {
		.has_he = true,
		.he_cap_elem = {
			.mac_cap_info[0] =
				IEEE80211_HE_MAC_CAP0_HTC_HE,
			.mac_cap_info[1] =
				IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US |
				IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_8,
			.mac_cap_info[2] =
				IEEE80211_HE_MAC_CAP2_BSR |
				IEEE80211_HE_MAC_CAP2_MU_CASCADING |
				IEEE80211_HE_MAC_CAP2_ACK_EN,
			.mac_cap_info[3] =
				IEEE80211_HE_MAC_CAP3_GRP_ADDR_MULTI_STA_BA_DL_MU |
				IEEE80211_HE_MAC_CAP3_OMI_CONTROL |
				IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_VHT_2,
			.mac_cap_info[4] = IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU,
			.phy_cap_info[0] =
				IEEE80211_HE_PHY_CAP0_DUAL_BAND |
				IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
				IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
				IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G,
			.phy_cap_info[1] =
				IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK |
				IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A |
				IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD |
				IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_MAX_NSTS,
			.phy_cap_info[2] =
				IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US |
				IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ |
				IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ |
				IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
				IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO,

			/* Leave all the other PHY capability bytes unset, as
			 * DCM, beam forming, RU and PPE threshold information
			 * are not supported
			 */
		},
		.he_mcs_nss_supp = {
			.rx_mcs_80 = cpu_to_le16(0xfffa),
			.tx_mcs_80 = cpu_to_le16(0xfffa),
			.rx_mcs_160 = cpu_to_le16(0xfffa),
			.tx_mcs_160 = cpu_to_le16(0xfffa),
			.rx_mcs_80p80 = cpu_to_le16(0xfffa),
			.tx_mcs_80p80 = cpu_to_le16(0xfffa),
		},
	},
};

static void mac80211_hswim_he_capab(struct ieee80211_supported_band *sband)
{
	if (sband->band == NL80211_BAND_2GHZ)
		sband->iftype_data =
			(struct ieee80211_sband_iftype_data *)&he_capa_2ghz;
	else if (sband->band == NL80211_BAND_5GHZ)
		sband->iftype_data =
			(struct ieee80211_sband_iftype_data *)&he_capa_5ghz;
	else
		return;

	sband->n_iftype_data = 1;
}

2639 2640
static int mac80211_hwsim_new_radio(struct genl_info *info,
				    struct hwsim_new_radio_params *param)
2641
{
2642 2643
	int err;
	u8 addr[ETH_ALEN];
2644
	struct mac80211_hwsim_data *data;
2645
	struct ieee80211_hw *hw;
2646
	enum nl80211_band band;
2647
	const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
2648
	struct net *net;
2649
	int idx;
2650

2651
	if (WARN_ON(param->channels > 1 && !param->use_chanctx))
2652 2653
		return -EINVAL;

2654
	spin_lock_bh(&hwsim_radio_lock);
2655
	idx = hwsim_radio_idx++;
2656 2657
	spin_unlock_bh(&hwsim_radio_lock);

2658
	if (param->use_chanctx)
2659
		ops = &mac80211_hwsim_mchan_ops;
2660
	hw = ieee80211_alloc_hw_nm(sizeof(*data), ops, param->hwname);
2661
	if (!hw) {
2662
		pr_debug("mac80211_hwsim: ieee80211_alloc_hw failed\n");
2663 2664 2665
		err = -ENOMEM;
		goto failed;
	}
2666

2667 2668 2669
	/* ieee80211_alloc_hw_nm may have used a default name */
	param->hwname = wiphy_name(hw->wiphy);

2670 2671 2672 2673 2674 2675
	if (info)
		net = genl_info_net(info);
	else
		net = &init_net;
	wiphy_net_set(hw->wiphy, net);

2676 2677
	data = hw->priv;
	data->hw = hw;
2678

2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689
	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) {
2690
		pr_debug("mac80211_hwsim: device_bind_driver failed (%d)\n",
2691
		       err);
2692
		goto failed_bind;
2693 2694
	}

2695
	skb_queue_head_init(&data->pending);
2696

2697
	SET_IEEE80211_DEV(hw, data->dev);
2698 2699 2700 2701 2702 2703 2704 2705
	if (!param->perm_addr) {
		eth_zero_addr(addr);
		addr[0] = 0x02;
		addr[3] = idx >> 8;
		addr[4] = idx;
		memcpy(data->addresses[0].addr, addr, ETH_ALEN);
		/* Why need here second address ? */
		memcpy(data->addresses[1].addr, addr, ETH_ALEN);
2706
		data->addresses[1].addr[0] |= 0x40;
2707 2708 2709 2710 2711 2712 2713 2714 2715 2716
		hw->wiphy->n_addresses = 2;
		hw->wiphy->addresses = data->addresses;
		/* possible address clash is checked at hash table insertion */
	} else {
		memcpy(data->addresses[0].addr, param->perm_addr, ETH_ALEN);
		/* compatibility with automatically generated mac addr */
		memcpy(data->addresses[1].addr, param->perm_addr, ETH_ALEN);
		hw->wiphy->n_addresses = 2;
		hw->wiphy->addresses = data->addresses;
	}
2717

2718 2719
	data->channels = param->channels;
	data->use_chanctx = param->use_chanctx;
2720
	data->idx = idx;
2721 2722 2723
	data->destroy_on_close = param->destroy_on_close;
	if (info)
		data->portid = info->snd_portid;
2724

2725
	if (data->use_chanctx) {
2726 2727 2728 2729
		hw->wiphy->max_scan_ssids = 255;
		hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
		hw->wiphy->max_remain_on_channel_duration = 1000;
		hw->wiphy->iface_combinations = &data->if_combination;
2730
		if (param->p2p_device)
2731 2732 2733
			data->if_combination = hwsim_if_comb_p2p_dev[0];
		else
			data->if_combination = hwsim_if_comb[0];
2734 2735 2736
		hw->wiphy->n_iface_combinations = 1;
		/* For channels > 1 DFS is not allowed */
		data->if_combination.radar_detect_widths = 0;
2737
		data->if_combination.num_different_channels = data->channels;
2738
	} else if (param->p2p_device) {
2739 2740 2741
		hw->wiphy->iface_combinations = hwsim_if_comb_p2p_dev;
		hw->wiphy->n_iface_combinations =
			ARRAY_SIZE(hwsim_if_comb_p2p_dev);
2742 2743 2744 2745
	} else {
		hw->wiphy->iface_combinations = hwsim_if_comb;
		hw->wiphy->n_iface_combinations = ARRAY_SIZE(hwsim_if_comb);
	}
2746

2747
	INIT_DELAYED_WORK(&data->roc_start, hw_roc_start);
2748 2749
	INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
	INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2750

2751 2752 2753 2754 2755 2756 2757
	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) |
2758 2759
				     BIT(NL80211_IFTYPE_MESH_POINT);

2760
	if (param->p2p_device)
2761
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_DEVICE);
2762

2763 2764 2765 2766 2767 2768 2769 2770
	ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
	ieee80211_hw_set(hw, CHANCTX_STA_CSA);
	ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES);
	ieee80211_hw_set(hw, QUEUE_CONTROL);
	ieee80211_hw_set(hw, WANT_MONITOR_VIF);
	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
	ieee80211_hw_set(hw, MFP_CAPABLE);
	ieee80211_hw_set(hw, SIGNAL_DBM);
2771
	ieee80211_hw_set(hw, SUPPORTS_PS);
2772
	ieee80211_hw_set(hw, TDLS_WIDER_BW);
2773
	if (rctbl)
2774
		ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
2775

2776 2777
	hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
			    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
2778 2779
			    WIPHY_FLAG_AP_UAPSD |
			    WIPHY_FLAG_HAS_CHANNEL_SWITCH;
2780 2781 2782
	hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR |
			       NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
			       NL80211_FEATURE_STATIC_SMPS |
2783 2784
			       NL80211_FEATURE_DYNAMIC_SMPS |
			       NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
2785
	wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
2786

2787 2788 2789 2790
	/* 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);
2791

2792 2793 2794 2795 2796
	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));
2797

2798
	for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
2799
		struct ieee80211_supported_band *sband = &data->bands[band];
I
Ilan Peer 已提交
2800 2801 2802

		sband->band = band;

2803
		switch (band) {
2804
		case NL80211_BAND_2GHZ:
2805 2806 2807 2808 2809
			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;
2810
		case NL80211_BAND_5GHZ:
2811 2812 2813 2814
			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;
2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826

			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_4 |
				IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
			sband->vht_cap.vht_mcs.rx_mcs_map =
2827 2828
				cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
2829
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
2830 2831
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 |
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 |
2832 2833
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 |
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 |
2834
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 14);
2835 2836
			sband->vht_cap.vht_mcs.tx_mcs_map =
				sband->vht_cap.vht_mcs.rx_mcs_map;
2837 2838 2839 2840
			break;
		default:
			continue;
		}
2841

2842 2843 2844
		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 已提交
2845
				    IEEE80211_HT_CAP_SGI_20 |
2846 2847 2848 2849 2850 2851 2852 2853 2854
				    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;
2855

I
Ilan Peer 已提交
2856 2857
		mac80211_hswim_he_capab(sband);

2858 2859
		hw->wiphy->bands[band] = sband;
	}
2860

2861 2862 2863
	/* By default all radios belong to the first group */
	data->group = 1;
	mutex_init(&data->mutex);
2864

2865
	data->netgroup = hwsim_net_get_netgroup(net);
2866
	data->wmediumd = hwsim_net_get_wmediumd(net);
2867

2868 2869 2870
	/* Enable frame retransmissions for lossy channels */
	hw->max_rates = 4;
	hw->max_rate_tries = 11;
2871

2872 2873 2874 2875 2876 2877
	hw->wiphy->vendor_commands = mac80211_hwsim_vendor_commands;
	hw->wiphy->n_vendor_commands =
		ARRAY_SIZE(mac80211_hwsim_vendor_commands);
	hw->wiphy->vendor_events = mac80211_hwsim_vendor_events;
	hw->wiphy->n_vendor_events = ARRAY_SIZE(mac80211_hwsim_vendor_events);

2878
	if (param->reg_strict)
2879
		hw->wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
2880
	if (param->regd) {
2881
		data->regd = param->regd;
2882
		hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2883
		wiphy_apply_custom_regulatory(hw->wiphy, param->regd);
2884 2885 2886
		/* give the regulatory workqueue a chance to run */
		schedule_timeout_interruptible(1);
	}
2887

2888
	if (param->no_vif)
2889
		ieee80211_hw_set(hw, NO_AUTO_VIF);
2890

2891 2892
	wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);

2893 2894
	err = ieee80211_register_hw(hw);
	if (err < 0) {
2895
		pr_debug("mac80211_hwsim: ieee80211_register_hw failed (%d)\n",
2896 2897 2898
		       err);
		goto failed_hw;
	}
2899

2900
	wiphy_dbg(hw->wiphy, "hwaddr %pM registered\n", hw->wiphy->perm_addr);
2901

2902 2903 2904
	if (param->reg_alpha2) {
		data->alpha2[0] = param->reg_alpha2[0];
		data->alpha2[1] = param->reg_alpha2[1];
2905
		regulatory_hint(hw->wiphy, param->reg_alpha2);
2906
	}
2907

2908 2909 2910 2911
	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);
2912
	if (!data->use_chanctx)
2913 2914 2915
		debugfs_create_file("dfs_simulate_radar", 0222,
				    data->debugfs,
				    data, &hwsim_simulate_radar);
2916

2917 2918
	tasklet_hrtimer_init(&data->beacon_timer,
			     mac80211_hwsim_beacon,
2919
			     CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
2920

2921
	spin_lock_bh(&hwsim_radio_lock);
2922 2923 2924
	err = rhashtable_insert_fast(&hwsim_radios_rht, &data->rht,
				     hwsim_rht_params);
	if (err < 0) {
2925 2926 2927 2928 2929
		if (info) {
			GENL_SET_ERR_MSG(info, "perm addr already present");
			NL_SET_BAD_ATTR(info->extack,
					info->attrs[HWSIM_ATTR_PERM_ADDR]);
		}
2930 2931 2932 2933
		spin_unlock_bh(&hwsim_radio_lock);
		goto failed_final_insert;
	}

2934
	list_add_tail(&data->list, &hwsim_radios);
2935
	hwsim_radios_generation++;
2936
	spin_unlock_bh(&hwsim_radio_lock);
2937

2938
	if (idx > 0)
2939
		hwsim_mcast_new_radio(idx, info, param);
2940

2941
	return idx;
2942

2943 2944 2945
failed_final_insert:
	debugfs_remove_recursive(data->debugfs);
	ieee80211_unregister_hw(data->hw);
2946
failed_hw:
2947 2948
	device_release_driver(data->dev);
failed_bind:
2949 2950 2951 2952 2953
	device_unregister(data->dev);
failed_drvdata:
	ieee80211_free_hw(hw);
failed:
	return err;
2954 2955
}

2956 2957
static void hwsim_mcast_del_radio(int id, const char *hwname,
				  struct genl_info *info)
2958
{
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975
	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;

2976 2977 2978 2979
	ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME, strlen(hwname),
		      hwname);
	if (ret < 0)
		goto error;
2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995

	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);
2996 2997 2998 2999 3000
	debugfs_remove_recursive(data->debugfs);
	ieee80211_unregister_hw(data->hw);
	device_release_driver(data->dev);
	device_unregister(data->dev);
	ieee80211_free_hw(data->hw);
3001 3002
}

3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017
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)
M
Michal Kubecek 已提交
3018
		genl_dump_check_consistent(cb, hdr);
3019

3020 3021 3022
	if (data->alpha2[0] && data->alpha2[1])
		param.reg_alpha2 = data->alpha2;

3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035
	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;

3036 3037
	genlmsg_end(skb, hdr);
	return 0;
3038 3039 3040 3041 3042 3043

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

3044
static void mac80211_hwsim_free(void)
3045
{
3046
	struct mac80211_hwsim_data *data;
3047

3048 3049 3050 3051 3052 3053
	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);
3054 3055
		mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
					 NULL);
3056
		spin_lock_bh(&hwsim_radio_lock);
3057
	}
3058 3059
	spin_unlock_bh(&hwsim_radio_lock);
	class_destroy(hwsim_class);
3060 3061
}

3062 3063 3064 3065 3066
static const struct net_device_ops hwsim_netdev_ops = {
	.ndo_start_xmit 	= hwsim_mon_xmit,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
};
D
Daniel Wagner 已提交
3067

3068
static void hwsim_mon_setup(struct net_device *dev)
D
Daniel Wagner 已提交
3069
{
3070
	dev->netdev_ops = &hwsim_netdev_ops;
3071
	dev->needs_free_netdev = true;
3072
	ether_setup(dev);
3073
	dev->priv_flags |= IFF_NO_QUEUE;
3074
	dev->type = ARPHRD_IEEE80211_RADIOTAP;
3075
	eth_zero_addr(dev->dev_addr);
3076
	dev->dev_addr[0] = 0x12;
D
Daniel Wagner 已提交
3077 3078
}

3079
static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr)
3080
{
3081 3082 3083
	return rhashtable_lookup_fast(&hwsim_radios_rht,
				      addr,
				      hwsim_rht_params);
3084 3085
}

3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099
static void hwsim_register_wmediumd(struct net *net, u32 portid)
{
	struct mac80211_hwsim_data *data;

	hwsim_net_set_wmediumd(net, portid);

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
		if (data->netgroup == hwsim_net_get_netgroup(net))
			data->wmediumd = portid;
	}
	spin_unlock_bh(&hwsim_radio_lock);
}

3100 3101 3102 3103 3104 3105 3106 3107
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;
3108
	u64 ret_skb_cookie;
3109
	struct sk_buff *skb, *tmp;
3110
	const u8 *src;
3111 3112 3113 3114 3115
	unsigned int hwsim_flags;
	int i;
	bool found = false;

	if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
3116 3117
	    !info->attrs[HWSIM_ATTR_FLAGS] ||
	    !info->attrs[HWSIM_ATTR_COOKIE] ||
3118
	    !info->attrs[HWSIM_ATTR_SIGNAL] ||
3119
	    !info->attrs[HWSIM_ATTR_TX_INFO])
3120 3121
		goto out;

3122
	src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
3123
	hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
3124
	ret_skb_cookie = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
3125 3126

	data2 = get_hwsim_data_ref_from_addr(src);
3127
	if (!data2)
3128 3129
		goto out;

3130 3131 3132 3133 3134 3135
	if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
		goto out;

	if (info->snd_portid != data2->wmediumd)
		goto out;

3136 3137
	/* look for the skb matching the cookie passed back from user */
	skb_queue_walk_safe(&data2->pending, skb, tmp) {
3138 3139 3140 3141 3142 3143
		u64 skb_cookie;

		txi = IEEE80211_SKB_CB(skb);
		skb_cookie = (u64)(uintptr_t)txi->rate_driver_data[0];

		if (skb_cookie == ret_skb_cookie) {
3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
			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.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;
3176
			mac80211_hwsim_monitor_ack(data2->channel,
3177
						   hdr->addr2);
3178
		}
3179
		txi->flags |= IEEE80211_TX_STAT_ACK;
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
	}
	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)
{
3191
	struct mac80211_hwsim_data *data2;
3192
	struct ieee80211_rx_status rx_status;
3193
	const u8 *dst;
3194
	int frame_data_len;
3195
	void *frame_data;
3196 3197 3198
	struct sk_buff *skb = NULL;

	if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
3199 3200 3201
	    !info->attrs[HWSIM_ATTR_FRAME] ||
	    !info->attrs[HWSIM_ATTR_RX_RATE] ||
	    !info->attrs[HWSIM_ATTR_SIGNAL])
3202 3203
		goto out;

3204
	dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
3205
	frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
3206
	frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
3207 3208 3209 3210 3211 3212

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

3213
	if (frame_data_len > IEEE80211_MAX_DATA_LEN)
3214 3215
		goto err;

3216
	/* Copy the data */
3217
	skb_put_data(skb, frame_data, frame_data_len);
3218

3219 3220
	data2 = get_hwsim_data_ref_from_addr(dst);
	if (!data2)
3221 3222
		goto out;

3223 3224 3225 3226 3227 3228
	if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
		goto out;

	if (info->snd_portid != data2->wmediumd)
		goto out;

3229 3230
	/* check if radio is configured properly */

3231
	if (data2->idle || !data2->started)
3232 3233
		goto out;

3234
	/* A frame is received from user space */
3235
	memset(&rx_status, 0, sizeof(rx_status));
3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254
	if (info->attrs[HWSIM_ATTR_FREQ]) {
		/* throw away off-channel packets, but allow both the temporary
		 * ("hw" scan/remain-on-channel) and regular channel, since the
		 * internal datapath also allows this
		 */
		mutex_lock(&data2->mutex);
		rx_status.freq = nla_get_u32(info->attrs[HWSIM_ATTR_FREQ]);

		if (rx_status.freq != data2->channel->center_freq &&
		    (!data2->tmp_chan ||
		     rx_status.freq != data2->tmp_chan->center_freq)) {
			mutex_unlock(&data2->mutex);
			goto out;
		}
		mutex_unlock(&data2->mutex);
	} else {
		rx_status.freq = data2->channel->center_freq;
	}

3255 3256 3257 3258 3259
	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));
3260 3261
	data2->rx_pkts++;
	data2->rx_bytes += skb->len;
3262 3263 3264 3265
	ieee80211_rx_irqsafe(data2->hw, skb);

	return 0;
err:
3266
	pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
3267 3268 3269 3270 3271 3272 3273 3274
out:
	dev_kfree_skb(skb);
	return -EINVAL;
}

static int hwsim_register_received_nl(struct sk_buff *skb_2,
				      struct genl_info *info)
{
3275
	struct net *net = genl_info_net(info);
3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291
	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;

3292
	if (hwsim_net_get_wmediumd(net))
3293
		return -EBUSY;
3294

3295
	hwsim_register_wmediumd(net, info->snd_portid);
3296

3297
	pr_debug("mac80211_hwsim: received a REGISTER, "
3298
	       "switching to wmediumd mode with pid %d\n", info->snd_portid);
3299 3300 3301 3302

	return 0;
}

3303
static int hwsim_new_radio_nl(struct sk_buff *msg, struct genl_info *info)
3304
{
3305
	struct hwsim_new_radio_params param = { 0 };
3306
	const char *hwname = NULL;
3307
	int ret;
3308 3309 3310 3311 3312 3313

	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];
3314 3315

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

3318 3319 3320 3321 3322
	if (param.channels < 1) {
		GENL_SET_ERR_MSG(info, "must have at least one channel");
		return -EINVAL;
	}

3323 3324 3325 3326 3327
	if (param.channels > CFG80211_MAX_NUM_DIFFERENT_CHANNELS) {
		GENL_SET_ERR_MSG(info, "too many channels specified");
		return -EINVAL;
	}

3328
	if (info->attrs[HWSIM_ATTR_NO_VIF])
3329
		param.no_vif = true;
3330

3331 3332 3333 3334 3335 3336 3337 3338
	if (info->attrs[HWSIM_ATTR_RADIO_NAME]) {
		hwname = kasprintf(GFP_KERNEL, "%.*s",
				   nla_len(info->attrs[HWSIM_ATTR_RADIO_NAME]),
				   (char *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]));
		if (!hwname)
			return -ENOMEM;
		param.hwname = hwname;
	}
3339

3340
	if (info->attrs[HWSIM_ATTR_USE_CHANCTX])
3341
		param.use_chanctx = true;
3342
	else
3343
		param.use_chanctx = (param.channels > 1);
3344

3345
	if (info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2])
3346 3347
		param.reg_alpha2 =
			nla_data(info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]);
3348 3349 3350 3351

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

3352 3353
		if (idx >= ARRAY_SIZE(hwsim_world_regdom_custom)) {
			kfree(hwname);
3354
			return -EINVAL;
3355
		}
3356 3357 3358

		idx = array_index_nospec(idx,
					 ARRAY_SIZE(hwsim_world_regdom_custom));
3359
		param.regd = hwsim_world_regdom_custom[idx];
3360 3361
	}

3362 3363 3364 3365 3366 3367
	if (info->attrs[HWSIM_ATTR_PERM_ADDR]) {
		if (!is_valid_ether_addr(
				nla_data(info->attrs[HWSIM_ATTR_PERM_ADDR]))) {
			GENL_SET_ERR_MSG(info,"MAC is no valid source addr");
			NL_SET_BAD_ATTR(info->extack,
					info->attrs[HWSIM_ATTR_PERM_ADDR]);
3368
			kfree(hwname);
3369 3370 3371 3372 3373 3374 3375
			return -EINVAL;
		}


		param.perm_addr = nla_data(info->attrs[HWSIM_ATTR_PERM_ADDR]);
	}

3376 3377 3378
	ret = mac80211_hwsim_new_radio(info, &param);
	kfree(hwname);
	return ret;
3379 3380
}

3381
static int hwsim_del_radio_nl(struct sk_buff *msg, struct genl_info *info)
3382 3383
{
	struct mac80211_hwsim_data *data;
3384 3385
	s64 idx = -1;
	const char *hwname = NULL;
3386

3387
	if (info->attrs[HWSIM_ATTR_RADIO_ID]) {
3388
		idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);
3389 3390 3391 3392 3393 3394 3395
	} else if (info->attrs[HWSIM_ATTR_RADIO_NAME]) {
		hwname = kasprintf(GFP_KERNEL, "%.*s",
				   nla_len(info->attrs[HWSIM_ATTR_RADIO_NAME]),
				   (char *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]));
		if (!hwname)
			return -ENOMEM;
	} else
3396 3397 3398 3399
		return -EINVAL;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
3400 3401 3402 3403
		if (idx >= 0) {
			if (data->idx != idx)
				continue;
		} else {
3404 3405
			if (!hwname ||
			    strcmp(hwname, wiphy_name(data->hw->wiphy)))
3406 3407 3408
				continue;
		}

3409 3410 3411
		if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
			continue;

3412
		list_del(&data->list);
3413 3414
		rhashtable_remove_fast(&hwsim_radios_rht, &data->rht,
				       hwsim_rht_params);
3415
		hwsim_radios_generation++;
3416
		spin_unlock_bh(&hwsim_radio_lock);
3417 3418
		mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
					 info);
3419
		kfree(hwname);
3420 3421 3422 3423
		return 0;
	}
	spin_unlock_bh(&hwsim_radio_lock);

3424
	kfree(hwname);
3425
	return -ENODEV;
3426 3427
}

3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442
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;

3443 3444 3445
		if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
			continue;

3446
		skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471
		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)
{
3472
	int last_idx = cb->args[0] - 1;
3473
	struct mac80211_hwsim_data *data = NULL;
3474 3475
	int res = 0;
	void *hdr;
3476 3477

	spin_lock_bh(&hwsim_radio_lock);
3478
	cb->seq = hwsim_radios_generation;
3479

3480
	if (last_idx >= hwsim_radio_idx-1)
3481 3482 3483
		goto done;

	list_for_each_entry(data, &hwsim_radios, list) {
3484
		if (data->idx <= last_idx)
3485 3486
			continue;

3487 3488 3489
		if (!net_eq(wiphy_net(data->hw->wiphy), sock_net(skb->sk)))
			continue;

3490 3491 3492 3493 3494 3495 3496
		res = mac80211_hwsim_get_radio(skb, data,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq, cb,
					       NLM_F_MULTI);
		if (res < 0)
			break;

3497
		last_idx = data->idx;
3498 3499
	}

3500
	cb->args[0] = last_idx + 1;
3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511

	/* list changed, but no new element sent, set interrupted flag */
	if (skb->len == 0 && cb->prev_seq && cb->seq != cb->prev_seq) {
		hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
				  cb->nlh->nlmsg_seq, &hwsim_genl_family,
				  NLM_F_MULTI, HWSIM_CMD_GET_RADIO);
		if (!hdr)
			res = -EMSGSIZE;
		genl_dump_check_consistent(cb, hdr);
		genlmsg_end(skb, hdr);
	}
3512 3513 3514

done:
	spin_unlock_bh(&hwsim_radio_lock);
3515
	return res ?: skb->len;
3516 3517
}

3518
/* Generic Netlink operations array */
3519
static const struct genl_ops hwsim_ops[] = {
3520 3521 3522 3523
	{
		.cmd = HWSIM_CMD_REGISTER,
		.policy = hwsim_genl_policy,
		.doit = hwsim_register_received_nl,
3524
		.flags = GENL_UNS_ADMIN_PERM,
3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
	},
	{
		.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,
	},
3536
	{
3537
		.cmd = HWSIM_CMD_NEW_RADIO,
3538
		.policy = hwsim_genl_policy,
3539
		.doit = hwsim_new_radio_nl,
3540
		.flags = GENL_UNS_ADMIN_PERM,
3541 3542
	},
	{
3543
		.cmd = HWSIM_CMD_DEL_RADIO,
3544
		.policy = hwsim_genl_policy,
3545
		.doit = hwsim_del_radio_nl,
3546
		.flags = GENL_UNS_ADMIN_PERM,
3547
	},
3548 3549 3550 3551 3552 3553
	{
		.cmd = HWSIM_CMD_GET_RADIO,
		.policy = hwsim_genl_policy,
		.doit = hwsim_get_radio_nl,
		.dumpit = hwsim_dump_radio_nl,
	},
3554 3555
};

3556
static struct genl_family hwsim_genl_family __ro_after_init = {
3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567
	.name = "MAC80211_HWSIM",
	.version = 1,
	.maxattr = HWSIM_ATTR_MAX,
	.netnsok = true,
	.module = THIS_MODULE,
	.ops = hwsim_ops,
	.n_ops = ARRAY_SIZE(hwsim_ops),
	.mcgrps = hwsim_mcgrps,
	.n_mcgrps = ARRAY_SIZE(hwsim_mcgrps),
};

3568 3569 3570 3571 3572
static void destroy_radio(struct work_struct *work)
{
	struct mac80211_hwsim_data *data =
		container_of(work, struct mac80211_hwsim_data, destroy_work);

3573
	hwsim_radios_generation++;
3574
	mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy), NULL);
3575 3576 3577 3578 3579 3580 3581 3582 3583 3584
}

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);
3585 3586
			rhashtable_remove_fast(&hwsim_radios_rht, &entry->rht,
					       hwsim_rht_params);
3587
			INIT_WORK(&entry->destroy_work, destroy_radio);
3588
			queue_work(hwsim_wq, &entry->destroy_work);
3589 3590 3591 3592 3593
		}
	}
	spin_unlock_bh(&hwsim_radio_lock);
}

3594 3595 3596 3597 3598 3599 3600 3601 3602
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;

3603 3604
	remove_user_radios(notify->portid);

3605
	if (notify->portid == hwsim_net_get_wmediumd(notify->net)) {
3606 3607
		printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
		       " socket, switching to perfect channel medium\n");
3608
		hwsim_register_wmediumd(notify->net, 0);
3609 3610 3611 3612 3613 3614 3615 3616 3617
	}
	return NOTIFY_DONE;

}

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

3618
static int __init hwsim_init_netlink(void)
3619 3620
{
	int rc;
3621

3622 3623
	printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");

3624
	rc = genl_register_family(&hwsim_genl_family);
3625 3626 3627 3628
	if (rc)
		goto failure;

	rc = netlink_register_notifier(&hwsim_netlink_notifier);
3629 3630
	if (rc) {
		genl_unregister_family(&hwsim_genl_family);
3631
		goto failure;
3632
	}
3633 3634 3635 3636

	return 0;

failure:
3637
	pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
3638 3639 3640
	return -EINVAL;
}

3641 3642
static __net_init int hwsim_init_net(struct net *net)
{
3643
	return hwsim_net_set_netgroup(net);
3644 3645 3646 3647 3648
}

static void __net_exit hwsim_exit_net(struct net *net)
{
	struct mac80211_hwsim_data *data, *tmp;
3649
	LIST_HEAD(list);
3650 3651 3652 3653 3654 3655 3656 3657 3658 3659

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry_safe(data, tmp, &hwsim_radios, list) {
		if (!net_eq(wiphy_net(data->hw->wiphy), net))
			continue;

		/* Radios created in init_net are returned to init_net. */
		if (data->netgroup == hwsim_net_get_netgroup(&init_net))
			continue;

3660
		list_move(&data->list, &list);
3661 3662
		rhashtable_remove_fast(&hwsim_radios_rht, &data->rht,
				       hwsim_rht_params);
3663
		hwsim_radios_generation++;
3664 3665 3666 3667 3668
	}
	spin_unlock_bh(&hwsim_radio_lock);

	list_for_each_entry_safe(data, tmp, &list, list) {
		list_del(&data->list);
3669 3670 3671
		mac80211_hwsim_del_radio(data,
					 wiphy_name(data->hw->wiphy),
					 NULL);
3672
	}
3673 3674

	ida_simple_remove(&hwsim_netgroup_ida, hwsim_net_get_netgroup(net));
3675 3676 3677 3678 3679 3680 3681 3682 3683
}

static struct pernet_operations hwsim_net_ops = {
	.init = hwsim_init_net,
	.exit = hwsim_exit_net,
	.id   = &hwsim_net_id,
	.size = sizeof(struct hwsim_net),
};

3684 3685 3686 3687 3688
static void hwsim_exit_netlink(void)
{
	/* unregister the notifier */
	netlink_unregister_notifier(&hwsim_netlink_notifier);
	/* unregister the family */
3689
	genl_unregister_family(&hwsim_genl_family);
3690 3691
}

3692 3693
static int __init init_mac80211_hwsim(void)
{
3694
	int i, err;
3695

3696
	if (radios < 0 || radios > 100)
3697 3698
		return -EINVAL;

3699 3700 3701
	if (channels < 1)
		return -EINVAL;

3702
	spin_lock_init(&hwsim_radio_lock);
3703

3704
	hwsim_wq = alloc_workqueue("hwsim_wq", 0, 0);
3705 3706
	if (!hwsim_wq)
		return -ENOMEM;
3707 3708 3709 3710

	err = rhashtable_init(&hwsim_radios_rht, &hwsim_rht_params);
	if (err)
		goto out_free_wq;
3711

3712
	err = register_pernet_device(&hwsim_net_ops);
3713
	if (err)
3714
		goto out_free_rht;
3715

3716 3717 3718 3719
	err = platform_driver_register(&mac80211_hwsim_driver);
	if (err)
		goto out_unregister_pernet;

3720
	hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
3721 3722
	if (IS_ERR(hwsim_class)) {
		err = PTR_ERR(hwsim_class);
3723
		goto out_unregister_driver;
3724
	}
3725

3726 3727 3728 3729
	err = hwsim_init_netlink();
	if (err < 0)
		goto out_unregister_driver;

3730
	for (i = 0; i < radios; i++) {
3731 3732 3733
		struct hwsim_new_radio_params param = { 0 };

		param.channels = channels;
3734

3735 3736
		switch (regtest) {
		case HWSIM_REGTEST_DIFF_COUNTRY:
3737
			if (i < ARRAY_SIZE(hwsim_alpha2s))
3738
				param.reg_alpha2 = hwsim_alpha2s[i];
3739 3740 3741
			break;
		case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
			if (!i)
3742
				param.reg_alpha2 = hwsim_alpha2s[0];
3743 3744
			break;
		case HWSIM_REGTEST_STRICT_ALL:
3745
			param.reg_strict = true;
3746
		case HWSIM_REGTEST_DRIVER_REG_ALL:
3747
			param.reg_alpha2 = hwsim_alpha2s[0];
3748
			break;
3749 3750
		case HWSIM_REGTEST_WORLD_ROAM:
			if (i == 0)
3751
				param.regd = &hwsim_world_regdom_custom_01;
3752 3753
			break;
		case HWSIM_REGTEST_CUSTOM_WORLD:
3754
			param.regd = &hwsim_world_regdom_custom_01;
3755
			break;
3756
		case HWSIM_REGTEST_CUSTOM_WORLD_2:
3757
			if (i == 0)
3758
				param.regd = &hwsim_world_regdom_custom_01;
3759
			else if (i == 1)
3760
				param.regd = &hwsim_world_regdom_custom_02;
3761 3762
			break;
		case HWSIM_REGTEST_STRICT_FOLLOW:
3763
			if (i == 0) {
3764 3765
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[0];
3766
			}
3767 3768
			break;
		case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
3769
			if (i == 0) {
3770 3771
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[0];
3772
			} else if (i == 1) {
3773
				param.reg_alpha2 = hwsim_alpha2s[1];
3774
			}
3775 3776
			break;
		case HWSIM_REGTEST_ALL:
3777 3778
			switch (i) {
			case 0:
3779
				param.regd = &hwsim_world_regdom_custom_01;
3780 3781
				break;
			case 1:
3782
				param.regd = &hwsim_world_regdom_custom_02;
3783 3784
				break;
			case 2:
3785
				param.reg_alpha2 = hwsim_alpha2s[0];
3786 3787
				break;
			case 3:
3788
				param.reg_alpha2 = hwsim_alpha2s[1];
3789 3790
				break;
			case 4:
3791 3792
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[2];
3793 3794
				break;
			}
3795 3796 3797 3798 3799
			break;
		default:
			break;
		}

3800 3801 3802 3803
		param.p2p_device = support_p2p_device;
		param.use_chanctx = channels > 1;

		err = mac80211_hwsim_new_radio(NULL, &param);
3804
		if (err < 0)
3805
			goto out_free_radios;
3806 3807
	}

3808 3809
	hwsim_mon = alloc_netdev(0, "hwsim%d", NET_NAME_UNKNOWN,
				 hwsim_mon_setup);
3810 3811
	if (hwsim_mon == NULL) {
		err = -ENOMEM;
3812
		goto out_free_radios;
3813
	}
3814

3815 3816
	rtnl_lock();
	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
3817 3818 3819 3820
	if (err < 0) {
		rtnl_unlock();
		goto out_free_radios;
	}
3821 3822

	err = register_netdevice(hwsim_mon);
3823 3824 3825 3826
	if (err < 0) {
		rtnl_unlock();
		goto out_free_mon;
	}
3827 3828
	rtnl_unlock();

3829 3830
	return 0;

3831
out_free_mon:
3832
	free_netdev(hwsim_mon);
3833
out_free_radios:
3834
	mac80211_hwsim_free();
3835
out_unregister_driver:
3836
	platform_driver_unregister(&mac80211_hwsim_driver);
3837 3838
out_unregister_pernet:
	unregister_pernet_device(&hwsim_net_ops);
3839 3840 3841 3842
out_free_rht:
	rhashtable_destroy(&hwsim_radios_rht);
out_free_wq:
	destroy_workqueue(hwsim_wq);
3843 3844
	return err;
}
3845
module_init(init_mac80211_hwsim);
3846 3847 3848

static void __exit exit_mac80211_hwsim(void)
{
3849
	pr_debug("mac80211_hwsim: unregister radios\n");
3850

3851 3852
	hwsim_exit_netlink();

3853
	mac80211_hwsim_free();
3854 3855
	flush_workqueue(hwsim_wq);

3856
	rhashtable_destroy(&hwsim_radios_rht);
3857
	unregister_netdev(hwsim_mon);
3858
	platform_driver_unregister(&mac80211_hwsim_driver);
3859
	unregister_pernet_device(&hwsim_net_ops);
3860
	destroy_workqueue(hwsim_wq);
3861 3862
}
module_exit(exit_mac80211_hwsim);