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

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

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

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

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

42
static u32 wmediumd_portid;
43

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

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

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

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

60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/**
 * 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.
Lucas De Marchi's avatar
Lucas De Marchi committed
84
 * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We accomplish
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 *	this by using a custom beacon-capable regulatory domain for the first
 *	radio. All other device world roam.
 * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory
 * 	domain requests. All radios will adhere to this custom world regulatory
 * 	domain.
 * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory
 * 	domain requests. The first radio will adhere to the first custom world
 * 	regulatory domain, the second one to the second custom world regulatory
 * 	domain. All other devices will world roam.
 * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain
 *	settings, only the first radio will send a regulatory domain request
 *	and use strict settings. The rest of the radios are expected to follow.
 * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain
 *	settings. All radios will adhere to this.
 * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory
 *	domain settings, combined with secondary driver regulatory domain
 *	settings. The first radio will get a strict regulatory domain setting
 *	using the first driver regulatory request and the second radio will use
 *	non-strict settings using the second driver regulatory request. All
 *	other devices should follow the intersection created between the
 *	first two.
 * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need
 * 	at least 6 radios for a complete test. We will test in this order:
 * 	1 - driver custom world regulatory domain
 * 	2 - second custom world regulatory domain
 * 	3 - first driver regulatory domain request
 * 	4 - second driver regulatory domain request
 * 	5 - strict regulatory domain settings using the third driver regulatory
 * 	    domain request
 * 	6 and on - should follow the intersection of the 3rd, 4rth and 5th radio
 * 	           regulatory requests.
 */
enum hwsim_regtest {
	HWSIM_REGTEST_DISABLED = 0,
	HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
	HWSIM_REGTEST_DRIVER_REG_ALL = 2,
	HWSIM_REGTEST_DIFF_COUNTRY = 3,
	HWSIM_REGTEST_WORLD_ROAM = 4,
	HWSIM_REGTEST_CUSTOM_WORLD = 5,
	HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
	HWSIM_REGTEST_STRICT_FOLLOW = 7,
	HWSIM_REGTEST_STRICT_ALL = 8,
	HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
	HWSIM_REGTEST_ALL = 10,
};

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

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

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

static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
	.n_reg_rules = 2,
	.alpha2 =  "99",
	.reg_rules = {
		REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
		REG_RULE(5725-10, 5850+10, 40, 0, 30,
			NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
	}
};

166
167
struct hwsim_vif_priv {
	u32 magic;
168
169
170
	u8 bssid[ETH_ALEN];
	bool assoc;
	u16 aid;
171
172
173
174
175
176
177
};

#define HWSIM_VIF_MAGIC	0x69537748

static inline void hwsim_check_magic(struct ieee80211_vif *vif)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
178
179
180
	WARN(vp->magic != HWSIM_VIF_MAGIC,
	     "Invalid VIF (%p) magic %#x, %pM, %d/%d\n",
	     vif, vp->magic, vif->addr, vif->type, vif->p2p);
181
182
183
184
185
186
187
188
189
190
191
192
193
}

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

195
196
197
198
struct hwsim_sta_priv {
	u32 magic;
};

199
#define HWSIM_STA_MAGIC	0x6d537749
200
201
202
203

static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
204
	WARN_ON(sp->magic != HWSIM_STA_MAGIC);
205
206
207
208
209
}

static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
210
	sp->magic = HWSIM_STA_MAGIC;
211
212
213
214
215
216
217
218
}

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

219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
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;
}

243
244
245
246
static struct class *hwsim_class;

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

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
#define CHAN2G(_freq)  { \
	.band = IEEE80211_BAND_2GHZ, \
	.center_freq = (_freq), \
	.hw_value = (_freq), \
	.max_power = 20, \
}

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

