1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/list.h>
19#include <linux/slab.h>
20#include <linux/spinlock.h>
21#include <net/dst.h>
22#include <net/xfrm.h>
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>
28#include <linux/platform_device.h>
29#include <linux/debugfs.h>
30#include <linux/module.h>
31#include <linux/ktime.h>
32#include <net/genetlink.h>
33#include <net/net_namespace.h>
34#include <net/netns/generic.h>
35#include "mac80211_hwsim.h"
36
37#define WARN_QUEUE 100
38#define MAX_QUEUE 200
39
40MODULE_AUTHOR("Jouni Malinen");
41MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211");
42MODULE_LICENSE("GPL");
43
44static int radios = 2;
45module_param(radios, int, 0444);
46MODULE_PARM_DESC(radios, "Number of simulated radios");
47
48static int channels = 1;
49module_param(channels, int, 0444);
50MODULE_PARM_DESC(channels, "Number of concurrent channels");
51
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
56static bool rctbl = false;
57module_param(rctbl, bool, 0444);
58MODULE_PARM_DESC(rctbl, "Handle rate control table");
59
60static bool support_p2p_device = true;
61module_param(support_p2p_device, bool, 0444);
62MODULE_PARM_DESC(support_p2p_device, "Support P2P-Device interface type");
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
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
121enum hwsim_regtest {
122 HWSIM_REGTEST_DISABLED = 0,
123 HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
124 HWSIM_REGTEST_DRIVER_REG_ALL = 2,
125 HWSIM_REGTEST_DIFF_COUNTRY = 3,
126 HWSIM_REGTEST_WORLD_ROAM = 4,
127 HWSIM_REGTEST_CUSTOM_WORLD = 5,
128 HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
129 HWSIM_REGTEST_STRICT_FOLLOW = 7,
130 HWSIM_REGTEST_STRICT_ALL = 8,
131 HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
132 HWSIM_REGTEST_ALL = 10,
133};
134
135
136static int regtest = HWSIM_REGTEST_DISABLED;
137module_param(regtest, int, 0444);
138MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run");
139
140static const char *hwsim_alpha2s[] = {
141 "FI",
142 "AL",
143 "US",
144 "DE",
145 "JP",
146 "AL",
147};
148
149static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = {
150 .n_reg_rules = 4,
151 .alpha2 = "99",
152 .reg_rules = {
153 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
154 REG_RULE(2484-10, 2484+10, 40, 0, 20, 0),
155 REG_RULE(5150-10, 5240+10, 40, 0, 30, 0),
156 REG_RULE(5745-10, 5825+10, 40, 0, 30, 0),
157 }
158};
159
160static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
161 .n_reg_rules = 2,
162 .alpha2 = "99",
163 .reg_rules = {
164 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
165 REG_RULE(5725-10, 5850+10, 40, 0, 30,
166 NL80211_RRF_NO_IR),
167 }
168};
169
170static const struct ieee80211_regdomain *hwsim_world_regdom_custom[] = {
171 &hwsim_world_regdom_custom_01,
172 &hwsim_world_regdom_custom_02,
173};
174
175struct hwsim_vif_priv {
176 u32 magic;
177 u8 bssid[ETH_ALEN];
178 bool assoc;
179 bool bcn_en;
180 u16 aid;
181};
182
183#define HWSIM_VIF_MAGIC 0x69537748
184
185static inline void hwsim_check_magic(struct ieee80211_vif *vif)
186{
187 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
188 WARN(vp->magic != HWSIM_VIF_MAGIC,
189 "Invalid VIF (%p) magic %#x, %pM, %d/%d\n",
190 vif, vp->magic, vif->addr, vif->type, vif->p2p);
191}
192
193static inline void hwsim_set_magic(struct ieee80211_vif *vif)
194{
195 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
196 vp->magic = HWSIM_VIF_MAGIC;
197}
198
199static inline void hwsim_clear_magic(struct ieee80211_vif *vif)
200{
201 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
202 vp->magic = 0;
203}
204
205struct hwsim_sta_priv {
206 u32 magic;
207};
208
209#define HWSIM_STA_MAGIC 0x6d537749
210
211static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta)
212{
213 struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
214 WARN_ON(sp->magic != HWSIM_STA_MAGIC);
215}
216
217static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta)
218{
219 struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
220 sp->magic = HWSIM_STA_MAGIC;
221}
222
223static inline void hwsim_clear_sta_magic(struct ieee80211_sta *sta)
224{
225 struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
226 sp->magic = 0;
227}
228
229struct hwsim_chanctx_priv {
230 u32 magic;
231};
232
233#define HWSIM_CHANCTX_MAGIC 0x6d53774a
234
235static inline void hwsim_check_chanctx_magic(struct ieee80211_chanctx_conf *c)
236{
237 struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
238 WARN_ON(cp->magic != HWSIM_CHANCTX_MAGIC);
239}
240
241static inline void hwsim_set_chanctx_magic(struct ieee80211_chanctx_conf *c)
242{
243 struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
244 cp->magic = HWSIM_CHANCTX_MAGIC;
245}
246
247static inline void hwsim_clear_chanctx_magic(struct ieee80211_chanctx_conf *c)
248{
249 struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
250 cp->magic = 0;
251}
252
253static int hwsim_net_id;
254
255static int hwsim_netgroup;
256
257struct hwsim_net {
258 int netgroup;
259 u32 wmediumd;
260};
261
262static inline int hwsim_net_get_netgroup(struct net *net)
263{
264 struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
265
266 return hwsim_net->netgroup;
267}
268
269static inline void hwsim_net_set_netgroup(struct net *net)
270{
271 struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
272
273 hwsim_net->netgroup = hwsim_netgroup++;
274}
275
276static inline u32 hwsim_net_get_wmediumd(struct net *net)
277{
278 struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
279
280 return hwsim_net->wmediumd;
281}
282
283static inline void hwsim_net_set_wmediumd(struct net *net, u32 portid)
284{
285 struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
286
287 hwsim_net->wmediumd = portid;
288}
289
290static struct class *hwsim_class;
291
292static struct net_device *hwsim_mon;
293
294#define CHAN2G(_freq) { \
295 .band = NL80211_BAND_2GHZ, \
296 .center_freq = (_freq), \
297 .hw_value = (_freq), \
298 .max_power = 20, \
299}
300
301#define CHAN5G(_freq) { \
302 .band = NL80211_BAND_5GHZ, \
303 .center_freq = (_freq), \
304 .hw_value = (_freq), \
305 .max_power = 20, \
306}
307
308static const struct ieee80211_channel hwsim_channels_2ghz[] = {
309 CHAN2G(2412),
310 CHAN2G(2417),
311 CHAN2G(2422),
312 CHAN2G(2427),
313 CHAN2G(2432),
314 CHAN2G(2437),
315 CHAN2G(2442),
316 CHAN2G(2447),
317 CHAN2G(2452),
318 CHAN2G(2457),
319 CHAN2G(2462),
320 CHAN2G(2467),
321 CHAN2G(2472),
322 CHAN2G(2484),
323};
324
325static const struct ieee80211_channel hwsim_channels_5ghz[] = {
326 CHAN5G(5180),
327 CHAN5G(5200),
328 CHAN5G(5220),
329 CHAN5G(5240),
330
331 CHAN5G(5260),
332 CHAN5G(5280),
333 CHAN5G(5300),
334 CHAN5G(5320),
335
336 CHAN5G(5500),
337 CHAN5G(5520),
338 CHAN5G(5540),
339 CHAN5G(5560),
340 CHAN5G(5580),
341 CHAN5G(5600),
342 CHAN5G(5620),
343 CHAN5G(5640),
344 CHAN5G(5660),
345 CHAN5G(5680),
346 CHAN5G(5700),
347
348 CHAN5G(5745),
349 CHAN5G(5765),
350 CHAN5G(5785),
351 CHAN5G(5805),
352 CHAN5G(5825),
353};
354
355static const struct ieee80211_rate hwsim_rates[] = {
356 { .bitrate = 10 },
357 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
358 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
359 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
360 { .bitrate = 60 },
361 { .bitrate = 90 },
362 { .bitrate = 120 },
363 { .bitrate = 180 },
364 { .bitrate = 240 },
365 { .bitrate = 360 },
366 { .bitrate = 480 },
367 { .bitrate = 540 }
368};
369
370#define OUI_QCA 0x001374
371#define QCA_NL80211_SUBCMD_TEST 1
372enum qca_nl80211_vendor_subcmds {
373 QCA_WLAN_VENDOR_ATTR_TEST = 8,
374 QCA_WLAN_VENDOR_ATTR_MAX = QCA_WLAN_VENDOR_ATTR_TEST
375};
376
377static const struct nla_policy
378hwsim_vendor_test_policy[QCA_WLAN_VENDOR_ATTR_MAX + 1] = {
379 [QCA_WLAN_VENDOR_ATTR_MAX] = { .type = NLA_U32 },
380};
381
382static int mac80211_hwsim_vendor_cmd_test(struct wiphy *wiphy,
383 struct wireless_dev *wdev,
384 const void *data, int data_len)
385{
386 struct sk_buff *skb;
387 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_MAX + 1];
388 int err;
389 u32 val;
390
391 err = nla_parse(tb, QCA_WLAN_VENDOR_ATTR_MAX, data, data_len,
392 hwsim_vendor_test_policy);
393 if (err)
394 return err;
395 if (!tb[QCA_WLAN_VENDOR_ATTR_TEST])
396 return -EINVAL;
397 val = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_TEST]);
398 wiphy_debug(wiphy, "%s: test=%u\n", __func__, val);
399
400
401
402
403
404
405
406
407 skb = cfg80211_vendor_event_alloc(wiphy, wdev, 100, 0, GFP_KERNEL);
408 if (skb) {
409
410
411
412
413
414 nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 1);
415
416
417 cfg80211_vendor_event(skb, GFP_KERNEL);
418 }
419
420
421 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 10);
422 if (!skb)
423 return -ENOMEM;
424
425
426
427
428 nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 2);
429
430 return cfg80211_vendor_cmd_reply(skb);
431}
432
433static struct wiphy_vendor_command mac80211_hwsim_vendor_commands[] = {
434 {
435 .info = { .vendor_id = OUI_QCA,
436 .subcmd = QCA_NL80211_SUBCMD_TEST },
437 .flags = WIPHY_VENDOR_CMD_NEED_NETDEV,
438 .doit = mac80211_hwsim_vendor_cmd_test,
439 }
440};
441
442
443static const struct nl80211_vendor_cmd_info mac80211_hwsim_vendor_events[] = {
444 { .vendor_id = OUI_QCA, .subcmd = 1 },
445};
446
447static const struct ieee80211_iface_limit hwsim_if_limits[] = {
448 { .max = 1, .types = BIT(NL80211_IFTYPE_ADHOC) },
449 { .max = 2048, .types = BIT(NL80211_IFTYPE_STATION) |
450 BIT(NL80211_IFTYPE_P2P_CLIENT) |
451#ifdef CONFIG_MAC80211_MESH
452 BIT(NL80211_IFTYPE_MESH_POINT) |
453#endif
454 BIT(NL80211_IFTYPE_AP) |
455 BIT(NL80211_IFTYPE_P2P_GO) },
456
457 { .max = 1, .types = BIT(NL80211_IFTYPE_P2P_DEVICE) }
458};
459
460static const struct ieee80211_iface_combination hwsim_if_comb[] = {
461 {
462 .limits = hwsim_if_limits,
463
464 .n_limits = ARRAY_SIZE(hwsim_if_limits) - 1,
465 .max_interfaces = 2048,
466 .num_different_channels = 1,
467 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
468 BIT(NL80211_CHAN_WIDTH_20) |
469 BIT(NL80211_CHAN_WIDTH_40) |
470 BIT(NL80211_CHAN_WIDTH_80) |
471 BIT(NL80211_CHAN_WIDTH_160),
472 },
473};
474
475static const struct ieee80211_iface_combination hwsim_if_comb_p2p_dev[] = {
476 {
477 .limits = hwsim_if_limits,
478 .n_limits = ARRAY_SIZE(hwsim_if_limits),
479 .max_interfaces = 2048,
480 .num_different_channels = 1,
481 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
482 BIT(NL80211_CHAN_WIDTH_20) |
483 BIT(NL80211_CHAN_WIDTH_40) |
484 BIT(NL80211_CHAN_WIDTH_80) |
485 BIT(NL80211_CHAN_WIDTH_160),
486 },
487};
488
489static spinlock_t hwsim_radio_lock;
490static struct list_head hwsim_radios;
491static int hwsim_radio_idx;
492
493static struct platform_driver mac80211_hwsim_driver = {
494 .driver = {
495 .name = "mac80211_hwsim",
496 },
497};
498
499struct mac80211_hwsim_data {
500 struct list_head list;
501 struct ieee80211_hw *hw;
502 struct device *dev;
503 struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
504 struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
505 struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
506 struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
507 struct ieee80211_iface_combination if_combination;
508
509 struct mac_address addresses[2];
510 int channels, idx;
511 bool use_chanctx;
512 bool destroy_on_close;
513 struct work_struct destroy_work;
514 u32 portid;
515 char alpha2[2];
516 const struct ieee80211_regdomain *regd;
517
518 struct ieee80211_channel *tmp_chan;
519 struct ieee80211_channel *roc_chan;
520 u32 roc_duration;
521 struct delayed_work roc_start;
522 struct delayed_work roc_done;
523 struct delayed_work hw_scan;
524 struct cfg80211_scan_request *hw_scan_request;
525 struct ieee80211_vif *hw_scan_vif;
526 int scan_chan_idx;
527 u8 scan_addr[ETH_ALEN];
528
529 struct ieee80211_channel *channel;
530 u64 beacon_int ;
531 unsigned int rx_filter;
532 bool started, idle, scanning;
533 struct mutex mutex;
534 struct tasklet_hrtimer beacon_timer;
535 enum ps_mode {
536 PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
537 } ps;
538 bool ps_poll_pending;
539 struct dentry *debugfs;
540
541 uintptr_t pending_cookie;
542 struct sk_buff_head pending;
543
544
545
546
547
548 u64 group;
549
550
551 int netgroup;
552
553 u32 wmediumd;
554
555 int power_level;
556
557
558 s64 tsf_offset;
559 s64 bcn_delta;
560
561 u64 abs_bcn_ts;
562
563
564 u64 tx_pkts;
565 u64 rx_pkts;
566 u64 tx_bytes;
567 u64 rx_bytes;
568 u64 tx_dropped;
569 u64 tx_failed;
570};
571
572
573struct hwsim_radiotap_hdr {
574 struct ieee80211_radiotap_header hdr;
575 __le64 rt_tsft;
576 u8 rt_flags;
577 u8 rt_rate;
578 __le16 rt_channel;
579 __le16 rt_chbitmask;
580} __packed;
581
582struct hwsim_radiotap_ack_hdr {
583 struct ieee80211_radiotap_header hdr;
584 u8 rt_flags;
585 u8 pad;
586 __le16 rt_channel;
587 __le16 rt_chbitmask;
588} __packed;
589
590
591static struct genl_family hwsim_genl_family = {
592 .id = GENL_ID_GENERATE,
593 .hdrsize = 0,
594 .name = "MAC80211_HWSIM",
595 .version = 1,
596 .maxattr = HWSIM_ATTR_MAX,
597 .netnsok = true,
598};
599
600enum hwsim_multicast_groups {
601 HWSIM_MCGRP_CONFIG,
602};
603
604static const struct genl_multicast_group hwsim_mcgrps[] = {
605 [HWSIM_MCGRP_CONFIG] = { .name = "config", },
606};
607
608
609
610static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
611 [HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
612 [HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
613 [HWSIM_ATTR_FRAME] = { .type = NLA_BINARY,
614 .len = IEEE80211_MAX_DATA_LEN },
615 [HWSIM_ATTR_FLAGS] = { .type = NLA_U32 },
616 [HWSIM_ATTR_RX_RATE] = { .type = NLA_U32 },
617 [HWSIM_ATTR_SIGNAL] = { .type = NLA_U32 },
618 [HWSIM_ATTR_TX_INFO] = { .type = NLA_UNSPEC,
619 .len = IEEE80211_TX_MAX_RATES *
620 sizeof(struct hwsim_tx_rate)},
621 [HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
622 [HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 },
623 [HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 },
624 [HWSIM_ATTR_REG_HINT_ALPHA2] = { .type = NLA_STRING, .len = 2 },
625 [HWSIM_ATTR_REG_CUSTOM_REG] = { .type = NLA_U32 },
626 [HWSIM_ATTR_REG_STRICT_REG] = { .type = NLA_FLAG },
627 [HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG },
628 [HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE] = { .type = NLA_FLAG },
629 [HWSIM_ATTR_RADIO_NAME] = { .type = NLA_STRING },
630 [HWSIM_ATTR_NO_VIF] = { .type = NLA_FLAG },
631 [HWSIM_ATTR_FREQ] = { .type = NLA_U32 },
632};
633
634static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
635 struct sk_buff *skb,
636 struct ieee80211_channel *chan);
637
638
639static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
640{
641 struct mac80211_hwsim_data *data = dat;
642 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
643 struct sk_buff *skb;
644 struct ieee80211_pspoll *pspoll;
645
646 if (!vp->assoc)
647 return;
648
649 wiphy_debug(data->hw->wiphy,
650 "%s: send PS-Poll to %pM for aid %d\n",
651 __func__, vp->bssid, vp->aid);
652
653 skb = dev_alloc_skb(sizeof(*pspoll));
654 if (!skb)
655 return;
656 pspoll = (void *) skb_put(skb, sizeof(*pspoll));
657 pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
658 IEEE80211_STYPE_PSPOLL |
659 IEEE80211_FCTL_PM);
660 pspoll->aid = cpu_to_le16(0xc000 | vp->aid);
661 memcpy(pspoll->bssid, vp->bssid, ETH_ALEN);
662 memcpy(pspoll->ta, mac, ETH_ALEN);
663
664 rcu_read_lock();
665 mac80211_hwsim_tx_frame(data->hw, skb,
666 rcu_dereference(vif->chanctx_conf)->def.chan);
667 rcu_read_unlock();
668}
669
670static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
671 struct ieee80211_vif *vif, int ps)
672{
673 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
674 struct sk_buff *skb;
675 struct ieee80211_hdr *hdr;
676
677 if (!vp->assoc)
678 return;
679
680 wiphy_debug(data->hw->wiphy,
681 "%s: send data::nullfunc to %pM ps=%d\n",
682 __func__, vp->bssid, ps);
683
684 skb = dev_alloc_skb(sizeof(*hdr));
685 if (!skb)
686 return;
687 hdr = (void *) skb_put(skb, sizeof(*hdr) - ETH_ALEN);
688 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
689 IEEE80211_STYPE_NULLFUNC |
690 (ps ? IEEE80211_FCTL_PM : 0));
691 hdr->duration_id = cpu_to_le16(0);
692 memcpy(hdr->addr1, vp->bssid, ETH_ALEN);
693 memcpy(hdr->addr2, mac, ETH_ALEN);
694 memcpy(hdr->addr3, vp->bssid, ETH_ALEN);
695
696 rcu_read_lock();
697 mac80211_hwsim_tx_frame(data->hw, skb,
698 rcu_dereference(vif->chanctx_conf)->def.chan);
699 rcu_read_unlock();
700}
701
702
703static void hwsim_send_nullfunc_ps(void *dat, u8 *mac,
704 struct ieee80211_vif *vif)
705{
706 struct mac80211_hwsim_data *data = dat;
707 hwsim_send_nullfunc(data, mac, vif, 1);
708}
709
710static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac,
711 struct ieee80211_vif *vif)
712{
713 struct mac80211_hwsim_data *data = dat;
714 hwsim_send_nullfunc(data, mac, vif, 0);
715}
716
717static int hwsim_fops_ps_read(void *dat, u64 *val)
718{
719 struct mac80211_hwsim_data *data = dat;
720 *val = data->ps;
721 return 0;
722}
723
724static int hwsim_fops_ps_write(void *dat, u64 val)
725{
726 struct mac80211_hwsim_data *data = dat;
727 enum ps_mode old_ps;
728
729 if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL &&
730 val != PS_MANUAL_POLL)
731 return -EINVAL;
732
733 old_ps = data->ps;
734 data->ps = val;
735
736 local_bh_disable();
737 if (val == PS_MANUAL_POLL) {
738 ieee80211_iterate_active_interfaces_atomic(
739 data->hw, IEEE80211_IFACE_ITER_NORMAL,
740 hwsim_send_ps_poll, data);
741 data->ps_poll_pending = true;
742 } else if (old_ps == PS_DISABLED && val != PS_DISABLED) {
743 ieee80211_iterate_active_interfaces_atomic(
744 data->hw, IEEE80211_IFACE_ITER_NORMAL,
745 hwsim_send_nullfunc_ps, data);
746 } else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
747 ieee80211_iterate_active_interfaces_atomic(
748 data->hw, IEEE80211_IFACE_ITER_NORMAL,
749 hwsim_send_nullfunc_no_ps, data);
750 }
751 local_bh_enable();
752
753 return 0;
754}
755
756DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write,
757 "%llu\n");
758
759static int hwsim_write_simulate_radar(void *dat, u64 val)
760{
761 struct mac80211_hwsim_data *data = dat;
762
763 ieee80211_radar_detected(data->hw);
764
765 return 0;
766}
767
768DEFINE_SIMPLE_ATTRIBUTE(hwsim_simulate_radar, NULL,
769 hwsim_write_simulate_radar, "%llu\n");
770
771static int hwsim_fops_group_read(void *dat, u64 *val)
772{
773 struct mac80211_hwsim_data *data = dat;
774 *val = data->group;
775 return 0;
776}
777
778static int hwsim_fops_group_write(void *dat, u64 val)
779{
780 struct mac80211_hwsim_data *data = dat;
781 data->group = val;
782 return 0;
783}
784
785DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_group,
786 hwsim_fops_group_read, hwsim_fops_group_write,
787 "%llx\n");
788
789static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
790 struct net_device *dev)
791{
792
793 dev_kfree_skb(skb);
794 return NETDEV_TX_OK;
795}
796
797static inline u64 mac80211_hwsim_get_tsf_raw(void)
798{
799 return ktime_to_us(ktime_get_real());
800}
801
802static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
803{
804 u64 now = mac80211_hwsim_get_tsf_raw();
805 return cpu_to_le64(now + data->tsf_offset);
806}
807
808static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
809 struct ieee80211_vif *vif)
810{
811 struct mac80211_hwsim_data *data = hw->priv;
812 return le64_to_cpu(__mac80211_hwsim_get_tsf(data));
813}
814
815static void mac80211_hwsim_set_tsf(struct ieee80211_hw *hw,
816 struct ieee80211_vif *vif, u64 tsf)
817{
818 struct mac80211_hwsim_data *data = hw->priv;
819 u64 now = mac80211_hwsim_get_tsf(hw, vif);
820 u32 bcn_int = data->beacon_int;
821 u64 delta = abs(tsf - now);
822
823
824 if (tsf > now) {
825 data->tsf_offset += delta;
826 data->bcn_delta = do_div(delta, bcn_int);
827 } else {
828 data->tsf_offset -= delta;
829 data->bcn_delta = -do_div(delta, bcn_int);
830 }
831}
832
833static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
834 struct sk_buff *tx_skb,
835 struct ieee80211_channel *chan)
836{
837 struct mac80211_hwsim_data *data = hw->priv;
838 struct sk_buff *skb;
839 struct hwsim_radiotap_hdr *hdr;
840 u16 flags;
841 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb);
842 struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info);
843
844 if (WARN_ON(!txrate))
845 return;
846
847 if (!netif_running(hwsim_mon))
848 return;
849
850 skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC);
851 if (skb == NULL)
852 return;
853
854 hdr = (struct hwsim_radiotap_hdr *) skb_push(skb, sizeof(*hdr));
855 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
856 hdr->hdr.it_pad = 0;
857 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
858 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
859 (1 << IEEE80211_RADIOTAP_RATE) |
860 (1 << IEEE80211_RADIOTAP_TSFT) |
861 (1 << IEEE80211_RADIOTAP_CHANNEL));
862 hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
863 hdr->rt_flags = 0;
864 hdr->rt_rate = txrate->bitrate / 5;
865 hdr->rt_channel = cpu_to_le16(chan->center_freq);
866 flags = IEEE80211_CHAN_2GHZ;
867 if (txrate->flags & IEEE80211_RATE_ERP_G)
868 flags |= IEEE80211_CHAN_OFDM;
869 else
870 flags |= IEEE80211_CHAN_CCK;
871 hdr->rt_chbitmask = cpu_to_le16(flags);
872
873 skb->dev = hwsim_mon;
874 skb_reset_mac_header(skb);
875 skb->ip_summed = CHECKSUM_UNNECESSARY;
876 skb->pkt_type = PACKET_OTHERHOST;
877 skb->protocol = htons(ETH_P_802_2);
878 memset(skb->cb, 0, sizeof(skb->cb));
879 netif_rx(skb);
880}
881
882
883static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
884 const u8 *addr)
885{
886 struct sk_buff *skb;
887 struct hwsim_radiotap_ack_hdr *hdr;
888 u16 flags;
889 struct ieee80211_hdr *hdr11;
890
891 if (!netif_running(hwsim_mon))
892 return;
893
894 skb = dev_alloc_skb(100);
895 if (skb == NULL)
896 return;
897
898 hdr = (struct hwsim_radiotap_ack_hdr *) skb_put(skb, sizeof(*hdr));
899 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
900 hdr->hdr.it_pad = 0;
901 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
902 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
903 (1 << IEEE80211_RADIOTAP_CHANNEL));
904 hdr->rt_flags = 0;
905 hdr->pad = 0;
906 hdr->rt_channel = cpu_to_le16(chan->center_freq);
907 flags = IEEE80211_CHAN_2GHZ;
908 hdr->rt_chbitmask = cpu_to_le16(flags);
909
910 hdr11 = (struct ieee80211_hdr *) skb_put(skb, 10);
911 hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
912 IEEE80211_STYPE_ACK);
913 hdr11->duration_id = cpu_to_le16(0);
914 memcpy(hdr11->addr1, addr, ETH_ALEN);
915
916 skb->dev = hwsim_mon;
917 skb_reset_mac_header(skb);
918 skb->ip_summed = CHECKSUM_UNNECESSARY;
919 skb->pkt_type = PACKET_OTHERHOST;
920 skb->protocol = htons(ETH_P_802_2);
921 memset(skb->cb, 0, sizeof(skb->cb));
922 netif_rx(skb);
923}
924
925struct mac80211_hwsim_addr_match_data {
926 u8 addr[ETH_ALEN];
927 bool ret;
928};
929
930static void mac80211_hwsim_addr_iter(void *data, u8 *mac,
931 struct ieee80211_vif *vif)
932{
933 struct mac80211_hwsim_addr_match_data *md = data;
934
935 if (memcmp(mac, md->addr, ETH_ALEN) == 0)
936 md->ret = true;
937}
938
939static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data,
940 const u8 *addr)
941{
942 struct mac80211_hwsim_addr_match_data md = {
943 .ret = false,
944 };
945
946 if (data->scanning && memcmp(addr, data->scan_addr, ETH_ALEN) == 0)
947 return true;
948
949 memcpy(md.addr, addr, ETH_ALEN);
950
951 ieee80211_iterate_active_interfaces_atomic(data->hw,
952 IEEE80211_IFACE_ITER_NORMAL,
953 mac80211_hwsim_addr_iter,
954 &md);
955
956 return md.ret;
957}
958
959static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
960 struct sk_buff *skb)
961{
962 switch (data->ps) {
963 case PS_DISABLED:
964 return true;
965 case PS_ENABLED:
966 return false;
967 case PS_AUTO_POLL:
968
969
970 return true;
971 case PS_MANUAL_POLL:
972
973
974 if (data->ps_poll_pending &&
975 mac80211_hwsim_addr_match(data, skb->data + 4)) {
976 data->ps_poll_pending = false;
977 return true;
978 }
979 return false;
980 }
981
982 return true;
983}
984
985static int hwsim_unicast_netgroup(struct mac80211_hwsim_data *data,
986 struct sk_buff *skb, int portid)
987{
988 struct net *net;
989 bool found = false;
990 int res = -ENOENT;
991
992 rcu_read_lock();
993 for_each_net_rcu(net) {
994 if (data->netgroup == hwsim_net_get_netgroup(net)) {
995 res = genlmsg_unicast(net, skb, portid);
996 found = true;
997 break;
998 }
999 }
1000 rcu_read_unlock();
1001
1002 if (!found)
1003 nlmsg_free(skb);
1004
1005 return res;
1006}
1007
1008static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
1009 struct sk_buff *my_skb,
1010 int dst_portid)
1011{
1012 struct sk_buff *skb;
1013 struct mac80211_hwsim_data *data = hw->priv;
1014 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data;
1015 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb);
1016 void *msg_head;
1017 unsigned int hwsim_flags = 0;
1018 int i;
1019 struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES];
1020 uintptr_t cookie;
1021
1022 if (data->ps != PS_DISABLED)
1023 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
1024
1025 if (skb_queue_len(&data->pending) >= MAX_QUEUE) {
1026
1027 while (skb_queue_len(&data->pending) >= WARN_QUEUE) {
1028 ieee80211_free_txskb(hw, skb_dequeue(&data->pending));
1029 data->tx_dropped++;
1030 }
1031 }
1032
1033 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1034 if (skb == NULL)
1035 goto nla_put_failure;
1036
1037 msg_head = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
1038 HWSIM_CMD_FRAME);
1039 if (msg_head == NULL) {
1040 printk(KERN_DEBUG "mac80211_hwsim: problem with msg_head\n");
1041 goto nla_put_failure;
1042 }
1043
1044 if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
1045 ETH_ALEN, data->addresses[1].addr))
1046 goto nla_put_failure;
1047
1048
1049 if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
1050 goto nla_put_failure;
1051
1052
1053
1054
1055 if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
1056 hwsim_flags |= HWSIM_TX_CTL_REQ_TX_STATUS;
1057
1058 if (info->flags & IEEE80211_TX_CTL_NO_ACK)
1059 hwsim_flags |= HWSIM_TX_CTL_NO_ACK;
1060
1061 if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
1062 goto nla_put_failure;
1063
1064 if (nla_put_u32(skb, HWSIM_ATTR_FREQ, data->channel->center_freq))
1065 goto nla_put_failure;
1066
1067
1068
1069 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
1070 tx_attempts[i].idx = info->status.rates[i].idx;
1071 tx_attempts[i].count = info->status.rates[i].count;
1072 }
1073
1074 if (nla_put(skb, HWSIM_ATTR_TX_INFO,
1075 sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
1076 tx_attempts))
1077 goto nla_put_failure;
1078
1079
1080 data->pending_cookie++;
1081 cookie = data->pending_cookie;
1082 info->rate_driver_data[0] = (void *)cookie;
1083 if (nla_put_u64_64bit(skb, HWSIM_ATTR_COOKIE, cookie, HWSIM_ATTR_PAD))
1084 goto nla_put_failure;
1085
1086 genlmsg_end(skb, msg_head);
1087 if (hwsim_unicast_netgroup(data, skb, dst_portid))
1088 goto err_free_txskb;
1089
1090
1091 skb_queue_tail(&data->pending, my_skb);
1092 data->tx_pkts++;
1093 data->tx_bytes += my_skb->len;
1094 return;
1095
1096nla_put_failure:
1097 nlmsg_free(skb);
1098err_free_txskb:
1099 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
1100 ieee80211_free_txskb(hw, my_skb);
1101 data->tx_failed++;
1102}
1103
1104static bool hwsim_chans_compat(struct ieee80211_channel *c1,
1105 struct ieee80211_channel *c2)
1106{
1107 if (!c1 || !c2)
1108 return false;
1109
1110 return c1->center_freq == c2->center_freq;
1111}
1112
1113struct tx_iter_data {
1114 struct ieee80211_channel *channel;
1115 bool receive;
1116};
1117
1118static void mac80211_hwsim_tx_iter(void *_data, u8 *addr,
1119 struct ieee80211_vif *vif)
1120{
1121 struct tx_iter_data *data = _data;
1122
1123 if (!vif->chanctx_conf)
1124 return;
1125
1126 if (!hwsim_chans_compat(data->channel,
1127 rcu_dereference(vif->chanctx_conf)->def.chan))
1128 return;
1129
1130 data->receive = true;
1131}
1132
1133static void mac80211_hwsim_add_vendor_rtap(struct sk_buff *skb)
1134{
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145#ifdef HWSIM_RADIOTAP_OUI
1146 struct ieee80211_vendor_radiotap *rtap;
1147
1148
1149
1150
1151
1152 rtap = (void *)skb_push(skb, sizeof(*rtap) + 8 + 4);
1153 rtap->oui[0] = HWSIM_RADIOTAP_OUI[0];
1154 rtap->oui[1] = HWSIM_RADIOTAP_OUI[1];
1155 rtap->oui[2] = HWSIM_RADIOTAP_OUI[2];
1156 rtap->subns = 127;
1157
1158
1159
1160
1161
1162
1163
1164 rtap->present = BIT(0);
1165
1166 rtap->len = 8;
1167
1168 rtap->align = 8;
1169
1170 rtap->pad = 4;
1171
1172 memcpy(rtap->data, "ABCDEFGH", 8);
1173
1174 memset(rtap->data + 8, 0, 4);
1175
1176 IEEE80211_SKB_RXCB(skb)->flag |= RX_FLAG_RADIOTAP_VENDOR_DATA;
1177#endif
1178}
1179
1180static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
1181 struct sk_buff *skb,
1182 struct ieee80211_channel *chan)
1183{
1184 struct mac80211_hwsim_data *data = hw->priv, *data2;
1185 bool ack = false;
1186 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1187 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1188 struct ieee80211_rx_status rx_status;
1189 u64 now;
1190
1191 memset(&rx_status, 0, sizeof(rx_status));
1192 rx_status.flag |= RX_FLAG_MACTIME_START;
1193 rx_status.freq = chan->center_freq;
1194 rx_status.band = chan->band;
1195 if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
1196 rx_status.rate_idx =
1197 ieee80211_rate_get_vht_mcs(&info->control.rates[0]);
1198 rx_status.vht_nss =
1199 ieee80211_rate_get_vht_nss(&info->control.rates[0]);
1200 rx_status.flag |= RX_FLAG_VHT;
1201 } else {
1202 rx_status.rate_idx = info->control.rates[0].idx;
1203 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
1204 rx_status.flag |= RX_FLAG_HT;
1205 }
1206 if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
1207 rx_status.flag |= RX_FLAG_40MHZ;
1208 if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
1209 rx_status.flag |= RX_FLAG_SHORT_GI;
1210
1211 rx_status.signal = data->power_level - 50;
1212
1213 if (data->ps != PS_DISABLED)
1214 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
1215
1216
1217 skb_orphan(skb);
1218 skb_dst_drop(skb);
1219 skb->mark = 0;
1220 secpath_reset(skb);
1221 nf_reset(skb);
1222
1223
1224
1225
1226
1227
1228
1229
1230 if (ieee80211_is_beacon(hdr->frame_control) ||
1231 ieee80211_is_probe_resp(hdr->frame_control))
1232 now = data->abs_bcn_ts;
1233 else
1234 now = mac80211_hwsim_get_tsf_raw();
1235
1236
1237 spin_lock(&hwsim_radio_lock);
1238 list_for_each_entry(data2, &hwsim_radios, list) {
1239 struct sk_buff *nskb;
1240 struct tx_iter_data tx_iter_data = {
1241 .receive = false,
1242 .channel = chan,
1243 };
1244
1245 if (data == data2)
1246 continue;
1247
1248 if (!data2->started || (data2->idle && !data2->tmp_chan) ||
1249 !hwsim_ps_rx_ok(data2, skb))
1250 continue;
1251
1252 if (!(data->group & data2->group))
1253 continue;
1254
1255 if (data->netgroup != data2->netgroup)
1256 continue;
1257
1258 if (!hwsim_chans_compat(chan, data2->tmp_chan) &&
1259 !hwsim_chans_compat(chan, data2->channel)) {
1260 ieee80211_iterate_active_interfaces_atomic(
1261 data2->hw, IEEE80211_IFACE_ITER_NORMAL,
1262 mac80211_hwsim_tx_iter, &tx_iter_data);
1263 if (!tx_iter_data.receive)
1264 continue;
1265 }
1266
1267
1268
1269
1270
1271 if (skb->len < PAGE_SIZE && paged_rx) {
1272 struct page *page = alloc_page(GFP_ATOMIC);
1273
1274 if (!page)
1275 continue;
1276
1277 nskb = dev_alloc_skb(128);
1278 if (!nskb) {
1279 __free_page(page);
1280 continue;
1281 }
1282
1283 memcpy(page_address(page), skb->data, skb->len);
1284 skb_add_rx_frag(nskb, 0, page, 0, skb->len, skb->len);
1285 } else {
1286 nskb = skb_copy(skb, GFP_ATOMIC);
1287 if (!nskb)
1288 continue;
1289 }
1290
1291 if (mac80211_hwsim_addr_match(data2, hdr->addr1))
1292 ack = true;
1293
1294 rx_status.mactime = now + data2->tsf_offset;
1295
1296 memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
1297
1298 mac80211_hwsim_add_vendor_rtap(nskb);
1299
1300 data2->rx_pkts++;
1301 data2->rx_bytes += nskb->len;
1302 ieee80211_rx_irqsafe(data2->hw, nskb);
1303 }
1304 spin_unlock(&hwsim_radio_lock);
1305
1306 return ack;
1307}
1308
1309static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
1310 struct ieee80211_tx_control *control,
1311 struct sk_buff *skb)
1312{
1313 struct mac80211_hwsim_data *data = hw->priv;
1314 struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
1315 struct ieee80211_hdr *hdr = (void *)skb->data;
1316 struct ieee80211_chanctx_conf *chanctx_conf;
1317 struct ieee80211_channel *channel;
1318 bool ack;
1319 u32 _portid;
1320
1321 if (WARN_ON(skb->len < 10)) {
1322
1323 ieee80211_free_txskb(hw, skb);
1324 return;
1325 }
1326
1327 if (!data->use_chanctx) {
1328 channel = data->channel;
1329 } else if (txi->hw_queue == 4) {
1330 channel = data->tmp_chan;
1331 } else {
1332 chanctx_conf = rcu_dereference(txi->control.vif->chanctx_conf);
1333 if (chanctx_conf)
1334 channel = chanctx_conf->def.chan;
1335 else
1336 channel = NULL;
1337 }
1338
1339 if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
1340 ieee80211_free_txskb(hw, skb);
1341 return;
1342 }
1343
1344 if (data->idle && !data->tmp_chan) {
1345 wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
1346 ieee80211_free_txskb(hw, skb);
1347 return;
1348 }
1349
1350 if (txi->control.vif)
1351 hwsim_check_magic(txi->control.vif);
1352 if (control->sta)
1353 hwsim_check_sta_magic(control->sta);
1354
1355 if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1356 ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
1357 txi->control.rates,
1358 ARRAY_SIZE(txi->control.rates));
1359
1360 txi->rate_driver_data[0] = channel;
1361
1362 if (skb->len >= 24 + 8 &&
1363 ieee80211_is_probe_resp(hdr->frame_control)) {
1364
1365 struct ieee80211_mgmt *mgmt;
1366 struct ieee80211_rate *txrate;
1367 u64 ts;
1368
1369 mgmt = (struct ieee80211_mgmt *)skb->data;
1370 txrate = ieee80211_get_tx_rate(hw, txi);
1371 ts = mac80211_hwsim_get_tsf_raw();
1372 mgmt->u.probe_resp.timestamp =
1373 cpu_to_le64(ts + data->tsf_offset +
1374 24 * 8 * 10 / txrate->bitrate);
1375 }
1376
1377 mac80211_hwsim_monitor_rx(hw, skb, channel);
1378
1379
1380 _portid = ACCESS_ONCE(data->wmediumd);
1381
1382 if (_portid)
1383 return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
1384
1385
1386 data->tx_pkts++;
1387 data->tx_bytes += skb->len;
1388 ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
1389
1390 if (ack && skb->len >= 16)
1391 mac80211_hwsim_monitor_ack(channel, hdr->addr2);
1392
1393 ieee80211_tx_info_clear_status(txi);
1394
1395
1396 txi->control.rates[0].count = 1;
1397 txi->control.rates[1].idx = -1;
1398
1399 if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
1400 txi->flags |= IEEE80211_TX_STAT_ACK;
1401 ieee80211_tx_status_irqsafe(hw, skb);
1402}
1403
1404
1405static int mac80211_hwsim_start(struct ieee80211_hw *hw)
1406{
1407 struct mac80211_hwsim_data *data = hw->priv;
1408 wiphy_debug(hw->wiphy, "%s\n", __func__);
1409 data->started = true;
1410 return 0;
1411}
1412
1413
1414static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
1415{
1416 struct mac80211_hwsim_data *data = hw->priv;
1417 data->started = false;
1418 tasklet_hrtimer_cancel(&data->beacon_timer);
1419 wiphy_debug(hw->wiphy, "%s\n", __func__);
1420}
1421
1422
1423static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1424 struct ieee80211_vif *vif)
1425{
1426 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1427 __func__, ieee80211_vif_type_p2p(vif),
1428 vif->addr);
1429 hwsim_set_magic(vif);
1430
1431 vif->cab_queue = 0;
1432 vif->hw_queue[IEEE80211_AC_VO] = 0;
1433 vif->hw_queue[IEEE80211_AC_VI] = 1;
1434 vif->hw_queue[IEEE80211_AC_BE] = 2;
1435 vif->hw_queue[IEEE80211_AC_BK] = 3;
1436
1437 return 0;
1438}
1439
1440
1441static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
1442 struct ieee80211_vif *vif,
1443 enum nl80211_iftype newtype,
1444 bool newp2p)
1445{
1446 newtype = ieee80211_iftype_p2p(newtype, newp2p);
1447 wiphy_debug(hw->wiphy,
1448 "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
1449 __func__, ieee80211_vif_type_p2p(vif),
1450 newtype, vif->addr);
1451 hwsim_check_magic(vif);
1452
1453
1454
1455
1456
1457 vif->cab_queue = 0;
1458
1459 return 0;
1460}
1461
1462static void mac80211_hwsim_remove_interface(
1463 struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1464{
1465 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1466 __func__, ieee80211_vif_type_p2p(vif),
1467 vif->addr);
1468 hwsim_check_magic(vif);
1469 hwsim_clear_magic(vif);
1470}
1471
1472static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
1473 struct sk_buff *skb,
1474 struct ieee80211_channel *chan)
1475{
1476 struct mac80211_hwsim_data *data = hw->priv;
1477 u32 _pid = ACCESS_ONCE(data->wmediumd);
1478
1479 if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE)) {
1480 struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
1481 ieee80211_get_tx_rates(txi->control.vif, NULL, skb,
1482 txi->control.rates,
1483 ARRAY_SIZE(txi->control.rates));
1484 }
1485
1486 mac80211_hwsim_monitor_rx(hw, skb, chan);
1487
1488 if (_pid)
1489 return mac80211_hwsim_tx_frame_nl(hw, skb, _pid);
1490
1491 mac80211_hwsim_tx_frame_no_nl(hw, skb, chan);
1492 dev_kfree_skb(skb);
1493}
1494
1495static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
1496 struct ieee80211_vif *vif)
1497{
1498 struct mac80211_hwsim_data *data = arg;
1499 struct ieee80211_hw *hw = data->hw;
1500 struct ieee80211_tx_info *info;
1501 struct ieee80211_rate *txrate;
1502 struct ieee80211_mgmt *mgmt;
1503 struct sk_buff *skb;
1504
1505 hwsim_check_magic(vif);
1506
1507 if (vif->type != NL80211_IFTYPE_AP &&
1508 vif->type != NL80211_IFTYPE_MESH_POINT &&
1509 vif->type != NL80211_IFTYPE_ADHOC)
1510 return;
1511
1512 skb = ieee80211_beacon_get(hw, vif);
1513 if (skb == NULL)
1514 return;
1515 info = IEEE80211_SKB_CB(skb);
1516 if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1517 ieee80211_get_tx_rates(vif, NULL, skb,
1518 info->control.rates,
1519 ARRAY_SIZE(info->control.rates));
1520
1521 txrate = ieee80211_get_tx_rate(hw, info);
1522
1523 mgmt = (struct ieee80211_mgmt *) skb->data;
1524
1525 data->abs_bcn_ts = mac80211_hwsim_get_tsf_raw();
1526 mgmt->u.beacon.timestamp = cpu_to_le64(data->abs_bcn_ts +
1527 data->tsf_offset +
1528 24 * 8 * 10 / txrate->bitrate);
1529
1530 mac80211_hwsim_tx_frame(hw, skb,
1531 rcu_dereference(vif->chanctx_conf)->def.chan);
1532
1533 if (vif->csa_active && ieee80211_csa_is_complete(vif))
1534 ieee80211_csa_finish(vif);
1535}
1536
1537static enum hrtimer_restart
1538mac80211_hwsim_beacon(struct hrtimer *timer)
1539{
1540 struct mac80211_hwsim_data *data =
1541 container_of(timer, struct mac80211_hwsim_data,
1542 beacon_timer.timer);
1543 struct ieee80211_hw *hw = data->hw;
1544 u64 bcn_int = data->beacon_int;
1545 ktime_t next_bcn;
1546
1547 if (!data->started)
1548 goto out;
1549
1550 ieee80211_iterate_active_interfaces_atomic(
1551 hw, IEEE80211_IFACE_ITER_NORMAL,
1552 mac80211_hwsim_beacon_tx, data);
1553
1554
1555 if (data->bcn_delta) {
1556 bcn_int -= data->bcn_delta;
1557 data->bcn_delta = 0;
1558 }
1559
1560 next_bcn = ktime_add(hrtimer_get_expires(timer),
1561 ns_to_ktime(bcn_int * 1000));
1562 tasklet_hrtimer_start(&data->beacon_timer, next_bcn, HRTIMER_MODE_ABS);
1563out:
1564 return HRTIMER_NORESTART;
1565}
1566
1567static const char * const hwsim_chanwidths[] = {
1568 [NL80211_CHAN_WIDTH_20_NOHT] = "noht",
1569 [NL80211_CHAN_WIDTH_20] = "ht20",
1570 [NL80211_CHAN_WIDTH_40] = "ht40",
1571 [NL80211_CHAN_WIDTH_80] = "vht80",
1572 [NL80211_CHAN_WIDTH_80P80] = "vht80p80",
1573 [NL80211_CHAN_WIDTH_160] = "vht160",
1574};
1575
1576static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1577{
1578 struct mac80211_hwsim_data *data = hw->priv;
1579 struct ieee80211_conf *conf = &hw->conf;
1580 static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
1581 [IEEE80211_SMPS_AUTOMATIC] = "auto",
1582 [IEEE80211_SMPS_OFF] = "off",
1583 [IEEE80211_SMPS_STATIC] = "static",
1584 [IEEE80211_SMPS_DYNAMIC] = "dynamic",
1585 };
1586
1587 if (conf->chandef.chan)
1588 wiphy_debug(hw->wiphy,
1589 "%s (freq=%d(%d - %d)/%s idle=%d ps=%d smps=%s)\n",
1590 __func__,
1591 conf->chandef.chan->center_freq,
1592 conf->chandef.center_freq1,
1593 conf->chandef.center_freq2,
1594 hwsim_chanwidths[conf->chandef.width],
1595 !!(conf->flags & IEEE80211_CONF_IDLE),
1596 !!(conf->flags & IEEE80211_CONF_PS),
1597 smps_modes[conf->smps_mode]);
1598 else
1599 wiphy_debug(hw->wiphy,
1600 "%s (freq=0 idle=%d ps=%d smps=%s)\n",
1601 __func__,
1602 !!(conf->flags & IEEE80211_CONF_IDLE),
1603 !!(conf->flags & IEEE80211_CONF_PS),
1604 smps_modes[conf->smps_mode]);
1605
1606 data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1607
1608 data->channel = conf->chandef.chan;
1609
1610 WARN_ON(data->channel && data->use_chanctx);
1611
1612 data->power_level = conf->power_level;
1613 if (!data->started || !data->beacon_int)
1614 tasklet_hrtimer_cancel(&data->beacon_timer);
1615 else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
1616 u64 tsf = mac80211_hwsim_get_tsf(hw, NULL);
1617 u32 bcn_int = data->beacon_int;
1618 u64 until_tbtt = bcn_int - do_div(tsf, bcn_int);
1619
1620 tasklet_hrtimer_start(&data->beacon_timer,
1621 ns_to_ktime(until_tbtt * 1000),
1622 HRTIMER_MODE_REL);
1623 }
1624
1625 return 0;
1626}
1627
1628
1629static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
1630 unsigned int changed_flags,
1631 unsigned int *total_flags,u64 multicast)
1632{
1633 struct mac80211_hwsim_data *data = hw->priv;
1634
1635 wiphy_debug(hw->wiphy, "%s\n", __func__);
1636
1637 data->rx_filter = 0;
1638 if (*total_flags & FIF_ALLMULTI)
1639 data->rx_filter |= FIF_ALLMULTI;
1640
1641 *total_flags = data->rx_filter;
1642}
1643
1644static void mac80211_hwsim_bcn_en_iter(void *data, u8 *mac,
1645 struct ieee80211_vif *vif)
1646{
1647 unsigned int *count = data;
1648 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1649
1650 if (vp->bcn_en)
1651 (*count)++;
1652}
1653
1654static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
1655 struct ieee80211_vif *vif,
1656 struct ieee80211_bss_conf *info,
1657 u32 changed)
1658{
1659 struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1660 struct mac80211_hwsim_data *data = hw->priv;
1661
1662 hwsim_check_magic(vif);
1663
1664 wiphy_debug(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n",
1665 __func__, changed, vif->addr);
1666
1667 if (changed & BSS_CHANGED_BSSID) {
1668 wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n",
1669 __func__, info->bssid);
1670 memcpy(vp->bssid, info->bssid, ETH_ALEN);
1671 }
1672
1673 if (changed & BSS_CHANGED_ASSOC) {
1674 wiphy_debug(hw->wiphy, " ASSOC: assoc=%d aid=%d\n",
1675 info->assoc, info->aid);
1676 vp->assoc = info->assoc;
1677 vp->aid = info->aid;
1678 }
1679
1680 if (changed & BSS_CHANGED_BEACON_ENABLED) {
1681 wiphy_debug(hw->wiphy, " BCN EN: %d (BI=%u)\n",
1682 info->enable_beacon, info->beacon_int);
1683 vp->bcn_en = info->enable_beacon;
1684 if (data->started &&
1685 !hrtimer_is_queued(&data->beacon_timer.timer) &&
1686 info->enable_beacon) {
1687 u64 tsf, until_tbtt;
1688 u32 bcn_int;
1689 data->beacon_int = info->beacon_int * 1024;
1690 tsf = mac80211_hwsim_get_tsf(hw, vif);
1691 bcn_int = data->beacon_int;
1692 until_tbtt = bcn_int - do_div(tsf, bcn_int);
1693 tasklet_hrtimer_start(&data->beacon_timer,
1694 ns_to_ktime(until_tbtt * 1000),
1695 HRTIMER_MODE_REL);
1696 } else if (!info->enable_beacon) {
1697 unsigned int count = 0;
1698 ieee80211_iterate_active_interfaces_atomic(
1699 data->hw, IEEE80211_IFACE_ITER_NORMAL,
1700 mac80211_hwsim_bcn_en_iter, &count);
1701 wiphy_debug(hw->wiphy, " beaconing vifs remaining: %u",
1702 count);
1703 if (count == 0) {
1704 tasklet_hrtimer_cancel(&data->beacon_timer);
1705 data->beacon_int = 0;
1706 }
1707 }
1708 }
1709
1710 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1711 wiphy_debug(hw->wiphy, " ERP_CTS_PROT: %d\n",
1712 info->use_cts_prot);
1713 }
1714
1715 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1716 wiphy_debug(hw->wiphy, " ERP_PREAMBLE: %d\n",
1717 info->use_short_preamble);
1718 }
1719
1720 if (changed & BSS_CHANGED_ERP_SLOT) {
1721 wiphy_debug(hw->wiphy, " ERP_SLOT: %d\n", info->use_short_slot);
1722 }
1723
1724 if (changed & BSS_CHANGED_HT) {
1725 wiphy_debug(hw->wiphy, " HT: op_mode=0x%x\n",
1726 info->ht_operation_mode);
1727 }
1728
1729 if (changed & BSS_CHANGED_BASIC_RATES) {
1730 wiphy_debug(hw->wiphy, " BASIC_RATES: 0x%llx\n",
1731 (unsigned long long) info->basic_rates);
1732 }
1733
1734 if (changed & BSS_CHANGED_TXPOWER)
1735 wiphy_debug(hw->wiphy, " TX Power: %d dBm\n", info->txpower);
1736}
1737
1738static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw,
1739 struct ieee80211_vif *vif,
1740 struct ieee80211_sta *sta)
1741{
1742 hwsim_check_magic(vif);
1743 hwsim_set_sta_magic(sta);
1744
1745 return 0;
1746}
1747
1748static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw,
1749 struct ieee80211_vif *vif,
1750 struct ieee80211_sta *sta)
1751{
1752 hwsim_check_magic(vif);
1753 hwsim_clear_sta_magic(sta);
1754
1755 return 0;
1756}
1757
1758static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
1759 struct ieee80211_vif *vif,
1760 enum sta_notify_cmd cmd,
1761 struct ieee80211_sta *sta)
1762{
1763 hwsim_check_magic(vif);
1764
1765 switch (cmd) {
1766 case STA_NOTIFY_SLEEP:
1767 case STA_NOTIFY_AWAKE:
1768
1769 break;
1770 default:
1771 WARN(1, "Invalid sta notify: %d\n", cmd);
1772 break;
1773 }
1774}
1775
1776static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw,
1777 struct ieee80211_sta *sta,
1778 bool set)
1779{
1780 hwsim_check_sta_magic(sta);
1781 return 0;
1782}
1783
1784static int mac80211_hwsim_conf_tx(
1785 struct ieee80211_hw *hw,
1786 struct ieee80211_vif *vif, u16 queue,
1787 const struct ieee80211_tx_queue_params *params)
1788{
1789 wiphy_debug(hw->wiphy,
1790 "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n",
1791 __func__, queue,
1792 params->txop, params->cw_min,
1793 params->cw_max, params->aifs);
1794 return 0;
1795}
1796
1797static int mac80211_hwsim_get_survey(
1798 struct ieee80211_hw *hw, int idx,
1799 struct survey_info *survey)
1800{
1801 struct ieee80211_conf *conf = &hw->conf;
1802
1803 wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx);
1804
1805 if (idx != 0)
1806 return -ENOENT;
1807
1808
1809 survey->channel = conf->chandef.chan;
1810
1811
1812
1813
1814
1815
1816
1817 survey->filled = SURVEY_INFO_NOISE_DBM;
1818 survey->noise = -92;
1819
1820 return 0;
1821}
1822
1823#ifdef CONFIG_NL80211_TESTMODE
1824
1825
1826
1827
1828
1829
1830enum hwsim_testmode_attr {
1831 __HWSIM_TM_ATTR_INVALID = 0,
1832 HWSIM_TM_ATTR_CMD = 1,
1833 HWSIM_TM_ATTR_PS = 2,
1834
1835
1836 __HWSIM_TM_ATTR_AFTER_LAST,
1837 HWSIM_TM_ATTR_MAX = __HWSIM_TM_ATTR_AFTER_LAST - 1
1838};
1839
1840enum hwsim_testmode_cmd {
1841 HWSIM_TM_CMD_SET_PS = 0,
1842 HWSIM_TM_CMD_GET_PS = 1,
1843 HWSIM_TM_CMD_STOP_QUEUES = 2,
1844 HWSIM_TM_CMD_WAKE_QUEUES = 3,
1845};
1846
1847static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = {
1848 [HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 },
1849 [HWSIM_TM_ATTR_PS] = { .type = NLA_U32 },
1850};
1851
1852static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1853 struct ieee80211_vif *vif,
1854 void *data, int len)
1855{
1856 struct mac80211_hwsim_data *hwsim = hw->priv;
1857 struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1];
1858 struct sk_buff *skb;
1859 int err, ps;
1860
1861 err = nla_parse(tb, HWSIM_TM_ATTR_MAX, data, len,
1862 hwsim_testmode_policy);
1863 if (err)
1864 return err;
1865
1866 if (!tb[HWSIM_TM_ATTR_CMD])
1867 return -EINVAL;
1868
1869 switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) {
1870 case HWSIM_TM_CMD_SET_PS:
1871 if (!tb[HWSIM_TM_ATTR_PS])
1872 return -EINVAL;
1873 ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]);
1874 return hwsim_fops_ps_write(hwsim, ps);
1875 case HWSIM_TM_CMD_GET_PS:
1876 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
1877 nla_total_size(sizeof(u32)));
1878 if (!skb)
1879 return -ENOMEM;
1880 if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
1881 goto nla_put_failure;
1882 return cfg80211_testmode_reply(skb);
1883 case HWSIM_TM_CMD_STOP_QUEUES:
1884 ieee80211_stop_queues(hw);
1885 return 0;
1886 case HWSIM_TM_CMD_WAKE_QUEUES:
1887 ieee80211_wake_queues(hw);
1888 return 0;
1889 default:
1890 return -EOPNOTSUPP;
1891 }
1892
1893 nla_put_failure:
1894 kfree_skb(skb);
1895 return -ENOBUFS;
1896}
1897#endif
1898
1899static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
1900 struct ieee80211_vif *vif,
1901 struct ieee80211_ampdu_params *params)
1902{
1903 struct ieee80211_sta *sta = params->sta;
1904 enum ieee80211_ampdu_mlme_action action = params->action;
1905 u16 tid = params->tid;
1906
1907 switch (action) {
1908 case IEEE80211_AMPDU_TX_START:
1909 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1910 break;
1911 case IEEE80211_AMPDU_TX_STOP_CONT:
1912 case IEEE80211_AMPDU_TX_STOP_FLUSH:
1913 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1914 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1915 break;
1916 case IEEE80211_AMPDU_TX_OPERATIONAL:
1917 break;
1918 case IEEE80211_AMPDU_RX_START:
1919 case IEEE80211_AMPDU_RX_STOP:
1920 break;
1921 default:
1922 return -EOPNOTSUPP;
1923 }
1924
1925 return 0;
1926}
1927
1928static void mac80211_hwsim_flush(struct ieee80211_hw *hw,
1929 struct ieee80211_vif *vif,
1930 u32 queues, bool drop)
1931{
1932
1933}
1934
1935static void hw_scan_work(struct work_struct *work)
1936{
1937 struct mac80211_hwsim_data *hwsim =
1938 container_of(work, struct mac80211_hwsim_data, hw_scan.work);
1939 struct cfg80211_scan_request *req = hwsim->hw_scan_request;
1940 int dwell, i;
1941
1942 mutex_lock(&hwsim->mutex);
1943 if (hwsim->scan_chan_idx >= req->n_channels) {
1944 struct cfg80211_scan_info info = {
1945 .aborted = false,
1946 };
1947
1948 wiphy_debug(hwsim->hw->wiphy, "hw scan complete\n");
1949 ieee80211_scan_completed(hwsim->hw, &info);
1950 hwsim->hw_scan_request = NULL;
1951 hwsim->hw_scan_vif = NULL;
1952 hwsim->tmp_chan = NULL;
1953 mutex_unlock(&hwsim->mutex);
1954 return;
1955 }
1956
1957 wiphy_debug(hwsim->hw->wiphy, "hw scan %d MHz\n",
1958 req->channels[hwsim->scan_chan_idx]->center_freq);
1959
1960 hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx];
1961 if (hwsim->tmp_chan->flags & (IEEE80211_CHAN_NO_IR |
1962 IEEE80211_CHAN_RADAR) ||
1963 !req->n_ssids) {
1964 dwell = 120;
1965 } else {
1966 dwell = 30;
1967
1968 for (i = 0; i < req->n_ssids; i++) {
1969 struct sk_buff *probe;
1970 struct ieee80211_mgmt *mgmt;
1971
1972 probe = ieee80211_probereq_get(hwsim->hw,
1973 hwsim->scan_addr,
1974 req->ssids[i].ssid,
1975 req->ssids[i].ssid_len,
1976 req->ie_len);
1977 if (!probe)
1978 continue;
1979
1980 mgmt = (struct ieee80211_mgmt *) probe->data;
1981 memcpy(mgmt->da, req->bssid, ETH_ALEN);
1982 memcpy(mgmt->bssid, req->bssid, ETH_ALEN);
1983
1984 if (req->ie_len)
1985 memcpy(skb_put(probe, req->ie_len), req->ie,
1986 req->ie_len);
1987
1988 local_bh_disable();
1989 mac80211_hwsim_tx_frame(hwsim->hw, probe,
1990 hwsim->tmp_chan);
1991 local_bh_enable();
1992 }
1993 }
1994 ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan,
1995 msecs_to_jiffies(dwell));
1996 hwsim->scan_chan_idx++;
1997 mutex_unlock(&hwsim->mutex);
1998}
1999
2000static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
2001 struct ieee80211_vif *vif,
2002 struct ieee80211_scan_request *hw_req)
2003{
2004 struct mac80211_hwsim_data *hwsim = hw->priv;
2005 struct cfg80211_scan_request *req = &hw_req->req;
2006
2007 mutex_lock(&hwsim->mutex);
2008 if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
2009 mutex_unlock(&hwsim->mutex);
2010 return -EBUSY;
2011 }
2012 hwsim->hw_scan_request = req;
2013 hwsim->hw_scan_vif = vif;
2014 hwsim->scan_chan_idx = 0;
2015 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)
2016 get_random_mask_addr(hwsim->scan_addr,
2017 hw_req->req.mac_addr,
2018 hw_req->req.mac_addr_mask);
2019 else
2020 memcpy(hwsim->scan_addr, vif->addr, ETH_ALEN);
2021 mutex_unlock(&hwsim->mutex);
2022
2023 wiphy_debug(hw->wiphy, "hwsim hw_scan request\n");
2024
2025 ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
2026
2027 return 0;
2028}
2029
2030static void mac80211_hwsim_cancel_hw_scan(struct ieee80211_hw *hw,
2031 struct ieee80211_vif *vif)
2032{
2033 struct mac80211_hwsim_data *hwsim = hw->priv;
2034 struct cfg80211_scan_info info = {
2035 .aborted = true,
2036 };
2037
2038 wiphy_debug(hw->wiphy, "hwsim cancel_hw_scan\n");
2039
2040 cancel_delayed_work_sync(&hwsim->hw_scan);
2041
2042 mutex_lock(&hwsim->mutex);
2043 ieee80211_scan_completed(hwsim->hw, &info);
2044 hwsim->tmp_chan = NULL;
2045 hwsim->hw_scan_request = NULL;
2046 hwsim->hw_scan_vif = NULL;
2047 mutex_unlock(&hwsim->mutex);
2048}
2049
2050static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw,
2051 struct ieee80211_vif *vif,
2052 const u8 *mac_addr)
2053{
2054 struct mac80211_hwsim_data *hwsim = hw->priv;
2055
2056 mutex_lock(&hwsim->mutex);
2057
2058 if (hwsim->scanning) {
2059 printk(KERN_DEBUG "two hwsim sw_scans detected!\n");
2060 goto out;
2061 }
2062
2063 printk(KERN_DEBUG "hwsim sw_scan request, prepping stuff\n");
2064
2065 memcpy(hwsim->scan_addr, mac_addr, ETH_ALEN);
2066 hwsim->scanning = true;
2067
2068out:
2069 mutex_unlock(&hwsim->mutex);
2070}
2071
2072static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw,
2073 struct ieee80211_vif *vif)
2074{
2075 struct mac80211_hwsim_data *hwsim = hw->priv;
2076
2077 mutex_lock(&hwsim->mutex);
2078
2079 printk(KERN_DEBUG "hwsim sw_scan_complete\n");
2080 hwsim->scanning = false;
2081 eth_zero_addr(hwsim->scan_addr);
2082
2083 mutex_unlock(&hwsim->mutex);
2084}
2085
2086static void hw_roc_start(struct work_struct *work)
2087{
2088 struct mac80211_hwsim_data *hwsim =
2089 container_of(work, struct mac80211_hwsim_data, roc_start.work);
2090
2091 mutex_lock(&hwsim->mutex);
2092
2093 wiphy_debug(hwsim->hw->wiphy, "hwsim ROC begins\n");
2094 hwsim->tmp_chan = hwsim->roc_chan;
2095 ieee80211_ready_on_channel(hwsim->hw);
2096
2097 ieee80211_queue_delayed_work(hwsim->hw, &hwsim->roc_done,
2098 msecs_to_jiffies(hwsim->roc_duration));
2099
2100 mutex_unlock(&hwsim->mutex);
2101}
2102
2103static void hw_roc_done(struct work_struct *work)
2104{
2105 struct mac80211_hwsim_data *hwsim =
2106 container_of(work, struct mac80211_hwsim_data, roc_done.work);
2107
2108 mutex_lock(&hwsim->mutex);
2109 ieee80211_remain_on_channel_expired(hwsim->hw);
2110 hwsim->tmp_chan = NULL;
2111 mutex_unlock(&hwsim->mutex);
2112
2113 wiphy_debug(hwsim->hw->wiphy, "hwsim ROC expired\n");
2114}
2115
2116static int mac80211_hwsim_roc(struct ieee80211_hw *hw,
2117 struct ieee80211_vif *vif,
2118 struct ieee80211_channel *chan,
2119 int duration,
2120 enum ieee80211_roc_type type)
2121{
2122 struct mac80211_hwsim_data *hwsim = hw->priv;
2123
2124 mutex_lock(&hwsim->mutex);
2125 if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
2126 mutex_unlock(&hwsim->mutex);
2127 return -EBUSY;
2128 }
2129
2130 hwsim->roc_chan = chan;
2131 hwsim->roc_duration = duration;
2132 mutex_unlock(&hwsim->mutex);
2133
2134 wiphy_debug(hw->wiphy, "hwsim ROC (%d MHz, %d ms)\n",
2135 chan->center_freq, duration);
2136 ieee80211_queue_delayed_work(hw, &hwsim->roc_start, HZ/50);
2137
2138 return 0;
2139}
2140
2141static int mac80211_hwsim_croc(struct ieee80211_hw *hw)
2142{
2143 struct mac80211_hwsim_data *hwsim = hw->priv;
2144
2145 cancel_delayed_work_sync(&hwsim->roc_start);
2146 cancel_delayed_work_sync(&hwsim->roc_done);
2147
2148 mutex_lock(&hwsim->mutex);
2149 hwsim->tmp_chan = NULL;
2150 mutex_unlock(&hwsim->mutex);
2151
2152 wiphy_debug(hw->wiphy, "hwsim ROC canceled\n");
2153
2154 return 0;
2155}
2156
2157static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw,
2158 struct ieee80211_chanctx_conf *ctx)
2159{
2160 hwsim_set_chanctx_magic(ctx);
2161 wiphy_debug(hw->wiphy,
2162 "add channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
2163 ctx->def.chan->center_freq, ctx->def.width,
2164 ctx->def.center_freq1, ctx->def.center_freq2);
2165 return 0;
2166}
2167
2168static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
2169 struct ieee80211_chanctx_conf *ctx)
2170{
2171 wiphy_debug(hw->wiphy,
2172 "remove channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
2173 ctx->def.chan->center_freq, ctx->def.width,
2174 ctx->def.center_freq1, ctx->def.center_freq2);
2175 hwsim_check_chanctx_magic(ctx);
2176 hwsim_clear_chanctx_magic(ctx);
2177}
2178
2179static void mac80211_hwsim_change_chanctx(struct ieee80211_hw *hw,
2180 struct ieee80211_chanctx_conf *ctx,
2181 u32 changed)
2182{
2183 hwsim_check_chanctx_magic(ctx);
2184 wiphy_debug(hw->wiphy,
2185 "change channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
2186 ctx->def.chan->center_freq, ctx->def.width,
2187 ctx->def.center_freq1, ctx->def.center_freq2);
2188}
2189
2190static int mac80211_hwsim_assign_vif_chanctx(struct ieee80211_hw *hw,
2191 struct ieee80211_vif *vif,
2192 struct ieee80211_chanctx_conf *ctx)
2193{
2194 hwsim_check_magic(vif);
2195 hwsim_check_chanctx_magic(ctx);
2196
2197 return 0;
2198}
2199
2200static void mac80211_hwsim_unassign_vif_chanctx(struct ieee80211_hw *hw,
2201 struct ieee80211_vif *vif,
2202 struct ieee80211_chanctx_conf *ctx)
2203{
2204 hwsim_check_magic(vif);
2205 hwsim_check_chanctx_magic(ctx);
2206}
2207
2208static const char mac80211_hwsim_gstrings_stats[][ETH_GSTRING_LEN] = {
2209 "tx_pkts_nic",
2210 "tx_bytes_nic",
2211 "rx_pkts_nic",
2212 "rx_bytes_nic",
2213 "d_tx_dropped",
2214 "d_tx_failed",
2215 "d_ps_mode",
2216 "d_group",
2217 "d_tx_power",
2218};
2219
2220#define MAC80211_HWSIM_SSTATS_LEN ARRAY_SIZE(mac80211_hwsim_gstrings_stats)
2221
2222static void mac80211_hwsim_get_et_strings(struct ieee80211_hw *hw,
2223 struct ieee80211_vif *vif,
2224 u32 sset, u8 *data)
2225{
2226 if (sset == ETH_SS_STATS)
2227 memcpy(data, *mac80211_hwsim_gstrings_stats,
2228 sizeof(mac80211_hwsim_gstrings_stats));
2229}
2230
2231static int mac80211_hwsim_get_et_sset_count(struct ieee80211_hw *hw,
2232 struct ieee80211_vif *vif, int sset)
2233{
2234 if (sset == ETH_SS_STATS)
2235 return MAC80211_HWSIM_SSTATS_LEN;
2236 return 0;
2237}
2238
2239static void mac80211_hwsim_get_et_stats(struct ieee80211_hw *hw,
2240 struct ieee80211_vif *vif,
2241 struct ethtool_stats *stats, u64 *data)
2242{
2243 struct mac80211_hwsim_data *ar = hw->priv;
2244 int i = 0;
2245
2246 data[i++] = ar->tx_pkts;
2247 data[i++] = ar->tx_bytes;
2248 data[i++] = ar->rx_pkts;
2249 data[i++] = ar->rx_bytes;
2250 data[i++] = ar->tx_dropped;
2251 data[i++] = ar->tx_failed;
2252 data[i++] = ar->ps;
2253 data[i++] = ar->group;
2254 data[i++] = ar->power_level;
2255
2256 WARN_ON(i != MAC80211_HWSIM_SSTATS_LEN);
2257}
2258
2259static const struct ieee80211_ops mac80211_hwsim_ops = {
2260 .tx = mac80211_hwsim_tx,
2261 .start = mac80211_hwsim_start,
2262 .stop = mac80211_hwsim_stop,
2263 .add_interface = mac80211_hwsim_add_interface,
2264 .change_interface = mac80211_hwsim_change_interface,
2265 .remove_interface = mac80211_hwsim_remove_interface,
2266 .config = mac80211_hwsim_config,
2267 .configure_filter = mac80211_hwsim_configure_filter,
2268 .bss_info_changed = mac80211_hwsim_bss_info_changed,
2269 .sta_add = mac80211_hwsim_sta_add,
2270 .sta_remove = mac80211_hwsim_sta_remove,
2271 .sta_notify = mac80211_hwsim_sta_notify,
2272 .set_tim = mac80211_hwsim_set_tim,
2273 .conf_tx = mac80211_hwsim_conf_tx,
2274 .get_survey = mac80211_hwsim_get_survey,
2275 CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)
2276 .ampdu_action = mac80211_hwsim_ampdu_action,
2277 .sw_scan_start = mac80211_hwsim_sw_scan,
2278 .sw_scan_complete = mac80211_hwsim_sw_scan_complete,
2279 .flush = mac80211_hwsim_flush,
2280 .get_tsf = mac80211_hwsim_get_tsf,
2281 .set_tsf = mac80211_hwsim_set_tsf,
2282 .get_et_sset_count = mac80211_hwsim_get_et_sset_count,
2283 .get_et_stats = mac80211_hwsim_get_et_stats,
2284 .get_et_strings = mac80211_hwsim_get_et_strings,
2285};
2286
2287static struct ieee80211_ops mac80211_hwsim_mchan_ops;
2288
2289struct hwsim_new_radio_params {
2290 unsigned int channels;
2291 const char *reg_alpha2;
2292 const struct ieee80211_regdomain *regd;
2293 bool reg_strict;
2294 bool p2p_device;
2295 bool use_chanctx;
2296 bool destroy_on_close;
2297 const char *hwname;
2298 bool no_vif;
2299};
2300
2301static void hwsim_mcast_config_msg(struct sk_buff *mcast_skb,
2302 struct genl_info *info)
2303{
2304 if (info)
2305 genl_notify(&hwsim_genl_family, mcast_skb, info,
2306 HWSIM_MCGRP_CONFIG, GFP_KERNEL);
2307 else
2308 genlmsg_multicast(&hwsim_genl_family, mcast_skb, 0,
2309 HWSIM_MCGRP_CONFIG, GFP_KERNEL);
2310}
2311
2312static int append_radio_msg(struct sk_buff *skb, int id,
2313 struct hwsim_new_radio_params *param)
2314{
2315 int ret;
2316
2317 ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
2318 if (ret < 0)
2319 return ret;
2320
2321 if (param->channels) {
2322 ret = nla_put_u32(skb, HWSIM_ATTR_CHANNELS, param->channels);
2323 if (ret < 0)
2324 return ret;
2325 }
2326
2327 if (param->reg_alpha2) {
2328 ret = nla_put(skb, HWSIM_ATTR_REG_HINT_ALPHA2, 2,
2329 param->reg_alpha2);
2330 if (ret < 0)
2331 return ret;
2332 }
2333
2334 if (param->regd) {
2335 int i;
2336
2337 for (i = 0; i < ARRAY_SIZE(hwsim_world_regdom_custom); i++) {
2338 if (hwsim_world_regdom_custom[i] != param->regd)
2339 continue;
2340
2341 ret = nla_put_u32(skb, HWSIM_ATTR_REG_CUSTOM_REG, i);
2342 if (ret < 0)
2343 return ret;
2344 break;
2345 }
2346 }
2347
2348 if (param->reg_strict) {
2349 ret = nla_put_flag(skb, HWSIM_ATTR_REG_STRICT_REG);
2350 if (ret < 0)
2351 return ret;
2352 }
2353
2354 if (param->p2p_device) {
2355 ret = nla_put_flag(skb, HWSIM_ATTR_SUPPORT_P2P_DEVICE);
2356 if (ret < 0)
2357 return ret;
2358 }
2359
2360 if (param->use_chanctx) {
2361 ret = nla_put_flag(skb, HWSIM_ATTR_USE_CHANCTX);
2362 if (ret < 0)
2363 return ret;
2364 }
2365
2366 if (param->hwname) {
2367 ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME,
2368 strlen(param->hwname), param->hwname);
2369 if (ret < 0)
2370 return ret;
2371 }
2372
2373 return 0;
2374}
2375
2376static void hwsim_mcast_new_radio(int id, struct genl_info *info,
2377 struct hwsim_new_radio_params *param)
2378{
2379 struct sk_buff *mcast_skb;
2380 void *data;
2381
2382 mcast_skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2383 if (!mcast_skb)
2384 return;
2385
2386 data = genlmsg_put(mcast_skb, 0, 0, &hwsim_genl_family, 0,
2387 HWSIM_CMD_NEW_RADIO);
2388 if (!data)
2389 goto out_err;
2390
2391 if (append_radio_msg(mcast_skb, id, param) < 0)
2392 goto out_err;
2393
2394 genlmsg_end(mcast_skb, data);
2395
2396 hwsim_mcast_config_msg(mcast_skb, info);
2397 return;
2398
2399out_err:
2400 genlmsg_cancel(mcast_skb, data);
2401 nlmsg_free(mcast_skb);
2402}
2403
2404static int mac80211_hwsim_new_radio(struct genl_info *info,
2405 struct hwsim_new_radio_params *param)
2406{
2407 int err;
2408 u8 addr[ETH_ALEN];
2409 struct mac80211_hwsim_data *data;
2410 struct ieee80211_hw *hw;
2411 enum nl80211_band band;
2412 const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
2413 struct net *net;
2414 int idx;
2415
2416 if (WARN_ON(param->channels > 1 && !param->use_chanctx))
2417 return -EINVAL;
2418
2419 spin_lock_bh(&hwsim_radio_lock);
2420 idx = hwsim_radio_idx++;
2421 spin_unlock_bh(&hwsim_radio_lock);
2422
2423 if (param->use_chanctx)
2424 ops = &mac80211_hwsim_mchan_ops;
2425 hw = ieee80211_alloc_hw_nm(sizeof(*data), ops, param->hwname);
2426 if (!hw) {
2427 printk(KERN_DEBUG "mac80211_hwsim: ieee80211_alloc_hw failed\n");
2428 err = -ENOMEM;
2429 goto failed;
2430 }
2431
2432 if (info)
2433 net = genl_info_net(info);
2434 else
2435 net = &init_net;
2436 wiphy_net_set(hw->wiphy, net);
2437
2438 data = hw->priv;
2439 data->hw = hw;
2440
2441 data->dev = device_create(hwsim_class, NULL, 0, hw, "hwsim%d", idx);
2442 if (IS_ERR(data->dev)) {
2443 printk(KERN_DEBUG
2444 "mac80211_hwsim: device_create failed (%ld)\n",
2445 PTR_ERR(data->dev));
2446 err = -ENOMEM;
2447 goto failed_drvdata;
2448 }
2449 data->dev->driver = &mac80211_hwsim_driver.driver;
2450 err = device_bind_driver(data->dev);
2451 if (err != 0) {
2452 printk(KERN_DEBUG "mac80211_hwsim: device_bind_driver failed (%d)\n",
2453 err);
2454 goto failed_bind;
2455 }
2456
2457 skb_queue_head_init(&data->pending);
2458
2459 SET_IEEE80211_DEV(hw, data->dev);
2460 eth_zero_addr(addr);
2461 addr[0] = 0x02;
2462 addr[3] = idx >> 8;
2463 addr[4] = idx;
2464 memcpy(data->addresses[0].addr, addr, ETH_ALEN);
2465 memcpy(data->addresses[1].addr, addr, ETH_ALEN);
2466 data->addresses[1].addr[0] |= 0x40;
2467 hw->wiphy->n_addresses = 2;
2468 hw->wiphy->addresses = data->addresses;
2469
2470 data->channels = param->channels;
2471 data->use_chanctx = param->use_chanctx;
2472 data->idx = idx;
2473 data->destroy_on_close = param->destroy_on_close;
2474 if (info)
2475 data->portid = info->snd_portid;
2476
2477 if (data->use_chanctx) {
2478 hw->wiphy->max_scan_ssids = 255;
2479 hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
2480 hw->wiphy->max_remain_on_channel_duration = 1000;
2481 hw->wiphy->iface_combinations = &data->if_combination;
2482 if (param->p2p_device)
2483 data->if_combination = hwsim_if_comb_p2p_dev[0];
2484 else
2485 data->if_combination = hwsim_if_comb[0];
2486 hw->wiphy->n_iface_combinations = 1;
2487
2488 data->if_combination.radar_detect_widths = 0;
2489 data->if_combination.num_different_channels = data->channels;
2490 } else if (param->p2p_device) {
2491 hw->wiphy->iface_combinations = hwsim_if_comb_p2p_dev;
2492 hw->wiphy->n_iface_combinations =
2493 ARRAY_SIZE(hwsim_if_comb_p2p_dev);
2494 } else {
2495 hw->wiphy->iface_combinations = hwsim_if_comb;
2496 hw->wiphy->n_iface_combinations = ARRAY_SIZE(hwsim_if_comb);
2497 }
2498
2499 INIT_DELAYED_WORK(&data->roc_start, hw_roc_start);
2500 INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
2501 INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2502
2503 hw->queues = 5;
2504 hw->offchannel_tx_hw_queue = 4;
2505 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2506 BIT(NL80211_IFTYPE_AP) |
2507 BIT(NL80211_IFTYPE_P2P_CLIENT) |
2508 BIT(NL80211_IFTYPE_P2P_GO) |
2509 BIT(NL80211_IFTYPE_ADHOC) |
2510 BIT(NL80211_IFTYPE_MESH_POINT);
2511
2512 if (param->p2p_device)
2513 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_DEVICE);
2514
2515 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
2516 ieee80211_hw_set(hw, CHANCTX_STA_CSA);
2517 ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES);
2518 ieee80211_hw_set(hw, QUEUE_CONTROL);
2519 ieee80211_hw_set(hw, WANT_MONITOR_VIF);
2520 ieee80211_hw_set(hw, AMPDU_AGGREGATION);
2521 ieee80211_hw_set(hw, MFP_CAPABLE);
2522 ieee80211_hw_set(hw, SIGNAL_DBM);
2523 ieee80211_hw_set(hw, TDLS_WIDER_BW);
2524 if (rctbl)
2525 ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
2526
2527 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
2528 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
2529 WIPHY_FLAG_AP_UAPSD |
2530 WIPHY_FLAG_HAS_CHANNEL_SWITCH;
2531 hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR |
2532 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
2533 NL80211_FEATURE_STATIC_SMPS |
2534 NL80211_FEATURE_DYNAMIC_SMPS |
2535 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
2536 wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
2537
2538
2539 hw->vif_data_size = sizeof(struct hwsim_vif_priv);
2540 hw->sta_data_size = sizeof(struct hwsim_sta_priv);
2541 hw->chanctx_data_size = sizeof(struct hwsim_chanctx_priv);
2542
2543 memcpy(data->channels_2ghz, hwsim_channels_2ghz,
2544 sizeof(hwsim_channels_2ghz));
2545 memcpy(data->channels_5ghz, hwsim_channels_5ghz,
2546 sizeof(hwsim_channels_5ghz));
2547 memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
2548
2549 for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
2550 struct ieee80211_supported_band *sband = &data->bands[band];
2551 switch (band) {
2552 case NL80211_BAND_2GHZ:
2553 sband->channels = data->channels_2ghz;
2554 sband->n_channels = ARRAY_SIZE(hwsim_channels_2ghz);
2555 sband->bitrates = data->rates;
2556 sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
2557 break;
2558 case NL80211_BAND_5GHZ:
2559 sband->channels = data->channels_5ghz;
2560 sband->n_channels = ARRAY_SIZE(hwsim_channels_5ghz);
2561 sband->bitrates = data->rates + 4;
2562 sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4;
2563
2564 sband->vht_cap.vht_supported = true;
2565 sband->vht_cap.cap =
2566 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
2567 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ |
2568 IEEE80211_VHT_CAP_RXLDPC |
2569 IEEE80211_VHT_CAP_SHORT_GI_80 |
2570 IEEE80211_VHT_CAP_SHORT_GI_160 |
2571 IEEE80211_VHT_CAP_TXSTBC |
2572 IEEE80211_VHT_CAP_RXSTBC_1 |
2573 IEEE80211_VHT_CAP_RXSTBC_2 |
2574 IEEE80211_VHT_CAP_RXSTBC_3 |
2575 IEEE80211_VHT_CAP_RXSTBC_4 |
2576 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
2577 sband->vht_cap.vht_mcs.rx_mcs_map =
2578 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
2579 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
2580 IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
2581 IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 |
2582 IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 |
2583 IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 |
2584 IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 |
2585 IEEE80211_VHT_MCS_SUPPORT_0_9 << 14);
2586 sband->vht_cap.vht_mcs.tx_mcs_map =
2587 sband->vht_cap.vht_mcs.rx_mcs_map;
2588 break;
2589 default:
2590 continue;
2591 }
2592
2593 sband->ht_cap.ht_supported = true;
2594 sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
2595 IEEE80211_HT_CAP_GRN_FLD |
2596 IEEE80211_HT_CAP_SGI_20 |
2597 IEEE80211_HT_CAP_SGI_40 |
2598 IEEE80211_HT_CAP_DSSSCCK40;
2599 sband->ht_cap.ampdu_factor = 0x3;
2600 sband->ht_cap.ampdu_density = 0x6;
2601 memset(&sband->ht_cap.mcs, 0,
2602 sizeof(sband->ht_cap.mcs));
2603 sband->ht_cap.mcs.rx_mask[0] = 0xff;
2604 sband->ht_cap.mcs.rx_mask[1] = 0xff;
2605 sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
2606
2607 hw->wiphy->bands[band] = sband;
2608 }
2609
2610
2611 data->group = 1;
2612 mutex_init(&data->mutex);
2613
2614 data->netgroup = hwsim_net_get_netgroup(net);
2615
2616
2617 hw->max_rates = 4;
2618 hw->max_rate_tries = 11;
2619
2620 hw->wiphy->vendor_commands = mac80211_hwsim_vendor_commands;
2621 hw->wiphy->n_vendor_commands =
2622 ARRAY_SIZE(mac80211_hwsim_vendor_commands);
2623 hw->wiphy->vendor_events = mac80211_hwsim_vendor_events;
2624 hw->wiphy->n_vendor_events = ARRAY_SIZE(mac80211_hwsim_vendor_events);
2625
2626 if (param->reg_strict)
2627 hw->wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
2628 if (param->regd) {
2629 data->regd = param->regd;
2630 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2631 wiphy_apply_custom_regulatory(hw->wiphy, param->regd);
2632
2633 schedule_timeout_interruptible(1);
2634 }
2635
2636 if (param->no_vif)
2637 ieee80211_hw_set(hw, NO_AUTO_VIF);
2638
2639 err = ieee80211_register_hw(hw);
2640 if (err < 0) {
2641 printk(KERN_DEBUG "mac80211_hwsim: ieee80211_register_hw failed (%d)\n",
2642 err);
2643 goto failed_hw;
2644 }
2645
2646 wiphy_debug(hw->wiphy, "hwaddr %pM registered\n", hw->wiphy->perm_addr);
2647
2648 if (param->reg_alpha2) {
2649 data->alpha2[0] = param->reg_alpha2[0];
2650 data->alpha2[1] = param->reg_alpha2[1];
2651 regulatory_hint(hw->wiphy, param->reg_alpha2);
2652 }
2653
2654 data->debugfs = debugfs_create_dir("hwsim", hw->wiphy->debugfsdir);
2655 debugfs_create_file("ps", 0666, data->debugfs, data, &hwsim_fops_ps);
2656 debugfs_create_file("group", 0666, data->debugfs, data,
2657 &hwsim_fops_group);
2658 if (!data->use_chanctx)
2659 debugfs_create_file("dfs_simulate_radar", 0222,
2660 data->debugfs,
2661 data, &hwsim_simulate_radar);
2662
2663 tasklet_hrtimer_init(&data->beacon_timer,
2664 mac80211_hwsim_beacon,
2665 CLOCK_MONOTONIC_RAW, HRTIMER_MODE_ABS);
2666
2667 spin_lock_bh(&hwsim_radio_lock);
2668 list_add_tail(&data->list, &hwsim_radios);
2669 spin_unlock_bh(&hwsim_radio_lock);
2670
2671 if (idx > 0)
2672 hwsim_mcast_new_radio(idx, info, param);
2673
2674 return idx;
2675
2676failed_hw:
2677 device_release_driver(data->dev);
2678failed_bind:
2679 device_unregister(data->dev);
2680failed_drvdata:
2681 ieee80211_free_hw(hw);
2682failed:
2683 return err;
2684}
2685
2686static void hwsim_mcast_del_radio(int id, const char *hwname,
2687 struct genl_info *info)
2688{
2689 struct sk_buff *skb;
2690 void *data;
2691 int ret;
2692
2693 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2694 if (!skb)
2695 return;
2696
2697 data = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
2698 HWSIM_CMD_DEL_RADIO);
2699 if (!data)
2700 goto error;
2701
2702 ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
2703 if (ret < 0)
2704 goto error;
2705
2706 ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME, strlen(hwname),
2707 hwname);
2708 if (ret < 0)
2709 goto error;
2710
2711 genlmsg_end(skb, data);
2712
2713 hwsim_mcast_config_msg(skb, info);
2714
2715 return;
2716
2717error:
2718 nlmsg_free(skb);
2719}
2720
2721static void mac80211_hwsim_del_radio(struct mac80211_hwsim_data *data,
2722 const char *hwname,
2723 struct genl_info *info)
2724{
2725 hwsim_mcast_del_radio(data->idx, hwname, info);
2726 debugfs_remove_recursive(data->debugfs);
2727 ieee80211_unregister_hw(data->hw);
2728 device_release_driver(data->dev);
2729 device_unregister(data->dev);
2730 ieee80211_free_hw(data->hw);
2731}
2732
2733static int mac80211_hwsim_get_radio(struct sk_buff *skb,
2734 struct mac80211_hwsim_data *data,
2735 u32 portid, u32 seq,
2736 struct netlink_callback *cb, int flags)
2737{
2738 void *hdr;
2739 struct hwsim_new_radio_params param = { };
2740 int res = -EMSGSIZE;
2741
2742 hdr = genlmsg_put(skb, portid, seq, &hwsim_genl_family, flags,
2743 HWSIM_CMD_GET_RADIO);
2744 if (!hdr)
2745 return -EMSGSIZE;
2746
2747 if (cb)
2748 genl_dump_check_consistent(cb, hdr, &hwsim_genl_family);
2749
2750 if (data->alpha2[0] && data->alpha2[1])
2751 param.reg_alpha2 = data->alpha2;
2752
2753 param.reg_strict = !!(data->hw->wiphy->regulatory_flags &
2754 REGULATORY_STRICT_REG);
2755 param.p2p_device = !!(data->hw->wiphy->interface_modes &
2756 BIT(NL80211_IFTYPE_P2P_DEVICE));
2757 param.use_chanctx = data->use_chanctx;
2758 param.regd = data->regd;
2759 param.channels = data->channels;
2760 param.hwname = wiphy_name(data->hw->wiphy);
2761
2762 res = append_radio_msg(skb, data->idx, ¶m);
2763 if (res < 0)
2764 goto out_err;
2765
2766 genlmsg_end(skb, hdr);
2767 return 0;
2768
2769out_err:
2770 genlmsg_cancel(skb, hdr);
2771 return res;
2772}
2773
2774static void mac80211_hwsim_free(void)
2775{
2776 struct mac80211_hwsim_data *data;
2777
2778 spin_lock_bh(&hwsim_radio_lock);
2779 while ((data = list_first_entry_or_null(&hwsim_radios,
2780 struct mac80211_hwsim_data,
2781 list))) {
2782 list_del(&data->list);
2783 spin_unlock_bh(&hwsim_radio_lock);
2784 mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
2785 NULL);
2786 spin_lock_bh(&hwsim_radio_lock);
2787 }
2788 spin_unlock_bh(&hwsim_radio_lock);
2789 class_destroy(hwsim_class);
2790}
2791
2792static const struct net_device_ops hwsim_netdev_ops = {
2793 .ndo_start_xmit = hwsim_mon_xmit,
2794 .ndo_change_mtu = eth_change_mtu,
2795 .ndo_set_mac_address = eth_mac_addr,
2796 .ndo_validate_addr = eth_validate_addr,
2797};
2798
2799static void hwsim_mon_setup(struct net_device *dev)
2800{
2801 dev->netdev_ops = &hwsim_netdev_ops;
2802 dev->destructor = free_netdev;
2803 ether_setup(dev);
2804 dev->priv_flags |= IFF_NO_QUEUE;
2805 dev->type = ARPHRD_IEEE80211_RADIOTAP;
2806 eth_zero_addr(dev->dev_addr);
2807 dev->dev_addr[0] = 0x12;
2808}
2809
2810static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr)
2811{
2812 struct mac80211_hwsim_data *data;
2813 bool _found = false;
2814
2815 spin_lock_bh(&hwsim_radio_lock);
2816 list_for_each_entry(data, &hwsim_radios, list) {
2817 if (memcmp(data->addresses[1].addr, addr, ETH_ALEN) == 0) {
2818 _found = true;
2819 break;
2820 }
2821 }
2822 spin_unlock_bh(&hwsim_radio_lock);
2823
2824 if (!_found)
2825 return NULL;
2826
2827 return data;
2828}
2829
2830static void hwsim_register_wmediumd(struct net *net, u32 portid)
2831{
2832 struct mac80211_hwsim_data *data;
2833
2834 hwsim_net_set_wmediumd(net, portid);
2835
2836 spin_lock_bh(&hwsim_radio_lock);
2837 list_for_each_entry(data, &hwsim_radios, list) {
2838 if (data->netgroup == hwsim_net_get_netgroup(net))
2839 data->wmediumd = portid;
2840 }
2841 spin_unlock_bh(&hwsim_radio_lock);
2842}
2843
2844static int hwsim_tx_info_frame_received_nl(struct sk_buff *skb_2,
2845 struct genl_info *info)
2846{
2847
2848 struct ieee80211_hdr *hdr;
2849 struct mac80211_hwsim_data *data2;
2850 struct ieee80211_tx_info *txi;
2851 struct hwsim_tx_rate *tx_attempts;
2852 u64 ret_skb_cookie;
2853 struct sk_buff *skb, *tmp;
2854 const u8 *src;
2855 unsigned int hwsim_flags;
2856 int i;
2857 bool found = false;
2858
2859 if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
2860 !info->attrs[HWSIM_ATTR_FLAGS] ||
2861 !info->attrs[HWSIM_ATTR_COOKIE] ||
2862 !info->attrs[HWSIM_ATTR_SIGNAL] ||
2863 !info->attrs[HWSIM_ATTR_TX_INFO])
2864 goto out;
2865
2866 src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
2867 hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
2868 ret_skb_cookie = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
2869
2870 data2 = get_hwsim_data_ref_from_addr(src);
2871 if (!data2)
2872 goto out;
2873
2874 if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
2875 goto out;
2876
2877 if (info->snd_portid != data2->wmediumd)
2878 goto out;
2879
2880
2881 skb_queue_walk_safe(&data2->pending, skb, tmp) {
2882 u64 skb_cookie;
2883
2884 txi = IEEE80211_SKB_CB(skb);
2885 skb_cookie = (u64)(uintptr_t)txi->rate_driver_data[0];
2886
2887 if (skb_cookie == ret_skb_cookie) {
2888 skb_unlink(skb, &data2->pending);
2889 found = true;
2890 break;
2891 }
2892 }
2893
2894
2895 if (!found)
2896 goto out;
2897
2898
2899
2900
2901 tx_attempts = (struct hwsim_tx_rate *)nla_data(
2902 info->attrs[HWSIM_ATTR_TX_INFO]);
2903
2904
2905 txi = IEEE80211_SKB_CB(skb);
2906
2907 ieee80211_tx_info_clear_status(txi);
2908
2909 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
2910 txi->status.rates[i].idx = tx_attempts[i].idx;
2911 txi->status.rates[i].count = tx_attempts[i].count;
2912
2913 }
2914
2915 txi->status.ack_signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
2916
2917 if (!(hwsim_flags & HWSIM_TX_CTL_NO_ACK) &&
2918 (hwsim_flags & HWSIM_TX_STAT_ACK)) {
2919 if (skb->len >= 16) {
2920 hdr = (struct ieee80211_hdr *) skb->data;
2921 mac80211_hwsim_monitor_ack(data2->channel,
2922 hdr->addr2);
2923 }
2924 txi->flags |= IEEE80211_TX_STAT_ACK;
2925 }
2926 ieee80211_tx_status_irqsafe(data2->hw, skb);
2927 return 0;
2928out:
2929 return -EINVAL;
2930
2931}
2932
2933static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2,
2934 struct genl_info *info)
2935{
2936 struct mac80211_hwsim_data *data2;
2937 struct ieee80211_rx_status rx_status;
2938 const u8 *dst;
2939 int frame_data_len;
2940 void *frame_data;
2941 struct sk_buff *skb = NULL;
2942
2943 if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
2944 !info->attrs[HWSIM_ATTR_FRAME] ||
2945 !info->attrs[HWSIM_ATTR_RX_RATE] ||
2946 !info->attrs[HWSIM_ATTR_SIGNAL])
2947 goto out;
2948
2949 dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
2950 frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
2951 frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
2952
2953
2954 skb = alloc_skb(frame_data_len, GFP_KERNEL);
2955 if (skb == NULL)
2956 goto err;
2957
2958 if (frame_data_len > IEEE80211_MAX_DATA_LEN)
2959 goto err;
2960
2961
2962 memcpy(skb_put(skb, frame_data_len), frame_data, frame_data_len);
2963
2964 data2 = get_hwsim_data_ref_from_addr(dst);
2965 if (!data2)
2966 goto out;
2967
2968 if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
2969 goto out;
2970
2971 if (info->snd_portid != data2->wmediumd)
2972 goto out;
2973
2974
2975
2976 if (data2->idle || !data2->started)
2977 goto out;
2978
2979
2980 memset(&rx_status, 0, sizeof(rx_status));
2981 if (info->attrs[HWSIM_ATTR_FREQ]) {
2982
2983
2984
2985
2986 mutex_lock(&data2->mutex);
2987 rx_status.freq = nla_get_u32(info->attrs[HWSIM_ATTR_FREQ]);
2988
2989 if (rx_status.freq != data2->channel->center_freq &&
2990 (!data2->tmp_chan ||
2991 rx_status.freq != data2->tmp_chan->center_freq)) {
2992 mutex_unlock(&data2->mutex);
2993 goto out;
2994 }
2995 mutex_unlock(&data2->mutex);
2996 } else {
2997 rx_status.freq = data2->channel->center_freq;
2998 }
2999
3000 rx_status.band = data2->channel->band;
3001 rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]);
3002 rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
3003
3004 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
3005 data2->rx_pkts++;
3006 data2->rx_bytes += skb->len;
3007 ieee80211_rx_irqsafe(data2->hw, skb);
3008
3009 return 0;
3010err:
3011 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
3012out:
3013 dev_kfree_skb(skb);
3014 return -EINVAL;
3015}
3016
3017static int hwsim_register_received_nl(struct sk_buff *skb_2,
3018 struct genl_info *info)
3019{
3020 struct net *net = genl_info_net(info);
3021 struct mac80211_hwsim_data *data;
3022 int chans = 1;
3023
3024 spin_lock_bh(&hwsim_radio_lock);
3025 list_for_each_entry(data, &hwsim_radios, list)
3026 chans = max(chans, data->channels);
3027 spin_unlock_bh(&hwsim_radio_lock);
3028
3029
3030
3031
3032
3033
3034 if (chans > 1)
3035 return -EOPNOTSUPP;
3036
3037 if (hwsim_net_get_wmediumd(net))
3038 return -EBUSY;
3039
3040 hwsim_register_wmediumd(net, info->snd_portid);
3041
3042 printk(KERN_DEBUG "mac80211_hwsim: received a REGISTER, "
3043 "switching to wmediumd mode with pid %d\n", info->snd_portid);
3044
3045 return 0;
3046}
3047
3048static int hwsim_new_radio_nl(struct sk_buff *msg, struct genl_info *info)
3049{
3050 struct hwsim_new_radio_params param = { 0 };
3051
3052 param.reg_strict = info->attrs[HWSIM_ATTR_REG_STRICT_REG];
3053 param.p2p_device = info->attrs[HWSIM_ATTR_SUPPORT_P2P_DEVICE];
3054 param.channels = channels;
3055 param.destroy_on_close =
3056 info->attrs[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE];
3057
3058 if (info->attrs[HWSIM_ATTR_CHANNELS])
3059 param.channels = nla_get_u32(info->attrs[HWSIM_ATTR_CHANNELS]);
3060
3061 if (info->attrs[HWSIM_ATTR_NO_VIF])
3062 param.no_vif = true;
3063
3064 if (info->attrs[HWSIM_ATTR_RADIO_NAME])
3065 param.hwname = nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]);
3066
3067 if (info->attrs[HWSIM_ATTR_USE_CHANCTX])
3068 param.use_chanctx = true;
3069 else
3070 param.use_chanctx = (param.channels > 1);
3071
3072 if (info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2])
3073 param.reg_alpha2 =
3074 nla_data(info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]);
3075
3076 if (info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]) {
3077 u32 idx = nla_get_u32(info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]);
3078
3079 if (idx >= ARRAY_SIZE(hwsim_world_regdom_custom))
3080 return -EINVAL;
3081 param.regd = hwsim_world_regdom_custom[idx];
3082 }
3083
3084 return mac80211_hwsim_new_radio(info, ¶m);
3085}
3086
3087static int hwsim_del_radio_nl(struct sk_buff *msg, struct genl_info *info)
3088{
3089 struct mac80211_hwsim_data *data;
3090 s64 idx = -1;
3091 const char *hwname = NULL;
3092
3093 if (info->attrs[HWSIM_ATTR_RADIO_ID])
3094 idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);
3095 else if (info->attrs[HWSIM_ATTR_RADIO_NAME])
3096 hwname = (void *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]);
3097 else
3098 return -EINVAL;
3099
3100 spin_lock_bh(&hwsim_radio_lock);
3101 list_for_each_entry(data, &hwsim_radios, list) {
3102 if (idx >= 0) {
3103 if (data->idx != idx)
3104 continue;
3105 } else {
3106 if (strcmp(hwname, wiphy_name(data->hw->wiphy)))
3107 continue;
3108 }
3109
3110 if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
3111 continue;
3112
3113 list_del(&data->list);
3114 spin_unlock_bh(&hwsim_radio_lock);
3115 mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
3116 info);
3117 return 0;
3118 }
3119 spin_unlock_bh(&hwsim_radio_lock);
3120
3121 return -ENODEV;
3122}
3123
3124static int hwsim_get_radio_nl(struct sk_buff *msg, struct genl_info *info)
3125{
3126 struct mac80211_hwsim_data *data;
3127 struct sk_buff *skb;
3128 int idx, res = -ENODEV;
3129
3130 if (!info->attrs[HWSIM_ATTR_RADIO_ID])
3131 return -EINVAL;
3132 idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);
3133
3134 spin_lock_bh(&hwsim_radio_lock);
3135 list_for_each_entry(data, &hwsim_radios, list) {
3136 if (data->idx != idx)
3137 continue;
3138
3139 if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
3140 continue;
3141
3142 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3143 if (!skb) {
3144 res = -ENOMEM;
3145 goto out_err;
3146 }
3147
3148 res = mac80211_hwsim_get_radio(skb, data, info->snd_portid,
3149 info->snd_seq, NULL, 0);
3150 if (res < 0) {
3151 nlmsg_free(skb);
3152 goto out_err;
3153 }
3154
3155 genlmsg_reply(skb, info);
3156 break;
3157 }
3158
3159out_err:
3160 spin_unlock_bh(&hwsim_radio_lock);
3161
3162 return res;
3163}
3164
3165static int hwsim_dump_radio_nl(struct sk_buff *skb,
3166 struct netlink_callback *cb)
3167{
3168 int idx = cb->args[0];
3169 struct mac80211_hwsim_data *data = NULL;
3170 int res;
3171
3172 spin_lock_bh(&hwsim_radio_lock);
3173
3174 if (idx == hwsim_radio_idx)
3175 goto done;
3176
3177 list_for_each_entry(data, &hwsim_radios, list) {
3178 if (data->idx < idx)
3179 continue;
3180
3181 if (!net_eq(wiphy_net(data->hw->wiphy), sock_net(skb->sk)))
3182 continue;
3183
3184 res = mac80211_hwsim_get_radio(skb, data,
3185 NETLINK_CB(cb->skb).portid,
3186 cb->nlh->nlmsg_seq, cb,
3187 NLM_F_MULTI);
3188 if (res < 0)
3189 break;
3190
3191 idx = data->idx + 1;
3192 }
3193
3194 cb->args[0] = idx;
3195
3196done:
3197 spin_unlock_bh(&hwsim_radio_lock);
3198 return skb->len;
3199}
3200
3201
3202static const struct genl_ops hwsim_ops[] = {
3203 {
3204 .cmd = HWSIM_CMD_REGISTER,
3205 .policy = hwsim_genl_policy,
3206 .doit = hwsim_register_received_nl,
3207 .flags = GENL_UNS_ADMIN_PERM,
3208 },
3209 {
3210 .cmd = HWSIM_CMD_FRAME,
3211 .policy = hwsim_genl_policy,
3212 .doit = hwsim_cloned_frame_received_nl,
3213 },
3214 {
3215 .cmd = HWSIM_CMD_TX_INFO_FRAME,
3216 .policy = hwsim_genl_policy,
3217 .doit = hwsim_tx_info_frame_received_nl,
3218 },
3219 {
3220 .cmd = HWSIM_CMD_NEW_RADIO,
3221 .policy = hwsim_genl_policy,
3222 .doit = hwsim_new_radio_nl,
3223 .flags = GENL_UNS_ADMIN_PERM,
3224 },
3225 {
3226 .cmd = HWSIM_CMD_DEL_RADIO,
3227 .policy = hwsim_genl_policy,
3228 .doit = hwsim_del_radio_nl,
3229 .flags = GENL_UNS_ADMIN_PERM,
3230 },
3231 {
3232 .cmd = HWSIM_CMD_GET_RADIO,
3233 .policy = hwsim_genl_policy,
3234 .doit = hwsim_get_radio_nl,
3235 .dumpit = hwsim_dump_radio_nl,
3236 },
3237};
3238
3239static void destroy_radio(struct work_struct *work)
3240{
3241 struct mac80211_hwsim_data *data =
3242 container_of(work, struct mac80211_hwsim_data, destroy_work);
3243
3244 mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy), NULL);
3245}
3246
3247static void remove_user_radios(u32 portid)
3248{
3249 struct mac80211_hwsim_data *entry, *tmp;
3250
3251 spin_lock_bh(&hwsim_radio_lock);
3252 list_for_each_entry_safe(entry, tmp, &hwsim_radios, list) {
3253 if (entry->destroy_on_close && entry->portid == portid) {
3254 list_del(&entry->list);
3255 INIT_WORK(&entry->destroy_work, destroy_radio);
3256 schedule_work(&entry->destroy_work);
3257 }
3258 }
3259 spin_unlock_bh(&hwsim_radio_lock);
3260}
3261
3262static int mac80211_hwsim_netlink_notify(struct notifier_block *nb,
3263 unsigned long state,
3264 void *_notify)
3265{
3266 struct netlink_notify *notify = _notify;
3267
3268 if (state != NETLINK_URELEASE)
3269 return NOTIFY_DONE;
3270
3271 remove_user_radios(notify->portid);
3272
3273 if (notify->portid == hwsim_net_get_wmediumd(notify->net)) {
3274 printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
3275 " socket, switching to perfect channel medium\n");
3276 hwsim_register_wmediumd(notify->net, 0);
3277 }
3278 return NOTIFY_DONE;
3279
3280}
3281
3282static struct notifier_block hwsim_netlink_notifier = {
3283 .notifier_call = mac80211_hwsim_netlink_notify,
3284};
3285
3286static int hwsim_init_netlink(void)
3287{
3288 int rc;
3289
3290 printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");
3291
3292 rc = genl_register_family_with_ops_groups(&hwsim_genl_family,
3293 hwsim_ops,
3294 hwsim_mcgrps);
3295 if (rc)
3296 goto failure;
3297
3298 rc = netlink_register_notifier(&hwsim_netlink_notifier);
3299 if (rc) {
3300 genl_unregister_family(&hwsim_genl_family);
3301 goto failure;
3302 }
3303
3304 return 0;
3305
3306failure:
3307 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
3308 return -EINVAL;
3309}
3310
3311static __net_init int hwsim_init_net(struct net *net)
3312{
3313 hwsim_net_set_netgroup(net);
3314
3315 return 0;
3316}
3317
3318static void __net_exit hwsim_exit_net(struct net *net)
3319{
3320 struct mac80211_hwsim_data *data, *tmp;
3321
3322 spin_lock_bh(&hwsim_radio_lock);
3323 list_for_each_entry_safe(data, tmp, &hwsim_radios, list) {
3324 if (!net_eq(wiphy_net(data->hw->wiphy), net))
3325 continue;
3326
3327
3328 if (data->netgroup == hwsim_net_get_netgroup(&init_net))
3329 continue;
3330
3331 list_del(&data->list);
3332 INIT_WORK(&data->destroy_work, destroy_radio);
3333 schedule_work(&data->destroy_work);
3334 }
3335 spin_unlock_bh(&hwsim_radio_lock);
3336}
3337
3338static struct pernet_operations hwsim_net_ops = {
3339 .init = hwsim_init_net,
3340 .exit = hwsim_exit_net,
3341 .id = &hwsim_net_id,
3342 .size = sizeof(struct hwsim_net),
3343};
3344
3345static void hwsim_exit_netlink(void)
3346{
3347
3348 netlink_unregister_notifier(&hwsim_netlink_notifier);
3349
3350 genl_unregister_family(&hwsim_genl_family);
3351}
3352
3353static int __init init_mac80211_hwsim(void)
3354{
3355 int i, err;
3356
3357 if (radios < 0 || radios > 100)
3358 return -EINVAL;
3359
3360 if (channels < 1)
3361 return -EINVAL;
3362
3363 mac80211_hwsim_mchan_ops = mac80211_hwsim_ops;
3364 mac80211_hwsim_mchan_ops.hw_scan = mac80211_hwsim_hw_scan;
3365 mac80211_hwsim_mchan_ops.cancel_hw_scan = mac80211_hwsim_cancel_hw_scan;
3366 mac80211_hwsim_mchan_ops.sw_scan_start = NULL;
3367 mac80211_hwsim_mchan_ops.sw_scan_complete = NULL;
3368 mac80211_hwsim_mchan_ops.remain_on_channel = mac80211_hwsim_roc;
3369 mac80211_hwsim_mchan_ops.cancel_remain_on_channel = mac80211_hwsim_croc;
3370 mac80211_hwsim_mchan_ops.add_chanctx = mac80211_hwsim_add_chanctx;
3371 mac80211_hwsim_mchan_ops.remove_chanctx = mac80211_hwsim_remove_chanctx;
3372 mac80211_hwsim_mchan_ops.change_chanctx = mac80211_hwsim_change_chanctx;
3373 mac80211_hwsim_mchan_ops.assign_vif_chanctx =
3374 mac80211_hwsim_assign_vif_chanctx;
3375 mac80211_hwsim_mchan_ops.unassign_vif_chanctx =
3376 mac80211_hwsim_unassign_vif_chanctx;
3377
3378 spin_lock_init(&hwsim_radio_lock);
3379 INIT_LIST_HEAD(&hwsim_radios);
3380
3381 err = register_pernet_device(&hwsim_net_ops);
3382 if (err)
3383 return err;
3384
3385 err = platform_driver_register(&mac80211_hwsim_driver);
3386 if (err)
3387 goto out_unregister_pernet;
3388
3389 hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
3390 if (IS_ERR(hwsim_class)) {
3391 err = PTR_ERR(hwsim_class);
3392 goto out_unregister_driver;
3393 }
3394
3395 err = hwsim_init_netlink();
3396 if (err < 0)
3397 goto out_unregister_driver;
3398
3399 for (i = 0; i < radios; i++) {
3400 struct hwsim_new_radio_params param = { 0 };
3401
3402 param.channels = channels;
3403
3404 switch (regtest) {
3405 case HWSIM_REGTEST_DIFF_COUNTRY:
3406 if (i < ARRAY_SIZE(hwsim_alpha2s))
3407 param.reg_alpha2 = hwsim_alpha2s[i];
3408 break;
3409 case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
3410 if (!i)
3411 param.reg_alpha2 = hwsim_alpha2s[0];
3412 break;
3413 case HWSIM_REGTEST_STRICT_ALL:
3414 param.reg_strict = true;
3415 case HWSIM_REGTEST_DRIVER_REG_ALL:
3416 param.reg_alpha2 = hwsim_alpha2s[0];
3417 break;
3418 case HWSIM_REGTEST_WORLD_ROAM:
3419 if (i == 0)
3420 param.regd = &hwsim_world_regdom_custom_01;
3421 break;
3422 case HWSIM_REGTEST_CUSTOM_WORLD:
3423 param.regd = &hwsim_world_regdom_custom_01;
3424 break;
3425 case HWSIM_REGTEST_CUSTOM_WORLD_2:
3426 if (i == 0)
3427 param.regd = &hwsim_world_regdom_custom_01;
3428 else if (i == 1)
3429 param.regd = &hwsim_world_regdom_custom_02;
3430 break;
3431 case HWSIM_REGTEST_STRICT_FOLLOW:
3432 if (i == 0) {
3433 param.reg_strict = true;
3434 param.reg_alpha2 = hwsim_alpha2s[0];
3435 }
3436 break;
3437 case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
3438 if (i == 0) {
3439 param.reg_strict = true;
3440 param.reg_alpha2 = hwsim_alpha2s[0];
3441 } else if (i == 1) {
3442 param.reg_alpha2 = hwsim_alpha2s[1];
3443 }
3444 break;
3445 case HWSIM_REGTEST_ALL:
3446 switch (i) {
3447 case 0:
3448 param.regd = &hwsim_world_regdom_custom_01;
3449 break;
3450 case 1:
3451 param.regd = &hwsim_world_regdom_custom_02;
3452 break;
3453 case 2:
3454 param.reg_alpha2 = hwsim_alpha2s[0];
3455 break;
3456 case 3:
3457 param.reg_alpha2 = hwsim_alpha2s[1];
3458 break;
3459 case 4:
3460 param.reg_strict = true;
3461 param.reg_alpha2 = hwsim_alpha2s[2];
3462 break;
3463 }
3464 break;
3465 default:
3466 break;
3467 }
3468
3469 param.p2p_device = support_p2p_device;
3470 param.use_chanctx = channels > 1;
3471
3472 err = mac80211_hwsim_new_radio(NULL, ¶m);
3473 if (err < 0)
3474 goto out_free_radios;
3475 }
3476
3477 hwsim_mon = alloc_netdev(0, "hwsim%d", NET_NAME_UNKNOWN,
3478 hwsim_mon_setup);
3479 if (hwsim_mon == NULL) {
3480 err = -ENOMEM;
3481 goto out_free_radios;
3482 }
3483
3484 rtnl_lock();
3485 err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
3486 if (err < 0) {
3487 rtnl_unlock();
3488 goto out_free_radios;
3489 }
3490
3491 err = register_netdevice(hwsim_mon);
3492 if (err < 0) {
3493 rtnl_unlock();
3494 goto out_free_mon;
3495 }
3496 rtnl_unlock();
3497
3498 return 0;
3499
3500out_free_mon:
3501 free_netdev(hwsim_mon);
3502out_free_radios:
3503 mac80211_hwsim_free();
3504out_unregister_driver:
3505 platform_driver_unregister(&mac80211_hwsim_driver);
3506out_unregister_pernet:
3507 unregister_pernet_device(&hwsim_net_ops);
3508 return err;
3509}
3510module_init(init_mac80211_hwsim);
3511
3512static void __exit exit_mac80211_hwsim(void)
3513{
3514 printk(KERN_DEBUG "mac80211_hwsim: unregister radios\n");
3515
3516 hwsim_exit_netlink();
3517
3518 mac80211_hwsim_free();
3519 unregister_netdev(hwsim_mon);
3520 platform_driver_unregister(&mac80211_hwsim_driver);
3521 unregister_pernet_device(&hwsim_net_ops);
3522}
3523module_exit(exit_mac80211_hwsim);
3524