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