static const struct ieee80211_channel hwsim_channels_2ghz[] = {
	CHAN2G(2412), /* Channel 1 */
	CHAN2G(2417), /* Channel 2 */
	CHAN2G(2422), /* Channel 3 */
	CHAN2G(2427), /* Channel 4 */
	CHAN2G(2432), /* Channel 5 */
	CHAN2G(2437), /* Channel 6 */
	CHAN2G(2442), /* Channel 7 */
	CHAN2G(2447), /* Channel 8 */
	CHAN2G(2452), /* Channel 9 */
	CHAN2G(2457), /* Channel 10 */
	CHAN2G(2462), /* Channel 11 */
	CHAN2G(2467), /* Channel 12 */
	CHAN2G(2472), /* Channel 13 */
	CHAN2G(2484), /* Channel 14 */
};
277

278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
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 */
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
};

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

323
324
325
static spinlock_t hwsim_radio_lock;
static struct list_head hwsim_radios;

326
struct mac80211_hwsim_data {
327
328
	struct list_head list;
	struct ieee80211_hw *hw;
329
	struct device *dev;
330
	struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
331
332
	struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
	struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
333
334
	struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];

335
336
	struct mac_address addresses[2];

337
338
339
340
341
342
343
	struct ieee80211_channel *tmp_chan;
	struct delayed_work roc_done;
	struct delayed_work hw_scan;
	struct cfg80211_scan_request *hw_scan_request;
	struct ieee80211_vif *hw_scan_vif;
	int scan_chan_idx;

344
	struct ieee80211_channel *channel;
345
	u64 beacon_int	/* beacon interval in us */;
346
	unsigned int rx_filter;
347
348
	bool started, idle, scanning;
	struct mutex mutex;
349
	struct tasklet_hrtimer beacon_timer;
350
351
352
353
354
355
	enum ps_mode {
		PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
	} ps;
	bool ps_poll_pending;
	struct dentry *debugfs;
	struct dentry *debugfs_ps;
Daniel Wagner's avatar
Daniel Wagner committed
356

357
	struct sk_buff_head pending;	/* packets pending */
Daniel Wagner's avatar
Daniel Wagner committed
358
359
360
361
362
363
364
	/*
	 * Only radios in the same group can communicate together (the
	 * channel has to match too). Each bit represents a group. A
	 * radio can be in more then one group.
	 */
	u64 group;
	struct dentry *debugfs_group;
365
366

	int power_level;
367
368

	/* difference between this hw's clock and the real clock, in usecs */
369
	s64 tsf_offset;
370
	s64 bcn_delta;
371
372
	/* absolute beacon transmission time. Used to cover up "tx" delay. */
	u64 abs_bcn_ts;
373
374
375
376
377
};


struct hwsim_radiotap_hdr {
	struct ieee80211_radiotap_header hdr;
378
	__le64 rt_tsft;
379
380
381
382
	u8 rt_flags;
	u8 rt_rate;
	__le16 rt_channel;
	__le16 rt_chbitmask;
383
} __packed;
384

385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
/* MAC80211_HWSIM netlinf family */
static struct genl_family hwsim_genl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = 0,
	.name = "MAC80211_HWSIM",
	.version = 1,
	.maxattr = HWSIM_ATTR_MAX,
};

/* MAC80211_HWSIM netlink policy */

static struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
	[HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC,
				       .len = 6*sizeof(u8) },
	[HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC,
					  .len = 6*sizeof(u8) },
	[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,
				 .len = IEEE80211_TX_MAX_RATES*sizeof(
					struct hwsim_tx_rate)},
	[HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
};
411

412
413
static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
					struct net_device *dev)
414
415
416
{
	/* TODO: allow packet injection */
	dev_kfree_skb(skb);
417
	return NETDEV_TX_OK;
418
419
}

420
421
422
423
424
static inline u64 mac80211_hwsim_get_tsf_raw(void)
{
	return ktime_to_us(ktime_get_real());
}

425
426
static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
{
427
	u64 now = mac80211_hwsim_get_tsf_raw();
428
429
	return cpu_to_le64(now + data->tsf_offset);
}
430

431
static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
432
				  struct ieee80211_vif *vif)
