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 333static const struct ieee80211_iface_limit hwsim_if_limits[] = { 334 { .max = 1, .types = BIT(NL80211_IFTYPE_ADHOC) }, 335 { .max = 2048, .types = BIT(NL80211_IFTYPE_STATION) | 336 BIT(NL80211_IFTYPE_P2P_CLIENT) | 337#ifdef CONFIG_MAC80211_MESH 338 BIT(NL80211_IFTYPE_MESH_POINT) | 339#endif 340 BIT(NL80211_IFTYPE_AP) | 341 BIT(NL80211_IFTYPE_P2P_GO) }, 342 /* must be last, see hwsim_if_comb */ 343 { .max = 1, .types = BIT(NL80211_IFTYPE_P2P_DEVICE) } 344}; 345 346static const struct ieee80211_iface_limit hwsim_if_dfs_limits[] = { 347 { .max = 8, .types = BIT(NL80211_IFTYPE_AP) }, 348}; 349 350static const struct ieee80211_iface_combination hwsim_if_comb[] = { 351 { 352 .limits = hwsim_if_limits, 353 /* remove the last entry which is P2P_DEVICE */ 354 .n_limits = ARRAY_SIZE(hwsim_if_limits) - 1, 355 .max_interfaces = 2048, 356 .num_different_channels = 1, 357 }, 358 { 359 .limits = hwsim_if_dfs_limits, 360 .n_limits = ARRAY_SIZE(hwsim_if_dfs_limits), 361 .max_interfaces = 8, 362 .num_different_channels = 1, 363 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 364 BIT(NL80211_CHAN_WIDTH_20) | 365 BIT(NL80211_CHAN_WIDTH_40) | 366 BIT(NL80211_CHAN_WIDTH_80) | 367 BIT(NL80211_CHAN_WIDTH_160), 368 } 369}; 370 371static const struct ieee80211_iface_combination hwsim_if_comb_p2p_dev[] = { 372 { 373 .limits = hwsim_if_limits, 374 .n_limits = ARRAY_SIZE(hwsim_if_limits), 375 .max_interfaces = 2048, 376 .num_different_channels = 1, 377 }, 378 { 379 .limits = hwsim_if_dfs_limits, 380 .n_limits = ARRAY_SIZE(hwsim_if_dfs_limits), 381 .max_interfaces = 8, 382 .num_different_channels = 1, 383 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 384 BIT(NL80211_CHAN_WIDTH_20) | 385 BIT(NL80211_CHAN_WIDTH_40) | 386 BIT(NL80211_CHAN_WIDTH_80) | 387 BIT(NL80211_CHAN_WIDTH_160), 388 } 389}; 390 391static spinlock_t hwsim_radio_lock; 392static struct list_head hwsim_radios; 393static int hwsim_radio_idx; 394 395static struct platform_driver mac80211_hwsim_driver = { 396 .driver = { 397 .name = "mac80211_hwsim", 398 .owner = THIS_MODULE, 399 }, 400}; 401 402struct mac80211_hwsim_data { 403 struct list_head list; 404 struct ieee80211_hw *hw; 405 struct device *dev; 406 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS]; 407 struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)]; 408 struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)]; 409 struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)]; 410 struct ieee80211_iface_combination if_combination; 411 412 struct mac_address addresses[2]; 413 int channels, idx; 414 bool use_chanctx; 415 416 struct ieee80211_channel *tmp_chan; 417 struct delayed_work roc_done; 418 struct delayed_work hw_scan; 419 struct cfg80211_scan_request *hw_scan_request; 420 struct ieee80211_vif *hw_scan_vif; 421 int scan_chan_idx; 422 423 struct ieee80211_channel *channel; 424 u64 beacon_int /* beacon interval in us */; 425 unsigned int rx_filter; 426 bool started, idle, scanning; 427 struct mutex mutex; 428 struct tasklet_hrtimer beacon_timer; 429 enum ps_mode { 430 PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL 431 } ps; 432 bool ps_poll_pending; 433 struct dentry *debugfs; 434 435 struct sk_buff_head pending; /* packets pending */ 436 /* 437 * Only radios in the same group can communicate together (the 438 * channel has to match too). Each bit represents a group. A 439 * radio can be in more then one group. 440 */ 441 u64 group; 442 443 int power_level; 444 445 /* difference between this hw's clock and the real clock, in usecs */ 446 s64 tsf_offset; 447 s64 bcn_delta; 448 /* absolute beacon transmission time. Used to cover up "tx" delay. */ 449 u64 abs_bcn_ts; 450}; 451 452 453struct hwsim_radiotap_hdr { 454 struct ieee80211_radiotap_header hdr; 455 __le64 rt_tsft; 456 u8 rt_flags; 457 u8 rt_rate; 458 __le16 rt_channel; 459 __le16 rt_chbitmask; 460} __packed; 461 462struct hwsim_radiotap_ack_hdr { 463 struct ieee80211_radiotap_header hdr; 464 u8 rt_flags; 465 u8 pad; 466 __le16 rt_channel; 467 __le16 rt_chbitmask; 468} __packed; 469 470/* MAC80211_HWSIM netlinf family */ 471static struct genl_family hwsim_genl_family = { 472 .id = GENL_ID_GENERATE, 473 .hdrsize = 0, 474 .name = "MAC80211_HWSIM", 475 .version = 1, 476 .maxattr = HWSIM_ATTR_MAX, 477}; 478 479/* MAC80211_HWSIM netlink policy */ 480 481static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = { 482 [HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN }, 483 [HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN }, 484 [HWSIM_ATTR_FRAME] = { .type = NLA_BINARY, 485 .len = IEEE80211_MAX_DATA_LEN }, 486 [HWSIM_ATTR_FLAGS] = { .type = NLA_U32 }, 487 [HWSIM_ATTR_RX_RATE] = { .type = NLA_U32 }, 488 [HWSIM_ATTR_SIGNAL] = { .type = NLA_U32 }, 489 [HWSIM_ATTR_TX_INFO] = { .type = NLA_UNSPEC, 490 .len = IEEE80211_TX_MAX_RATES * 491 sizeof(struct hwsim_tx_rate)}, 492 [HWSIM_ATTR_COOKIE] = { .type = NLA_U64 }, 493 [HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 }, 494 [HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 }, 495 [HWSIM_ATTR_REG_HINT_ALPHA2] = { .type = NLA_STRING, .len = 2 }, 496 [HWSIM_ATTR_REG_CUSTOM_REG] = { .type = NLA_U32 }, 497 [HWSIM_ATTR_REG_STRICT_REG] = { .type = NLA_FLAG }, 498 [HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG }, 499}; 500 501static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw, 502 struct sk_buff *skb, 503 struct ieee80211_channel *chan); 504 505/* sysfs attributes */ 506static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif) 507{ 508 struct mac80211_hwsim_data *data = dat; 509 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 510 struct sk_buff *skb; 511 struct ieee80211_pspoll *pspoll; 512 513 if (!vp->assoc) 514 return; 515 516 wiphy_debug(data->hw->wiphy, 517 "%s: send PS-Poll to %pM for aid %d\n", 518 __func__, vp->bssid, vp->aid); 519 520 skb = dev_alloc_skb(sizeof(*pspoll)); 521 if (!skb) 522 return; 523 pspoll = (void *) skb_put(skb, sizeof(*pspoll)); 524 pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | 525 IEEE80211_STYPE_PSPOLL | 526 IEEE80211_FCTL_PM); 527 pspoll->aid = cpu_to_le16(0xc000 | vp->aid); 528 memcpy(pspoll->bssid, vp->bssid, ETH_ALEN); 529 memcpy(pspoll->ta, mac, ETH_ALEN); 530 531 rcu_read_lock(); 532 mac80211_hwsim_tx_frame(data->hw, skb, 533 rcu_dereference(vif->chanctx_conf)->def.chan); 534 rcu_read_unlock(); 535} 536 537static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac, 538 struct ieee80211_vif *vif, int ps) 539{ 540 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 541 struct sk_buff *skb; 542 struct ieee80211_hdr *hdr; 543 544 if (!vp->assoc) 545 return; 546 547 wiphy_debug(data->hw->wiphy, 548 "%s: send data::nullfunc to %pM ps=%d\n", 549 __func__, vp->bssid, ps); 550 551 skb = dev_alloc_skb(sizeof(*hdr)); 552 if (!skb) 553 return; 554 hdr = (void *) skb_put(skb, sizeof(*hdr) - ETH_ALEN); 555 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 556 IEEE80211_STYPE_NULLFUNC | 557 (ps ? IEEE80211_FCTL_PM : 0)); 558 hdr->duration_id = cpu_to_le16(0); 559 memcpy(hdr->addr1, vp->bssid, ETH_ALEN); 560 memcpy(hdr->addr2, mac, ETH_ALEN); 561 memcpy(hdr->addr3, vp->bssid, ETH_ALEN); 562 563 rcu_read_lock(); 564 mac80211_hwsim_tx_frame(data->hw, skb, 565 rcu_dereference(vif->chanctx_conf)->def.chan); 566 rcu_read_unlock(); 567} 568 569 570static void hwsim_send_nullfunc_ps(void *dat, u8 *mac, 571 struct ieee80211_vif *vif) 572{ 573 struct mac80211_hwsim_data *data = dat; 574 hwsim_send_nullfunc(data, mac, vif, 1); 575} 576 577static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac, 578 struct ieee80211_vif *vif) 579{ 580 struct mac80211_hwsim_data *data = dat; 581 hwsim_send_nullfunc(data, mac, vif, 0); 582} 583 584static int hwsim_fops_ps_read(void *dat, u64 *val) 585{ 586 struct mac80211_hwsim_data *data = dat; 587 *val = data->ps; 588 return 0; 589} 590 591static int hwsim_fops_ps_write(void *dat, u64 val) 592{ 593 struct mac80211_hwsim_data *data = dat; 594 enum ps_mode old_ps; 595 596 if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL && 597 val != PS_MANUAL_POLL) 598 return -EINVAL; 599 600 old_ps = data->ps; 601 data->ps = val; 602 603 if (val == PS_MANUAL_POLL) { 604 ieee80211_iterate_active_interfaces(data->hw, 605 IEEE80211_IFACE_ITER_NORMAL, 606 hwsim_send_ps_poll, data); 607 data->ps_poll_pending = true; 608 } else if (old_ps == PS_DISABLED && val != PS_DISABLED) { 609 ieee80211_iterate_active_interfaces(data->hw, 610 IEEE80211_IFACE_ITER_NORMAL, 611 hwsim_send_nullfunc_ps, 612 data); 613 } else if (old_ps != PS_DISABLED && val == PS_DISABLED) { 614 ieee80211_iterate_active_interfaces(data->hw, 615 IEEE80211_IFACE_ITER_NORMAL, 616 hwsim_send_nullfunc_no_ps, 617 data); 618 } 619 620 return 0; 621} 622 623DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write, 624 "%llu\n"); 625 626static int hwsim_write_simulate_radar(void *dat, u64 val) 627{ 628 struct mac80211_hwsim_data *data = dat; 629 630 ieee80211_radar_detected(data->hw); 631 632 return 0; 633} 634 635DEFINE_SIMPLE_ATTRIBUTE(hwsim_simulate_radar, NULL, 636 hwsim_write_simulate_radar, "%llu\n"); 637 638static int hwsim_fops_group_read(void *dat, u64 *val) 639{ 640 struct mac80211_hwsim_data *data = dat; 641 *val = data->group; 642 return 0; 643} 644 645static int hwsim_fops_group_write(void *dat, u64 val) 646{ 647 struct mac80211_hwsim_data *data = dat; 648 data->group = val; 649 return 0; 650} 651 652DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_group, 653 hwsim_fops_group_read, hwsim_fops_group_write, 654 "%llx\n"); 655 656static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb, 657 struct net_device *dev) 658{ 659 /* TODO: allow packet injection */ 660 dev_kfree_skb(skb); 661 return NETDEV_TX_OK; 662} 663 664static inline u64 mac80211_hwsim_get_tsf_raw(void) 665{ 666 return ktime_to_us(ktime_get_real()); 667} 668 669static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data) 670{ 671 u64 now = mac80211_hwsim_get_tsf_raw(); 672 return cpu_to_le64(now + data->tsf_offset); 673} 674 675static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw, 676 struct ieee80211_vif *vif) 677{ 678 struct mac80211_hwsim_data *data = hw->priv; 679 return le64_to_cpu(__mac80211_hwsim_get_tsf(data)); 680} 681 682static void mac80211_hwsim_set_tsf(struct ieee80211_hw *hw, 683 struct ieee80211_vif *vif, u64 tsf) 684{ 685 struct mac80211_hwsim_data *data = hw->priv; 686 u64 now = mac80211_hwsim_get_tsf(hw, vif); 687 u32 bcn_int = data->beacon_int; 688 u64 delta = abs64(tsf - now); 689 690 /* adjust after beaconing with new timestamp at old TBTT */ 691 if (tsf > now) { 692 data->tsf_offset += delta; 693 data->bcn_delta = do_div(delta, bcn_int); 694 } else { 695 data->tsf_offset -= delta; 696 data->bcn_delta = -do_div(delta, bcn_int); 697 } 698} 699 700static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw, 701 struct sk_buff *tx_skb, 702 struct ieee80211_channel *chan) 703{ 704 struct mac80211_hwsim_data *data = hw->priv; 705 struct sk_buff *skb; 706 struct hwsim_radiotap_hdr *hdr; 707 u16 flags; 708 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb); 709 struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info); 710 711 if (!netif_running(hwsim_mon)) 712 return; 713 714 skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC); 715 if (skb == NULL) 716 return; 717 718 hdr = (struct hwsim_radiotap_hdr *) skb_push(skb, sizeof(*hdr)); 719 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION; 720 hdr->hdr.it_pad = 0; 721 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr)); 722 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) | 723 (1 << IEEE80211_RADIOTAP_RATE) | 724 (1 << IEEE80211_RADIOTAP_TSFT) | 725 (1 << IEEE80211_RADIOTAP_CHANNEL)); 726 hdr->rt_tsft = __mac80211_hwsim_get_tsf(data); 727 hdr->rt_flags = 0; 728 hdr->rt_rate = txrate->bitrate / 5; 729 hdr->rt_channel = cpu_to_le16(chan->center_freq); 730 flags = IEEE80211_CHAN_2GHZ; 731 if (txrate->flags & IEEE80211_RATE_ERP_G) 732 flags |= IEEE80211_CHAN_OFDM; 733 else 734 flags |= IEEE80211_CHAN_CCK; 735 hdr->rt_chbitmask = cpu_to_le16(flags); 736 737 skb->dev = hwsim_mon; 738 skb_set_mac_header(skb, 0); 739 skb->ip_summed = CHECKSUM_UNNECESSARY; 740 skb->pkt_type = PACKET_OTHERHOST; 741 skb->protocol = htons(ETH_P_802_2); 742 memset(skb->cb, 0, sizeof(skb->cb)); 743 netif_rx(skb); 744} 745 746 747static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan, 748 const u8 *addr) 749{ 750 struct sk_buff *skb; 751 struct hwsim_radiotap_ack_hdr *hdr; 752 u16 flags; 753 struct ieee80211_hdr *hdr11; 754 755 if (!netif_running(hwsim_mon)) 756 return; 757 758 skb = dev_alloc_skb(100); 759 if (skb == NULL) 760 return; 761 762 hdr = (struct hwsim_radiotap_ack_hdr *) skb_put(skb, sizeof(*hdr)); 763 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION; 764 hdr->hdr.it_pad = 0; 765 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr)); 766 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) | 767 (1 << IEEE80211_RADIOTAP_CHANNEL)); 768 hdr->rt_flags = 0; 769 hdr->pad = 0; 770 hdr->rt_channel = cpu_to_le16(chan->center_freq); 771 flags = IEEE80211_CHAN_2GHZ; 772 hdr->rt_chbitmask = cpu_to_le16(flags); 773 774 hdr11 = (struct ieee80211_hdr *) skb_put(skb, 10); 775 hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | 776 IEEE80211_STYPE_ACK); 777 hdr11->duration_id = cpu_to_le16(0); 778 memcpy(hdr11->addr1, addr, ETH_ALEN); 779 780 skb->dev = hwsim_mon; 781 skb_set_mac_header(skb, 0); 782 skb->ip_summed = CHECKSUM_UNNECESSARY; 783 skb->pkt_type = PACKET_OTHERHOST; 784 skb->protocol = htons(ETH_P_802_2); 785 memset(skb->cb, 0, sizeof(skb->cb)); 786 netif_rx(skb); 787} 788 789struct mac80211_hwsim_addr_match_data { 790 u8 addr[ETH_ALEN]; 791 bool ret; 792}; 793 794static void mac80211_hwsim_addr_iter(void *data, u8 *mac, 795 struct ieee80211_vif *vif) 796{ 797 struct mac80211_hwsim_addr_match_data *md = data; 798 799 if (memcmp(mac, md->addr, ETH_ALEN) == 0) 800 md->ret = true; 801} 802 803static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data, 804 const u8 *addr) 805{ 806 struct mac80211_hwsim_addr_match_data md = { 807 .ret = false, 808 }; 809 810 memcpy(md.addr, addr, ETH_ALEN); 811 812 ieee80211_iterate_active_interfaces_atomic(data->hw, 813 IEEE80211_IFACE_ITER_NORMAL, 814 mac80211_hwsim_addr_iter, 815 &md); 816 817 return md.ret; 818} 819 820static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data, 821 struct sk_buff *skb) 822{ 823 switch (data->ps) { 824 case PS_DISABLED: 825 return true; 826 case PS_ENABLED: 827 return false; 828 case PS_AUTO_POLL: 829 /* TODO: accept (some) Beacons by default and other frames only 830 * if pending PS-Poll has been sent */ 831 return true; 832 case PS_MANUAL_POLL: 833 /* Allow unicast frames to own address if there is a pending 834 * PS-Poll */ 835 if (data->ps_poll_pending && 836 mac80211_hwsim_addr_match(data, skb->data + 4)) { 837 data->ps_poll_pending = false; 838 return true; 839 } 840 return false; 841 } 842 843 return true; 844} 845 846static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw, 847 struct sk_buff *my_skb, 848 int dst_portid) 849{ 850 struct sk_buff *skb; 851 struct mac80211_hwsim_data *data = hw->priv; 852 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data; 853 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb); 854 void *msg_head; 855 unsigned int hwsim_flags = 0; 856 int i; 857 struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES]; 858 859 if (data->ps != PS_DISABLED) 860 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM); 861 /* If the queue contains MAX_QUEUE skb's drop some */ 862 if (skb_queue_len(&data->pending) >= MAX_QUEUE) { 863 /* Droping until WARN_QUEUE level */ 864 while (skb_queue_len(&data->pending) >= WARN_QUEUE) 865 skb_dequeue(&data->pending); 866 } 867 868 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC); 869 if (skb == NULL) 870 goto nla_put_failure; 871 872 msg_head = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0, 873 HWSIM_CMD_FRAME); 874 if (msg_head == NULL) { 875 printk(KERN_DEBUG "mac80211_hwsim: problem with msg_head\n"); 876 goto nla_put_failure; 877 } 878 879 if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER, 880 ETH_ALEN, data->addresses[1].addr)) 881 goto nla_put_failure; 882 883 /* We get the skb->data */ 884 if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data)) 885 goto nla_put_failure; 886 887 /* We get the flags for this transmission, and we translate them to 888 wmediumd flags */ 889 890 if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS) 891 hwsim_flags |= HWSIM_TX_CTL_REQ_TX_STATUS; 892 893 if (info->flags & IEEE80211_TX_CTL_NO_ACK) 894 hwsim_flags |= HWSIM_TX_CTL_NO_ACK; 895 896 if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags)) 897 goto nla_put_failure; 898 899 /* We get the tx control (rate and retries) info*/ 900 901 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 902 tx_attempts[i].idx = info->status.rates[i].idx; 903 tx_attempts[i].count = info->status.rates[i].count; 904 } 905 906 if (nla_put(skb, HWSIM_ATTR_TX_INFO, 907 sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES, 908 tx_attempts)) 909 goto nla_put_failure; 910 911 /* We create a cookie to identify this skb */ 912 if (nla_put_u64(skb, HWSIM_ATTR_COOKIE, (unsigned long) my_skb)) 913 goto nla_put_failure; 914 915 genlmsg_end(skb, msg_head); 916 genlmsg_unicast(&init_net, skb, dst_portid); 917 918 /* Enqueue the packet */ 919 skb_queue_tail(&data->pending, my_skb); 920 return; 921 922nla_put_failure: 923 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__); 924} 925 926static bool hwsim_chans_compat(struct ieee80211_channel *c1, 927 struct ieee80211_channel *c2) 928{ 929 if (!c1 || !c2) 930 return false; 931 932 return c1->center_freq == c2->center_freq; 933} 934 935struct tx_iter_data { 936 struct ieee80211_channel *channel; 937 bool receive; 938}; 939 940static void mac80211_hwsim_tx_iter(void *_data, u8 *addr, 941 struct ieee80211_vif *vif) 942{ 943 struct tx_iter_data *data = _data; 944 945 if (!vif->chanctx_conf) 946 return; 947 948 if (!hwsim_chans_compat(data->channel, 949 rcu_dereference(vif->chanctx_conf)->def.chan)) 950 return; 951 952 data->receive = true; 953} 954 955static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw, 956 struct sk_buff *skb, 957 struct ieee80211_channel *chan) 958{ 959 struct mac80211_hwsim_data *data = hw->priv, *data2; 960 bool ack = false; 961 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 962 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 963 struct ieee80211_rx_status rx_status; 964 u64 now; 965 966 memset(&rx_status, 0, sizeof(rx_status)); 967 rx_status.flag |= RX_FLAG_MACTIME_START; 968 rx_status.freq = chan->center_freq; 969 rx_status.band = chan->band; 970 if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) { 971 rx_status.rate_idx = 972 ieee80211_rate_get_vht_mcs(&info->control.rates[0]); 973 rx_status.vht_nss = 974 ieee80211_rate_get_vht_nss(&info->control.rates[0]); 975 rx_status.flag |= RX_FLAG_VHT; 976 } else { 977 rx_status.rate_idx = info->control.rates[0].idx; 978 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS) 979 rx_status.flag |= RX_FLAG_HT; 980 } 981 if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 982 rx_status.flag |= RX_FLAG_40MHZ; 983 if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI) 984 rx_status.flag |= RX_FLAG_SHORT_GI; 985 /* TODO: simulate real signal strength (and optional packet loss) */ 986 rx_status.signal = data->power_level - 50; 987 988 if (data->ps != PS_DISABLED) 989 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM); 990 991 /* release the skb's source info */ 992 skb_orphan(skb); 993 skb_dst_drop(skb); 994 skb->mark = 0; 995 secpath_reset(skb); 996 nf_reset(skb); 997 998 /* 999 * Get absolute mactime here so all HWs RX at the "same time", and 1000 * absolute TX time for beacon mactime so the timestamp matches. 1001 * Giving beacons a different mactime than non-beacons looks messy, but 1002 * it helps the Toffset be exact and a ~10us mactime discrepancy 1003 * probably doesn't really matter. 1004 */ 1005 if (ieee80211_is_beacon(hdr->frame_control) || 1006 ieee80211_is_probe_resp(hdr->frame_control)) 1007 now = data->abs_bcn_ts; 1008 else 1009 now = mac80211_hwsim_get_tsf_raw(); 1010 1011 /* Copy skb to all enabled radios that are on the current frequency */ 1012 spin_lock(&hwsim_radio_lock); 1013 list_for_each_entry(data2, &hwsim_radios, list) { 1014 struct sk_buff *nskb; 1015 struct tx_iter_data tx_iter_data = { 1016 .receive = false, 1017 .channel = chan, 1018 }; 1019 1020 if (data == data2) 1021 continue; 1022 1023 if (!data2->started || (data2->idle && !data2->tmp_chan) || 1024 !hwsim_ps_rx_ok(data2, skb)) 1025 continue; 1026 1027 if (!(data->group & data2->group)) 1028 continue; 1029 1030 if (!hwsim_chans_compat(chan, data2->tmp_chan) && 1031 !hwsim_chans_compat(chan, data2->channel)) { 1032 ieee80211_iterate_active_interfaces_atomic( 1033 data2->hw, IEEE80211_IFACE_ITER_NORMAL, 1034 mac80211_hwsim_tx_iter, &tx_iter_data); 1035 if (!tx_iter_data.receive) 1036 continue; 1037 } 1038 1039 /* 1040 * reserve some space for our vendor and the normal 1041 * radiotap header, since we're copying anyway 1042 */ 1043 if (skb->len < PAGE_SIZE && paged_rx) { 1044 struct page *page = alloc_page(GFP_ATOMIC); 1045 1046 if (!page) 1047 continue; 1048 1049 nskb = dev_alloc_skb(128); 1050 if (!nskb) { 1051 __free_page(page); 1052 continue; 1053 } 1054 1055 memcpy(page_address(page), skb->data, skb->len); 1056 skb_add_rx_frag(nskb, 0, page, 0, skb->len, skb->len); 1057 } else { 1058 nskb = skb_copy(skb, GFP_ATOMIC); 1059 if (!nskb) 1060 continue; 1061 } 1062 1063 if (mac80211_hwsim_addr_match(data2, hdr->addr1)) 1064 ack = true; 1065 1066 rx_status.mactime = now + data2->tsf_offset; 1067 1068 memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status)); 1069 ieee80211_rx_irqsafe(data2->hw, nskb); 1070 } 1071 spin_unlock(&hwsim_radio_lock); 1072 1073 return ack; 1074} 1075 1076static void mac80211_hwsim_tx(struct ieee80211_hw *hw, 1077 struct ieee80211_tx_control *control, 1078 struct sk_buff *skb) 1079{ 1080 struct mac80211_hwsim_data *data = hw->priv; 1081 struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb); 1082 struct ieee80211_chanctx_conf *chanctx_conf; 1083 struct ieee80211_channel *channel; 1084 bool ack; 1085 u32 _portid; 1086 1087 if (WARN_ON(skb->len < 10)) { 1088 /* Should not happen; just a sanity check for addr1 use */ 1089 ieee80211_free_txskb(hw, skb); 1090 return; 1091 } 1092 1093 if (!data->use_chanctx) { 1094 channel = data->channel; 1095 } else if (txi->hw_queue == 4) { 1096 channel = data->tmp_chan; 1097 } else { 1098 chanctx_conf = rcu_dereference(txi->control.vif->chanctx_conf); 1099 if (chanctx_conf) 1100 channel = chanctx_conf->def.chan; 1101 else 1102 channel = NULL; 1103 } 1104 1105 if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) { 1106 ieee80211_free_txskb(hw, skb); 1107 return; 1108 } 1109 1110 if (data->idle && !data->tmp_chan) { 1111 wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n"); 1112 ieee80211_free_txskb(hw, skb); 1113 return; 1114 } 1115 1116 if (txi->control.vif) 1117 hwsim_check_magic(txi->control.vif); 1118 if (control->sta) 1119 hwsim_check_sta_magic(control->sta); 1120 1121 if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE) 1122 ieee80211_get_tx_rates(txi->control.vif, control->sta, skb, 1123 txi->control.rates, 1124 ARRAY_SIZE(txi->control.rates)); 1125 1126 txi->rate_driver_data[0] = channel; 1127 mac80211_hwsim_monitor_rx(hw, skb, channel); 1128 1129 /* wmediumd mode check */ 1130 _portid = ACCESS_ONCE(wmediumd_portid); 1131 1132 if (_portid) 1133 return mac80211_hwsim_tx_frame_nl(hw, skb, _portid); 1134 1135 /* NO wmediumd detected, perfect medium simulation */ 1136 ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel); 1137 1138 if (ack && skb->len >= 16) { 1139 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 1140 mac80211_hwsim_monitor_ack(channel, hdr->addr2); 1141 } 1142 1143 ieee80211_tx_info_clear_status(txi); 1144 1145 /* frame was transmitted at most favorable rate at first attempt */ 1146 txi->control.rates[0].count = 1; 1147 txi->control.rates[1].idx = -1; 1148 1149 if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack) 1150 txi->flags |= IEEE80211_TX_STAT_ACK; 1151 ieee80211_tx_status_irqsafe(hw, skb); 1152} 1153 1154 1155static int mac80211_hwsim_start(struct ieee80211_hw *hw) 1156{ 1157 struct mac80211_hwsim_data *data = hw->priv; 1158 wiphy_debug(hw->wiphy, "%s\n", __func__); 1159 data->started = true; 1160 return 0; 1161} 1162 1163 1164static void mac80211_hwsim_stop(struct ieee80211_hw *hw) 1165{ 1166 struct mac80211_hwsim_data *data = hw->priv; 1167 data->started = false; 1168 tasklet_hrtimer_cancel(&data->beacon_timer); 1169 wiphy_debug(hw->wiphy, "%s\n", __func__); 1170} 1171 1172 1173static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw, 1174 struct ieee80211_vif *vif) 1175{ 1176 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n", 1177 __func__, ieee80211_vif_type_p2p(vif), 1178 vif->addr); 1179 hwsim_set_magic(vif); 1180 1181 vif->cab_queue = 0; 1182 vif->hw_queue[IEEE80211_AC_VO] = 0; 1183 vif->hw_queue[IEEE80211_AC_VI] = 1; 1184 vif->hw_queue[IEEE80211_AC_BE] = 2; 1185 vif->hw_queue[IEEE80211_AC_BK] = 3; 1186 1187 return 0; 1188} 1189 1190 1191static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw, 1192 struct ieee80211_vif *vif, 1193 enum nl80211_iftype newtype, 1194 bool newp2p) 1195{ 1196 newtype = ieee80211_iftype_p2p(newtype, newp2p); 1197 wiphy_debug(hw->wiphy, 1198 "%s (old type=%d, new type=%d, mac_addr=%pM)\n", 1199 __func__, ieee80211_vif_type_p2p(vif), 1200 newtype, vif->addr); 1201 hwsim_check_magic(vif); 1202 1203 /* 1204 * interface may change from non-AP to AP in 1205 * which case this needs to be set up again 1206 */ 1207 vif->cab_queue = 0; 1208 1209 return 0; 1210} 1211 1212static void mac80211_hwsim_remove_interface( 1213 struct ieee80211_hw *hw, struct ieee80211_vif *vif) 1214{ 1215 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n", 1216 __func__, ieee80211_vif_type_p2p(vif), 1217 vif->addr); 1218 hwsim_check_magic(vif); 1219 hwsim_clear_magic(vif); 1220} 1221 1222static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw, 1223 struct sk_buff *skb, 1224 struct ieee80211_channel *chan) 1225{ 1226 u32 _pid = ACCESS_ONCE(wmediumd_portid); 1227 1228 if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE) { 1229 struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb); 1230 ieee80211_get_tx_rates(txi->control.vif, NULL, skb, 1231 txi->control.rates, 1232 ARRAY_SIZE(txi->control.rates)); 1233 } 1234 1235 mac80211_hwsim_monitor_rx(hw, skb, chan); 1236 1237 if (_pid) 1238 return mac80211_hwsim_tx_frame_nl(hw, skb, _pid); 1239 1240 mac80211_hwsim_tx_frame_no_nl(hw, skb, chan); 1241 dev_kfree_skb(skb); 1242} 1243 1244static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac, 1245 struct ieee80211_vif *vif) 1246{ 1247 struct mac80211_hwsim_data *data = arg; 1248 struct ieee80211_hw *hw = data->hw; 1249 struct ieee80211_tx_info *info; 1250 struct ieee80211_rate *txrate; 1251 struct ieee80211_mgmt *mgmt; 1252 struct sk_buff *skb; 1253 1254 hwsim_check_magic(vif); 1255 1256 if (vif->type != NL80211_IFTYPE_AP && 1257 vif->type != NL80211_IFTYPE_MESH_POINT && 1258 vif->type != NL80211_IFTYPE_ADHOC) 1259 return; 1260 1261 skb = ieee80211_beacon_get(hw, vif); 1262 if (skb == NULL) 1263 return; 1264 info = IEEE80211_SKB_CB(skb); 1265 if (hw->flags & IEEE80211_HW_SUPPORTS_RC_TABLE) 1266 ieee80211_get_tx_rates(vif, NULL, skb, 1267 info->control.rates, 1268 ARRAY_SIZE(info->control.rates)); 1269 1270 txrate = ieee80211_get_tx_rate(hw, info); 1271 1272 mgmt = (struct ieee80211_mgmt *) skb->data; 1273 /* fake header transmission time */ 1274 data->abs_bcn_ts = mac80211_hwsim_get_tsf_raw(); 1275 mgmt->u.beacon.timestamp = cpu_to_le64(data->abs_bcn_ts + 1276 data->tsf_offset + 1277 24 * 8 * 10 / txrate->bitrate); 1278 1279 mac80211_hwsim_tx_frame(hw, skb, 1280 rcu_dereference(vif->chanctx_conf)->def.chan); 1281 1282 if (vif->csa_active && ieee80211_csa_is_complete(vif)) 1283 ieee80211_csa_finish(vif); 1284} 1285 1286static enum hrtimer_restart 1287mac80211_hwsim_beacon(struct hrtimer *timer) 1288{ 1289 struct mac80211_hwsim_data *data = 1290 container_of(timer, struct mac80211_hwsim_data, 1291 beacon_timer.timer); 1292 struct ieee80211_hw *hw = data->hw; 1293 u64 bcn_int = data->beacon_int; 1294 ktime_t next_bcn; 1295 1296 if (!data->started) 1297 goto out; 1298 1299 ieee80211_iterate_active_interfaces_atomic( 1300 hw, IEEE80211_IFACE_ITER_NORMAL, 1301 mac80211_hwsim_beacon_tx, data); 1302 1303 /* beacon at new TBTT + beacon interval */ 1304 if (data->bcn_delta) { 1305 bcn_int -= data->bcn_delta; 1306 data->bcn_delta = 0; 1307 } 1308 1309 next_bcn = ktime_add(hrtimer_get_expires(timer), 1310 ns_to_ktime(bcn_int * 1000)); 1311 tasklet_hrtimer_start(&data->beacon_timer, next_bcn, HRTIMER_MODE_ABS); 1312out: 1313 return HRTIMER_NORESTART; 1314} 1315 1316static const char * const hwsim_chanwidths[] = { 1317 [NL80211_CHAN_WIDTH_20_NOHT] = "noht", 1318 [NL80211_CHAN_WIDTH_20] = "ht20", 1319 [NL80211_CHAN_WIDTH_40] = "ht40", 1320 [NL80211_CHAN_WIDTH_80] = "vht80", 1321 [NL80211_CHAN_WIDTH_80P80] = "vht80p80", 1322 [NL80211_CHAN_WIDTH_160] = "vht160", 1323}; 1324 1325static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed) 1326{ 1327 struct mac80211_hwsim_data *data = hw->priv; 1328 struct ieee80211_conf *conf = &hw->conf; 1329 static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = { 1330 [IEEE80211_SMPS_AUTOMATIC] = "auto", 1331 [IEEE80211_SMPS_OFF] = "off", 1332 [IEEE80211_SMPS_STATIC] = "static", 1333 [IEEE80211_SMPS_DYNAMIC] = "dynamic", 1334 }; 1335 1336 if (conf->chandef.chan) 1337 wiphy_debug(hw->wiphy, 1338 "%s (freq=%d(%d - %d)/%s idle=%d ps=%d smps=%s)\n", 1339 __func__, 1340 conf->chandef.chan->center_freq, 1341 conf->chandef.center_freq1, 1342 conf->chandef.center_freq2, 1343 hwsim_chanwidths[conf->chandef.width], 1344 !!(conf->flags & IEEE80211_CONF_IDLE), 1345 !!(conf->flags & IEEE80211_CONF_PS), 1346 smps_modes[conf->smps_mode]); 1347 else 1348 wiphy_debug(hw->wiphy, 1349 "%s (freq=0 idle=%d ps=%d smps=%s)\n", 1350 __func__, 1351 !!(conf->flags & IEEE80211_CONF_IDLE), 1352 !!(conf->flags & IEEE80211_CONF_PS), 1353 smps_modes[conf->smps_mode]); 1354 1355 data->idle = !!(conf->flags & IEEE80211_CONF_IDLE); 1356 1357 data->channel = conf->chandef.chan; 1358 1359 WARN_ON(data->channel && data->use_chanctx); 1360 1361 data->power_level = conf->power_level; 1362 if (!data->started || !data->beacon_int) 1363 tasklet_hrtimer_cancel(&data->beacon_timer); 1364 else if (!hrtimer_is_queued(&data->beacon_timer.timer)) { 1365 u64 tsf = mac80211_hwsim_get_tsf(hw, NULL); 1366 u32 bcn_int = data->beacon_int; 1367 u64 until_tbtt = bcn_int - do_div(tsf, bcn_int); 1368 1369 tasklet_hrtimer_start(&data->beacon_timer, 1370 ns_to_ktime(until_tbtt * 1000), 1371 HRTIMER_MODE_REL); 1372 } 1373 1374 return 0; 1375} 1376 1377 1378static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw, 1379 unsigned int changed_flags, 1380 unsigned int *total_flags,u64 multicast) 1381{ 1382 struct mac80211_hwsim_data *data = hw->priv; 1383 1384 wiphy_debug(hw->wiphy, "%s\n", __func__); 1385 1386 data->rx_filter = 0; 1387 if (*total_flags & FIF_PROMISC_IN_BSS) 1388 data->rx_filter |= FIF_PROMISC_IN_BSS; 1389 if (*total_flags & FIF_ALLMULTI) 1390 data->rx_filter |= FIF_ALLMULTI; 1391 1392 *total_flags = data->rx_filter; 1393} 1394 1395static void mac80211_hwsim_bcn_en_iter(void *data, u8 *mac, 1396 struct ieee80211_vif *vif) 1397{ 1398 unsigned int *count = data; 1399 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 1400 1401 if (vp->bcn_en) 1402 (*count)++; 1403} 1404 1405static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw, 1406 struct ieee80211_vif *vif, 1407 struct ieee80211_bss_conf *info, 1408 u32 changed) 1409{ 1410 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 1411 struct mac80211_hwsim_data *data = hw->priv; 1412 1413 hwsim_check_magic(vif); 1414 1415 wiphy_debug(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n", 1416 __func__, changed, vif->addr); 1417 1418 if (changed & BSS_CHANGED_BSSID) { 1419 wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n", 1420 __func__, info->bssid); 1421 memcpy(vp->bssid, info->bssid, ETH_ALEN); 1422 } 1423 1424 if (changed & BSS_CHANGED_ASSOC) { 1425 wiphy_debug(hw->wiphy, " ASSOC: assoc=%d aid=%d\n", 1426 info->assoc, info->aid); 1427 vp->assoc = info->assoc; 1428 vp->aid = info->aid; 1429 } 1430 1431 if (changed & BSS_CHANGED_BEACON_INT) { 1432 wiphy_debug(hw->wiphy, " BCNINT: %d\n", info->beacon_int); 1433 data->beacon_int = info->beacon_int * 1024; 1434 } 1435 1436 if (changed & BSS_CHANGED_BEACON_ENABLED) { 1437 wiphy_debug(hw->wiphy, " BCN EN: %d\n", info->enable_beacon); 1438 vp->bcn_en = info->enable_beacon; 1439 if (data->started && 1440 !hrtimer_is_queued(&data->beacon_timer.timer) && 1441 info->enable_beacon) { 1442 u64 tsf, until_tbtt; 1443 u32 bcn_int; 1444 if (WARN_ON(!data->beacon_int)) 1445 data->beacon_int = 1000 * 1024; 1446 tsf = mac80211_hwsim_get_tsf(hw, vif); 1447 bcn_int = data->beacon_int; 1448 until_tbtt = bcn_int - do_div(tsf, bcn_int); 1449 tasklet_hrtimer_start(&data->beacon_timer, 1450 ns_to_ktime(until_tbtt * 1000), 1451 HRTIMER_MODE_REL); 1452 } else if (!info->enable_beacon) { 1453 unsigned int count = 0; 1454 ieee80211_iterate_active_interfaces_atomic( 1455 data->hw, IEEE80211_IFACE_ITER_NORMAL, 1456 mac80211_hwsim_bcn_en_iter, &count); 1457 wiphy_debug(hw->wiphy, " beaconing vifs remaining: %u", 1458 count); 1459 if (count == 0) 1460 tasklet_hrtimer_cancel(&data->beacon_timer); 1461 } 1462 } 1463 1464 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 1465 wiphy_debug(hw->wiphy, " ERP_CTS_PROT: %d\n", 1466 info->use_cts_prot); 1467 } 1468 1469 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 1470 wiphy_debug(hw->wiphy, " ERP_PREAMBLE: %d\n", 1471 info->use_short_preamble); 1472 } 1473 1474 if (changed & BSS_CHANGED_ERP_SLOT) { 1475 wiphy_debug(hw->wiphy, " ERP_SLOT: %d\n", info->use_short_slot); 1476 } 1477 1478 if (changed & BSS_CHANGED_HT) { 1479 wiphy_debug(hw->wiphy, " HT: op_mode=0x%x\n", 1480 info->ht_operation_mode); 1481 } 1482 1483 if (changed & BSS_CHANGED_BASIC_RATES) { 1484 wiphy_debug(hw->wiphy, " BASIC_RATES: 0x%llx\n", 1485 (unsigned long long) info->basic_rates); 1486 } 1487 1488 if (changed & BSS_CHANGED_TXPOWER) 1489 wiphy_debug(hw->wiphy, " TX Power: %d dBm\n", info->txpower); 1490} 1491 1492static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw, 1493 struct ieee80211_vif *vif, 1494 struct ieee80211_sta *sta) 1495{ 1496 hwsim_check_magic(vif); 1497 hwsim_set_sta_magic(sta); 1498 1499 return 0; 1500} 1501 1502static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw, 1503 struct ieee80211_vif *vif, 1504 struct ieee80211_sta *sta) 1505{ 1506 hwsim_check_magic(vif); 1507 hwsim_clear_sta_magic(sta); 1508 1509 return 0; 1510} 1511 1512static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw, 1513 struct ieee80211_vif *vif, 1514 enum sta_notify_cmd cmd, 1515 struct ieee80211_sta *sta) 1516{ 1517 hwsim_check_magic(vif); 1518 1519 switch (cmd) { 1520 case STA_NOTIFY_SLEEP: 1521 case STA_NOTIFY_AWAKE: 1522 /* TODO: make good use of these flags */ 1523 break; 1524 default: 1525 WARN(1, "Invalid sta notify: %d\n", cmd); 1526 break; 1527 } 1528} 1529 1530static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw, 1531 struct ieee80211_sta *sta, 1532 bool set) 1533{ 1534 hwsim_check_sta_magic(sta); 1535 return 0; 1536} 1537 1538static int mac80211_hwsim_conf_tx( 1539 struct ieee80211_hw *hw, 1540 struct ieee80211_vif *vif, u16 queue, 1541 const struct ieee80211_tx_queue_params *params) 1542{ 1543 wiphy_debug(hw->wiphy, 1544 "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n", 1545 __func__, queue, 1546 params->txop, params->cw_min, 1547 params->cw_max, params->aifs); 1548 return 0; 1549} 1550 1551static int mac80211_hwsim_get_survey( 1552 struct ieee80211_hw *hw, int idx, 1553 struct survey_info *survey) 1554{ 1555 struct ieee80211_conf *conf = &hw->conf; 1556 1557 wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx); 1558 1559 if (idx != 0) 1560 return -ENOENT; 1561 1562 /* Current channel */ 1563 survey->channel = conf->chandef.chan; 1564 1565 /* 1566 * Magically conjured noise level --- this is only ok for simulated hardware. 1567 * 1568 * A real driver which cannot determine the real channel noise MUST NOT 1569 * report any noise, especially not a magically conjured one :-) 1570 */ 1571 survey->filled = SURVEY_INFO_NOISE_DBM; 1572 survey->noise = -92; 1573 1574 return 0; 1575} 1576 1577#ifdef CONFIG_NL80211_TESTMODE 1578/* 1579 * This section contains example code for using netlink 1580 * attributes with the testmode command in nl80211. 1581 */ 1582 1583/* These enums need to be kept in sync with userspace */ 1584enum hwsim_testmode_attr { 1585 __HWSIM_TM_ATTR_INVALID = 0, 1586 HWSIM_TM_ATTR_CMD = 1, 1587 HWSIM_TM_ATTR_PS = 2, 1588 1589 /* keep last */ 1590 __HWSIM_TM_ATTR_AFTER_LAST, 1591 HWSIM_TM_ATTR_MAX = __HWSIM_TM_ATTR_AFTER_LAST - 1 1592}; 1593 1594enum hwsim_testmode_cmd { 1595 HWSIM_TM_CMD_SET_PS = 0, 1596 HWSIM_TM_CMD_GET_PS = 1, 1597 HWSIM_TM_CMD_STOP_QUEUES = 2, 1598 HWSIM_TM_CMD_WAKE_QUEUES = 3, 1599}; 1600 1601static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = { 1602 [HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 }, 1603 [HWSIM_TM_ATTR_PS] = { .type = NLA_U32 }, 1604}; 1605 1606static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw, 1607 struct ieee80211_vif *vif, 1608 void *data, int len) 1609{ 1610 struct mac80211_hwsim_data *hwsim = hw->priv; 1611 struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1]; 1612 struct sk_buff *skb; 1613 int err, ps; 1614 1615 err = nla_parse(tb, HWSIM_TM_ATTR_MAX, data, len, 1616 hwsim_testmode_policy); 1617 if (err) 1618 return err; 1619 1620 if (!tb[HWSIM_TM_ATTR_CMD]) 1621 return -EINVAL; 1622 1623 switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) { 1624 case HWSIM_TM_CMD_SET_PS: 1625 if (!tb[HWSIM_TM_ATTR_PS]) 1626 return -EINVAL; 1627 ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]); 1628 return hwsim_fops_ps_write(hwsim, ps); 1629 case HWSIM_TM_CMD_GET_PS: 1630 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 1631 nla_total_size(sizeof(u32))); 1632 if (!skb) 1633 return -ENOMEM; 1634 if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps)) 1635 goto nla_put_failure; 1636 return cfg80211_testmode_reply(skb); 1637 case HWSIM_TM_CMD_STOP_QUEUES: 1638 ieee80211_stop_queues(hw); 1639 return 0; 1640 case HWSIM_TM_CMD_WAKE_QUEUES: 1641 ieee80211_wake_queues(hw); 1642 return 0; 1643 default: 1644 return -EOPNOTSUPP; 1645 } 1646 1647 nla_put_failure: 1648 kfree_skb(skb); 1649 return -ENOBUFS; 1650} 1651#endif 1652 1653static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw, 1654 struct ieee80211_vif *vif, 1655 enum ieee80211_ampdu_mlme_action action, 1656 struct ieee80211_sta *sta, u16 tid, u16 *ssn, 1657 u8 buf_size) 1658{ 1659 switch (action) { 1660 case IEEE80211_AMPDU_TX_START: 1661 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1662 break; 1663 case IEEE80211_AMPDU_TX_STOP_CONT: 1664 case IEEE80211_AMPDU_TX_STOP_FLUSH: 1665 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 1666 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1667 break; 1668 case IEEE80211_AMPDU_TX_OPERATIONAL: 1669 break; 1670 case IEEE80211_AMPDU_RX_START: 1671 case IEEE80211_AMPDU_RX_STOP: 1672 break; 1673 default: 1674 return -EOPNOTSUPP; 1675 } 1676 1677 return 0; 1678} 1679 1680static void mac80211_hwsim_flush(struct ieee80211_hw *hw, 1681 struct ieee80211_vif *vif, 1682 u32 queues, bool drop) 1683{ 1684 /* Not implemented, queues only on kernel side */ 1685} 1686 1687static void hw_scan_work(struct work_struct *work) 1688{ 1689 struct mac80211_hwsim_data *hwsim = 1690 container_of(work, struct mac80211_hwsim_data, hw_scan.work); 1691 struct cfg80211_scan_request *req = hwsim->hw_scan_request; 1692 int dwell, i; 1693 1694 mutex_lock(&hwsim->mutex); 1695 if (hwsim->scan_chan_idx >= req->n_channels) { 1696 wiphy_debug(hwsim->hw->wiphy, "hw scan complete\n"); 1697 ieee80211_scan_completed(hwsim->hw, false); 1698 hwsim->hw_scan_request = NULL; 1699 hwsim->hw_scan_vif = NULL; 1700 hwsim->tmp_chan = NULL; 1701 mutex_unlock(&hwsim->mutex); 1702 return; 1703 } 1704 1705 wiphy_debug(hwsim->hw->wiphy, "hw scan %d MHz\n", 1706 req->channels[hwsim->scan_chan_idx]->center_freq); 1707 1708 hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx]; 1709 if (hwsim->tmp_chan->flags & IEEE80211_CHAN_NO_IR || 1710 !req->n_ssids) { 1711 dwell = 120; 1712 } else { 1713 dwell = 30; 1714 /* send probes */ 1715 for (i = 0; i < req->n_ssids; i++) { 1716 struct sk_buff *probe; 1717 1718 probe = ieee80211_probereq_get(hwsim->hw, 1719 hwsim->hw_scan_vif, 1720 req->ssids[i].ssid, 1721 req->ssids[i].ssid_len, 1722 req->ie_len); 1723 if (!probe) 1724 continue; 1725 1726 if (req->ie_len) 1727 memcpy(skb_put(probe, req->ie_len), req->ie, 1728 req->ie_len); 1729 1730 local_bh_disable(); 1731 mac80211_hwsim_tx_frame(hwsim->hw, probe, 1732 hwsim->tmp_chan); 1733 local_bh_enable(); 1734 } 1735 } 1736 ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 1737 msecs_to_jiffies(dwell)); 1738 hwsim->scan_chan_idx++; 1739 mutex_unlock(&hwsim->mutex); 1740} 1741 1742static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw, 1743 struct ieee80211_vif *vif, 1744 struct ieee80211_scan_request *hw_req) 1745{ 1746 struct mac80211_hwsim_data *hwsim = hw->priv; 1747 struct cfg80211_scan_request *req = &hw_req->req; 1748 1749 mutex_lock(&hwsim->mutex); 1750 if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) { 1751 mutex_unlock(&hwsim->mutex); 1752 return -EBUSY; 1753 } 1754 hwsim->hw_scan_request = req; 1755 hwsim->hw_scan_vif = vif; 1756 hwsim->scan_chan_idx = 0; 1757 mutex_unlock(&hwsim->mutex); 1758 1759 wiphy_debug(hw->wiphy, "hwsim hw_scan request\n"); 1760 1761 ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0); 1762 1763 return 0; 1764} 1765 1766static void mac80211_hwsim_cancel_hw_scan(struct ieee80211_hw *hw, 1767 struct ieee80211_vif *vif) 1768{ 1769 struct mac80211_hwsim_data *hwsim = hw->priv; 1770 1771 wiphy_debug(hw->wiphy, "hwsim cancel_hw_scan\n"); 1772 1773 cancel_delayed_work_sync(&hwsim->hw_scan); 1774 1775 mutex_lock(&hwsim->mutex); 1776 ieee80211_scan_completed(hwsim->hw, true); 1777 hwsim->tmp_chan = NULL; 1778 hwsim->hw_scan_request = NULL; 1779 hwsim->hw_scan_vif = NULL; 1780 mutex_unlock(&hwsim->mutex); 1781} 1782 1783static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw) 1784{ 1785 struct mac80211_hwsim_data *hwsim = hw->priv; 1786 1787 mutex_lock(&hwsim->mutex); 1788 1789 if (hwsim->scanning) { 1790 printk(KERN_DEBUG "two hwsim sw_scans detected!\n"); 1791 goto out; 1792 } 1793 1794 printk(KERN_DEBUG "hwsim sw_scan request, prepping stuff\n"); 1795 hwsim->scanning = true; 1796 1797out: 1798 mutex_unlock(&hwsim->mutex); 1799} 1800 1801static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw) 1802{ 1803 struct mac80211_hwsim_data *hwsim = hw->priv; 1804 1805 mutex_lock(&hwsim->mutex); 1806 1807 printk(KERN_DEBUG "hwsim sw_scan_complete\n"); 1808 hwsim->scanning = false; 1809 1810 mutex_unlock(&hwsim->mutex); 1811} 1812 1813static void hw_roc_done(struct work_struct *work) 1814{ 1815 struct mac80211_hwsim_data *hwsim = 1816 container_of(work, struct mac80211_hwsim_data, roc_done.work); 1817 1818 mutex_lock(&hwsim->mutex); 1819 ieee80211_remain_on_channel_expired(hwsim->hw); 1820 hwsim->tmp_chan = NULL; 1821 mutex_unlock(&hwsim->mutex); 1822 1823 wiphy_debug(hwsim->hw->wiphy, "hwsim ROC expired\n"); 1824} 1825 1826static int mac80211_hwsim_roc(struct ieee80211_hw *hw, 1827 struct ieee80211_vif *vif, 1828 struct ieee80211_channel *chan, 1829 int duration, 1830 enum ieee80211_roc_type type) 1831{ 1832 struct mac80211_hwsim_data *hwsim = hw->priv; 1833 1834 mutex_lock(&hwsim->mutex); 1835 if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) { 1836 mutex_unlock(&hwsim->mutex); 1837 return -EBUSY; 1838 } 1839 1840 hwsim->tmp_chan = chan; 1841 mutex_unlock(&hwsim->mutex); 1842 1843 wiphy_debug(hw->wiphy, "hwsim ROC (%d MHz, %d ms)\n", 1844 chan->center_freq, duration); 1845 1846 ieee80211_ready_on_channel(hw); 1847 1848 ieee80211_queue_delayed_work(hw, &hwsim->roc_done, 1849 msecs_to_jiffies(duration)); 1850 return 0; 1851} 1852 1853static int mac80211_hwsim_croc(struct ieee80211_hw *hw) 1854{ 1855 struct mac80211_hwsim_data *hwsim = hw->priv; 1856 1857 cancel_delayed_work_sync(&hwsim->roc_done); 1858 1859 mutex_lock(&hwsim->mutex); 1860 hwsim->tmp_chan = NULL; 1861 mutex_unlock(&hwsim->mutex); 1862 1863 wiphy_debug(hw->wiphy, "hwsim ROC canceled\n"); 1864 1865 return 0; 1866} 1867 1868static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw, 1869 struct ieee80211_chanctx_conf *ctx) 1870{ 1871 hwsim_set_chanctx_magic(ctx); 1872 wiphy_debug(hw->wiphy, 1873 "add channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n", 1874 ctx->def.chan->center_freq, ctx->def.width, 1875 ctx->def.center_freq1, ctx->def.center_freq2); 1876 return 0; 1877} 1878 1879static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw, 1880 struct ieee80211_chanctx_conf *ctx) 1881{ 1882 wiphy_debug(hw->wiphy, 1883 "remove channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n", 1884 ctx->def.chan->center_freq, ctx->def.width, 1885 ctx->def.center_freq1, ctx->def.center_freq2); 1886 hwsim_check_chanctx_magic(ctx); 1887 hwsim_clear_chanctx_magic(ctx); 1888} 1889 1890static void mac80211_hwsim_change_chanctx(struct ieee80211_hw *hw, 1891 struct ieee80211_chanctx_conf *ctx, 1892 u32 changed) 1893{ 1894 hwsim_check_chanctx_magic(ctx); 1895 wiphy_debug(hw->wiphy, 1896 "change channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n", 1897 ctx->def.chan->center_freq, ctx->def.width, 1898 ctx->def.center_freq1, ctx->def.center_freq2); 1899} 1900 1901static int mac80211_hwsim_assign_vif_chanctx(struct ieee80211_hw *hw, 1902 struct ieee80211_vif *vif, 1903 struct ieee80211_chanctx_conf *ctx) 1904{ 1905 hwsim_check_magic(vif); 1906 hwsim_check_chanctx_magic(ctx); 1907 1908 return 0; 1909} 1910 1911static void mac80211_hwsim_unassign_vif_chanctx(struct ieee80211_hw *hw, 1912 struct ieee80211_vif *vif, 1913 struct ieee80211_chanctx_conf *ctx) 1914{ 1915 hwsim_check_magic(vif); 1916 hwsim_check_chanctx_magic(ctx); 1917} 1918 1919static const struct ieee80211_ops mac80211_hwsim_ops = { 1920 .tx = mac80211_hwsim_tx, 1921 .start = mac80211_hwsim_start, 1922 .stop = mac80211_hwsim_stop, 1923 .add_interface = mac80211_hwsim_add_interface, 1924 .change_interface = mac80211_hwsim_change_interface, 1925 .remove_interface = mac80211_hwsim_remove_interface, 1926 .config = mac80211_hwsim_config, 1927 .configure_filter = mac80211_hwsim_configure_filter, 1928 .bss_info_changed = mac80211_hwsim_bss_info_changed, 1929 .sta_add = mac80211_hwsim_sta_add, 1930 .sta_remove = mac80211_hwsim_sta_remove, 1931 .sta_notify = mac80211_hwsim_sta_notify, 1932 .set_tim = mac80211_hwsim_set_tim, 1933 .conf_tx = mac80211_hwsim_conf_tx, 1934 .get_survey = mac80211_hwsim_get_survey, 1935 CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd) 1936 .ampdu_action = mac80211_hwsim_ampdu_action, 1937 .sw_scan_start = mac80211_hwsim_sw_scan, 1938 .sw_scan_complete = mac80211_hwsim_sw_scan_complete, 1939 .flush = mac80211_hwsim_flush, 1940 .get_tsf = mac80211_hwsim_get_tsf, 1941 .set_tsf = mac80211_hwsim_set_tsf, 1942}; 1943 1944static struct ieee80211_ops mac80211_hwsim_mchan_ops; 1945 1946static int mac80211_hwsim_create_radio(int channels, const char *reg_alpha2, 1947 const struct ieee80211_regdomain *regd, 1948 bool reg_strict, bool p2p_device, 1949 bool use_chanctx) 1950{ 1951 int err; 1952 u8 addr[ETH_ALEN]; 1953 struct mac80211_hwsim_data *data; 1954 struct ieee80211_hw *hw; 1955 enum ieee80211_band band; 1956 const struct ieee80211_ops *ops = &mac80211_hwsim_ops; 1957 int idx; 1958 1959 if (WARN_ON(channels > 1 && !use_chanctx)) 1960 return -EINVAL; 1961 1962 spin_lock_bh(&hwsim_radio_lock); 1963 idx = hwsim_radio_idx++; 1964 spin_unlock_bh(&hwsim_radio_lock); 1965 1966 if (use_chanctx) 1967 ops = &mac80211_hwsim_mchan_ops; 1968 hw = ieee80211_alloc_hw(sizeof(*data), ops); 1969 if (!hw) { 1970 printk(KERN_DEBUG "mac80211_hwsim: ieee80211_alloc_hw failed\n"); 1971 err = -ENOMEM; 1972 goto failed; 1973 } 1974 data = hw->priv; 1975 data->hw = hw; 1976 1977 data->dev = device_create(hwsim_class, NULL, 0, hw, "hwsim%d", idx); 1978 if (IS_ERR(data->dev)) { 1979 printk(KERN_DEBUG 1980 "mac80211_hwsim: device_create failed (%ld)\n", 1981 PTR_ERR(data->dev)); 1982 err = -ENOMEM; 1983 goto failed_drvdata; 1984 } 1985 data->dev->driver = &mac80211_hwsim_driver.driver; 1986 err = device_bind_driver(data->dev); 1987 if (err != 0) { 1988 printk(KERN_DEBUG "mac80211_hwsim: device_bind_driver failed (%d)\n", 1989 err); 1990 goto failed_bind; 1991 } 1992 1993 skb_queue_head_init(&data->pending); 1994 1995 SET_IEEE80211_DEV(hw, data->dev); 1996 memset(addr, 0, ETH_ALEN); 1997 addr[0] = 0x02; 1998 addr[3] = idx >> 8; 1999 addr[4] = idx; 2000 memcpy(data->addresses[0].addr, addr, ETH_ALEN); 2001 memcpy(data->addresses[1].addr, addr, ETH_ALEN); 2002 data->addresses[1].addr[0] |= 0x40; 2003 hw->wiphy->n_addresses = 2; 2004 hw->wiphy->addresses = data->addresses; 2005 2006 data->channels = channels; 2007 data->use_chanctx = use_chanctx; 2008 data->idx = idx; 2009 2010 if (data->use_chanctx) { 2011 hw->wiphy->max_scan_ssids = 255; 2012 hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; 2013 hw->wiphy->max_remain_on_channel_duration = 1000; 2014 /* For channels > 1 DFS is not allowed */ 2015 hw->wiphy->n_iface_combinations = 1; 2016 hw->wiphy->iface_combinations = &data->if_combination; 2017 if (p2p_device) 2018 data->if_combination = hwsim_if_comb_p2p_dev[0]; 2019 else 2020 data->if_combination = hwsim_if_comb[0]; 2021 data->if_combination.num_different_channels = data->channels; 2022 } else if (p2p_device) { 2023 hw->wiphy->iface_combinations = hwsim_if_comb_p2p_dev; 2024 hw->wiphy->n_iface_combinations = 2025 ARRAY_SIZE(hwsim_if_comb_p2p_dev); 2026 } else { 2027 hw->wiphy->iface_combinations = hwsim_if_comb; 2028 hw->wiphy->n_iface_combinations = ARRAY_SIZE(hwsim_if_comb); 2029 } 2030 2031 INIT_DELAYED_WORK(&data->roc_done, hw_roc_done); 2032 INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work); 2033 2034 hw->queues = 5; 2035 hw->offchannel_tx_hw_queue = 4; 2036 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 2037 BIT(NL80211_IFTYPE_AP) | 2038 BIT(NL80211_IFTYPE_P2P_CLIENT) | 2039 BIT(NL80211_IFTYPE_P2P_GO) | 2040 BIT(NL80211_IFTYPE_ADHOC) | 2041 BIT(NL80211_IFTYPE_MESH_POINT); 2042 2043 if (p2p_device) 2044 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_DEVICE); 2045 2046 hw->flags = IEEE80211_HW_MFP_CAPABLE | 2047 IEEE80211_HW_SIGNAL_DBM | 2048 IEEE80211_HW_AMPDU_AGGREGATION | 2049 IEEE80211_HW_WANT_MONITOR_VIF | 2050 IEEE80211_HW_QUEUE_CONTROL | 2051 IEEE80211_HW_SUPPORTS_HT_CCK_RATES | 2052 IEEE80211_HW_CHANCTX_STA_CSA; 2053 if (rctbl) 2054 hw->flags |= IEEE80211_HW_SUPPORTS_RC_TABLE; 2055 2056 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS | 2057 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL | 2058 WIPHY_FLAG_AP_UAPSD | 2059 WIPHY_FLAG_HAS_CHANNEL_SWITCH; 2060 hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR | 2061 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 2062 NL80211_FEATURE_STATIC_SMPS | 2063 NL80211_FEATURE_DYNAMIC_SMPS; 2064 2065 /* ask mac80211 to reserve space for magic */ 2066 hw->vif_data_size = sizeof(struct hwsim_vif_priv); 2067 hw->sta_data_size = sizeof(struct hwsim_sta_priv); 2068 hw->chanctx_data_size = sizeof(struct hwsim_chanctx_priv); 2069 2070 memcpy(data->channels_2ghz, hwsim_channels_2ghz, 2071 sizeof(hwsim_channels_2ghz)); 2072 memcpy(data->channels_5ghz, hwsim_channels_5ghz, 2073 sizeof(hwsim_channels_5ghz)); 2074 memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates)); 2075 2076 for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) { 2077 struct ieee80211_supported_band *sband = &data->bands[band]; 2078 switch (band) { 2079 case IEEE80211_BAND_2GHZ: 2080 sband->channels = data->channels_2ghz; 2081 sband->n_channels = ARRAY_SIZE(hwsim_channels_2ghz); 2082 sband->bitrates = data->rates; 2083 sband->n_bitrates = ARRAY_SIZE(hwsim_rates); 2084 break; 2085 case IEEE80211_BAND_5GHZ: 2086 sband->channels = data->channels_5ghz; 2087 sband->n_channels = ARRAY_SIZE(hwsim_channels_5ghz); 2088 sband->bitrates = data->rates + 4; 2089 sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4; 2090 break; 2091 default: 2092 continue; 2093 } 2094 2095 sband->ht_cap.ht_supported = true; 2096 sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 2097 IEEE80211_HT_CAP_GRN_FLD | 2098 IEEE80211_HT_CAP_SGI_40 | 2099 IEEE80211_HT_CAP_DSSSCCK40; 2100 sband->ht_cap.ampdu_factor = 0x3; 2101 sband->ht_cap.ampdu_density = 0x6; 2102 memset(&sband->ht_cap.mcs, 0, 2103 sizeof(sband->ht_cap.mcs)); 2104 sband->ht_cap.mcs.rx_mask[0] = 0xff; 2105 sband->ht_cap.mcs.rx_mask[1] = 0xff; 2106 sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 2107 2108 hw->wiphy->bands[band] = sband; 2109 2110 sband->vht_cap.vht_supported = true; 2111 sband->vht_cap.cap = 2112 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 | 2113 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ | 2114 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ | 2115 IEEE80211_VHT_CAP_RXLDPC | 2116 IEEE80211_VHT_CAP_SHORT_GI_80 | 2117 IEEE80211_VHT_CAP_SHORT_GI_160 | 2118 IEEE80211_VHT_CAP_TXSTBC | 2119 IEEE80211_VHT_CAP_RXSTBC_1 | 2120 IEEE80211_VHT_CAP_RXSTBC_2 | 2121 IEEE80211_VHT_CAP_RXSTBC_3 | 2122 IEEE80211_VHT_CAP_RXSTBC_4 | 2123 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK; 2124 sband->vht_cap.vht_mcs.rx_mcs_map = 2125 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_8 << 0 | 2126 IEEE80211_VHT_MCS_SUPPORT_0_8 << 2 | 2127 IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 | 2128 IEEE80211_VHT_MCS_SUPPORT_0_8 << 6 | 2129 IEEE80211_VHT_MCS_SUPPORT_0_8 << 8 | 2130 IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 | 2131 IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 | 2132 IEEE80211_VHT_MCS_SUPPORT_0_8 << 14); 2133 sband->vht_cap.vht_mcs.tx_mcs_map = 2134 sband->vht_cap.vht_mcs.rx_mcs_map; 2135 } 2136 2137 /* By default all radios belong to the first group */ 2138 data->group = 1; 2139 mutex_init(&data->mutex); 2140 2141 /* Enable frame retransmissions for lossy channels */ 2142 hw->max_rates = 4; 2143 hw->max_rate_tries = 11; 2144 2145 if (reg_strict) 2146 hw->wiphy->regulatory_flags |= REGULATORY_STRICT_REG; 2147 if (regd) { 2148 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG; 2149 wiphy_apply_custom_regulatory(hw->wiphy, regd); 2150 /* give the regulatory workqueue a chance to run */ 2151 schedule_timeout_interruptible(1); 2152 } 2153 2154 err = ieee80211_register_hw(hw); 2155 if (err < 0) { 2156 printk(KERN_DEBUG "mac80211_hwsim: ieee80211_register_hw failed (%d)\n", 2157 err); 2158 goto failed_hw; 2159 } 2160 2161 wiphy_debug(hw->wiphy, "hwaddr %pM registered\n", hw->wiphy->perm_addr); 2162 2163 if (reg_alpha2) 2164 regulatory_hint(hw->wiphy, reg_alpha2); 2165 2166 data->debugfs = debugfs_create_dir("hwsim", hw->wiphy->debugfsdir); 2167 debugfs_create_file("ps", 0666, data->debugfs, data, &hwsim_fops_ps); 2168 debugfs_create_file("group", 0666, data->debugfs, data, 2169 &hwsim_fops_group); 2170 if (!data->use_chanctx) 2171 debugfs_create_file("dfs_simulate_radar", 0222, 2172 data->debugfs, 2173 data, &hwsim_simulate_radar); 2174 2175 tasklet_hrtimer_init(&data->beacon_timer, 2176 mac80211_hwsim_beacon, 2177 CLOCK_MONOTONIC_RAW, HRTIMER_MODE_ABS); 2178 2179 spin_lock_bh(&hwsim_radio_lock); 2180 list_add_tail(&data->list, &hwsim_radios); 2181 spin_unlock_bh(&hwsim_radio_lock); 2182 2183 return idx; 2184 2185failed_hw: 2186 device_release_driver(data->dev); 2187failed_bind: 2188 device_unregister(data->dev); 2189failed_drvdata: 2190 ieee80211_free_hw(hw); 2191failed: 2192 return err; 2193} 2194 2195static void mac80211_hwsim_destroy_radio(struct mac80211_hwsim_data *data) 2196{ 2197 debugfs_remove_recursive(data->debugfs); 2198 ieee80211_unregister_hw(data->hw); 2199 device_release_driver(data->dev); 2200 device_unregister(data->dev); 2201 ieee80211_free_hw(data->hw); 2202} 2203 2204static void mac80211_hwsim_free(void) 2205{ 2206 struct mac80211_hwsim_data *data; 2207 2208 spin_lock_bh(&hwsim_radio_lock); 2209 while ((data = list_first_entry_or_null(&hwsim_radios, 2210 struct mac80211_hwsim_data, 2211 list))) { 2212 list_del(&data->list); 2213 spin_unlock_bh(&hwsim_radio_lock); 2214 mac80211_hwsim_destroy_radio(data); 2215 spin_lock_bh(&hwsim_radio_lock); 2216 } 2217 spin_unlock_bh(&hwsim_radio_lock); 2218 class_destroy(hwsim_class); 2219} 2220 2221static const struct net_device_ops hwsim_netdev_ops = { 2222 .ndo_start_xmit = hwsim_mon_xmit, 2223 .ndo_change_mtu = eth_change_mtu, 2224 .ndo_set_mac_address = eth_mac_addr, 2225 .ndo_validate_addr = eth_validate_addr, 2226}; 2227 2228static void hwsim_mon_setup(struct net_device *dev) 2229{ 2230 dev->netdev_ops = &hwsim_netdev_ops; 2231 dev->destructor = free_netdev; 2232 ether_setup(dev); 2233 dev->tx_queue_len = 0; 2234 dev->type = ARPHRD_IEEE80211_RADIOTAP; 2235 memset(dev->dev_addr, 0, ETH_ALEN); 2236 dev->dev_addr[0] = 0x12; 2237} 2238 2239static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr) 2240{ 2241 struct mac80211_hwsim_data *data; 2242 bool _found = false; 2243 2244 spin_lock_bh(&hwsim_radio_lock); 2245 list_for_each_entry(data, &hwsim_radios, list) { 2246 if (memcmp(data->addresses[1].addr, addr, ETH_ALEN) == 0) { 2247 _found = true; 2248 break; 2249 } 2250 } 2251 spin_unlock_bh(&hwsim_radio_lock); 2252 2253 if (!_found) 2254 return NULL; 2255 2256 return data; 2257} 2258 2259static int hwsim_tx_info_frame_received_nl(struct sk_buff *skb_2, 2260 struct genl_info *info) 2261{ 2262 2263 struct ieee80211_hdr *hdr; 2264 struct mac80211_hwsim_data *data2; 2265 struct ieee80211_tx_info *txi; 2266 struct hwsim_tx_rate *tx_attempts; 2267 unsigned long ret_skb_ptr; 2268 struct sk_buff *skb, *tmp; 2269 const u8 *src; 2270 unsigned int hwsim_flags; 2271 int i; 2272 bool found = false; 2273 2274 if (info->snd_portid != wmediumd_portid) 2275 return -EINVAL; 2276 2277 if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] || 2278 !info->attrs[HWSIM_ATTR_FLAGS] || 2279 !info->attrs[HWSIM_ATTR_COOKIE] || 2280 !info->attrs[HWSIM_ATTR_TX_INFO]) 2281 goto out; 2282 2283 src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]); 2284 hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]); 2285 ret_skb_ptr = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]); 2286 2287 data2 = get_hwsim_data_ref_from_addr(src); 2288 if (!data2) 2289 goto out; 2290 2291 /* look for the skb matching the cookie passed back from user */ 2292 skb_queue_walk_safe(&data2->pending, skb, tmp) { 2293 if ((unsigned long)skb == ret_skb_ptr) { 2294 skb_unlink(skb, &data2->pending); 2295 found = true; 2296 break; 2297 } 2298 } 2299 2300 /* not found */ 2301 if (!found) 2302 goto out; 2303 2304 /* Tx info received because the frame was broadcasted on user space, 2305 so we get all the necessary info: tx attempts and skb control buff */ 2306 2307 tx_attempts = (struct hwsim_tx_rate *)nla_data( 2308 info->attrs[HWSIM_ATTR_TX_INFO]); 2309 2310 /* now send back TX status */ 2311 txi = IEEE80211_SKB_CB(skb); 2312 2313 ieee80211_tx_info_clear_status(txi); 2314 2315 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 2316 txi->status.rates[i].idx = tx_attempts[i].idx; 2317 txi->status.rates[i].count = tx_attempts[i].count; 2318 /*txi->status.rates[i].flags = 0;*/ 2319 } 2320 2321 txi->status.ack_signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]); 2322 2323 if (!(hwsim_flags & HWSIM_TX_CTL_NO_ACK) && 2324 (hwsim_flags & HWSIM_TX_STAT_ACK)) { 2325 if (skb->len >= 16) { 2326 hdr = (struct ieee80211_hdr *) skb->data; 2327 mac80211_hwsim_monitor_ack(data2->channel, 2328 hdr->addr2); 2329 } 2330 txi->flags |= IEEE80211_TX_STAT_ACK; 2331 } 2332 ieee80211_tx_status_irqsafe(data2->hw, skb); 2333 return 0; 2334out: 2335 return -EINVAL; 2336 2337} 2338 2339static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2, 2340 struct genl_info *info) 2341{ 2342 2343 struct mac80211_hwsim_data *data2; 2344 struct ieee80211_rx_status rx_status; 2345 const u8 *dst; 2346 int frame_data_len; 2347 void *frame_data; 2348 struct sk_buff *skb = NULL; 2349 2350 if (info->snd_portid != wmediumd_portid) 2351 return -EINVAL; 2352 2353 if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] || 2354 !info->attrs[HWSIM_ATTR_FRAME] || 2355 !info->attrs[HWSIM_ATTR_RX_RATE] || 2356 !info->attrs[HWSIM_ATTR_SIGNAL]) 2357 goto out; 2358 2359 dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]); 2360 frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]); 2361 frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]); 2362 2363 /* Allocate new skb here */ 2364 skb = alloc_skb(frame_data_len, GFP_KERNEL); 2365 if (skb == NULL) 2366 goto err; 2367 2368 if (frame_data_len > IEEE80211_MAX_DATA_LEN) 2369 goto err; 2370 2371 /* Copy the data */ 2372 memcpy(skb_put(skb, frame_data_len), frame_data, frame_data_len); 2373 2374 data2 = get_hwsim_data_ref_from_addr(dst); 2375 if (!data2) 2376 goto out; 2377 2378 /* check if radio is configured properly */ 2379 2380 if (data2->idle || !data2->started) 2381 goto out; 2382 2383 /* A frame is received from user space */ 2384 memset(&rx_status, 0, sizeof(rx_status)); 2385 rx_status.freq = data2->channel->center_freq; 2386 rx_status.band = data2->channel->band; 2387 rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]); 2388 rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]); 2389 2390 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status)); 2391 ieee80211_rx_irqsafe(data2->hw, skb); 2392 2393 return 0; 2394err: 2395 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__); 2396 goto out; 2397out: 2398 dev_kfree_skb(skb); 2399 return -EINVAL; 2400} 2401 2402static int hwsim_register_received_nl(struct sk_buff *skb_2, 2403 struct genl_info *info) 2404{ 2405 struct mac80211_hwsim_data *data; 2406 int chans = 1; 2407 2408 spin_lock_bh(&hwsim_radio_lock); 2409 list_for_each_entry(data, &hwsim_radios, list) 2410 chans = max(chans, data->channels); 2411 spin_unlock_bh(&hwsim_radio_lock); 2412 2413 /* In the future we should revise the userspace API and allow it 2414 * to set a flag that it does support multi-channel, then we can 2415 * let this pass conditionally on the flag. 2416 * For current userspace, prohibit it since it won't work right. 2417 */ 2418 if (chans > 1) 2419 return -EOPNOTSUPP; 2420 2421 if (wmediumd_portid) 2422 return -EBUSY; 2423 2424 wmediumd_portid = info->snd_portid; 2425 2426 printk(KERN_DEBUG "mac80211_hwsim: received a REGISTER, " 2427 "switching to wmediumd mode with pid %d\n", info->snd_portid); 2428 2429 return 0; 2430} 2431 2432static int hwsim_create_radio_nl(struct sk_buff *msg, struct genl_info *info) 2433{ 2434 unsigned int chans = channels; 2435 const char *alpha2 = NULL; 2436 const struct ieee80211_regdomain *regd = NULL; 2437 bool reg_strict = info->attrs[HWSIM_ATTR_REG_STRICT_REG]; 2438 bool p2p_device = info->attrs[HWSIM_ATTR_SUPPORT_P2P_DEVICE]; 2439 bool use_chanctx; 2440 2441 if (info->attrs[HWSIM_ATTR_CHANNELS]) 2442 chans = nla_get_u32(info->attrs[HWSIM_ATTR_CHANNELS]); 2443 2444 if (info->attrs[HWSIM_ATTR_USE_CHANCTX]) 2445 use_chanctx = true; 2446 else 2447 use_chanctx = (chans > 1); 2448 2449 if (info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]) 2450 alpha2 = nla_data(info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]); 2451 2452 if (info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]) { 2453 u32 idx = nla_get_u32(info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]); 2454 2455 if (idx >= ARRAY_SIZE(hwsim_world_regdom_custom)) 2456 return -EINVAL; 2457 regd = hwsim_world_regdom_custom[idx]; 2458 } 2459 2460 return mac80211_hwsim_create_radio(chans, alpha2, regd, reg_strict, 2461 p2p_device, use_chanctx); 2462} 2463 2464static int hwsim_destroy_radio_nl(struct sk_buff *msg, struct genl_info *info) 2465{ 2466 struct mac80211_hwsim_data *data; 2467 int idx; 2468 2469 if (!info->attrs[HWSIM_ATTR_RADIO_ID]) 2470 return -EINVAL; 2471 idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]); 2472 2473 spin_lock_bh(&hwsim_radio_lock); 2474 list_for_each_entry(data, &hwsim_radios, list) { 2475 if (data->idx != idx) 2476 continue; 2477 list_del(&data->list); 2478 spin_unlock_bh(&hwsim_radio_lock); 2479 mac80211_hwsim_destroy_radio(data); 2480 return 0; 2481 } 2482 spin_unlock_bh(&hwsim_radio_lock); 2483 2484 return -ENODEV; 2485} 2486 2487/* Generic Netlink operations array */ 2488static const struct genl_ops hwsim_ops[] = { 2489 { 2490 .cmd = HWSIM_CMD_REGISTER, 2491 .policy = hwsim_genl_policy, 2492 .doit = hwsim_register_received_nl, 2493 .flags = GENL_ADMIN_PERM, 2494 }, 2495 { 2496 .cmd = HWSIM_CMD_FRAME, 2497 .policy = hwsim_genl_policy, 2498 .doit = hwsim_cloned_frame_received_nl, 2499 }, 2500 { 2501 .cmd = HWSIM_CMD_TX_INFO_FRAME, 2502 .policy = hwsim_genl_policy, 2503 .doit = hwsim_tx_info_frame_received_nl, 2504 }, 2505 { 2506 .cmd = HWSIM_CMD_CREATE_RADIO, 2507 .policy = hwsim_genl_policy, 2508 .doit = hwsim_create_radio_nl, 2509 .flags = GENL_ADMIN_PERM, 2510 }, 2511 { 2512 .cmd = HWSIM_CMD_DESTROY_RADIO, 2513 .policy = hwsim_genl_policy, 2514 .doit = hwsim_destroy_radio_nl, 2515 .flags = GENL_ADMIN_PERM, 2516 }, 2517}; 2518 2519static int mac80211_hwsim_netlink_notify(struct notifier_block *nb, 2520 unsigned long state, 2521 void *_notify) 2522{ 2523 struct netlink_notify *notify = _notify; 2524 2525 if (state != NETLINK_URELEASE) 2526 return NOTIFY_DONE; 2527 2528 if (notify->portid == wmediumd_portid) { 2529 printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink" 2530 " socket, switching to perfect channel medium\n"); 2531 wmediumd_portid = 0; 2532 } 2533 return NOTIFY_DONE; 2534 2535} 2536 2537static struct notifier_block hwsim_netlink_notifier = { 2538 .notifier_call = mac80211_hwsim_netlink_notify, 2539}; 2540 2541static int hwsim_init_netlink(void) 2542{ 2543 int rc; 2544 2545 printk(KERN_INFO "mac80211_hwsim: initializing netlink\n"); 2546 2547 rc = genl_register_family_with_ops(&hwsim_genl_family, hwsim_ops); 2548 if (rc) 2549 goto failure; 2550 2551 rc = netlink_register_notifier(&hwsim_netlink_notifier); 2552 if (rc) 2553 goto failure; 2554 2555 return 0; 2556 2557failure: 2558 printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__); 2559 return -EINVAL; 2560} 2561 2562static void hwsim_exit_netlink(void) 2563{ 2564 /* unregister the notifier */ 2565 netlink_unregister_notifier(&hwsim_netlink_notifier); 2566 /* unregister the family */ 2567 genl_unregister_family(&hwsim_genl_family); 2568} 2569 2570static int __init init_mac80211_hwsim(void) 2571{ 2572 int i, err; 2573 2574 if (radios < 0 || radios > 100) 2575 return -EINVAL; 2576 2577 if (channels < 1) 2578 return -EINVAL; 2579 2580 mac80211_hwsim_mchan_ops = mac80211_hwsim_ops; 2581 mac80211_hwsim_mchan_ops.hw_scan = mac80211_hwsim_hw_scan; 2582 mac80211_hwsim_mchan_ops.cancel_hw_scan = mac80211_hwsim_cancel_hw_scan; 2583 mac80211_hwsim_mchan_ops.sw_scan_start = NULL; 2584 mac80211_hwsim_mchan_ops.sw_scan_complete = NULL; 2585 mac80211_hwsim_mchan_ops.remain_on_channel = mac80211_hwsim_roc; 2586 mac80211_hwsim_mchan_ops.cancel_remain_on_channel = mac80211_hwsim_croc; 2587 mac80211_hwsim_mchan_ops.add_chanctx = mac80211_hwsim_add_chanctx; 2588 mac80211_hwsim_mchan_ops.remove_chanctx = mac80211_hwsim_remove_chanctx; 2589 mac80211_hwsim_mchan_ops.change_chanctx = mac80211_hwsim_change_chanctx; 2590 mac80211_hwsim_mchan_ops.assign_vif_chanctx = 2591 mac80211_hwsim_assign_vif_chanctx; 2592 mac80211_hwsim_mchan_ops.unassign_vif_chanctx = 2593 mac80211_hwsim_unassign_vif_chanctx; 2594 2595 spin_lock_init(&hwsim_radio_lock); 2596 INIT_LIST_HEAD(&hwsim_radios); 2597 2598 err = platform_driver_register(&mac80211_hwsim_driver); 2599 if (err) 2600 return err; 2601 2602 hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim"); 2603 if (IS_ERR(hwsim_class)) { 2604 err = PTR_ERR(hwsim_class); 2605 goto out_unregister_driver; 2606 } 2607 2608 for (i = 0; i < radios; i++) { 2609 const char *reg_alpha2 = NULL; 2610 const struct ieee80211_regdomain *regd = NULL; 2611 bool reg_strict = false; 2612 2613 switch (regtest) { 2614 case HWSIM_REGTEST_DIFF_COUNTRY: 2615 if (i < ARRAY_SIZE(hwsim_alpha2s)) 2616 reg_alpha2 = hwsim_alpha2s[i]; 2617 break; 2618 case HWSIM_REGTEST_DRIVER_REG_FOLLOW: 2619 if (!i) 2620 reg_alpha2 = hwsim_alpha2s[0]; 2621 break; 2622 case HWSIM_REGTEST_STRICT_ALL: 2623 reg_strict = true; 2624 case HWSIM_REGTEST_DRIVER_REG_ALL: 2625 reg_alpha2 = hwsim_alpha2s[0]; 2626 break; 2627 case HWSIM_REGTEST_WORLD_ROAM: 2628 if (i == 0) 2629 regd = &hwsim_world_regdom_custom_01; 2630 break; 2631 case HWSIM_REGTEST_CUSTOM_WORLD: 2632 regd = &hwsim_world_regdom_custom_01; 2633 break; 2634 case HWSIM_REGTEST_CUSTOM_WORLD_2: 2635 if (i == 0) 2636 regd = &hwsim_world_regdom_custom_01; 2637 else if (i == 1) 2638 regd = &hwsim_world_regdom_custom_02; 2639 break; 2640 case HWSIM_REGTEST_STRICT_FOLLOW: 2641 if (i == 0) { 2642 reg_strict = true; 2643 reg_alpha2 = hwsim_alpha2s[0]; 2644 } 2645 break; 2646 case HWSIM_REGTEST_STRICT_AND_DRIVER_REG: 2647 if (i == 0) { 2648 reg_strict = true; 2649 reg_alpha2 = hwsim_alpha2s[0]; 2650 } else if (i == 1) { 2651 reg_alpha2 = hwsim_alpha2s[1]; 2652 } 2653 break; 2654 case HWSIM_REGTEST_ALL: 2655 switch (i) { 2656 case 0: 2657 regd = &hwsim_world_regdom_custom_01; 2658 break; 2659 case 1: 2660 regd = &hwsim_world_regdom_custom_02; 2661 break; 2662 case 2: 2663 reg_alpha2 = hwsim_alpha2s[0]; 2664 break; 2665 case 3: 2666 reg_alpha2 = hwsim_alpha2s[1]; 2667 break; 2668 case 4: 2669 reg_strict = true; 2670 reg_alpha2 = hwsim_alpha2s[2]; 2671 break; 2672 } 2673 break; 2674 default: 2675 break; 2676 } 2677 2678 err = mac80211_hwsim_create_radio(channels, reg_alpha2, 2679 regd, reg_strict, 2680 support_p2p_device, 2681 channels > 1); 2682 if (err < 0) 2683 goto out_free_radios; 2684 } 2685 2686 hwsim_mon = alloc_netdev(0, "hwsim%d", NET_NAME_UNKNOWN, 2687 hwsim_mon_setup); 2688 if (hwsim_mon == NULL) { 2689 err = -ENOMEM; 2690 goto out_free_radios; 2691 } 2692 2693 rtnl_lock(); 2694 err = dev_alloc_name(hwsim_mon, hwsim_mon->name); 2695 if (err < 0) { 2696 rtnl_unlock(); 2697 goto out_free_radios; 2698 } 2699 2700 err = register_netdevice(hwsim_mon); 2701 if (err < 0) { 2702 rtnl_unlock(); 2703 goto out_free_mon; 2704 } 2705 rtnl_unlock(); 2706 2707 err = hwsim_init_netlink(); 2708 if (err < 0) 2709 goto out_free_mon; 2710 2711 return 0; 2712 2713out_free_mon: 2714 free_netdev(hwsim_mon); 2715out_free_radios: 2716 mac80211_hwsim_free(); 2717out_unregister_driver: 2718 platform_driver_unregister(&mac80211_hwsim_driver); 2719 return err; 2720} 2721module_init(init_mac80211_hwsim); 2722 2723static void __exit exit_mac80211_hwsim(void) 2724{ 2725 printk(KERN_DEBUG "mac80211_hwsim: unregister radios\n"); 2726 2727 hwsim_exit_netlink(); 2728 2729 mac80211_hwsim_free(); 2730 unregister_netdev(hwsim_mon); 2731 platform_driver_unregister(&mac80211_hwsim_driver); 2732} 2733module_exit(exit_mac80211_hwsim); 2734