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