433
434
435
436
437
438
439
440
441
{
	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;
442
	u64 now = mac80211_hwsim_get_tsf(hw, vif);
443
	u32 bcn_int = data->beacon_int;
444
445
446
	s64 delta = tsf - now;

	data->tsf_offset += delta;
447
448
	/* adjust after beaconing with new timestamp at old TBTT */
	data->bcn_delta = do_div(delta, bcn_int);
449
450
}

451
static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
452
453
				      struct sk_buff *tx_skb,
				      struct ieee80211_channel *chan)
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
{
	struct mac80211_hwsim_data *data = hw->priv;
	struct sk_buff *skb;
	struct hwsim_radiotap_hdr *hdr;
	u16 flags;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb);
	struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info);

	if (!netif_running(hwsim_mon))
		return;

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

	hdr = (struct hwsim_radiotap_hdr *) skb_push(skb, sizeof(*hdr));
	hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
	hdr->hdr.it_pad = 0;
	hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
Jouni Malinen's avatar
Jouni Malinen committed
473
474
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_RATE) |
475
					  (1 << IEEE80211_RADIOTAP_TSFT) |
Jouni Malinen's avatar
Jouni Malinen committed
476
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
477
	hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
478
479
	hdr->rt_flags = 0;
	hdr->rt_rate = txrate->bitrate / 5;
480
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
481
482
483
484
485
486
487
488
489
490
491
	flags = IEEE80211_CHAN_2GHZ;
	if (txrate->flags & IEEE80211_RATE_ERP_G)
		flags |= IEEE80211_CHAN_OFDM;
	else
		flags |= IEEE80211_CHAN_CCK;
	hdr->rt_chbitmask = cpu_to_le16(flags);

	skb->dev = hwsim_mon;
	skb_set_mac_header(skb, 0);
	skb->ip_summed = CHECKSUM_UNNECESSARY;
	skb->pkt_type = PACKET_OTHERHOST;
Jouni Malinen's avatar
Jouni Malinen committed
492
	skb->protocol = htons(ETH_P_802_2);
493
494
495
496
497
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}


498
499
static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
				       const u8 *addr)
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
{
	struct sk_buff *skb;
	struct hwsim_radiotap_hdr *hdr;
	u16 flags;
	struct ieee80211_hdr *hdr11;

	if (!netif_running(hwsim_mon))
		return;

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

	hdr = (struct hwsim_radiotap_hdr *) skb_put(skb, sizeof(*hdr));
	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;
	hdr->rt_rate = 0;
521
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
	flags = IEEE80211_CHAN_2GHZ;
	hdr->rt_chbitmask = cpu_to_le16(flags);

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

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


541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
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 &&
		    memcmp(data->hw->wiphy->perm_addr, skb->data + 4,
			   ETH_ALEN) == 0) {
			data->ps_poll_pending = false;
			return true;
		}
		return false;
	}

	return true;
}


569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
struct mac80211_hwsim_addr_match_data {
	bool ret;
	const u8 *addr;
};

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;

	if (memcmp(addr, data->hw->wiphy->perm_addr, ETH_ALEN) == 0)
		return true;

	md.ret = false;
	md.addr = addr;
	ieee80211_iterate_active_interfaces_atomic(data->hw,
594
						   IEEE80211_IFACE_ITER_NORMAL,
595
596
597
598
599
600
						   mac80211_hwsim_addr_iter,
						   &md);

	return md.ret;
}

601
602
static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
				       struct sk_buff *my_skb,
603
				       int dst_portid)
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
{
	struct sk_buff *skb;
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb);
	void *msg_head;
	unsigned int hwsim_flags = 0;
	int i;
	struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES];

	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
	/* If the queue contains MAX_QUEUE skb's drop some */
	if (skb_queue_len(&data->pending) >= MAX_QUEUE) {
		/* Droping until WARN_QUEUE level */
		while (skb_queue_len(&data->pending) >= WARN_QUEUE)
			skb_dequeue(&data->pending);
	}

623
	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
624
625
626
627
628
629
630
631
632
633
	if (skb == NULL)
		goto nla_put_failure;

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

