projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mac80211: VHT off-by-one NSS
[deliverable/linux.git] / drivers / net / wireless / mac80211_hwsim.c
CommitLineData
acc1e7a3
JM		 1/*
2 * mac80211_hwsim - software simulator of 802.11 radio(s) for mac80211
3 * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
7882513b 4 * Copyright (c) 2011, Javier Lopez <jlopex@gmail.com>
acc1e7a3
JM		 5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11/*
12 * TODO:
2b2d7795
JB		 13 * - Add TSF sync and fix IBSS beacon transmission by adding
14 * competition for "air time" at TBTT
acc1e7a3
JM		 15 * - RX filtering based on filter configuration (data->rx_filter)
16 */
17
0e057d73 18#include <linux/list.h>
5a0e3ad6 19#include <linux/slab.h>
0e057d73 20#include <linux/spinlock.h>
90e3012e
JB		 21#include <net/dst.h>
22#include <net/xfrm.h>
acc1e7a3
JM		 23#include <net/mac80211.h>
24#include <net/ieee80211_radiotap.h>
25#include <linux/if_arp.h>
26#include <linux/rtnetlink.h>
27#include <linux/etherdevice.h>
9ea92774 28#include <linux/platform_device.h>
fc6971d4 29#include <linux/debugfs.h>
9d9779e7 30#include <linux/module.h>
2f40b940 31#include <linux/ktime.h>
7882513b
JL		 32#include <net/genetlink.h>
33#include "mac80211_hwsim.h"
34
35#define WARN_QUEUE 100
36#define MAX_QUEUE 200
acc1e7a3
JM		 37
38MODULE_AUTHOR("Jouni Malinen");
39MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211");
40MODULE_LICENSE("GPL");
41
15e47304 42static u32 wmediumd_portid;
a1910f9c 43
acc1e7a3
JM		 44static int radios = 2;
45module_param(radios, int, 0444);
46MODULE_PARM_DESC(radios, "Number of simulated radios");
47
e8261171
JB		 48static int channels = 1;
49module_param(channels, int, 0444);
50MODULE_PARM_DESC(channels, "Number of concurrent channels");
69068036 51
a357d7f9
JB		 52static bool paged_rx = false;
53module_param(paged_rx, bool, 0644);
54MODULE_PARM_DESC(paged_rx, "Use paged SKBs for RX instead of linear ones");
55
4a5af9c2
LR		 56/**
57 * enum hwsim_regtest - the type of regulatory tests we offer
58 *
59 * These are the different values you can use for the regtest
60 * module parameter. This is useful to help test world roaming
61 * and the driver regulatory_hint() call and combinations of these.
62 * If you want to do specific alpha2 regulatory domain tests simply
63 * use the userspace regulatory request as that will be respected as
64 * well without the need of this module parameter. This is designed
65 * only for testing the driver regulatory request, world roaming
66 * and all possible combinations.
67 *
68 * @HWSIM_REGTEST_DISABLED: No regulatory tests are performed,
69 * this is the default value.
70 * @HWSIM_REGTEST_DRIVER_REG_FOLLOW: Used for testing the driver regulatory
71 * hint, only one driver regulatory hint will be sent as such the
72 * secondary radios are expected to follow.
73 * @HWSIM_REGTEST_DRIVER_REG_ALL: Used for testing the driver regulatory
74 * request with all radios reporting the same regulatory domain.
75 * @HWSIM_REGTEST_DIFF_COUNTRY: Used for testing the drivers calling
76 * different regulatory domains requests. Expected behaviour is for
77 * an intersection to occur but each device will still use their
78 * respective regulatory requested domains. Subsequent radios will
79 * use the resulting intersection.
25985edc 80 * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We accomplish
4a5af9c2
LR		 81 * this by using a custom beacon-capable regulatory domain for the first
82 * radio. All other device world roam.
83 * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory
84 * domain requests. All radios will adhere to this custom world regulatory
85 * domain.
86 * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory
87 * domain requests. The first radio will adhere to the first custom world
88 * regulatory domain, the second one to the second custom world regulatory
89 * domain. All other devices will world roam.
90 * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain
91 * settings, only the first radio will send a regulatory domain request
92 * and use strict settings. The rest of the radios are expected to follow.
93 * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain
94 * settings. All radios will adhere to this.
95 * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory
96 * domain settings, combined with secondary driver regulatory domain
97 * settings. The first radio will get a strict regulatory domain setting
98 * using the first driver regulatory request and the second radio will use
99 * non-strict settings using the second driver regulatory request. All
100 * other devices should follow the intersection created between the
101 * first two.
102 * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need
103 * at least 6 radios for a complete test. We will test in this order:
104 * 1 - driver custom world regulatory domain
105 * 2 - second custom world regulatory domain
106 * 3 - first driver regulatory domain request
107 * 4 - second driver regulatory domain request
108 * 5 - strict regulatory domain settings using the third driver regulatory
109 * domain request
110 * 6 and on - should follow the intersection of the 3rd, 4rth and 5th radio
111 * regulatory requests.
112 */
113enum hwsim_regtest {
114 HWSIM_REGTEST_DISABLED = 0,
115 HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
116 HWSIM_REGTEST_DRIVER_REG_ALL = 2,
117 HWSIM_REGTEST_DIFF_COUNTRY = 3,
118 HWSIM_REGTEST_WORLD_ROAM = 4,
119 HWSIM_REGTEST_CUSTOM_WORLD = 5,
120 HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
121 HWSIM_REGTEST_STRICT_FOLLOW = 7,
122 HWSIM_REGTEST_STRICT_ALL = 8,
123 HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
124 HWSIM_REGTEST_ALL = 10,
125};
126
127/* Set to one of the HWSIM_REGTEST_* values above */
128static int regtest = HWSIM_REGTEST_DISABLED;
129module_param(regtest, int, 0444);
130MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run");
131
132static const char *hwsim_alpha2s[] = {
133 "FI",
134 "AL",
135 "US",
136 "DE",
137 "JP",
138 "AL",
139};
140
141static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = {
142 .n_reg_rules = 4,
143 .alpha2 = "99",
144 .reg_rules = {
145 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
146 REG_RULE(2484-10, 2484+10, 40, 0, 20, 0),
147 REG_RULE(5150-10, 5240+10, 40, 0, 30, 0),
148 REG_RULE(5745-10, 5825+10, 40, 0, 30, 0),
149 }
150};
151
152static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
153 .n_reg_rules = 2,
154 .alpha2 = "99",
155 .reg_rules = {
156 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
157 REG_RULE(5725-10, 5850+10, 40, 0, 30,
158 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
159 }
160};
161
8aa21e6f
JB		 162struct hwsim_vif_priv {
163 u32 magic;
fc6971d4
JM		 164 u8 bssid[ETH_ALEN];
165 bool assoc;
166 u16 aid;
8aa21e6f
JB		 167};
168
169#define HWSIM_VIF_MAGIC 0x69537748
170
171static inline void hwsim_check_magic(struct ieee80211_vif *vif)
172{
173 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
e8261171
JB		 174 WARN(vp->magic != HWSIM_VIF_MAGIC,
175 "Invalid VIF (%p) magic %#x, %pM, %d/%d\n",
176 vif, vp->magic, vif->addr, vif->type, vif->p2p);
8aa21e6f
JB		 177}
178
179static inline void hwsim_set_magic(struct ieee80211_vif *vif)
180{
181 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
182 vp->magic = HWSIM_VIF_MAGIC;
183}
184
185static inline void hwsim_clear_magic(struct ieee80211_vif *vif)
186{
187 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
188 vp->magic = 0;
189}
acc1e7a3 190
81c06523
JB		 191struct hwsim_sta_priv {
192 u32 magic;
193};
194
e8261171 195#define HWSIM_STA_MAGIC 0x6d537749
81c06523
JB		 196
197static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta)
198{
199 struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
5d6924ea 200 WARN_ON(sp->magic != HWSIM_STA_MAGIC);
81c06523
JB		 201}
202
203static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta)
204{
205 struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
5d6924ea 206 sp->magic = HWSIM_STA_MAGIC;
81c06523
JB		 207}
208
209static inline void hwsim_clear_sta_magic(struct ieee80211_sta *sta)
210{
211 struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
212 sp->magic = 0;
213}
214
e8261171
JB		 215struct hwsim_chanctx_priv {
216 u32 magic;
217};
218
219#define HWSIM_CHANCTX_MAGIC 0x6d53774a
220
221static inline void hwsim_check_chanctx_magic(struct ieee80211_chanctx_conf *c)
222{
223 struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
224 WARN_ON(cp->magic != HWSIM_CHANCTX_MAGIC);
225}
226
227static inline void hwsim_set_chanctx_magic(struct ieee80211_chanctx_conf *c)
228{
229 struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
230 cp->magic = HWSIM_CHANCTX_MAGIC;
231}
232
233static inline void hwsim_clear_chanctx_magic(struct ieee80211_chanctx_conf *c)
234{
235 struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
236 cp->magic = 0;
237}
238
acc1e7a3
JM		 239static struct class *hwsim_class;
240
acc1e7a3
JM		 241static struct net_device *hwsim_mon; /* global monitor netdev */
242
22cad735
LR		 243#define CHAN2G(_freq) { \
244 .band = IEEE80211_BAND_2GHZ, \
245 .center_freq = (_freq), \
246 .hw_value = (_freq), \
247 .max_power = 20, \
248}
249
250#define CHAN5G(_freq) { \
251 .band = IEEE80211_BAND_5GHZ, \
252 .center_freq = (_freq), \
253 .hw_value = (_freq), \
254 .max_power = 20, \
255}
256
257static const struct ieee80211_channel hwsim_channels_2ghz[] = {
258 CHAN2G(2412), /* Channel 1 */
259 CHAN2G(2417), /* Channel 2 */
260 CHAN2G(2422), /* Channel 3 */
261 CHAN2G(2427), /* Channel 4 */
262 CHAN2G(2432), /* Channel 5 */
263 CHAN2G(2437), /* Channel 6 */
264 CHAN2G(2442), /* Channel 7 */
265 CHAN2G(2447), /* Channel 8 */
266 CHAN2G(2452), /* Channel 9 */
267 CHAN2G(2457), /* Channel 10 */
268 CHAN2G(2462), /* Channel 11 */
269 CHAN2G(2467), /* Channel 12 */
270 CHAN2G(2472), /* Channel 13 */
271 CHAN2G(2484), /* Channel 14 */
272};
acc1e7a3 273
22cad735
LR		 274static const struct ieee80211_channel hwsim_channels_5ghz[] = {
275 CHAN5G(5180), /* Channel 36 */
276 CHAN5G(5200), /* Channel 40 */
277 CHAN5G(5220), /* Channel 44 */
278 CHAN5G(5240), /* Channel 48 */
279
280 CHAN5G(5260), /* Channel 52 */
281 CHAN5G(5280), /* Channel 56 */
282 CHAN5G(5300), /* Channel 60 */
283 CHAN5G(5320), /* Channel 64 */
284
285 CHAN5G(5500), /* Channel 100 */
286 CHAN5G(5520), /* Channel 104 */
287 CHAN5G(5540), /* Channel 108 */
288 CHAN5G(5560), /* Channel 112 */
289 CHAN5G(5580), /* Channel 116 */
290 CHAN5G(5600), /* Channel 120 */
291 CHAN5G(5620), /* Channel 124 */
292 CHAN5G(5640), /* Channel 128 */
293 CHAN5G(5660), /* Channel 132 */
294 CHAN5G(5680), /* Channel 136 */
295 CHAN5G(5700), /* Channel 140 */
296
297 CHAN5G(5745), /* Channel 149 */
298 CHAN5G(5765), /* Channel 153 */
299 CHAN5G(5785), /* Channel 157 */
300 CHAN5G(5805), /* Channel 161 */
301 CHAN5G(5825), /* Channel 165 */
acc1e7a3
JM		 302};
303
304static const struct ieee80211_rate hwsim_rates[] = {
305 { .bitrate = 10 },
306 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
307 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
308 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
309 { .bitrate = 60 },
310 { .bitrate = 90 },
311 { .bitrate = 120 },
312 { .bitrate = 180 },
313 { .bitrate = 240 },
314 { .bitrate = 360 },
315 { .bitrate = 480 },
316 { .bitrate = 540 }
317};
318
0e057d73
JB		 319static spinlock_t hwsim_radio_lock;
320static struct list_head hwsim_radios;
321
acc1e7a3 322struct mac80211_hwsim_data {
0e057d73
JB		 323 struct list_head list;
324 struct ieee80211_hw *hw;
acc1e7a3 325 struct device *dev;
1b083ea4 326 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
22cad735
LR		 327 struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
328 struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
acc1e7a3
JM		 329 struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
330
ef15aac6
JB		 331 struct mac_address addresses[2];
332
e8261171
JB		 333 struct ieee80211_channel *tmp_chan;
334 struct delayed_work roc_done;
335 struct delayed_work hw_scan;
336 struct cfg80211_scan_request *hw_scan_request;
337 struct ieee80211_vif *hw_scan_vif;
338 int scan_chan_idx;
339
acc1e7a3 340 struct ieee80211_channel *channel;
01e59e46 341 u64 beacon_int /* beacon interval in us */;
acc1e7a3 342 unsigned int rx_filter;
f74cb0f7
LR		 343 bool started, idle, scanning;
344 struct mutex mutex;
01e59e46 345 struct tasklet_hrtimer beacon_timer;
fc6971d4
JM		 346 enum ps_mode {
347 PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
348 } ps;
349 bool ps_poll_pending;
350 struct dentry *debugfs;
351 struct dentry *debugfs_ps;
73606d00 352
7882513b 353 struct sk_buff_head pending; /* packets pending */
73606d00
DW		 354 /*
355 * Only radios in the same group can communicate together (the
356 * channel has to match too). Each bit represents a group. A
357 * radio can be in more then one group.
358 */
359 u64 group;
360 struct dentry *debugfs_group;
bdd7bd16
BG		 361
362 int power_level;
2f40b940
JC		 363
364 /* difference between this hw's clock and the real clock, in usecs */
45034bfb 365 s64 tsf_offset;
c51f8783 366 s64 bcn_delta;
b66851c3
TP		 367 /* absolute beacon transmission time. Used to cover up "tx" delay. */
368 u64 abs_bcn_ts;
acc1e7a3
JM		 369};
370
371
372struct hwsim_radiotap_hdr {
373 struct ieee80211_radiotap_header hdr;
2f40b940 374 __le64 rt_tsft;
acc1e7a3
JM		 375 u8 rt_flags;
376 u8 rt_rate;
377 __le16 rt_channel;
378 __le16 rt_chbitmask;
ba2d3587 379} __packed;
acc1e7a3 380
7882513b
JL		 381/* MAC80211_HWSIM netlinf family */
382static struct genl_family hwsim_genl_family = {
383 .id = GENL_ID_GENERATE,
384 .hdrsize = 0,
385 .name = "MAC80211_HWSIM",
386 .version = 1,
387 .maxattr = HWSIM_ATTR_MAX,
388};
389
390/* MAC80211_HWSIM netlink policy */
391
392static struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
393 [HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC,
394 .len = 6*sizeof(u8) },
395 [HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC,
396 .len = 6*sizeof(u8) },
397 [HWSIM_ATTR_FRAME] = { .type = NLA_BINARY,
398 .len = IEEE80211_MAX_DATA_LEN },
399 [HWSIM_ATTR_FLAGS] = { .type = NLA_U32 },
400 [HWSIM_ATTR_RX_RATE] = { .type = NLA_U32 },
401 [HWSIM_ATTR_SIGNAL] = { .type = NLA_U32 },
402 [HWSIM_ATTR_TX_INFO] = { .type = NLA_UNSPEC,
403 .len = IEEE80211_TX_MAX_RATES*sizeof(
404 struct hwsim_tx_rate)},
405 [HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
406};
acc1e7a3 407
d0cf9c0d
SH		 408static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
409 struct net_device *dev)
acc1e7a3
JM		 410{
411 /* TODO: allow packet injection */
412 dev_kfree_skb(skb);
6ed10654 413 return NETDEV_TX_OK;
acc1e7a3
JM		 414}
415
b66851c3
TP		 416static inline u64 mac80211_hwsim_get_tsf_raw(void)
417{
418 return ktime_to_us(ktime_get_real());
419}
420
2f40b940
JC		 421static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
422{
b66851c3 423 u64 now = mac80211_hwsim_get_tsf_raw();
2f40b940
JC		 424 return cpu_to_le64(now + data->tsf_offset);
425}
acc1e7a3 426
12ce8ba3 427static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
b66851c3 428 struct ieee80211_vif *vif)
12ce8ba3
JC		 429{
430 struct mac80211_hwsim_data *data = hw->priv;
431 return le64_to_cpu(__mac80211_hwsim_get_tsf(data));
432}
433
434static void mac80211_hwsim_set_tsf(struct ieee80211_hw *hw,
435 struct ieee80211_vif *vif, u64 tsf)
436{
437 struct mac80211_hwsim_data *data = hw->priv;
45034bfb 438 u64 now = mac80211_hwsim_get_tsf(hw, vif);
c51f8783 439 u32 bcn_int = data->beacon_int;
45034bfb
TP		 440 s64 delta = tsf - now;
441
442 data->tsf_offset += delta;
c51f8783
TP		 443 /* adjust after beaconing with new timestamp at old TBTT */
444 data->bcn_delta = do_div(delta, bcn_int);
12ce8ba3
JC		 445}
446
acc1e7a3 447static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
e8261171
JB		 448 struct sk_buff *tx_skb,
449 struct ieee80211_channel *chan)
acc1e7a3
JM		 450{
451 struct mac80211_hwsim_data *data = hw->priv;
452 struct sk_buff *skb;
453 struct hwsim_radiotap_hdr *hdr;
454 u16 flags;
455 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb);
456 struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info);
457
458 if (!netif_running(hwsim_mon))
459 return;
460
461 skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC);
462 if (skb == NULL)
463 return;
464
465 hdr = (struct hwsim_radiotap_hdr *) skb_push(skb, sizeof(*hdr));
466 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
467 hdr->hdr.it_pad = 0;
468 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
f248f105
JM		 469 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
470 (1 << IEEE80211_RADIOTAP_RATE) |
2f40b940 471 (1 << IEEE80211_RADIOTAP_TSFT) |
f248f105 472 (1 << IEEE80211_RADIOTAP_CHANNEL));
2f40b940 473 hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
acc1e7a3
JM		 474 hdr->rt_flags = 0;
475 hdr->rt_rate = txrate->bitrate / 5;
e8261171 476 hdr->rt_channel = cpu_to_le16(chan->center_freq);
acc1e7a3
JM		 477 flags = IEEE80211_CHAN_2GHZ;
478 if (txrate->flags & IEEE80211_RATE_ERP_G)
479 flags |= IEEE80211_CHAN_OFDM;
480 else
481 flags |= IEEE80211_CHAN_CCK;
482 hdr->rt_chbitmask = cpu_to_le16(flags);
483
484 skb->dev = hwsim_mon;
485 skb_set_mac_header(skb, 0);
486 skb->ip_summed = CHECKSUM_UNNECESSARY;
487 skb->pkt_type = PACKET_OTHERHOST;
f248f105 488 skb->protocol = htons(ETH_P_802_2);
acc1e7a3
JM		 489 memset(skb->cb, 0, sizeof(skb->cb));
490 netif_rx(skb);
491}
492
493
e8261171
JB		 494static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
495 const u8 *addr)
6c085227 496{
6c085227
JM		 497 struct sk_buff *skb;
498 struct hwsim_radiotap_hdr *hdr;
499 u16 flags;
500 struct ieee80211_hdr *hdr11;
501
502 if (!netif_running(hwsim_mon))
503 return;
504
505 skb = dev_alloc_skb(100);
506 if (skb == NULL)
507 return;
508
509 hdr = (struct hwsim_radiotap_hdr *) skb_put(skb, sizeof(*hdr));
510 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
511 hdr->hdr.it_pad = 0;
512 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
513 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
514 (1 << IEEE80211_RADIOTAP_CHANNEL));
515 hdr->rt_flags = 0;
516 hdr->rt_rate = 0;
e8261171 517 hdr->rt_channel = cpu_to_le16(chan->center_freq);
6c085227
JM		 518 flags = IEEE80211_CHAN_2GHZ;
519 hdr->rt_chbitmask = cpu_to_le16(flags);
520
521 hdr11 = (struct ieee80211_hdr *) skb_put(skb, 10);
522 hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
523 IEEE80211_STYPE_ACK);
524 hdr11->duration_id = cpu_to_le16(0);
525 memcpy(hdr11->addr1, addr, ETH_ALEN);
526
527 skb->dev = hwsim_mon;
528 skb_set_mac_header(skb, 0);
529 skb->ip_summed = CHECKSUM_UNNECESSARY;
530 skb->pkt_type = PACKET_OTHERHOST;
531 skb->protocol = htons(ETH_P_802_2);
532 memset(skb->cb, 0, sizeof(skb->cb));
533 netif_rx(skb);
534}
535
536
fc6971d4
JM		 537static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
538 struct sk_buff *skb)
539{
540 switch (data->ps) {
541 case PS_DISABLED:
542 return true;
543 case PS_ENABLED:
544 return false;
545 case PS_AUTO_POLL:
546 /* TODO: accept (some) Beacons by default and other frames only
547 * if pending PS-Poll has been sent */
548 return true;
549 case PS_MANUAL_POLL:
550 /* Allow unicast frames to own address if there is a pending
551 * PS-Poll */
552 if (data->ps_poll_pending &&
553 memcmp(data->hw->wiphy->perm_addr, skb->data + 4,
554 ETH_ALEN) == 0) {
555 data->ps_poll_pending = false;
556 return true;
557 }
558 return false;
559 }
560
561 return true;
562}
563
564
265dc7f0
JM		 565struct mac80211_hwsim_addr_match_data {
566 bool ret;
567 const u8 *addr;
568};
569
570static void mac80211_hwsim_addr_iter(void *data, u8 *mac,
571 struct ieee80211_vif *vif)
572{
573 struct mac80211_hwsim_addr_match_data *md = data;
574 if (memcmp(mac, md->addr, ETH_ALEN) == 0)
575 md->ret = true;
576}
577
578
579static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data,
580 const u8 *addr)
581{
582 struct mac80211_hwsim_addr_match_data md;
583
584 if (memcmp(addr, data->hw->wiphy->perm_addr, ETH_ALEN) == 0)
585 return true;
586
587 md.ret = false;
588 md.addr = addr;
589 ieee80211_iterate_active_interfaces_atomic(data->hw,
8b2c9824 590 IEEE80211_IFACE_ITER_NORMAL,
265dc7f0
JM		 591 mac80211_hwsim_addr_iter,
592 &md);
593
594 return md.ret;
595}
596
7882513b
JL		 597static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
598 struct sk_buff *my_skb,
15e47304 599 int dst_portid)
7882513b
JL		 600{
601 struct sk_buff *skb;
602 struct mac80211_hwsim_data *data = hw->priv;
603 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data;
604 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb);
605 void *msg_head;
606 unsigned int hwsim_flags = 0;
607 int i;
608 struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES];
609
7882513b
JL		 610 if (data->ps != PS_DISABLED)
611 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
612 /* If the queue contains MAX_QUEUE skb's drop some */
613 if (skb_queue_len(&data->pending) >= MAX_QUEUE) {
614 /* Droping until WARN_QUEUE level */
615 while (skb_queue_len(&data->pending) >= WARN_QUEUE)
616 skb_dequeue(&data->pending);
617 }
618
58050fce 619 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
7882513b
JL		 620 if (skb == NULL)
621 goto nla_put_failure;
622
623 msg_head = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
624 HWSIM_CMD_FRAME);
625 if (msg_head == NULL) {
626 printk(KERN_DEBUG "mac80211_hwsim: problem with msg_head\n");
627 goto nla_put_failure;
628 }
629
633c9389
DM		 630 if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
631 sizeof(struct mac_address), data->addresses[1].addr))
632 goto nla_put_failure;
265dc7f0 633
7882513b 634 /* We get the skb->data */
633c9389
DM		 635 if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
636 goto nla_put_failure;
7882513b
JL		 637
638 /* We get the flags for this transmission, and we translate them to
639 wmediumd flags */
640
641 if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
642 hwsim_flags |= HWSIM_TX_CTL_REQ_TX_STATUS;
643
644 if (info->flags & IEEE80211_TX_CTL_NO_ACK)
645 hwsim_flags |= HWSIM_TX_CTL_NO_ACK;
646
633c9389
DM		 647 if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
648 goto nla_put_failure;
7882513b
JL		 649
650 /* We get the tx control (rate and retries) info*/
651
652 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
653 tx_attempts[i].idx = info->status.rates[i].idx;
654 tx_attempts[i].count = info->status.rates[i].count;
655 }
656
633c9389
DM		 657 if (nla_put(skb, HWSIM_ATTR_TX_INFO,
658 sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
659 tx_attempts))
660 goto nla_put_failure;
7882513b
JL		 661
662 /* We create a cookie to identify this skb */
633c9389
DM		 663 if (nla_put_u64(skb, HWSIM_ATTR_COOKIE, (unsigned long) my_skb))
664 goto nla_put_failure;
7882513b
JL		 665
666 genlmsg_end(skb, msg_head);
15e47304 667 genlmsg_unicast(&init_net, skb, dst_portid);
7882513b
JL		 668
669 /* Enqueue the packet */
670 skb_queue_tail(&data->pending, my_skb);
671 return;
672
673nla_put_failure:
c393862f 674 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
7882513b
JL		 675}
676
e8261171
JB		 677static bool hwsim_chans_compat(struct ieee80211_channel *c1,
678 struct ieee80211_channel *c2)
679{
680 if (!c1 || !c2)
681 return false;
682
683 return c1->center_freq == c2->center_freq;
684}
685
686struct tx_iter_data {
687 struct ieee80211_channel *channel;
688 bool receive;
689};
690
691static void mac80211_hwsim_tx_iter(void *_data, u8 *addr,
692 struct ieee80211_vif *vif)
693{
694 struct tx_iter_data *data = _data;
695
696 if (!vif->chanctx_conf)
697 return;
698
699 if (!hwsim_chans_compat(data->channel,
4bf88530 700 rcu_dereference(vif->chanctx_conf)->def.chan))
e8261171
JB		 701 return;
702
703 data->receive = true;
704}
705
7882513b 706static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
e8261171
JB		 707 struct sk_buff *skb,
708 struct ieee80211_channel *chan)
acc1e7a3 709{
0e057d73
JB		 710 struct mac80211_hwsim_data *data = hw->priv, *data2;
711 bool ack = false;
e36cfdc9 712 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
acc1e7a3 713 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
e36cfdc9 714 struct ieee80211_rx_status rx_status;
b66851c3 715 u64 now;
acc1e7a3
JM		 716
717 memset(&rx_status, 0, sizeof(rx_status));
f4bda337 718 rx_status.flag |= RX_FLAG_MACTIME_START;
e8261171
JB		 719 rx_status.freq = chan->center_freq;
720 rx_status.band = chan->band;
e6a9854b 721 rx_status.rate_idx = info->control.rates[0].idx;
281ed297
JM		 722 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
723 rx_status.flag |= RX_FLAG_HT;
724 if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
725 rx_status.flag |= RX_FLAG_40MHZ;
726 if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
727 rx_status.flag |= RX_FLAG_SHORT_GI;
4b14c96d 728 /* TODO: simulate real signal strength (and optional packet loss) */
bdd7bd16 729 rx_status.signal = data->power_level - 50;
acc1e7a3 730
fc6971d4
JM		 731 if (data->ps != PS_DISABLED)
732 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
733
90e3012e
JB		 734 /* release the skb's source info */
735 skb_orphan(skb);
c0acf38e 736 skb_dst_drop(skb);
90e3012e
JB		 737 skb->mark = 0;
738 secpath_reset(skb);
739 nf_reset(skb);
740
b66851c3
TP		 741 /*
742 * Get absolute mactime here so all HWs RX at the "same time", and
743 * absolute TX time for beacon mactime so the timestamp matches.
744 * Giving beacons a different mactime than non-beacons looks messy, but
745 * it helps the Toffset be exact and a ~10us mactime discrepancy
746 * probably doesn't really matter.
747 */
748 if (ieee80211_is_beacon(hdr->frame_control) ||
749 ieee80211_is_probe_resp(hdr->frame_control))
750 now = data->abs_bcn_ts;
751 else
752 now = mac80211_hwsim_get_tsf_raw();
753
acc1e7a3 754 /* Copy skb to all enabled radios that are on the current frequency */
0e057d73
JB		 755 spin_lock(&hwsim_radio_lock);
756 list_for_each_entry(data2, &hwsim_radios, list) {
acc1e7a3 757 struct sk_buff *nskb;
e8261171
JB		 758 struct tx_iter_data tx_iter_data = {
759 .receive = false,
760 .channel = chan,
761 };
acc1e7a3 762
0e057d73 763 if (data == data2)
acc1e7a3 764 continue;
0e057d73 765
e8261171
JB		 766 if (!data2->started || (data2->idle && !data2->tmp_chan) ||
767 !hwsim_ps_rx_ok(data2, skb))
acc1e7a3
JM		 768 continue;
769
e8261171
JB		 770 if (!(data->group & data2->group))
771 continue;
772
773 if (!hwsim_chans_compat(chan, data2->tmp_chan) &&
774 !hwsim_chans_compat(chan, data2->channel)) {
775 ieee80211_iterate_active_interfaces_atomic(
8b2c9824
JB		 776 data2->hw, IEEE80211_IFACE_ITER_NORMAL,
777 mac80211_hwsim_tx_iter, &tx_iter_data);
e8261171
JB		 778 if (!tx_iter_data.receive)
779 continue;
780 }
781
90b9e446
JB		 782 /*
783 * reserve some space for our vendor and the normal
784 * radiotap header, since we're copying anyway
785 */
a357d7f9
JB		 786 if (skb->len < PAGE_SIZE && paged_rx) {
787 struct page *page = alloc_page(GFP_ATOMIC);
788
789 if (!page)
790 continue;
791
792 nskb = dev_alloc_skb(128);
793 if (!nskb) {
794 __free_page(page);
795 continue;
796 }
797
798 memcpy(page_address(page), skb->data, skb->len);
799 skb_add_rx_frag(nskb, 0, page, 0, skb->len, skb->len);
800 } else {
801 nskb = skb_copy(skb, GFP_ATOMIC);
802 if (!nskb)
803 continue;
804 }
acc1e7a3 805
265dc7f0 806 if (mac80211_hwsim_addr_match(data2, hdr->addr1))
0e057d73 807 ack = true;
f483ad25 808
b66851c3 809 rx_status.mactime = now + data2->tsf_offset;
90b9e446
JB		 810#if 0
811 /*
812 * Don't enable this code by default as the OUI 00:00:00
813 * is registered to Xerox so we shouldn't use it here, it
814 * might find its way into pcap files.
815 * Note that this code requires the headroom in the SKB
816 * that was allocated earlier.
817 */
818 rx_status.vendor_radiotap_oui[0] = 0x00;
819 rx_status.vendor_radiotap_oui[1] = 0x00;
820 rx_status.vendor_radiotap_oui[2] = 0x00;
821 rx_status.vendor_radiotap_subns = 127;
822 /*
823 * Radiotap vendor namespaces can (and should) also be
824 * split into fields by using the standard radiotap
825 * presence bitmap mechanism. Use just BIT(0) here for
826 * the presence bitmap.
827 */
828 rx_status.vendor_radiotap_bitmap = BIT(0);
829 /* We have 8 bytes of (dummy) data */
830 rx_status.vendor_radiotap_len = 8;
831 /* For testing, also require it to be aligned */
832 rx_status.vendor_radiotap_align = 8;
833 /* push the data */
834 memcpy(skb_push(nskb, 8), "ABCDEFGH", 8);
835#endif
836
f1d58c25
JB		 837 memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
838 ieee80211_rx_irqsafe(data2->hw, nskb);
acc1e7a3 839 }
0e057d73 840 spin_unlock(&hwsim_radio_lock);
acc1e7a3 841
e36cfdc9
JM		 842 return ack;
843}
844
36323f81
TH		 845static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
846 struct ieee80211_tx_control *control,
847 struct sk_buff *skb)
e36cfdc9 848{
e8261171
JB		 849 struct mac80211_hwsim_data *data = hw->priv;
850 struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
851 struct ieee80211_chanctx_conf *chanctx_conf;
852 struct ieee80211_channel *channel;
0e057d73 853 bool ack;
15e47304 854 u32 _portid;
e36cfdc9 855
e8261171 856 if (WARN_ON(skb->len < 10)) {
e36cfdc9
JM		 857 /* Should not happen; just a sanity check for addr1 use */
858 dev_kfree_skb(skb);
7bb45683 859 return;
e36cfdc9
JM		 860 }
861
e8261171
JB		 862 if (channels == 1) {
863 channel = data->channel;
864 } else if (txi->hw_queue == 4) {
865 channel = data->tmp_chan;
866 } else {
867 chanctx_conf = rcu_dereference(txi->control.vif->chanctx_conf);
868 if (chanctx_conf)
4bf88530 869 channel = chanctx_conf->def.chan;
e8261171
JB		 870 else
871 channel = NULL;
872 }
873
874 if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
875 dev_kfree_skb(skb);
876 return;
877 }
878
879 if (data->idle && !data->tmp_chan) {
880 wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
881 dev_kfree_skb(skb);
882 return;
883 }
884
885 if (txi->control.vif)
886 hwsim_check_magic(txi->control.vif);
887 if (control->sta)
888 hwsim_check_sta_magic(control->sta);
889
890 txi->rate_driver_data[0] = channel;
891
892 mac80211_hwsim_monitor_rx(hw, skb, channel);
893
7882513b 894 /* wmediumd mode check */
15e47304 895 _portid = ACCESS_ONCE(wmediumd_portid);
7882513b 896
15e47304
EB		 897 if (_portid)
898 return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
7882513b
JL		 899
900 /* NO wmediumd detected, perfect medium simulation */
e8261171 901 ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
7882513b 902
6c085227
JM		 903 if (ack && skb->len >= 16) {
904 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
e8261171 905 mac80211_hwsim_monitor_ack(channel, hdr->addr2);
6c085227 906 }
e36cfdc9 907
e6a9854b 908 ieee80211_tx_info_clear_status(txi);
2a4ffa4c
JC		 909
910 /* frame was transmitted at most favorable rate at first attempt */
911 txi->control.rates[0].count = 1;
912 txi->control.rates[1].idx = -1;
913
e6a9854b
JB		 914 if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
915 txi->flags |= IEEE80211_TX_STAT_ACK;
acc1e7a3 916 ieee80211_tx_status_irqsafe(hw, skb);
acc1e7a3
JM		 917}
918
919
920static int mac80211_hwsim_start(struct ieee80211_hw *hw)
921{
922 struct mac80211_hwsim_data *data = hw->priv;
c96c31e4 923 wiphy_debug(hw->wiphy, "%s\n", __func__);
3db1cd5c 924 data->started = true;
acc1e7a3
JM		 925 return 0;
926}
927
928
929static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
930{
931 struct mac80211_hwsim_data *data = hw->priv;
3db1cd5c 932 data->started = false;
01e59e46 933 tasklet_hrtimer_cancel(&data->beacon_timer);
c96c31e4 934 wiphy_debug(hw->wiphy, "%s\n", __func__);
acc1e7a3
JM		 935}
936
937
938static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1ed32e4f 939 struct ieee80211_vif *vif)
acc1e7a3 940{
c96c31e4 941 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
2ca27bcf
JB		 942 __func__, ieee80211_vif_type_p2p(vif),
943 vif->addr);
1ed32e4f 944 hwsim_set_magic(vif);
e8261171
JB		 945
946 vif->cab_queue = 0;
947 vif->hw_queue[IEEE80211_AC_VO] = 0;
948 vif->hw_queue[IEEE80211_AC_VI] = 1;
949 vif->hw_queue[IEEE80211_AC_BE] = 2;
950 vif->hw_queue[IEEE80211_AC_BK] = 3;
951
acc1e7a3
JM		 952 return 0;
953}
954
955
c35d0270
JB		 956static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
957 struct ieee80211_vif *vif,
2ca27bcf
JB		 958 enum nl80211_iftype newtype,
959 bool newp2p)
c35d0270 960{
2ca27bcf 961 newtype = ieee80211_iftype_p2p(newtype, newp2p);
c35d0270
JB		 962 wiphy_debug(hw->wiphy,
963 "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
2ca27bcf
JB		 964 __func__, ieee80211_vif_type_p2p(vif),
965 newtype, vif->addr);
c35d0270
JB		 966 hwsim_check_magic(vif);
967
3eb92f6a
JB		 968 /*
969 * interface may change from non-AP to AP in
970 * which case this needs to be set up again
971 */
972 vif->cab_queue = 0;
973
c35d0270
JB		 974 return 0;
975}
976
acc1e7a3 977static void mac80211_hwsim_remove_interface(
1ed32e4f 978 struct ieee80211_hw *hw, struct ieee80211_vif *vif)
acc1e7a3 979{
c96c31e4 980 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
2ca27bcf
JB		 981 __func__, ieee80211_vif_type_p2p(vif),
982 vif->addr);
1ed32e4f
JB		 983 hwsim_check_magic(vif);
984 hwsim_clear_magic(vif);
acc1e7a3
JM		 985}
986
e8261171
JB		 987static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
988 struct sk_buff *skb,
989 struct ieee80211_channel *chan)
990{
991 u32 _pid = ACCESS_ONCE(wmediumd_portid);
992
993 mac80211_hwsim_monitor_rx(hw, skb, chan);
994
995 if (_pid)
996 return mac80211_hwsim_tx_frame_nl(hw, skb, _pid);
997
998 mac80211_hwsim_tx_frame_no_nl(hw, skb, chan);
999 dev_kfree_skb(skb);
1000}
acc1e7a3
JM		 1001
1002static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
1003 struct ieee80211_vif *vif)
1004{
b66851c3
TP		 1005 struct mac80211_hwsim_data *data = arg;
1006 struct ieee80211_hw *hw = data->hw;
1007 struct ieee80211_tx_info *info;
1008 struct ieee80211_rate *txrate;
1009 struct ieee80211_mgmt *mgmt;
acc1e7a3 1010 struct sk_buff *skb;
acc1e7a3 1011
8aa21e6f
JB		 1012 hwsim_check_magic(vif);
1013
55b39619 1014 if (vif->type != NL80211_IFTYPE_AP &&
2b2d7795
JB		 1015 vif->type != NL80211_IFTYPE_MESH_POINT &&
1016 vif->type != NL80211_IFTYPE_ADHOC)
acc1e7a3
JM		 1017 return;
1018
1019 skb = ieee80211_beacon_get(hw, vif);
1020 if (skb == NULL)
1021 return;
b66851c3
TP		 1022 info = IEEE80211_SKB_CB(skb);
1023 txrate = ieee80211_get_tx_rate(hw, info);
1024
1025 mgmt = (struct ieee80211_mgmt *) skb->data;
1026 /* fake header transmission time */
1027 data->abs_bcn_ts = mac80211_hwsim_get_tsf_raw();
1028 mgmt->u.beacon.timestamp = cpu_to_le64(data->abs_bcn_ts +
1029 data->tsf_offset +
1030 24 * 8 * 10 / txrate->bitrate);
7882513b 1031
e8261171 1032 mac80211_hwsim_tx_frame(hw, skb,
4bf88530 1033 rcu_dereference(vif->chanctx_conf)->def.chan);
acc1e7a3
JM		 1034}
1035
01e59e46
TP		 1036static enum hrtimer_restart
1037mac80211_hwsim_beacon(struct hrtimer *timer)
acc1e7a3 1038{
01e59e46
TP		 1039 struct mac80211_hwsim_data *data =
1040 container_of(timer, struct mac80211_hwsim_data,
1041 beacon_timer.timer);
1042 struct ieee80211_hw *hw = data->hw;
1043 u64 bcn_int = data->beacon_int;
1044 ktime_t next_bcn;
acc1e7a3 1045
4c4c671a 1046 if (!data->started)
01e59e46 1047 goto out;
acc1e7a3 1048
f248f105 1049 ieee80211_iterate_active_interfaces_atomic(
8b2c9824 1050 hw, IEEE80211_IFACE_ITER_NORMAL,
b66851c3 1051 mac80211_hwsim_beacon_tx, data);
acc1e7a3 1052
c51f8783
TP		 1053 /* beacon at new TBTT + beacon interval */
1054 if (data->bcn_delta) {
1055 bcn_int -= data->bcn_delta;
1056 data->bcn_delta = 0;
1057 }
1058
01e59e46
TP		 1059 next_bcn = ktime_add(hrtimer_get_expires(timer),
1060 ns_to_ktime(bcn_int * 1000));
1061 tasklet_hrtimer_start(&data->beacon_timer, next_bcn, HRTIMER_MODE_ABS);
1062out:
1063 return HRTIMER_NORESTART;
acc1e7a3
JM		 1064}
1065
675a0b04
KB		 1066static const char * const hwsim_chanwidths[] = {
1067 [NL80211_CHAN_WIDTH_20_NOHT] = "noht",
1068 [NL80211_CHAN_WIDTH_20] = "ht20",
1069 [NL80211_CHAN_WIDTH_40] = "ht40",
1070 [NL80211_CHAN_WIDTH_80] = "vht80",
1071 [NL80211_CHAN_WIDTH_80P80] = "vht80p80",
1072 [NL80211_CHAN_WIDTH_160] = "vht160",
0aaffa9b 1073};
acc1e7a3 1074
e8975581 1075static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
acc1e7a3
JM		 1076{
1077 struct mac80211_hwsim_data *data = hw->priv;
e8975581 1078 struct ieee80211_conf *conf = &hw->conf;
0f78231b
JB		 1079 static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
1080 [IEEE80211_SMPS_AUTOMATIC] = "auto",
1081 [IEEE80211_SMPS_OFF] = "off",
1082 [IEEE80211_SMPS_STATIC] = "static",
1083 [IEEE80211_SMPS_DYNAMIC] = "dynamic",
1084 };
1085
675a0b04
KB		 1086 if (conf->chandef.chan)
1087 wiphy_debug(hw->wiphy,
1088 "%s (freq=%d(%d - %d)/%s idle=%d ps=%d smps=%s)\n",
1089 __func__,
1090 conf->chandef.chan->center_freq,
1091 conf->chandef.center_freq1,
1092 conf->chandef.center_freq2,
1093 hwsim_chanwidths[conf->chandef.width],
1094 !!(conf->flags & IEEE80211_CONF_IDLE),
1095 !!(conf->flags & IEEE80211_CONF_PS),
1096 smps_modes[conf->smps_mode]);
1097 else
1098 wiphy_debug(hw->wiphy,
1099 "%s (freq=0 idle=%d ps=%d smps=%s)\n",
1100 __func__,
1101 !!(conf->flags & IEEE80211_CONF_IDLE),
1102 !!(conf->flags & IEEE80211_CONF_PS),
1103 smps_modes[conf->smps_mode]);
acc1e7a3 1104
70541839
JM		 1105 data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1106
675a0b04 1107 data->channel = conf->chandef.chan;
e8261171
JB		 1108
1109 WARN_ON(data->channel && channels > 1);
1110
bdd7bd16 1111 data->power_level = conf->power_level;
4c4c671a 1112 if (!data->started || !data->beacon_int)
01e59e46
TP		 1113 tasklet_hrtimer_cancel(&data->beacon_timer);
1114 else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
c51f8783
TP		 1115 u64 tsf = mac80211_hwsim_get_tsf(hw, NULL);
1116 u32 bcn_int = data->beacon_int;
1117 u64 until_tbtt = bcn_int - do_div(tsf, bcn_int);
1118
01e59e46 1119 tasklet_hrtimer_start(&data->beacon_timer,
c51f8783 1120 ns_to_ktime(until_tbtt * 1000),
01e59e46
TP		 1121 HRTIMER_MODE_REL);
1122 }
acc1e7a3
JM		 1123
1124 return 0;
1125}
1126
1127
1128static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
1129 unsigned int changed_flags,
3ac64bee 1130 unsigned int *total_flags,u64 multicast)
acc1e7a3
JM		 1131{
1132 struct mac80211_hwsim_data *data = hw->priv;
1133
c96c31e4 1134 wiphy_debug(hw->wiphy, "%s\n", __func__);
acc1e7a3
JM		 1135
1136 data->rx_filter = 0;
1137 if (*total_flags & FIF_PROMISC_IN_BSS)
1138 data->rx_filter |= FIF_PROMISC_IN_BSS;
1139 if (*total_flags & FIF_ALLMULTI)
1140 data->rx_filter |= FIF_ALLMULTI;
1141
1142 *total_flags = data->rx_filter;
1143}
1144
8aa21e6f
JB		 1145static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
1146 struct ieee80211_vif *vif,
1147 struct ieee80211_bss_conf *info,
1148 u32 changed)
1149{
fc6971d4 1150 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
57c4d7b4 1151 struct mac80211_hwsim_data *data = hw->priv;
fc6971d4 1152
8aa21e6f 1153 hwsim_check_magic(vif);
fe63bfa3 1154
c96c31e4 1155 wiphy_debug(hw->wiphy, "%s(changed=0x%x)\n", __func__, changed);
fe63bfa3 1156
2d0ddec5 1157 if (changed & BSS_CHANGED_BSSID) {
c96c31e4
JP		 1158 wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n",
1159 __func__, info->bssid);
2d0ddec5
JB		 1160 memcpy(vp->bssid, info->bssid, ETH_ALEN);
1161 }
1162
fe63bfa3 1163 if (changed & BSS_CHANGED_ASSOC) {
c96c31e4
JP		 1164 wiphy_debug(hw->wiphy, " ASSOC: assoc=%d aid=%d\n",
1165 info->assoc, info->aid);
fc6971d4
JM		 1166 vp->assoc = info->assoc;
1167 vp->aid = info->aid;
fe63bfa3
JM		 1168 }
1169
57c4d7b4 1170 if (changed & BSS_CHANGED_BEACON_INT) {
c96c31e4 1171 wiphy_debug(hw->wiphy, " BCNINT: %d\n", info->beacon_int);
01e59e46
TP		 1172 data->beacon_int = info->beacon_int * 1024;
1173 }
1174
1175 if (changed & BSS_CHANGED_BEACON_ENABLED) {
1176 wiphy_debug(hw->wiphy, " BCN EN: %d\n", info->enable_beacon);
1177 if (data->started &&
1178 !hrtimer_is_queued(&data->beacon_timer.timer) &&
1179 info->enable_beacon) {
c51f8783
TP		 1180 u64 tsf, until_tbtt;
1181 u32 bcn_int;
01e59e46
TP		 1182 if (WARN_ON(!data->beacon_int))
1183 data->beacon_int = 1000 * 1024;
c51f8783
TP		 1184 tsf = mac80211_hwsim_get_tsf(hw, vif);
1185 bcn_int = data->beacon_int;
1186 until_tbtt = bcn_int - do_div(tsf, bcn_int);
01e59e46 1187 tasklet_hrtimer_start(&data->beacon_timer,
c51f8783 1188 ns_to_ktime(until_tbtt * 1000),
01e59e46
TP		 1189 HRTIMER_MODE_REL);
1190 } else if (!info->enable_beacon)
1191 tasklet_hrtimer_cancel(&data->beacon_timer);
57c4d7b4
JB		 1192 }
1193
fe63bfa3 1194 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
c96c31e4
JP		 1195 wiphy_debug(hw->wiphy, " ERP_CTS_PROT: %d\n",
1196 info->use_cts_prot);
fe63bfa3
JM		 1197 }
1198
1199 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
c96c31e4
JP		 1200 wiphy_debug(hw->wiphy, " ERP_PREAMBLE: %d\n",
1201 info->use_short_preamble);
fe63bfa3
JM		 1202 }
1203
1204 if (changed & BSS_CHANGED_ERP_SLOT) {
c96c31e4 1205 wiphy_debug(hw->wiphy, " ERP_SLOT: %d\n", info->use_short_slot);
fe63bfa3
JM		 1206 }
1207
1208 if (changed & BSS_CHANGED_HT) {
4bf88530
JB		 1209 wiphy_debug(hw->wiphy, " HT: op_mode=0x%x\n",
1210 info->ht_operation_mode);
fe63bfa3
JM		 1211 }
1212
1213 if (changed & BSS_CHANGED_BASIC_RATES) {
c96c31e4
JP		 1214 wiphy_debug(hw->wiphy, " BASIC_RATES: 0x%llx\n",
1215 (unsigned long long) info->basic_rates);
fe63bfa3 1216 }
cbc668a7
JB		 1217
1218 if (changed & BSS_CHANGED_TXPOWER)
1219 wiphy_debug(hw->wiphy, " TX Power: %d dBm\n", info->txpower);
8aa21e6f
JB		 1220}
1221
1d669cbf
JB		 1222static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw,
1223 struct ieee80211_vif *vif,
1224 struct ieee80211_sta *sta)
1225{
1226 hwsim_check_magic(vif);
1227 hwsim_set_sta_magic(sta);
1228
1229 return 0;
1230}
1231
1232static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw,
1233 struct ieee80211_vif *vif,
1234 struct ieee80211_sta *sta)
1235{
1236 hwsim_check_magic(vif);
1237 hwsim_clear_sta_magic(sta);
1238
1239 return 0;
1240}
1241
8aa21e6f
JB		 1242static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
1243 struct ieee80211_vif *vif,
17741cdc
JB		 1244 enum sta_notify_cmd cmd,
1245 struct ieee80211_sta *sta)
8aa21e6f
JB		 1246{
1247 hwsim_check_magic(vif);
1d669cbf 1248
81c06523 1249 switch (cmd) {
89fad578
CL		 1250 case STA_NOTIFY_SLEEP:
1251 case STA_NOTIFY_AWAKE:
1252 /* TODO: make good use of these flags */
1253 break;
1d669cbf
JB		 1254 default:
1255 WARN(1, "Invalid sta notify: %d\n", cmd);
1256 break;
81c06523
JB		 1257 }
1258}
1259
1260static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw,
1261 struct ieee80211_sta *sta,
1262 bool set)
1263{
1264 hwsim_check_sta_magic(sta);
1265 return 0;
8aa21e6f 1266}
acc1e7a3 1267
1e898ff8 1268static int mac80211_hwsim_conf_tx(
8a3a3c85
EP		 1269 struct ieee80211_hw *hw,
1270 struct ieee80211_vif *vif, u16 queue,
1e898ff8
JM		 1271 const struct ieee80211_tx_queue_params *params)
1272{
c96c31e4
JP		 1273 wiphy_debug(hw->wiphy,
1274 "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n",
1275 __func__, queue,
1276 params->txop, params->cw_min,
1277 params->cw_max, params->aifs);
1e898ff8
JM		 1278 return 0;
1279}
1280
1289723e
HS		 1281static int mac80211_hwsim_get_survey(
1282 struct ieee80211_hw *hw, int idx,
1283 struct survey_info *survey)
1284{
1285 struct ieee80211_conf *conf = &hw->conf;
1286
c96c31e4 1287 wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx);
1289723e
HS		 1288
1289 if (idx != 0)
1290 return -ENOENT;
1291
1292 /* Current channel */
675a0b04 1293 survey->channel = conf->chandef.chan;
1289723e
HS		 1294
1295 /*
1296 * Magically conjured noise level --- this is only ok for simulated hardware.
1297 *
1298 * A real driver which cannot determine the real channel noise MUST NOT
1299 * report any noise, especially not a magically conjured one :-)
1300 */
1301 survey->filled = SURVEY_INFO_NOISE_DBM;
1302 survey->noise = -92;
1303
1304 return 0;
1305}
1306
aff89a9b
JB		 1307#ifdef CONFIG_NL80211_TESTMODE
1308/*
1309 * This section contains example code for using netlink
1310 * attributes with the testmode command in nl80211.
1311 */
1312
1313/* These enums need to be kept in sync with userspace */
1314enum hwsim_testmode_attr {
1315 __HWSIM_TM_ATTR_INVALID = 0,
1316 HWSIM_TM_ATTR_CMD = 1,
1317 HWSIM_TM_ATTR_PS = 2,
1318
1319 /* keep last */
1320 __HWSIM_TM_ATTR_AFTER_LAST,
1321 HWSIM_TM_ATTR_MAX = __HWSIM_TM_ATTR_AFTER_LAST - 1
1322};
1323
1324enum hwsim_testmode_cmd {
1325 HWSIM_TM_CMD_SET_PS = 0,
1326 HWSIM_TM_CMD_GET_PS = 1,
4d6d0ae2
JB		 1327 HWSIM_TM_CMD_STOP_QUEUES = 2,
1328 HWSIM_TM_CMD_WAKE_QUEUES = 3,
aff89a9b
JB		 1329};
1330
1331static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = {
1332 [HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 },
1333 [HWSIM_TM_ATTR_PS] = { .type = NLA_U32 },
1334};
1335
1336static int hwsim_fops_ps_write(void *dat, u64 val);
1337
5bc38193
JB		 1338static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1339 void *data, int len)
aff89a9b
JB		 1340{
1341 struct mac80211_hwsim_data *hwsim = hw->priv;
1342 struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1];
1343 struct sk_buff *skb;
1344 int err, ps;
1345
1346 err = nla_parse(tb, HWSIM_TM_ATTR_MAX, data, len,
1347 hwsim_testmode_policy);
1348 if (err)
1349 return err;
1350
1351 if (!tb[HWSIM_TM_ATTR_CMD])
1352 return -EINVAL;
1353
1354 switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) {
1355 case HWSIM_TM_CMD_SET_PS:
1356 if (!tb[HWSIM_TM_ATTR_PS])
1357 return -EINVAL;
1358 ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]);
1359 return hwsim_fops_ps_write(hwsim, ps);
1360 case HWSIM_TM_CMD_GET_PS:
1361 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
1362 nla_total_size(sizeof(u32)));
1363 if (!skb)
1364 return -ENOMEM;
633c9389
DM		 1365 if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
1366 goto nla_put_failure;
aff89a9b 1367 return cfg80211_testmode_reply(skb);
4d6d0ae2
JB		 1368 case HWSIM_TM_CMD_STOP_QUEUES:
1369 ieee80211_stop_queues(hw);
1370 return 0;
1371 case HWSIM_TM_CMD_WAKE_QUEUES:
1372 ieee80211_wake_queues(hw);
1373 return 0;
aff89a9b
JB		 1374 default:
1375 return -EOPNOTSUPP;
1376 }
1377
1378 nla_put_failure:
1379 kfree_skb(skb);
1380 return -ENOBUFS;
1381}
1382#endif
1383
8b73d13a
JB		 1384static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
1385 struct ieee80211_vif *vif,
1386 enum ieee80211_ampdu_mlme_action action,
0b01f030
JB		 1387 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
1388 u8 buf_size)
8b73d13a
JB		 1389{
1390 switch (action) {
1391 case IEEE80211_AMPDU_TX_START:
1392 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1393 break;
18b559d5
JB		 1394 case IEEE80211_AMPDU_TX_STOP_CONT:
1395 case IEEE80211_AMPDU_TX_STOP_FLUSH:
1396 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
8b73d13a
JB		 1397 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1398 break;
1399 case IEEE80211_AMPDU_TX_OPERATIONAL:
1400 break;
1401 case IEEE80211_AMPDU_RX_START:
1402 case IEEE80211_AMPDU_RX_STOP:
1403 break;
1404 default:
1405 return -EOPNOTSUPP;
1406 }
1407
1408 return 0;
1409}
1410
39ecc01d 1411static void mac80211_hwsim_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
a80f7c0b 1412{
7882513b 1413 /* Not implemented, queues only on kernel side */
a80f7c0b
JB		 1414}
1415
e8261171 1416static void hw_scan_work(struct work_struct *work)
69068036 1417{
e8261171
JB		 1418 struct mac80211_hwsim_data *hwsim =
1419 container_of(work, struct mac80211_hwsim_data, hw_scan.work);
1420 struct cfg80211_scan_request *req = hwsim->hw_scan_request;
1421 int dwell, i;
69068036 1422
e8261171
JB		 1423 mutex_lock(&hwsim->mutex);
1424 if (hwsim->scan_chan_idx >= req->n_channels) {
1425 wiphy_debug(hwsim->hw->wiphy, "hw scan complete\n");
1426 ieee80211_scan_completed(hwsim->hw, false);
1427 hwsim->hw_scan_request = NULL;
1428 hwsim->hw_scan_vif = NULL;
1429 hwsim->tmp_chan = NULL;
1430 mutex_unlock(&hwsim->mutex);
1431 return;
1432 }
1433
1434 wiphy_debug(hwsim->hw->wiphy, "hw scan %d MHz\n",
1435 req->channels[hwsim->scan_chan_idx]->center_freq);
1436
1437 hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx];
1438 if (hwsim->tmp_chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
1439 !req->n_ssids) {
1440 dwell = 120;
1441 } else {
1442 dwell = 30;
1443 /* send probes */
1444 for (i = 0; i < req->n_ssids; i++) {
1445 struct sk_buff *probe;
1446
1447 probe = ieee80211_probereq_get(hwsim->hw,
1448 hwsim->hw_scan_vif,
1449 req->ssids[i].ssid,
1450 req->ssids[i].ssid_len,
b9a9ada1 1451 req->ie_len);
e8261171
JB		 1452 if (!probe)
1453 continue;
b9a9ada1
JB		 1454
1455 if (req->ie_len)
1456 memcpy(skb_put(probe, req->ie_len), req->ie,
1457 req->ie_len);
1458
e8261171
JB		 1459 local_bh_disable();
1460 mac80211_hwsim_tx_frame(hwsim->hw, probe,
1461 hwsim->tmp_chan);
1462 local_bh_enable();
1463 }
1464 }
1465 ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan,
1466 msecs_to_jiffies(dwell));
1467 hwsim->scan_chan_idx++;
1468 mutex_unlock(&hwsim->mutex);
69068036
JB		 1469}
1470
1471static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
a060bbfe 1472 struct ieee80211_vif *vif,
69068036
JB		 1473 struct cfg80211_scan_request *req)
1474{
e8261171 1475 struct mac80211_hwsim_data *hwsim = hw->priv;
69068036 1476
e8261171
JB		 1477 mutex_lock(&hwsim->mutex);
1478 if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
1479 mutex_unlock(&hwsim->mutex);
1480 return -EBUSY;
1481 }
1482 hwsim->hw_scan_request = req;
1483 hwsim->hw_scan_vif = vif;
1484 hwsim->scan_chan_idx = 0;
1485 mutex_unlock(&hwsim->mutex);
69068036 1486
e8261171 1487 wiphy_debug(hw->wiphy, "hwsim hw_scan request\n");
69068036 1488
e8261171 1489 ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
69068036
JB		 1490
1491 return 0;
1492}
1493
e8261171
JB		 1494static void mac80211_hwsim_cancel_hw_scan(struct ieee80211_hw *hw,
1495 struct ieee80211_vif *vif)
1496{
1497 struct mac80211_hwsim_data *hwsim = hw->priv;
1498
1499 wiphy_debug(hw->wiphy, "hwsim cancel_hw_scan\n");
1500
1501 cancel_delayed_work_sync(&hwsim->hw_scan);
1502
1503 mutex_lock(&hwsim->mutex);
1504 ieee80211_scan_completed(hwsim->hw, true);
1505 hwsim->tmp_chan = NULL;
1506 hwsim->hw_scan_request = NULL;
1507 hwsim->hw_scan_vif = NULL;
1508 mutex_unlock(&hwsim->mutex);
1509}
1510
f74cb0f7
LR		 1511static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw)
1512{
1513 struct mac80211_hwsim_data *hwsim = hw->priv;
1514
1515 mutex_lock(&hwsim->mutex);
1516
1517 if (hwsim->scanning) {
1518 printk(KERN_DEBUG "two hwsim sw_scans detected!\n");
1519 goto out;
1520 }
1521
1522 printk(KERN_DEBUG "hwsim sw_scan request, prepping stuff\n");
1523 hwsim->scanning = true;
1524
1525out:
1526 mutex_unlock(&hwsim->mutex);
1527}
1528
1529static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw)
1530{
1531 struct mac80211_hwsim_data *hwsim = hw->priv;
1532
1533 mutex_lock(&hwsim->mutex);
1534
1535 printk(KERN_DEBUG "hwsim sw_scan_complete\n");
23ff98fc 1536 hwsim->scanning = false;
f74cb0f7
LR		 1537
1538 mutex_unlock(&hwsim->mutex);
1539}
1540
e8261171
JB		 1541static void hw_roc_done(struct work_struct *work)
1542{
1543 struct mac80211_hwsim_data *hwsim =
1544 container_of(work, struct mac80211_hwsim_data, roc_done.work);
1545
1546 mutex_lock(&hwsim->mutex);
1547 ieee80211_remain_on_channel_expired(hwsim->hw);
1548 hwsim->tmp_chan = NULL;
1549 mutex_unlock(&hwsim->mutex);
1550
1551 wiphy_debug(hwsim->hw->wiphy, "hwsim ROC expired\n");
1552}
1553
1554static int mac80211_hwsim_roc(struct ieee80211_hw *hw,
49884568 1555 struct ieee80211_vif *vif,
e8261171 1556 struct ieee80211_channel *chan,
d339d5ca
IP		 1557 int duration,
1558 enum ieee80211_roc_type type)
e8261171
JB		 1559{
1560 struct mac80211_hwsim_data *hwsim = hw->priv;
1561
1562 mutex_lock(&hwsim->mutex);
1563 if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
1564 mutex_unlock(&hwsim->mutex);
1565 return -EBUSY;
1566 }
1567
1568 hwsim->tmp_chan = chan;
1569 mutex_unlock(&hwsim->mutex);
1570
1571 wiphy_debug(hw->wiphy, "hwsim ROC (%d MHz, %d ms)\n",
1572 chan->center_freq, duration);
1573
1574 ieee80211_ready_on_channel(hw);
1575
1576 ieee80211_queue_delayed_work(hw, &hwsim->roc_done,
1577 msecs_to_jiffies(duration));
1578 return 0;
1579}
1580
1581static int mac80211_hwsim_croc(struct ieee80211_hw *hw)
1582{
1583 struct mac80211_hwsim_data *hwsim = hw->priv;
1584
1585 cancel_delayed_work_sync(&hwsim->roc_done);
1586
1587 mutex_lock(&hwsim->mutex);
1588 hwsim->tmp_chan = NULL;
1589 mutex_unlock(&hwsim->mutex);
1590
1591 wiphy_debug(hw->wiphy, "hwsim ROC canceled\n");
1592
1593 return 0;
1594}
1595
1596static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw,
1597 struct ieee80211_chanctx_conf *ctx)
1598{
1599 hwsim_set_chanctx_magic(ctx);
4bf88530
JB		 1600 wiphy_debug(hw->wiphy,
1601 "add channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
1602 ctx->def.chan->center_freq, ctx->def.width,
1603 ctx->def.center_freq1, ctx->def.center_freq2);
e8261171
JB		 1604 return 0;
1605}
1606
1607static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
1608 struct ieee80211_chanctx_conf *ctx)
1609{
4bf88530
JB		 1610 wiphy_debug(hw->wiphy,
1611 "remove channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
1612 ctx->def.chan->center_freq, ctx->def.width,
1613 ctx->def.center_freq1, ctx->def.center_freq2);
e8261171
JB		 1614 hwsim_check_chanctx_magic(ctx);
1615 hwsim_clear_chanctx_magic(ctx);
1616}
1617
1618static void mac80211_hwsim_change_chanctx(struct ieee80211_hw *hw,
1619 struct ieee80211_chanctx_conf *ctx,
1620 u32 changed)
1621{
1622 hwsim_check_chanctx_magic(ctx);
4bf88530
JB		 1623 wiphy_debug(hw->wiphy,
1624 "change channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
1625 ctx->def.chan->center_freq, ctx->def.width,
1626 ctx->def.center_freq1, ctx->def.center_freq2);
e8261171
JB		 1627}
1628
1629static int mac80211_hwsim_assign_vif_chanctx(struct ieee80211_hw *hw,
1630 struct ieee80211_vif *vif,
1631 struct ieee80211_chanctx_conf *ctx)
1632{
1633 hwsim_check_magic(vif);
1634 hwsim_check_chanctx_magic(ctx);
1635
1636 return 0;
1637}
1638
1639static void mac80211_hwsim_unassign_vif_chanctx(struct ieee80211_hw *hw,
1640 struct ieee80211_vif *vif,
1641 struct ieee80211_chanctx_conf *ctx)
1642{
1643 hwsim_check_magic(vif);
1644 hwsim_check_chanctx_magic(ctx);
1645}
1646
69068036 1647static struct ieee80211_ops mac80211_hwsim_ops =
acc1e7a3
JM		 1648{
1649 .tx = mac80211_hwsim_tx,
1650 .start = mac80211_hwsim_start,
1651 .stop = mac80211_hwsim_stop,
1652 .add_interface = mac80211_hwsim_add_interface,
c35d0270 1653 .change_interface = mac80211_hwsim_change_interface,
acc1e7a3
JM		 1654 .remove_interface = mac80211_hwsim_remove_interface,
1655 .config = mac80211_hwsim_config,
1656 .configure_filter = mac80211_hwsim_configure_filter,
8aa21e6f 1657 .bss_info_changed = mac80211_hwsim_bss_info_changed,
1d669cbf
JB		 1658 .sta_add = mac80211_hwsim_sta_add,
1659 .sta_remove = mac80211_hwsim_sta_remove,
8aa21e6f 1660 .sta_notify = mac80211_hwsim_sta_notify,
81c06523 1661 .set_tim = mac80211_hwsim_set_tim,
1e898ff8 1662 .conf_tx = mac80211_hwsim_conf_tx,
1289723e 1663 .get_survey = mac80211_hwsim_get_survey,
aff89a9b 1664 CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)
8b73d13a 1665 .ampdu_action = mac80211_hwsim_ampdu_action,
f74cb0f7
LR		 1666 .sw_scan_start = mac80211_hwsim_sw_scan,
1667 .sw_scan_complete = mac80211_hwsim_sw_scan_complete,
a80f7c0b 1668 .flush = mac80211_hwsim_flush,
12ce8ba3
JC		 1669 .get_tsf = mac80211_hwsim_get_tsf,
1670 .set_tsf = mac80211_hwsim_set_tsf,
acc1e7a3
JM		 1671};
1672
1673
1674static void mac80211_hwsim_free(void)
1675{
0e057d73 1676 struct list_head tmplist, *i, *tmp;
e603d9d8 1677 struct mac80211_hwsim_data *data, *tmpdata;
0e057d73
JB		 1678
1679 INIT_LIST_HEAD(&tmplist);
1680
1681 spin_lock_bh(&hwsim_radio_lock);
1682 list_for_each_safe(i, tmp, &hwsim_radios)
1683 list_move(i, &tmplist);
1684 spin_unlock_bh(&hwsim_radio_lock);
1685
e603d9d8 1686 list_for_each_entry_safe(data, tmpdata, &tmplist, list) {
73606d00 1687 debugfs_remove(data->debugfs_group);
fc6971d4
JM		 1688 debugfs_remove(data->debugfs_ps);
1689 debugfs_remove(data->debugfs);
0e057d73 1690 ieee80211_unregister_hw(data->hw);
9ea92774 1691 device_release_driver(data->dev);
0e057d73
JB		 1692 device_unregister(data->dev);
1693 ieee80211_free_hw(data->hw);
acc1e7a3 1694 }
acc1e7a3
JM		 1695 class_destroy(hwsim_class);
1696}
1697
1698
1699static struct device_driver mac80211_hwsim_driver = {
9ea92774
MP		 1700 .name = "mac80211_hwsim",
1701 .bus = &platform_bus_type,
1702 .owner = THIS_MODULE,
acc1e7a3
JM		 1703};
1704
98d2faae
SH		 1705static const struct net_device_ops hwsim_netdev_ops = {
1706 .ndo_start_xmit = hwsim_mon_xmit,
1707 .ndo_change_mtu = eth_change_mtu,
1708 .ndo_set_mac_address = eth_mac_addr,
1709 .ndo_validate_addr = eth_validate_addr,
1710};
acc1e7a3
JM		 1711
1712static void hwsim_mon_setup(struct net_device *dev)
1713{
98d2faae 1714 dev->netdev_ops = &hwsim_netdev_ops;
acc1e7a3
JM		 1715 dev->destructor = free_netdev;
1716 ether_setup(dev);
1717 dev->tx_queue_len = 0;
1718 dev->type = ARPHRD_IEEE80211_RADIOTAP;
1719 memset(dev->dev_addr, 0, ETH_ALEN);
1720 dev->dev_addr[0] = 0x12;
1721}
1722
1723
fc6971d4
JM		 1724static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
1725{
1726 struct mac80211_hwsim_data *data = dat;
1727 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
fc6971d4
JM		 1728 struct sk_buff *skb;
1729 struct ieee80211_pspoll *pspoll;
1730
1731 if (!vp->assoc)
1732 return;
1733
c96c31e4
JP		 1734 wiphy_debug(data->hw->wiphy,
1735 "%s: send PS-Poll to %pM for aid %d\n",
1736 __func__, vp->bssid, vp->aid);
fc6971d4
JM		 1737
1738 skb = dev_alloc_skb(sizeof(*pspoll));
1739 if (!skb)
1740 return;
1741 pspoll = (void *) skb_put(skb, sizeof(*pspoll));
1742 pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
1743 IEEE80211_STYPE_PSPOLL |
1744 IEEE80211_FCTL_PM);
1745 pspoll->aid = cpu_to_le16(0xc000 | vp->aid);
1746 memcpy(pspoll->bssid, vp->bssid, ETH_ALEN);
1747 memcpy(pspoll->ta, mac, ETH_ALEN);
7882513b 1748
e8261171
JB		 1749 rcu_read_lock();
1750 mac80211_hwsim_tx_frame(data->hw, skb,
4bf88530 1751 rcu_dereference(vif->chanctx_conf)->def.chan);
e8261171 1752 rcu_read_unlock();
fc6971d4
JM		 1753}
1754
fc6971d4
JM		 1755static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
1756 struct ieee80211_vif *vif, int ps)
1757{
1758 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
fc6971d4
JM		 1759 struct sk_buff *skb;
1760 struct ieee80211_hdr *hdr;
1761
1762 if (!vp->assoc)
1763 return;
1764
c96c31e4
JP		 1765 wiphy_debug(data->hw->wiphy,
1766 "%s: send data::nullfunc to %pM ps=%d\n",
1767 __func__, vp->bssid, ps);
fc6971d4
JM		 1768
1769 skb = dev_alloc_skb(sizeof(*hdr));
1770 if (!skb)
1771 return;
1772 hdr = (void *) skb_put(skb, sizeof(*hdr) - ETH_ALEN);
1773 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1774 IEEE80211_STYPE_NULLFUNC |
1775 (ps ? IEEE80211_FCTL_PM : 0));
1776 hdr->duration_id = cpu_to_le16(0);
1777 memcpy(hdr->addr1, vp->bssid, ETH_ALEN);
1778 memcpy(hdr->addr2, mac, ETH_ALEN);
1779 memcpy(hdr->addr3, vp->bssid, ETH_ALEN);
7882513b 1780
e8261171
JB		 1781 rcu_read_lock();
1782 mac80211_hwsim_tx_frame(data->hw, skb,
4bf88530 1783 rcu_dereference(vif->chanctx_conf)->def.chan);
e8261171 1784 rcu_read_unlock();
fc6971d4
JM		 1785}
1786
1787
1788static void hwsim_send_nullfunc_ps(void *dat, u8 *mac,
1789 struct ieee80211_vif *vif)
1790{
1791 struct mac80211_hwsim_data *data = dat;
1792 hwsim_send_nullfunc(data, mac, vif, 1);
1793}
1794
1795
1796static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac,
1797 struct ieee80211_vif *vif)
1798{
1799 struct mac80211_hwsim_data *data = dat;
1800 hwsim_send_nullfunc(data, mac, vif, 0);
1801}
1802
1803
1804static int hwsim_fops_ps_read(void *dat, u64 *val)
1805{
1806 struct mac80211_hwsim_data *data = dat;
1807 *val = data->ps;
1808 return 0;
1809}
1810
1811static int hwsim_fops_ps_write(void *dat, u64 val)
1812{
1813 struct mac80211_hwsim_data *data = dat;
1814 enum ps_mode old_ps;
1815
1816 if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL &&
1817 val != PS_MANUAL_POLL)
1818 return -EINVAL;
1819
1820 old_ps = data->ps;
1821 data->ps = val;
1822
1823 if (val == PS_MANUAL_POLL) {
1824 ieee80211_iterate_active_interfaces(data->hw,
8b2c9824 1825 IEEE80211_IFACE_ITER_NORMAL,
fc6971d4
JM		 1826 hwsim_send_ps_poll, data);
1827 data->ps_poll_pending = true;
1828 } else if (old_ps == PS_DISABLED && val != PS_DISABLED) {
1829 ieee80211_iterate_active_interfaces(data->hw,
8b2c9824 1830 IEEE80211_IFACE_ITER_NORMAL,
fc6971d4
JM		 1831 hwsim_send_nullfunc_ps,
1832 data);
1833 } else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
1834 ieee80211_iterate_active_interfaces(data->hw,
8b2c9824 1835 IEEE80211_IFACE_ITER_NORMAL,
fc6971d4
JM		 1836 hwsim_send_nullfunc_no_ps,
1837 data);
1838 }
1839
1840 return 0;
1841}
1842
1843DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write,
1844 "%llu\n");
1845
1846
73606d00
DW		 1847static int hwsim_fops_group_read(void *dat, u64 *val)
1848{
1849 struct mac80211_hwsim_data *data = dat;
1850 *val = data->group;
1851 return 0;
1852}
1853
1854static int hwsim_fops_group_write(void *dat, u64 val)
1855{
1856 struct mac80211_hwsim_data *data = dat;
1857 data->group = val;
1858 return 0;
1859}
1860
1861DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_group,
1862 hwsim_fops_group_read, hwsim_fops_group_write,
1863 "%llx\n");
1864
f483ad25 1865static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(
7882513b
JL		 1866 struct mac_address *addr)
1867{
1868 struct mac80211_hwsim_data *data;
1869 bool _found = false;
1870
1871 spin_lock_bh(&hwsim_radio_lock);
1872 list_for_each_entry(data, &hwsim_radios, list) {
1873 if (memcmp(data->addresses[1].addr, addr,
1874 sizeof(struct mac_address)) == 0) {
1875 _found = true;
1876 break;
1877 }
1878 }
1879 spin_unlock_bh(&hwsim_radio_lock);
1880
1881 if (!_found)
1882 return NULL;
1883
1884 return data;
1885}
1886
1887static int hwsim_tx_info_frame_received_nl(struct sk_buff *skb_2,
1888 struct genl_info *info)
1889{
1890
1891 struct ieee80211_hdr *hdr;
1892 struct mac80211_hwsim_data *data2;
1893 struct ieee80211_tx_info *txi;
1894 struct hwsim_tx_rate *tx_attempts;
d0f718c1 1895 unsigned long ret_skb_ptr;
7882513b
JL		 1896 struct sk_buff *skb, *tmp;
1897 struct mac_address *src;
1898 unsigned int hwsim_flags;
1899
1900 int i;
1901 bool found = false;
1902
1903 if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
1904 !info->attrs[HWSIM_ATTR_FLAGS] ||
1905 !info->attrs[HWSIM_ATTR_COOKIE] ||
1906 !info->attrs[HWSIM_ATTR_TX_INFO])
1907 goto out;
1908
1909 src = (struct mac_address *)nla_data(
1910 info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
1911 hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
1912
d0f718c1 1913 ret_skb_ptr = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
7882513b
JL		 1914
1915 data2 = get_hwsim_data_ref_from_addr(src);
1916
1917 if (data2 == NULL)
1918 goto out;
1919
1920 /* look for the skb matching the cookie passed back from user */
1921 skb_queue_walk_safe(&data2->pending, skb, tmp) {
d0f718c1 1922 if ((unsigned long)skb == ret_skb_ptr) {
7882513b
JL		 1923 skb_unlink(skb, &data2->pending);
1924 found = true;
1925 break;
1926 }
1927 }
1928
1929 /* not found */
1930 if (!found)
1931 goto out;
1932
1933 /* Tx info received because the frame was broadcasted on user space,
1934 so we get all the necessary info: tx attempts and skb control buff */
1935
1936 tx_attempts = (struct hwsim_tx_rate *)nla_data(
1937 info->attrs[HWSIM_ATTR_TX_INFO]);
1938
1939 /* now send back TX status */
1940 txi = IEEE80211_SKB_CB(skb);
1941
7882513b
JL		 1942 ieee80211_tx_info_clear_status(txi);
1943
1944 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
1945 txi->status.rates[i].idx = tx_attempts[i].idx;
1946 txi->status.rates[i].count = tx_attempts[i].count;
1947 /*txi->status.rates[i].flags = 0;*/
1948 }
1949
1950 txi->status.ack_signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
1951
1952 if (!(hwsim_flags & HWSIM_TX_CTL_NO_ACK) &&
1953 (hwsim_flags & HWSIM_TX_STAT_ACK)) {
1954 if (skb->len >= 16) {
1955 hdr = (struct ieee80211_hdr *) skb->data;
e8261171
JB		 1956 mac80211_hwsim_monitor_ack(txi->rate_driver_data[0],
1957 hdr->addr2);
7882513b 1958 }
06cf5c4c 1959 txi->flags |= IEEE80211_TX_STAT_ACK;
7882513b
JL		 1960 }
1961 ieee80211_tx_status_irqsafe(data2->hw, skb);
1962 return 0;
1963out:
1964 return -EINVAL;
1965
1966}
1967
1968static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2,
1969 struct genl_info *info)
1970{
1971
e8261171 1972 struct mac80211_hwsim_data *data2;
7882513b
JL		 1973 struct ieee80211_rx_status rx_status;
1974 struct mac_address *dst;
1975 int frame_data_len;
1976 char *frame_data;
1977 struct sk_buff *skb = NULL;
1978
1979 if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
e8261171
JB		 1980 !info->attrs[HWSIM_ATTR_FRAME] ||
1981 !info->attrs[HWSIM_ATTR_RX_RATE] ||
1982 !info->attrs[HWSIM_ATTR_SIGNAL])
7882513b
JL		 1983 goto out;
1984
1985 dst = (struct mac_address *)nla_data(
1986 info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
1987
1988 frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
1989 frame_data = (char *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
1990
1991 /* Allocate new skb here */
1992 skb = alloc_skb(frame_data_len, GFP_KERNEL);
1993 if (skb == NULL)
1994 goto err;
1995
1996 if (frame_data_len <= IEEE80211_MAX_DATA_LEN) {
1997 /* Copy the data */
1998 memcpy(skb_put(skb, frame_data_len), frame_data,
1999 frame_data_len);
2000 } else
2001 goto err;
2002
2003 data2 = get_hwsim_data_ref_from_addr(dst);
2004
2005 if (data2 == NULL)
2006 goto out;
2007
2008 /* check if radio is configured properly */
2009
e8261171 2010 if (data2->idle || !data2->started)
7882513b
JL		 2011 goto out;
2012
2013 /*A frame is received from user space*/
2014 memset(&rx_status, 0, sizeof(rx_status));
2015 rx_status.freq = data2->channel->center_freq;
2016 rx_status.band = data2->channel->band;
2017 rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]);
2018 rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
2019
2020 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
2021 ieee80211_rx_irqsafe(data2->hw, skb);
2022
2023 return 0;
2024err:
c393862f 2025 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
7882513b
JL		 2026 goto out;
2027out:
2028 dev_kfree_skb(skb);
2029 return -EINVAL;
2030}
2031
2032static int hwsim_register_received_nl(struct sk_buff *skb_2,
2033 struct genl_info *info)
2034{
2035 if (info == NULL)
2036 goto out;
2037
15e47304 2038 wmediumd_portid = info->snd_portid;
7882513b
JL		 2039
2040 printk(KERN_DEBUG "mac80211_hwsim: received a REGISTER, "
15e47304 2041 "switching to wmediumd mode with pid %d\n", info->snd_portid);
7882513b
JL		 2042
2043 return 0;
2044out:
c393862f 2045 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
7882513b
JL		 2046 return -EINVAL;
2047}
2048
2049/* Generic Netlink operations array */
2050static struct genl_ops hwsim_ops[] = {
2051 {
2052 .cmd = HWSIM_CMD_REGISTER,
2053 .policy = hwsim_genl_policy,
2054 .doit = hwsim_register_received_nl,
2055 .flags = GENL_ADMIN_PERM,
2056 },
2057 {
2058 .cmd = HWSIM_CMD_FRAME,
2059 .policy = hwsim_genl_policy,
2060 .doit = hwsim_cloned_frame_received_nl,
2061 },
2062 {
2063 .cmd = HWSIM_CMD_TX_INFO_FRAME,
2064 .policy = hwsim_genl_policy,
2065 .doit = hwsim_tx_info_frame_received_nl,
2066 },
2067};
2068
2069static int mac80211_hwsim_netlink_notify(struct notifier_block *nb,
2070 unsigned long state,
2071 void *_notify)
2072{
2073 struct netlink_notify *notify = _notify;
2074
2075 if (state != NETLINK_URELEASE)
2076 return NOTIFY_DONE;
2077
15e47304 2078 if (notify->portid == wmediumd_portid) {
7882513b
JL		 2079 printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
2080 " socket, switching to perfect channel medium\n");
15e47304 2081 wmediumd_portid = 0;
7882513b
JL		 2082 }
2083 return NOTIFY_DONE;
2084
2085}
2086
2087static struct notifier_block hwsim_netlink_notifier = {
2088 .notifier_call = mac80211_hwsim_netlink_notify,
2089};
2090
2091static int hwsim_init_netlink(void)
2092{
2093 int rc;
e8261171
JB		 2094
2095 /* userspace test API hasn't been adjusted for multi-channel */
2096 if (channels > 1)
2097 return 0;
2098
7882513b
JL		 2099 printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");
2100
7882513b
JL		 2101 rc = genl_register_family_with_ops(&hwsim_genl_family,
2102 hwsim_ops, ARRAY_SIZE(hwsim_ops));
2103 if (rc)
2104 goto failure;
2105
2106 rc = netlink_register_notifier(&hwsim_netlink_notifier);
2107 if (rc)
2108 goto failure;
2109
2110 return 0;
2111
2112failure:
c393862f 2113 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
7882513b
JL		 2114 return -EINVAL;
2115}
2116
2117static void hwsim_exit_netlink(void)
2118{
2119 int ret;
2120
e8261171
JB		 2121 /* userspace test API hasn't been adjusted for multi-channel */
2122 if (channels > 1)
2123 return;
2124
7882513b
JL		 2125 printk(KERN_INFO "mac80211_hwsim: closing netlink\n");
2126 /* unregister the notifier */
2127 netlink_unregister_notifier(&hwsim_netlink_notifier);
2128 /* unregister the family */
2129 ret = genl_unregister_family(&hwsim_genl_family);
2130 if (ret)
2131 printk(KERN_DEBUG "mac80211_hwsim: "
2132 "unregister family %i\n", ret);
2133}
2134
1ae2fc25
JB		 2135static const struct ieee80211_iface_limit hwsim_if_limits[] = {
2136 { .max = 1, .types = BIT(NL80211_IFTYPE_ADHOC) },
2137 { .max = 2048, .types = BIT(NL80211_IFTYPE_STATION) |
2138 BIT(NL80211_IFTYPE_P2P_CLIENT) |
2139#ifdef CONFIG_MAC80211_MESH
2140 BIT(NL80211_IFTYPE_MESH_POINT) |
2141#endif
2142 BIT(NL80211_IFTYPE_AP) |
2143 BIT(NL80211_IFTYPE_P2P_GO) },
8b3d1cc2 2144 { .max = 1, .types = BIT(NL80211_IFTYPE_P2P_DEVICE) },
1ae2fc25
JB		 2145};
2146
e8261171 2147static struct ieee80211_iface_combination hwsim_if_comb = {
1ae2fc25
JB		 2148 .limits = hwsim_if_limits,
2149 .n_limits = ARRAY_SIZE(hwsim_if_limits),
2150 .max_interfaces = 2048,
2151 .num_different_channels = 1,
2152};
2153
acc1e7a3
JM		 2154static int __init init_mac80211_hwsim(void)
2155{
2156 int i, err = 0;
2157 u8 addr[ETH_ALEN];
2158 struct mac80211_hwsim_data *data;
2159 struct ieee80211_hw *hw;
22cad735 2160 enum ieee80211_band band;
acc1e7a3 2161
0e057d73 2162 if (radios < 1 || radios > 100)
acc1e7a3
JM		 2163 return -EINVAL;
2164
e8261171
JB		 2165 if (channels < 1)
2166 return -EINVAL;
2167
2168 if (channels > 1) {
2169 hwsim_if_comb.num_different_channels = channels;
69068036 2170 mac80211_hwsim_ops.hw_scan = mac80211_hwsim_hw_scan;
e8261171
JB		 2171 mac80211_hwsim_ops.cancel_hw_scan =
2172 mac80211_hwsim_cancel_hw_scan;
f74cb0f7
LR		 2173 mac80211_hwsim_ops.sw_scan_start = NULL;
2174 mac80211_hwsim_ops.sw_scan_complete = NULL;
e8261171
JB		 2175 mac80211_hwsim_ops.remain_on_channel =
2176 mac80211_hwsim_roc;
2177 mac80211_hwsim_ops.cancel_remain_on_channel =
2178 mac80211_hwsim_croc;
2179 mac80211_hwsim_ops.add_chanctx =
2180 mac80211_hwsim_add_chanctx;
2181 mac80211_hwsim_ops.remove_chanctx =
2182 mac80211_hwsim_remove_chanctx;
2183 mac80211_hwsim_ops.change_chanctx =
2184 mac80211_hwsim_change_chanctx;
2185 mac80211_hwsim_ops.assign_vif_chanctx =
2186 mac80211_hwsim_assign_vif_chanctx;
2187 mac80211_hwsim_ops.unassign_vif_chanctx =
2188 mac80211_hwsim_unassign_vif_chanctx;
f74cb0f7 2189 }
69068036 2190
0e057d73
JB		 2191 spin_lock_init(&hwsim_radio_lock);
2192 INIT_LIST_HEAD(&hwsim_radios);
acc1e7a3 2193
9ea92774
MP		 2194 err = driver_register(&mac80211_hwsim_driver);
2195 if (err)
2196 return err;
2197
acc1e7a3 2198 hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
9ea92774
MP		 2199 if (IS_ERR(hwsim_class)) {
2200 err = PTR_ERR(hwsim_class);
2201 goto failed_unregister_driver;
2202 }
acc1e7a3
JM		 2203
2204 memset(addr, 0, ETH_ALEN);
2205 addr[0] = 0x02;
2206
0e057d73 2207 for (i = 0; i < radios; i++) {
acc1e7a3
JM		 2208 printk(KERN_DEBUG "mac80211_hwsim: Initializing radio %d\n",
2209 i);
2210 hw = ieee80211_alloc_hw(sizeof(*data), &mac80211_hwsim_ops);
0e057d73 2211 if (!hw) {
acc1e7a3
JM		 2212 printk(KERN_DEBUG "mac80211_hwsim: ieee80211_alloc_hw "
2213 "failed\n");
2214 err = -ENOMEM;
2215 goto failed;
2216 }
acc1e7a3 2217 data = hw->priv;
0e057d73
JB		 2218 data->hw = hw;
2219
6e05d6c4
GKH		 2220 data->dev = device_create(hwsim_class, NULL, 0, hw,
2221 "hwsim%d", i);
acc1e7a3 2222 if (IS_ERR(data->dev)) {
e800f17c 2223 printk(KERN_DEBUG
9ea92774
MP		 2224 "mac80211_hwsim: device_create failed (%ld)\n",
2225 PTR_ERR(data->dev));
acc1e7a3 2226 err = -ENOMEM;
3a33cc10 2227 goto failed_drvdata;
acc1e7a3
JM		 2228 }
2229 data->dev->driver = &mac80211_hwsim_driver;
9ea92774
MP		 2230 err = device_bind_driver(data->dev);
2231 if (err != 0) {
2232 printk(KERN_DEBUG
2233 "mac80211_hwsim: device_bind_driver failed (%d)\n",
2234 err);
2235 goto failed_hw;
2236 }
2237
7882513b 2238 skb_queue_head_init(&data->pending);
acc1e7a3
JM		 2239
2240 SET_IEEE80211_DEV(hw, data->dev);
2241 addr[3] = i >> 8;
2242 addr[4] = i;
ef15aac6
JB		 2243 memcpy(data->addresses[0].addr, addr, ETH_ALEN);
2244 memcpy(data->addresses[1].addr, addr, ETH_ALEN);
2245 data->addresses[1].addr[0] |= 0x40;
2246 hw->wiphy->n_addresses = 2;
2247 hw->wiphy->addresses = data->addresses;
acc1e7a3 2248
1ae2fc25
JB		 2249 hw->wiphy->iface_combinations = &hwsim_if_comb;
2250 hw->wiphy->n_iface_combinations = 1;
2251
e8261171 2252 if (channels > 1) {
8223d2f5
JB		 2253 hw->wiphy->max_scan_ssids = 255;
2254 hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
e8261171 2255 hw->wiphy->max_remain_on_channel_duration = 1000;
8223d2f5
JB		 2256 }
2257
e8261171
JB		 2258 INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
2259 INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2260
acc1e7a3 2261 hw->channel_change_time = 1;
e8261171
JB		 2262 hw->queues = 5;
2263 hw->offchannel_tx_hw_queue = 4;
f59ac048
LR		 2264 hw->wiphy->interface_modes =
2265 BIT(NL80211_IFTYPE_STATION) |
55b39619 2266 BIT(NL80211_IFTYPE_AP) |
2ca27bcf
JB		 2267 BIT(NL80211_IFTYPE_P2P_CLIENT) |
2268 BIT(NL80211_IFTYPE_P2P_GO) |
2b2d7795 2269 BIT(NL80211_IFTYPE_ADHOC) |
8b3d1cc2
JB		 2270 BIT(NL80211_IFTYPE_MESH_POINT) |
2271 BIT(NL80211_IFTYPE_P2P_DEVICE);
acc1e7a3 2272
4b14c96d 2273 hw->flags = IEEE80211_HW_MFP_CAPABLE |
0f78231b
JB		 2274 IEEE80211_HW_SIGNAL_DBM |
2275 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
a75b4363 2276 IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
4b6f1dd6 2277 IEEE80211_HW_AMPDU_AGGREGATION |
e8261171
JB		 2278 IEEE80211_HW_WANT_MONITOR_VIF |
2279 IEEE80211_HW_QUEUE_CONTROL;
fa77533e 2280
81ddbb5c
JB		 2281 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
2282 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
43bc3e89 2283
8aa21e6f
JB		 2284 /* ask mac80211 to reserve space for magic */
2285 hw->vif_data_size = sizeof(struct hwsim_vif_priv);
81c06523 2286 hw->sta_data_size = sizeof(struct hwsim_sta_priv);
93c78c5d 2287 hw->chanctx_data_size = sizeof(struct hwsim_chanctx_priv);
8aa21e6f 2288
22cad735
LR		 2289 memcpy(data->channels_2ghz, hwsim_channels_2ghz,
2290 sizeof(hwsim_channels_2ghz));
2291 memcpy(data->channels_5ghz, hwsim_channels_5ghz,
2292 sizeof(hwsim_channels_5ghz));
acc1e7a3 2293 memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
22cad735
LR		 2294
2295 for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) {
2296 struct ieee80211_supported_band *sband = &data->bands[band];
2297 switch (band) {
2298 case IEEE80211_BAND_2GHZ:
2299 sband->channels = data->channels_2ghz;
2300 sband->n_channels =
2301 ARRAY_SIZE(hwsim_channels_2ghz);
d130eb49
JB		 2302 sband->bitrates = data->rates;
2303 sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
22cad735
LR		 2304 break;
2305 case IEEE80211_BAND_5GHZ:
2306 sband->channels = data->channels_5ghz;
2307 sband->n_channels =
2308 ARRAY_SIZE(hwsim_channels_5ghz);
d130eb49
JB		 2309 sband->bitrates = data->rates + 4;
2310 sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4;
22cad735
LR		 2311 break;
2312 default:
1b083ea4 2313 continue;
22cad735
LR		 2314 }
2315
22cad735
LR		 2316 sband->ht_cap.ht_supported = true;
2317 sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
2318 IEEE80211_HT_CAP_GRN_FLD |
2319 IEEE80211_HT_CAP_SGI_40 |
2320 IEEE80211_HT_CAP_DSSSCCK40;
2321 sband->ht_cap.ampdu_factor = 0x3;
2322 sband->ht_cap.ampdu_density = 0x6;
2323 memset(&sband->ht_cap.mcs, 0,
2324 sizeof(sband->ht_cap.mcs));
2325 sband->ht_cap.mcs.rx_mask[0] = 0xff;
2326 sband->ht_cap.mcs.rx_mask[1] = 0xff;
2327 sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
2328
2329 hw->wiphy->bands[band] = sband;
b296005c 2330
b296005c
JB		 2331 sband->vht_cap.vht_supported = true;
2332 sband->vht_cap.cap =
2333 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
2334 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ |
2335 IEEE80211_VHT_CAP_RXLDPC |
2336 IEEE80211_VHT_CAP_SHORT_GI_80 |
2337 IEEE80211_VHT_CAP_SHORT_GI_160 |
2338 IEEE80211_VHT_CAP_TXSTBC |
2339 IEEE80211_VHT_CAP_RXSTBC_1 |
2340 IEEE80211_VHT_CAP_RXSTBC_2 |
2341 IEEE80211_VHT_CAP_RXSTBC_3 |
2342 IEEE80211_VHT_CAP_RXSTBC_4 |
01331040 2343 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
b296005c
JB		 2344 sband->vht_cap.vht_mcs.rx_mcs_map =
2345 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_8 << 0 |
2346 IEEE80211_VHT_MCS_SUPPORT_0_8 << 2 |
2347 IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
2348 IEEE80211_VHT_MCS_SUPPORT_0_8 << 6 |
2349 IEEE80211_VHT_MCS_SUPPORT_0_8 << 8 |
2350 IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 |
2351 IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 |
2352 IEEE80211_VHT_MCS_SUPPORT_0_8 << 14);
2353 sband->vht_cap.vht_mcs.tx_mcs_map =
2354 sband->vht_cap.vht_mcs.rx_mcs_map;
22cad735 2355 }
73606d00
DW		 2356 /* By default all radios are belonging to the first group */
2357 data->group = 1;
f74cb0f7 2358 mutex_init(&data->mutex);
acc1e7a3 2359
7882513b
JL		 2360 /* Enable frame retransmissions for lossy channels */
2361 hw->max_rates = 4;
2362 hw->max_rate_tries = 11;
2363
4a5af9c2
LR		 2364 /* Work to be done prior to ieee80211_register_hw() */
2365 switch (regtest) {
2366 case HWSIM_REGTEST_DISABLED:
2367 case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
2368 case HWSIM_REGTEST_DRIVER_REG_ALL:
2369 case HWSIM_REGTEST_DIFF_COUNTRY:
2370 /*
2371 * Nothing to be done for driver regulatory domain
2372 * hints prior to ieee80211_register_hw()
2373 */
2374 break;
2375 case HWSIM_REGTEST_WORLD_ROAM:
2376 if (i == 0) {
5be83de5 2377 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
4a5af9c2
LR		 2378 wiphy_apply_custom_regulatory(hw->wiphy,
2379 &hwsim_world_regdom_custom_01);
2380 }
2381 break;
2382 case HWSIM_REGTEST_CUSTOM_WORLD:
5be83de5 2383 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
4a5af9c2
LR		 2384 wiphy_apply_custom_regulatory(hw->wiphy,
2385 &hwsim_world_regdom_custom_01);
2386 break;
2387 case HWSIM_REGTEST_CUSTOM_WORLD_2:
2388 if (i == 0) {
5be83de5 2389 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
4a5af9c2
LR		 2390 wiphy_apply_custom_regulatory(hw->wiphy,
2391 &hwsim_world_regdom_custom_01);
2392 } else if (i == 1) {
5be83de5 2393 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
4a5af9c2
LR		 2394 wiphy_apply_custom_regulatory(hw->wiphy,
2395 &hwsim_world_regdom_custom_02);
2396 }
2397 break;
2398 case HWSIM_REGTEST_STRICT_ALL:
5be83de5 2399 hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
4a5af9c2
LR		 2400 break;
2401 case HWSIM_REGTEST_STRICT_FOLLOW:
2402 case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
2403 if (i == 0)
5be83de5 2404 hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
4a5af9c2
LR		 2405 break;
2406 case HWSIM_REGTEST_ALL:
2407 if (i == 0) {
5be83de5 2408 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
4a5af9c2
LR		 2409 wiphy_apply_custom_regulatory(hw->wiphy,
2410 &hwsim_world_regdom_custom_01);
2411 } else if (i == 1) {
5be83de5 2412 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
4a5af9c2
LR		 2413 wiphy_apply_custom_regulatory(hw->wiphy,
2414 &hwsim_world_regdom_custom_02);
2415 } else if (i == 4)
5be83de5 2416 hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
4a5af9c2
LR		 2417 break;
2418 default:
2419 break;
2420 }
2421
98dfaa57
LR		 2422 /* give the regulatory workqueue a chance to run */
2423 if (regtest)
2424 schedule_timeout_interruptible(1);
acc1e7a3
JM		 2425 err = ieee80211_register_hw(hw);
2426 if (err < 0) {
2427 printk(KERN_DEBUG "mac80211_hwsim: "
2428 "ieee80211_register_hw failed (%d)\n", err);
3a33cc10 2429 goto failed_hw;
acc1e7a3
JM		 2430 }
2431
4a5af9c2
LR		 2432 /* Work to be done after to ieee80211_register_hw() */
2433 switch (regtest) {
2434 case HWSIM_REGTEST_WORLD_ROAM:
2435 case HWSIM_REGTEST_DISABLED:
2436 break;
2437 case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
2438 if (!i)
2439 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
2440 break;
2441 case HWSIM_REGTEST_DRIVER_REG_ALL:
2442 case HWSIM_REGTEST_STRICT_ALL:
2443 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
2444 break;
2445 case HWSIM_REGTEST_DIFF_COUNTRY:
2446 if (i < ARRAY_SIZE(hwsim_alpha2s))
2447 regulatory_hint(hw->wiphy, hwsim_alpha2s[i]);
2448 break;
2449 case HWSIM_REGTEST_CUSTOM_WORLD:
2450 case HWSIM_REGTEST_CUSTOM_WORLD_2:
2451 /*
2452 * Nothing to be done for custom world regulatory
2453 * domains after to ieee80211_register_hw
2454 */
2455 break;
2456 case HWSIM_REGTEST_STRICT_FOLLOW:
2457 if (i == 0)
2458 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
2459 break;
2460 case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
2461 if (i == 0)
2462 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
2463 else if (i == 1)
2464 regulatory_hint(hw->wiphy, hwsim_alpha2s[1]);
2465 break;
2466 case HWSIM_REGTEST_ALL:
2467 if (i == 2)
2468 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
2469 else if (i == 3)
2470 regulatory_hint(hw->wiphy, hwsim_alpha2s[1]);
2471 else if (i == 4)
2472 regulatory_hint(hw->wiphy, hwsim_alpha2s[2]);
2473 break;
2474 default:
2475 break;
2476 }
2477
c96c31e4
JP		 2478 wiphy_debug(hw->wiphy, "hwaddr %pm registered\n",
2479 hw->wiphy->perm_addr);
acc1e7a3 2480
fc6971d4
JM		 2481 data->debugfs = debugfs_create_dir("hwsim",
2482 hw->wiphy->debugfsdir);
2483 data->debugfs_ps = debugfs_create_file("ps", 0666,
2484 data->debugfs, data,
2485 &hwsim_fops_ps);
73606d00
DW		 2486 data->debugfs_group = debugfs_create_file("group", 0666,
2487 data->debugfs, data,
2488 &hwsim_fops_group);
fc6971d4 2489
01e59e46
TP		 2490 tasklet_hrtimer_init(&data->beacon_timer,
2491 mac80211_hwsim_beacon,
2492 CLOCK_REALTIME, HRTIMER_MODE_ABS);
0e057d73
JB		 2493
2494 list_add_tail(&data->list, &hwsim_radios);
acc1e7a3
JM		 2495 }
2496
2497 hwsim_mon = alloc_netdev(0, "hwsim%d", hwsim_mon_setup);
2498 if (hwsim_mon == NULL)
2499 goto failed;
2500
7882513b
JL		 2501 rtnl_lock();
2502
2503 err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
3a33cc10 2504 if (err < 0)
acc1e7a3 2505 goto failed_mon;
3a33cc10 2506
7882513b
JL		 2507
2508 err = register_netdevice(hwsim_mon);
2509 if (err < 0)
2510 goto failed_mon;
2511
2512 rtnl_unlock();
2513
2514 err = hwsim_init_netlink();
2515 if (err < 0)
2516 goto failed_nl;
2517
acc1e7a3
JM		 2518 return 0;
2519
7882513b
JL		 2520failed_nl:
2521 printk(KERN_DEBUG "mac_80211_hwsim: failed initializing netlink\n");
2522 return err;
2523
acc1e7a3
JM		 2524failed_mon:
2525 rtnl_unlock();
2526 free_netdev(hwsim_mon);
3a33cc10
IS		 2527 mac80211_hwsim_free();
2528 return err;
acc1e7a3 2529
3a33cc10
IS		 2530failed_hw:
2531 device_unregister(data->dev);
2532failed_drvdata:
2533 ieee80211_free_hw(hw);
acc1e7a3
JM		 2534failed:
2535 mac80211_hwsim_free();
9ea92774
MP		 2536failed_unregister_driver:
2537 driver_unregister(&mac80211_hwsim_driver);
acc1e7a3
JM		 2538 return err;
2539}
f8fffc7e 2540module_init(init_mac80211_hwsim);
acc1e7a3
JM		 2541
2542static void __exit exit_mac80211_hwsim(void)
2543{
0e057d73 2544 printk(KERN_DEBUG "mac80211_hwsim: unregister radios\n");
acc1e7a3 2545
7882513b
JL		 2546 hwsim_exit_netlink();
2547
acc1e7a3 2548 mac80211_hwsim_free();
5d416351 2549 unregister_netdev(hwsim_mon);
9ea92774 2550 driver_unregister(&mac80211_hwsim_driver);
acc1e7a3 2551}
acc1e7a3 2552module_exit(exit_mac80211_hwsim);
Linux kernel - Deliverables
This page took 0.742189 seconds and 5 git commands to generate.