634
635
636
	if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
		    sizeof(struct mac_address), data->addresses[1].addr))
		goto nla_put_failure;
637

638
	/* We get the skb->data */
639
640
	if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
		goto nla_put_failure;
641
642
643
644
645
646
647
648
649
650

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

651
652
	if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
		goto nla_put_failure;
653
654
655
656
657
658
659
660

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

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

661
662
663
664
	if (nla_put(skb, HWSIM_ATTR_TX_INFO,
		    sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
		    tx_attempts))
		goto nla_put_failure;
665
666

	/* We create a cookie to identify this skb */
667
668
	if (nla_put_u64(skb, HWSIM_ATTR_COOKIE, (unsigned long) my_skb))
		goto nla_put_failure;
669
670

	genlmsg_end(skb, msg_head);
671
	genlmsg_unicast(&init_net, skb, dst_portid);
672
673
674
675
676
677

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

nla_put_failure:
678
	printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
679
680
}

681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
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,
704
				rcu_dereference(vif->chanctx_conf)->def.chan))
705
706
707
708
709
		return;

	data->receive = true;
}

710
static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
711
712
					  struct sk_buff *skb,
					  struct ieee80211_channel *chan)
713
{
714
715
	struct mac80211_hwsim_data *data = hw->priv, *data2;
	bool ack = false;
716
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
717
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
718
	struct ieee80211_rx_status rx_status;
719
	u64 now;
720
721

	memset(&rx_status, 0, sizeof(rx_status));
722
	rx_status.flag |= RX_FLAG_MACTIME_START;
723
724
	rx_status.freq = chan->center_freq;
	rx_status.band = chan->band;
725
726
727
728
729
730
731
732
733
734
735
	if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
		rx_status.rate_idx =
			ieee80211_rate_get_vht_mcs(&info->control.rates[0]);
		rx_status.vht_nss =
			ieee80211_rate_get_vht_nss(&info->control.rates[0]);
		rx_status.flag |= RX_FLAG_VHT;
	} else {
		rx_status.rate_idx = info->control.rates[0].idx;
		if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
			rx_status.flag |= RX_FLAG_HT;
	}
736
737
738
739
	if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		rx_status.flag |= RX_FLAG_40MHZ;
	if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
		rx_status.flag |= RX_FLAG_SHORT_GI;
740
	/* TODO: simulate real signal strength (and optional packet loss) */
741
	rx_status.signal = data->power_level - 50;
742

743
744
745
	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);

746
747
	/* release the skb's source info */
	skb_orphan(skb);
748
	skb_dst_drop(skb);
749
750
751
752
	skb->mark = 0;
	secpath_reset(skb);
	nf_reset(skb);

753
754
755
756
757
758
759
760
761
762
763
764
765
	/*
	 * 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();

766
	/* Copy skb to all enabled radios that are on the current frequency */
767
768
	spin_lock(&hwsim_radio_lock);
	list_for_each_entry(data2, &hwsim_radios, list) {
769
		struct sk_buff *nskb;
770
771
772
773
		struct tx_iter_data tx_iter_data = {
			.receive = false,
			.channel = chan,
		};
774

775
		if (data == data2)
776
			continue;
777

778
779
		if (!data2->started || (data2->idle && !data2->tmp_chan) ||
		    !hwsim_ps_rx_ok(data2, skb))
780
781
			continue;

782
783
784
785
786
787
		if (!(data->group & data2->group))
			continue;

		if (!hwsim_chans_compat(chan, data2->tmp_chan) &&
		    !hwsim_chans_compat(chan, data2->channel)) {
			ieee80211_iterate_active_interfaces_atomic(
788
789
				data2->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_tx_iter, &tx_iter_data);
790
791
792
793
			if (!tx_iter_data.receive)
				continue;
		}

794
795
796
797
		/*
		 * reserve some space for our vendor and the normal
		 * radiotap header, since we're copying anyway
		 */
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
		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;
		}
817

818
		if (mac80211_hwsim_addr_match(data2, hdr->addr1))
819
			ack = true;
820

821
		rx_status.mactime = now + data2->tsf_offset;
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
#if 0
		/*
		 * Don't enable this code by default as the OUI 00:00:00
		 * is registered to Xerox so we shouldn't use it here, it
		 * might find its way into pcap files.
		 * Note that this code requires the headroom in the SKB
		 * that was allocated earlier.
		 */
		rx_status.vendor_radiotap_oui[0] = 0x00;
		rx_status.vendor_radiotap_oui[1] = 0x00;
		rx_status.vendor_radiotap_oui[2] = 0x00;
		rx_status.vendor_radiotap_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.
		 */
		rx_status.vendor_radiotap_bitmap = BIT(0);
		/* We have 8 bytes of (dummy) data */
		rx_status.vendor_radiotap_len = 8;
		/* For testing, also require it to be aligned */
		rx_status.vendor_radiotap_align = 8;
		/* push the data */
		memcpy(skb_push(nskb, 8), "ABCDEFGH", 8);
#endif

849
850
		memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
		ieee80211_rx_irqsafe(data2->hw, nskb);
851
	}
852
	spin_unlock(&hwsim_radio_lock);
853

854
855
856
	return ack;
}

857
858
859
static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
			      struct ieee80211_tx_control *control,
			      struct sk_buff *skb)
860
{
861
862
863
864
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_channel *channel;
865
	bool ack;
866
	u32 _portid;
867

868
	if (WARN_ON(skb->len < 10)) {
869
870
		/* Should not happen; just a sanity check for addr1 use */
		dev_kfree_skb(skb);
871
		return;
872
873
	}

874
875
876
877
878
879
880
	if (channels == 1) {
		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)
881
			channel = chanctx_conf->def.chan;
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
		else
			channel = NULL;
	}

	if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
		dev_kfree_skb(skb);
		return;
	}

	if (data->idle && !data->tmp_chan) {
		wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
		dev_kfree_skb(skb);
		return;
	}

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

902
903
904
905
	if (rctbl)
		ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
906

907
	txi->rate_driver_data[0] = channel;
908
909
	mac80211_hwsim_monitor_rx(hw, skb, channel);

910
	/* wmediumd mode check */
911
	_portid = ACCESS_ONCE(wmediumd_portid);
912

913
914
	if (_portid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
915
916

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

919
920
	if (ack && skb->len >= 16) {
		struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
921
		mac80211_hwsim_monitor_ack(channel, hdr->addr2);
922
	}
923

924
	ieee80211_tx_info_clear_status(txi);
925
926
927
928
929

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

930
931
	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
		txi->flags |= IEEE80211_TX_STAT_ACK;
932
933
934
935
936
937
938
	ieee80211_tx_status_irqsafe(hw, skb);
}


static int mac80211_hwsim_start(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
939
	wiphy_debug(hw->wiphy, "%s\n", __func__);
940
	data->started = true;
941
942
943
944
945
946
947
	return 0;
}


static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
948
	data->started = false;
949
	tasklet_hrtimer_cancel(&data->beacon_timer);
950
	wiphy_debug(hw->wiphy, "%s\n", __func__);
951
952
953
954
}


static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
955
					struct ieee80211_vif *vif)
956
{
957
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
958
959
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
960
	hwsim_set_magic(vif);
961
962
963
964
965
966
967

	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;

968
969
970
971
	return 0;
}


972
973
static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
					   struct ieee80211_vif *vif,
974
975
					   enum nl80211_iftype newtype,
					   bool newp2p)
976
{
977
	newtype = ieee80211_iftype_p2p(newtype, newp2p);
978
979
	wiphy_debug(hw->wiphy,
		    "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
980
981
		    __func__, ieee80211_vif_type_p2p(vif),
		    newtype, vif->addr);
982
983
	hwsim_check_magic(vif);

984
985
986
987
988
989
	/*
	 * interface may change from non-AP to AP in
	 * which case this needs to be set up again
	 */
	vif->cab_queue = 0;

990
991
992
	return 0;
}

993
static void mac80211_hwsim_remove_interface(
994
	struct ieee80211_hw *hw, struct ieee80211_vif *vif)
995
{
996
	wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
997
998
		    __func__, ieee80211_vif_type_p2p(vif),
		    vif->addr);
999
1000
	hwsim_check_magic(vif);
	hwsim_clear_magic(vif);
1001
1002
}

1003
1004
1005
1006
1007
1008
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan)
{
	u32 _pid = ACCESS_ONCE(wmediumd_portid);

1009
1010
1011
1012
1013
1014
1015
	if (rctbl) {
		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));
	}

1016
1017
1018
1019
1020
1021
1022
1023
	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);
}
1024
1025
1026
1027

static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
				     struct ieee80211_vif *vif)
{
1028
1029
1030
1031
1032
	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;
1033
1034
	struct sk_buff *skb;

1035
1036
	hwsim_check_magic(vif);

1037
	if (vif->type != NL80211_IFTYPE_AP &&
1038
1039
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_ADHOC)
1040
1041
1042
1043
1044
		return;

	skb = ieee80211_beacon_get(hw, vif);
	if (skb == NULL)
		return;
1045
	info = IEEE80211_SKB_CB(skb);
1046
1047
1048
1049
1050
	if (rctbl)
		ieee80211_get_tx_rates(vif, NULL, skb,
				       info->control.rates,
				       ARRAY_SIZE(info->control.rates));

1051
1052
1053
1054
1055
1056
1057
1058
	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);
1059

1060
	mac80211_hwsim_tx_frame(hw, skb,
1061
				rcu_dereference(vif->chanctx_conf)->def.chan);
1062
1063
}

1064
1065
static enum hrtimer_restart
mac80211_hwsim_beacon(struct hrtimer *timer)
1066
{
1067
1068
1069
1070
1071
1072
	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;
1073

1074
	if (!data->started)
1075
		goto out;
1076

Jouni Malinen's avatar
Jouni Malinen committed
1077
	ieee80211_iterate_active_interfaces_atomic(
1078
		hw, IEEE80211_IFACE_ITER_NORMAL,
1079
		mac80211_hwsim_beacon_tx, data);
1080

1081
1082
1083
1084
1085
1086
	/* beacon at new TBTT + beacon interval */
	if (data->bcn_delta) {
		bcn_int -= data->bcn_delta;
		data->bcn_delta = 0;
	}

1087
1088
1089
1090
1091
	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;
1092
1093
}

1094
1095
1096
1097
1098
1099
1100
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",
1101
};
1102

1103
static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1104
1105
{
	struct mac80211_hwsim_data *data = hw->priv;
1106
	struct ieee80211_conf *conf = &hw->conf;
1107
1108
1109
1110
1111
1112
1113
	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",
	};

1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
	if (conf->chandef.chan)
		wiphy_debug(hw->wiphy,
			    "%s (freq=%d(%d - %d)/%s idle=%d ps=%d smps=%s)\n",
			    __func__,
			    conf->chandef.chan->center_freq,
			    conf->chandef.center_freq1,
			    conf->chandef.center_freq2,
			    hwsim_chanwidths[conf->chandef.width],
			    !!(conf->flags & IEEE80211_CONF_IDLE),
			    !!(conf->flags & IEEE80211_CONF_PS),
			    smps_modes[conf->smps_mode]);
	else
		wiphy_debug(hw->wiphy,
			    "%s (freq=0 idle=%d ps=%d smps=%s)\n",
			    __func__,
			    !!(conf->flags & IEEE80211_CONF_IDLE),
			    !!(conf->flags & IEEE80211_CONF_PS),
			    smps_modes[conf->smps_mode]);
1132

1133
1134
	data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);

1135
	data->channel = conf->chandef.chan;
1136
1137
1138

	WARN_ON(data->channel && channels > 1);

1139
	data->power_level = conf->power_level;
1140
	if (!data->started || !data->beacon_int)
1141
1142
		tasklet_hrtimer_cancel(&data->beacon_timer);
	else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
1143
1144
1145
1146
		u64 tsf = mac80211_hwsim_get_tsf(hw, NULL);
		u32 bcn_int = data->beacon_int;
		u64 until_tbtt = bcn_int - do_div(tsf, bcn_int);

1147
		tasklet_hrtimer_start(&data->beacon_timer,
1148
				      ns_to_ktime(until_tbtt * 1000),
1149
1150
				      HRTIMER_MODE_REL);
	}
1151
1152
1153
1154
1155
1156
1157

	return 0;
}


static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
					    unsigned int changed_flags,
1158
					    unsigned int *total_flags,u64 multicast)
1159
1160
1161
{
	struct mac80211_hwsim_data *data = hw->priv;

1162
	wiphy_debug(hw->wiphy, "%s\n", __func__);
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172

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

	*total_flags = data->rx_filter;
}

1173
1174
1175
1176
1177
static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif,
					    struct ieee80211_bss_conf *info,
					    u32 changed)
{
1178
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1179
	struct mac80211_hwsim_data *data = hw->priv;
1180

1181
	hwsim_check_magic(vif);
1182

1183
	wiphy_debug(hw->wiphy, "%s(changed=0x%x)\n", __func__, changed);
1184

1185
	if (changed & BSS_CHANGED_BSSID) {
1186
1187
		wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n",
			    __func__, info->bssid);
1188
1189
1190
		memcpy(vp->bssid, info->bssid, ETH_ALEN);
	}

1191
	if (changed & BSS_CHANGED_ASSOC) {
1192
1193
		wiphy_debug(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
			    info->assoc, info->aid);
1194
1195
		vp->assoc = info->assoc;
		vp->aid = info->aid;
1196
1197
	}

1198
	if (changed & BSS_CHANGED_BEACON_INT) {
1199
		wiphy_debug(hw->wiphy, "  BCNINT: %d\n", info->beacon_int);
1200
1201
1202
1203
1204
1205
1206
1207
		data->beacon_int = info->beacon_int * 1024;
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED) {
		wiphy_debug(hw->wiphy, "  BCN EN: %d\n", info->enable_beacon);
		if (data->started &&
		    !hrtimer_is_queued(&data->beacon_timer.timer) &&
		    info->enable_beacon) {
1208
1209
			u64 tsf, until_tbtt;
			u32 bcn_int;
1210
1211
			if (WARN_ON(!data->beacon_int))
				data->beacon_int = 1000 * 1024;
1212
1213
1214
			tsf = mac80211_hwsim_get_tsf(hw, vif);
			bcn_int = data->beacon_int;
			until_tbtt = bcn_int - do_div(tsf, bcn_int);
1215
			tasklet_hrtimer_start(&data->beacon_timer,
1216
					      ns_to_ktime(until_tbtt * 1000),
1217
1218
1219
					      HRTIMER_MODE_REL);
		} else if (!info->enable_beacon)
			tasklet_hrtimer_cancel(&data->beacon_timer);
1220
1221
	}

1222
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1223
1224
		wiphy_debug(hw->wiphy, "  ERP_CTS_PROT: %d\n",
			    info->use_cts_prot);
1225
1226
1227
	}

	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1228
1229
		wiphy_debug(hw->wiphy, "  ERP_PREAMBLE: %d\n",
			    info->use_short_preamble);
1230
1231
1232
	}

	if (changed & BSS_CHANGED_ERP_SLOT) {
1233
		wiphy_debug(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
1234
1235
1236
	}

	if (changed & BSS_CHANGED_HT) {
1237
1238
		wiphy_debug(hw->wiphy, "  HT: op_mode=0x%x\n",
			    info->ht_operation_mode);
1239
1240
1241
	}

	if (changed & BSS_CHANGED_BASIC_RATES) {
1242
1243
		wiphy_debug(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
			    (unsigned long long) info->basic_rates);
1244
	}
1245
1246
1247

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

1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
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;
}