1/* 2 * mac80211_hwsim - software simulator of 802.11 radio(s) for mac80211 3 * Copyright (c) 2008, Jouni Malinen <j@w1.fi> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 */ 9 10/* 11 * TODO: 12 * - IBSS mode simulation (Beacon transmission with competition for "air time") 13 * - RX filtering based on filter configuration (data->rx_filter) 14 */ 15 16#include <linux/list.h> 17#include <linux/slab.h> 18#include <linux/spinlock.h> 19#include <net/dst.h> 20#include <net/xfrm.h> 21#include <net/mac80211.h> 22#include <net/ieee80211_radiotap.h> 23#include <linux/if_arp.h> 24#include <linux/rtnetlink.h> 25#include <linux/etherdevice.h> 26#include <linux/debugfs.h> 27 28MODULE_AUTHOR("Jouni Malinen"); 29MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211"); 30MODULE_LICENSE("GPL"); 31 32static int radios = 2; 33module_param(radios, int, 0444); 34MODULE_PARM_DESC(radios, "Number of simulated radios"); 35 36static bool fake_hw_scan; 37module_param(fake_hw_scan, bool, 0444); 38MODULE_PARM_DESC(fake_hw_scan, "Install fake (no-op) hw-scan handler"); 39 40/** 41 * enum hwsim_regtest - the type of regulatory tests we offer 42 * 43 * These are the different values you can use for the regtest 44 * module parameter. This is useful to help test world roaming 45 * and the driver regulatory_hint() call and combinations of these. 46 * If you want to do specific alpha2 regulatory domain tests simply 47 * use the userspace regulatory request as that will be respected as 48 * well without the need of this module parameter. This is designed 49 * only for testing the driver regulatory request, world roaming 50 * and all possible combinations. 51 * 52 * @HWSIM_REGTEST_DISABLED: No regulatory tests are performed, 53 * this is the default value. 54 * @HWSIM_REGTEST_DRIVER_REG_FOLLOW: Used for testing the driver regulatory 55 * hint, only one driver regulatory hint will be sent as such the 56 * secondary radios are expected to follow. 57 * @HWSIM_REGTEST_DRIVER_REG_ALL: Used for testing the driver regulatory 58 * request with all radios reporting the same regulatory domain. 59 * @HWSIM_REGTEST_DIFF_COUNTRY: Used for testing the drivers calling 60 * different regulatory domains requests. Expected behaviour is for 61 * an intersection to occur but each device will still use their 62 * respective regulatory requested domains. Subsequent radios will 63 * use the resulting intersection. 64 * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We acomplish 65 * this by using a custom beacon-capable regulatory domain for the first 66 * radio. All other device world roam. 67 * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory 68 * domain requests. All radios will adhere to this custom world regulatory 69 * domain. 70 * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory 71 * domain requests. The first radio will adhere to the first custom world 72 * regulatory domain, the second one to the second custom world regulatory 73 * domain. All other devices will world roam. 74 * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain 75 * settings, only the first radio will send a regulatory domain request 76 * and use strict settings. The rest of the radios are expected to follow. 77 * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain 78 * settings. All radios will adhere to this. 79 * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory 80 * domain settings, combined with secondary driver regulatory domain 81 * settings. The first radio will get a strict regulatory domain setting 82 * using the first driver regulatory request and the second radio will use 83 * non-strict settings using the second driver regulatory request. All 84 * other devices should follow the intersection created between the 85 * first two. 86 * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need 87 * at least 6 radios for a complete test. We will test in this order: 88 * 1 - driver custom world regulatory domain 89 * 2 - second custom world regulatory domain 90 * 3 - first driver regulatory domain request 91 * 4 - second driver regulatory domain request 92 * 5 - strict regulatory domain settings using the third driver regulatory 93 * domain request 94 * 6 and on - should follow the intersection of the 3rd, 4rth and 5th radio 95 * regulatory requests. 96 */ 97enum hwsim_regtest { 98 HWSIM_REGTEST_DISABLED = 0, 99 HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1, 100 HWSIM_REGTEST_DRIVER_REG_ALL = 2, 101 HWSIM_REGTEST_DIFF_COUNTRY = 3, 102 HWSIM_REGTEST_WORLD_ROAM = 4, 103 HWSIM_REGTEST_CUSTOM_WORLD = 5, 104 HWSIM_REGTEST_CUSTOM_WORLD_2 = 6, 105 HWSIM_REGTEST_STRICT_FOLLOW = 7, 106 HWSIM_REGTEST_STRICT_ALL = 8, 107 HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9, 108 HWSIM_REGTEST_ALL = 10, 109}; 110 111/* Set to one of the HWSIM_REGTEST_* values above */ 112static int regtest = HWSIM_REGTEST_DISABLED; 113module_param(regtest, int, 0444); 114MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run"); 115 116static const char *hwsim_alpha2s[] = { 117 "FI", 118 "AL", 119 "US", 120 "DE", 121 "JP", 122 "AL", 123}; 124 125static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = { 126 .n_reg_rules = 4, 127 .alpha2 = "99", 128 .reg_rules = { 129 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0), 130 REG_RULE(2484-10, 2484+10, 40, 0, 20, 0), 131 REG_RULE(5150-10, 5240+10, 40, 0, 30, 0), 132 REG_RULE(5745-10, 5825+10, 40, 0, 30, 0), 133 } 134}; 135 136static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = { 137 .n_reg_rules = 2, 138 .alpha2 = "99", 139 .reg_rules = { 140 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0), 141 REG_RULE(5725-10, 5850+10, 40, 0, 30, 142 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS), 143 } 144}; 145 146struct hwsim_vif_priv { 147 u32 magic; 148 u8 bssid[ETH_ALEN]; 149 bool assoc; 150 u16 aid; 151}; 152 153#define HWSIM_VIF_MAGIC 0x69537748 154 155static inline void hwsim_check_magic(struct ieee80211_vif *vif) 156{ 157 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 158 WARN_ON(vp->magic != HWSIM_VIF_MAGIC); 159} 160 161static inline void hwsim_set_magic(struct ieee80211_vif *vif) 162{ 163 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 164 vp->magic = HWSIM_VIF_MAGIC; 165} 166 167static inline void hwsim_clear_magic(struct ieee80211_vif *vif) 168{ 169 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 170 vp->magic = 0; 171} 172 173struct hwsim_sta_priv { 174 u32 magic; 175}; 176 177#define HWSIM_STA_MAGIC 0x6d537748 178 179static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta) 180{ 181 struct hwsim_sta_priv *sp = (void *)sta->drv_priv; 182 WARN_ON(sp->magic != HWSIM_STA_MAGIC); 183} 184 185static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta) 186{ 187 struct hwsim_sta_priv *sp = (void *)sta->drv_priv; 188 sp->magic = HWSIM_STA_MAGIC; 189} 190 191static inline void hwsim_clear_sta_magic(struct ieee80211_sta *sta) 192{ 193 struct hwsim_sta_priv *sp = (void *)sta->drv_priv; 194 sp->magic = 0; 195} 196 197static struct class *hwsim_class; 198 199static struct net_device *hwsim_mon; /* global monitor netdev */ 200 201#define CHAN2G(_freq) { \ 202 .band = IEEE80211_BAND_2GHZ, \ 203 .center_freq = (_freq), \ 204 .hw_value = (_freq), \ 205 .max_power = 20, \ 206} 207 208#define CHAN5G(_freq) { \ 209 .band = IEEE80211_BAND_5GHZ, \ 210 .center_freq = (_freq), \ 211 .hw_value = (_freq), \ 212 .max_power = 20, \ 213} 214 215static const struct ieee80211_channel hwsim_channels_2ghz[] = { 216 CHAN2G(2412), /* Channel 1 */ 217 CHAN2G(2417), /* Channel 2 */ 218 CHAN2G(2422), /* Channel 3 */ 219 CHAN2G(2427), /* Channel 4 */ 220 CHAN2G(2432), /* Channel 5 */ 221 CHAN2G(2437), /* Channel 6 */ 222 CHAN2G(2442), /* Channel 7 */ 223 CHAN2G(2447), /* Channel 8 */ 224 CHAN2G(2452), /* Channel 9 */ 225 CHAN2G(2457), /* Channel 10 */ 226 CHAN2G(2462), /* Channel 11 */ 227 CHAN2G(2467), /* Channel 12 */ 228 CHAN2G(2472), /* Channel 13 */ 229 CHAN2G(2484), /* Channel 14 */ 230}; 231 232static const struct ieee80211_channel hwsim_channels_5ghz[] = { 233 CHAN5G(5180), /* Channel 36 */ 234 CHAN5G(5200), /* Channel 40 */ 235 CHAN5G(5220), /* Channel 44 */ 236 CHAN5G(5240), /* Channel 48 */ 237 238 CHAN5G(5260), /* Channel 52 */ 239 CHAN5G(5280), /* Channel 56 */ 240 CHAN5G(5300), /* Channel 60 */ 241 CHAN5G(5320), /* Channel 64 */ 242 243 CHAN5G(5500), /* Channel 100 */ 244 CHAN5G(5520), /* Channel 104 */ 245 CHAN5G(5540), /* Channel 108 */ 246 CHAN5G(5560), /* Channel 112 */ 247 CHAN5G(5580), /* Channel 116 */ 248 CHAN5G(5600), /* Channel 120 */ 249 CHAN5G(5620), /* Channel 124 */ 250 CHAN5G(5640), /* Channel 128 */ 251 CHAN5G(5660), /* Channel 132 */ 252 CHAN5G(5680), /* Channel 136 */ 253 CHAN5G(5700), /* Channel 140 */ 254 255 CHAN5G(5745), /* Channel 149 */ 256 CHAN5G(5765), /* Channel 153 */ 257 CHAN5G(5785), /* Channel 157 */ 258 CHAN5G(5805), /* Channel 161 */ 259 CHAN5G(5825), /* Channel 165 */ 260}; 261 262static const struct ieee80211_rate hwsim_rates[] = { 263 { .bitrate = 10 }, 264 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 265 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 266 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 267 { .bitrate = 60 }, 268 { .bitrate = 90 }, 269 { .bitrate = 120 }, 270 { .bitrate = 180 }, 271 { .bitrate = 240 }, 272 { .bitrate = 360 }, 273 { .bitrate = 480 }, 274 { .bitrate = 540 } 275}; 276 277static spinlock_t hwsim_radio_lock; 278static struct list_head hwsim_radios; 279 280struct mac80211_hwsim_data { 281 struct list_head list; 282 struct ieee80211_hw *hw; 283 struct device *dev; 284 struct ieee80211_supported_band bands[2]; 285 struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)]; 286 struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)]; 287 struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)]; 288 289 struct mac_address addresses[2]; 290 291 struct ieee80211_channel *channel; 292 unsigned long beacon_int; /* in jiffies unit */ 293 unsigned int rx_filter; 294 bool started, idle, scanning; 295 struct mutex mutex; 296 struct timer_list beacon_timer; 297 enum ps_mode { 298 PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL 299 } ps; 300 bool ps_poll_pending; 301 struct dentry *debugfs; 302 struct dentry *debugfs_ps; 303 304 /* 305 * Only radios in the same group can communicate together (the 306 * channel has to match too). Each bit represents a group. A 307 * radio can be in more then one group. 308 */ 309 u64 group; 310 struct dentry *debugfs_group; 311}; 312 313 314struct hwsim_radiotap_hdr { 315 struct ieee80211_radiotap_header hdr; 316 u8 rt_flags; 317 u8 rt_rate; 318 __le16 rt_channel; 319 __le16 rt_chbitmask; 320} __packed; 321 322 323static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb, 324 struct net_device *dev) 325{ 326 /* TODO: allow packet injection */ 327 dev_kfree_skb(skb); 328 return NETDEV_TX_OK; 329} 330 331 332static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw, 333 struct sk_buff *tx_skb) 334{ 335 struct mac80211_hwsim_data *data = hw->priv; 336 struct sk_buff *skb; 337 struct hwsim_radiotap_hdr *hdr; 338 u16 flags; 339 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb); 340 struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info); 341 342 if (!netif_running(hwsim_mon)) 343 return; 344 345 skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC); 346 if (skb == NULL) 347 return; 348 349 hdr = (struct hwsim_radiotap_hdr *) skb_push(skb, sizeof(*hdr)); 350 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION; 351 hdr->hdr.it_pad = 0; 352 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr)); 353 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) | 354 (1 << IEEE80211_RADIOTAP_RATE) | 355 (1 << IEEE80211_RADIOTAP_CHANNEL)); 356 hdr->rt_flags = 0; 357 hdr->rt_rate = txrate->bitrate / 5; 358 hdr->rt_channel = cpu_to_le16(data->channel->center_freq); 359 flags = IEEE80211_CHAN_2GHZ; 360 if (txrate->flags & IEEE80211_RATE_ERP_G) 361 flags |= IEEE80211_CHAN_OFDM; 362 else 363 flags |= IEEE80211_CHAN_CCK; 364 hdr->rt_chbitmask = cpu_to_le16(flags); 365 366 skb->dev = hwsim_mon; 367 skb_set_mac_header(skb, 0); 368 skb->ip_summed = CHECKSUM_UNNECESSARY; 369 skb->pkt_type = PACKET_OTHERHOST; 370 skb->protocol = htons(ETH_P_802_2); 371 memset(skb->cb, 0, sizeof(skb->cb)); 372 netif_rx(skb); 373} 374 375 376static void mac80211_hwsim_monitor_ack(struct ieee80211_hw *hw, const u8 *addr) 377{ 378 struct mac80211_hwsim_data *data = hw->priv; 379 struct sk_buff *skb; 380 struct hwsim_radiotap_hdr *hdr; 381 u16 flags; 382 struct ieee80211_hdr *hdr11; 383 384 if (!netif_running(hwsim_mon)) 385 return; 386 387 skb = dev_alloc_skb(100); 388 if (skb == NULL) 389 return; 390 391 hdr = (struct hwsim_radiotap_hdr *) skb_put(skb, sizeof(*hdr)); 392 hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION; 393 hdr->hdr.it_pad = 0; 394 hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr)); 395 hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) | 396 (1 << IEEE80211_RADIOTAP_CHANNEL)); 397 hdr->rt_flags = 0; 398 hdr->rt_rate = 0; 399 hdr->rt_channel = cpu_to_le16(data->channel->center_freq); 400 flags = IEEE80211_CHAN_2GHZ; 401 hdr->rt_chbitmask = cpu_to_le16(flags); 402 403 hdr11 = (struct ieee80211_hdr *) skb_put(skb, 10); 404 hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | 405 IEEE80211_STYPE_ACK); 406 hdr11->duration_id = cpu_to_le16(0); 407 memcpy(hdr11->addr1, addr, ETH_ALEN); 408 409 skb->dev = hwsim_mon; 410 skb_set_mac_header(skb, 0); 411 skb->ip_summed = CHECKSUM_UNNECESSARY; 412 skb->pkt_type = PACKET_OTHERHOST; 413 skb->protocol = htons(ETH_P_802_2); 414 memset(skb->cb, 0, sizeof(skb->cb)); 415 netif_rx(skb); 416} 417 418 419static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data, 420 struct sk_buff *skb) 421{ 422 switch (data->ps) { 423 case PS_DISABLED: 424 return true; 425 case PS_ENABLED: 426 return false; 427 case PS_AUTO_POLL: 428 /* TODO: accept (some) Beacons by default and other frames only 429 * if pending PS-Poll has been sent */ 430 return true; 431 case PS_MANUAL_POLL: 432 /* Allow unicast frames to own address if there is a pending 433 * PS-Poll */ 434 if (data->ps_poll_pending && 435 memcmp(data->hw->wiphy->perm_addr, skb->data + 4, 436 ETH_ALEN) == 0) { 437 data->ps_poll_pending = false; 438 return true; 439 } 440 return false; 441 } 442 443 return true; 444} 445 446 447struct mac80211_hwsim_addr_match_data { 448 bool ret; 449 const u8 *addr; 450}; 451 452static void mac80211_hwsim_addr_iter(void *data, u8 *mac, 453 struct ieee80211_vif *vif) 454{ 455 struct mac80211_hwsim_addr_match_data *md = data; 456 if (memcmp(mac, md->addr, ETH_ALEN) == 0) 457 md->ret = true; 458} 459 460 461static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data, 462 const u8 *addr) 463{ 464 struct mac80211_hwsim_addr_match_data md; 465 466 if (memcmp(addr, data->hw->wiphy->perm_addr, ETH_ALEN) == 0) 467 return true; 468 469 md.ret = false; 470 md.addr = addr; 471 ieee80211_iterate_active_interfaces_atomic(data->hw, 472 mac80211_hwsim_addr_iter, 473 &md); 474 475 return md.ret; 476} 477 478 479static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw, 480 struct sk_buff *skb) 481{ 482 struct mac80211_hwsim_data *data = hw->priv, *data2; 483 bool ack = false; 484 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 485 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 486 struct ieee80211_rx_status rx_status; 487 488 if (data->idle) { 489 wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n"); 490 return false; 491 } 492 493 memset(&rx_status, 0, sizeof(rx_status)); 494 /* TODO: set mactime */ 495 rx_status.freq = data->channel->center_freq; 496 rx_status.band = data->channel->band; 497 rx_status.rate_idx = info->control.rates[0].idx; 498 /* TODO: simulate real signal strength (and optional packet loss) */ 499 rx_status.signal = -50; 500 501 if (data->ps != PS_DISABLED) 502 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM); 503 504 /* release the skb's source info */ 505 skb_orphan(skb); 506 skb_dst_drop(skb); 507 skb->mark = 0; 508 secpath_reset(skb); 509 nf_reset(skb); 510 511 /* Copy skb to all enabled radios that are on the current frequency */ 512 spin_lock(&hwsim_radio_lock); 513 list_for_each_entry(data2, &hwsim_radios, list) { 514 struct sk_buff *nskb; 515 516 if (data == data2) 517 continue; 518 519 if (data2->idle || !data2->started || 520 !hwsim_ps_rx_ok(data2, skb) || 521 !data->channel || !data2->channel || 522 data->channel->center_freq != data2->channel->center_freq || 523 !(data->group & data2->group)) 524 continue; 525 526 nskb = skb_copy(skb, GFP_ATOMIC); 527 if (nskb == NULL) 528 continue; 529 530 if (mac80211_hwsim_addr_match(data2, hdr->addr1)) 531 ack = true; 532 memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status)); 533 ieee80211_rx_irqsafe(data2->hw, nskb); 534 } 535 spin_unlock(&hwsim_radio_lock); 536 537 return ack; 538} 539 540 541static int mac80211_hwsim_tx(struct ieee80211_hw *hw, struct sk_buff *skb) 542{ 543 bool ack; 544 struct ieee80211_tx_info *txi; 545 546 mac80211_hwsim_monitor_rx(hw, skb); 547 548 if (skb->len < 10) { 549 /* Should not happen; just a sanity check for addr1 use */ 550 dev_kfree_skb(skb); 551 return NETDEV_TX_OK; 552 } 553 554 ack = mac80211_hwsim_tx_frame(hw, skb); 555 if (ack && skb->len >= 16) { 556 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 557 mac80211_hwsim_monitor_ack(hw, hdr->addr2); 558 } 559 560 txi = IEEE80211_SKB_CB(skb); 561 562 if (txi->control.vif) 563 hwsim_check_magic(txi->control.vif); 564 if (txi->control.sta) 565 hwsim_check_sta_magic(txi->control.sta); 566 567 ieee80211_tx_info_clear_status(txi); 568 if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack) 569 txi->flags |= IEEE80211_TX_STAT_ACK; 570 ieee80211_tx_status_irqsafe(hw, skb); 571 return NETDEV_TX_OK; 572} 573 574 575static int mac80211_hwsim_start(struct ieee80211_hw *hw) 576{ 577 struct mac80211_hwsim_data *data = hw->priv; 578 wiphy_debug(hw->wiphy, "%s\n", __func__); 579 data->started = 1; 580 return 0; 581} 582 583 584static void mac80211_hwsim_stop(struct ieee80211_hw *hw) 585{ 586 struct mac80211_hwsim_data *data = hw->priv; 587 data->started = 0; 588 del_timer(&data->beacon_timer); 589 wiphy_debug(hw->wiphy, "%s\n", __func__); 590} 591 592 593static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw, 594 struct ieee80211_vif *vif) 595{ 596 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n", 597 __func__, vif->type, vif->addr); 598 hwsim_set_magic(vif); 599 return 0; 600} 601 602 603static void mac80211_hwsim_remove_interface( 604 struct ieee80211_hw *hw, struct ieee80211_vif *vif) 605{ 606 wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n", 607 __func__, vif->type, vif->addr); 608 hwsim_check_magic(vif); 609 hwsim_clear_magic(vif); 610} 611 612 613static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac, 614 struct ieee80211_vif *vif) 615{ 616 struct ieee80211_hw *hw = arg; 617 struct sk_buff *skb; 618 struct ieee80211_tx_info *info; 619 620 hwsim_check_magic(vif); 621 622 if (vif->type != NL80211_IFTYPE_AP && 623 vif->type != NL80211_IFTYPE_MESH_POINT) 624 return; 625 626 skb = ieee80211_beacon_get(hw, vif); 627 if (skb == NULL) 628 return; 629 info = IEEE80211_SKB_CB(skb); 630 631 mac80211_hwsim_monitor_rx(hw, skb); 632 mac80211_hwsim_tx_frame(hw, skb); 633 dev_kfree_skb(skb); 634} 635 636 637static void mac80211_hwsim_beacon(unsigned long arg) 638{ 639 struct ieee80211_hw *hw = (struct ieee80211_hw *) arg; 640 struct mac80211_hwsim_data *data = hw->priv; 641 642 if (!data->started) 643 return; 644 645 ieee80211_iterate_active_interfaces_atomic( 646 hw, mac80211_hwsim_beacon_tx, hw); 647 648 data->beacon_timer.expires = jiffies + data->beacon_int; 649 add_timer(&data->beacon_timer); 650} 651 652static const char *hwsim_chantypes[] = { 653 [NL80211_CHAN_NO_HT] = "noht", 654 [NL80211_CHAN_HT20] = "ht20", 655 [NL80211_CHAN_HT40MINUS] = "ht40-", 656 [NL80211_CHAN_HT40PLUS] = "ht40+", 657}; 658 659static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed) 660{ 661 struct mac80211_hwsim_data *data = hw->priv; 662 struct ieee80211_conf *conf = &hw->conf; 663 static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = { 664 [IEEE80211_SMPS_AUTOMATIC] = "auto", 665 [IEEE80211_SMPS_OFF] = "off", 666 [IEEE80211_SMPS_STATIC] = "static", 667 [IEEE80211_SMPS_DYNAMIC] = "dynamic", 668 }; 669 670 wiphy_debug(hw->wiphy, 671 "%s (freq=%d/%s idle=%d ps=%d smps=%s)\n", 672 __func__, 673 conf->channel->center_freq, 674 hwsim_chantypes[conf->channel_type], 675 !!(conf->flags & IEEE80211_CONF_IDLE), 676 !!(conf->flags & IEEE80211_CONF_PS), 677 smps_modes[conf->smps_mode]); 678 679 data->idle = !!(conf->flags & IEEE80211_CONF_IDLE); 680 681 data->channel = conf->channel; 682 if (!data->started || !data->beacon_int) 683 del_timer(&data->beacon_timer); 684 else 685 mod_timer(&data->beacon_timer, jiffies + data->beacon_int); 686 687 return 0; 688} 689 690 691static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw, 692 unsigned int changed_flags, 693 unsigned int *total_flags,u64 multicast) 694{ 695 struct mac80211_hwsim_data *data = hw->priv; 696 697 wiphy_debug(hw->wiphy, "%s\n", __func__); 698 699 data->rx_filter = 0; 700 if (*total_flags & FIF_PROMISC_IN_BSS) 701 data->rx_filter |= FIF_PROMISC_IN_BSS; 702 if (*total_flags & FIF_ALLMULTI) 703 data->rx_filter |= FIF_ALLMULTI; 704 705 *total_flags = data->rx_filter; 706} 707 708static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw, 709 struct ieee80211_vif *vif, 710 struct ieee80211_bss_conf *info, 711 u32 changed) 712{ 713 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 714 struct mac80211_hwsim_data *data = hw->priv; 715 716 hwsim_check_magic(vif); 717 718 wiphy_debug(hw->wiphy, "%s(changed=0x%x)\n", __func__, changed); 719 720 if (changed & BSS_CHANGED_BSSID) { 721 wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n", 722 __func__, info->bssid); 723 memcpy(vp->bssid, info->bssid, ETH_ALEN); 724 } 725 726 if (changed & BSS_CHANGED_ASSOC) { 727 wiphy_debug(hw->wiphy, " ASSOC: assoc=%d aid=%d\n", 728 info->assoc, info->aid); 729 vp->assoc = info->assoc; 730 vp->aid = info->aid; 731 } 732 733 if (changed & BSS_CHANGED_BEACON_INT) { 734 wiphy_debug(hw->wiphy, " BCNINT: %d\n", info->beacon_int); 735 data->beacon_int = 1024 * info->beacon_int / 1000 * HZ / 1000; 736 if (WARN_ON(!data->beacon_int)) 737 data->beacon_int = 1; 738 if (data->started) 739 mod_timer(&data->beacon_timer, 740 jiffies + data->beacon_int); 741 } 742 743 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 744 wiphy_debug(hw->wiphy, " ERP_CTS_PROT: %d\n", 745 info->use_cts_prot); 746 } 747 748 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 749 wiphy_debug(hw->wiphy, " ERP_PREAMBLE: %d\n", 750 info->use_short_preamble); 751 } 752 753 if (changed & BSS_CHANGED_ERP_SLOT) { 754 wiphy_debug(hw->wiphy, " ERP_SLOT: %d\n", info->use_short_slot); 755 } 756 757 if (changed & BSS_CHANGED_HT) { 758 wiphy_debug(hw->wiphy, " HT: op_mode=0x%x, chantype=%s\n", 759 info->ht_operation_mode, 760 hwsim_chantypes[info->channel_type]); 761 } 762 763 if (changed & BSS_CHANGED_BASIC_RATES) { 764 wiphy_debug(hw->wiphy, " BASIC_RATES: 0x%llx\n", 765 (unsigned long long) info->basic_rates); 766 } 767} 768 769static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw, 770 struct ieee80211_vif *vif, 771 struct ieee80211_sta *sta) 772{ 773 hwsim_check_magic(vif); 774 hwsim_set_sta_magic(sta); 775 776 return 0; 777} 778 779static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw, 780 struct ieee80211_vif *vif, 781 struct ieee80211_sta *sta) 782{ 783 hwsim_check_magic(vif); 784 hwsim_clear_sta_magic(sta); 785 786 return 0; 787} 788 789static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw, 790 struct ieee80211_vif *vif, 791 enum sta_notify_cmd cmd, 792 struct ieee80211_sta *sta) 793{ 794 hwsim_check_magic(vif); 795 796 switch (cmd) { 797 case STA_NOTIFY_SLEEP: 798 case STA_NOTIFY_AWAKE: 799 /* TODO: make good use of these flags */ 800 break; 801 default: 802 WARN(1, "Invalid sta notify: %d\n", cmd); 803 break; 804 } 805} 806 807static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw, 808 struct ieee80211_sta *sta, 809 bool set) 810{ 811 hwsim_check_sta_magic(sta); 812 return 0; 813} 814 815static int mac80211_hwsim_conf_tx( 816 struct ieee80211_hw *hw, u16 queue, 817 const struct ieee80211_tx_queue_params *params) 818{ 819 wiphy_debug(hw->wiphy, 820 "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n", 821 __func__, queue, 822 params->txop, params->cw_min, 823 params->cw_max, params->aifs); 824 return 0; 825} 826 827static int mac80211_hwsim_get_survey( 828 struct ieee80211_hw *hw, int idx, 829 struct survey_info *survey) 830{ 831 struct ieee80211_conf *conf = &hw->conf; 832 833 wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx); 834 835 if (idx != 0) 836 return -ENOENT; 837 838 /* Current channel */ 839 survey->channel = conf->channel; 840 841 /* 842 * Magically conjured noise level --- this is only ok for simulated hardware. 843 * 844 * A real driver which cannot determine the real channel noise MUST NOT 845 * report any noise, especially not a magically conjured one :-) 846 */ 847 survey->filled = SURVEY_INFO_NOISE_DBM; 848 survey->noise = -92; 849 850 return 0; 851} 852 853#ifdef CONFIG_NL80211_TESTMODE 854/* 855 * This section contains example code for using netlink 856 * attributes with the testmode command in nl80211. 857 */ 858 859/* These enums need to be kept in sync with userspace */ 860enum hwsim_testmode_attr { 861 __HWSIM_TM_ATTR_INVALID = 0, 862 HWSIM_TM_ATTR_CMD = 1, 863 HWSIM_TM_ATTR_PS = 2, 864 865 /* keep last */ 866 __HWSIM_TM_ATTR_AFTER_LAST, 867 HWSIM_TM_ATTR_MAX = __HWSIM_TM_ATTR_AFTER_LAST - 1 868}; 869 870enum hwsim_testmode_cmd { 871 HWSIM_TM_CMD_SET_PS = 0, 872 HWSIM_TM_CMD_GET_PS = 1, 873}; 874 875static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = { 876 [HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 }, 877 [HWSIM_TM_ATTR_PS] = { .type = NLA_U32 }, 878}; 879 880static int hwsim_fops_ps_write(void *dat, u64 val); 881 882static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw, 883 void *data, int len) 884{ 885 struct mac80211_hwsim_data *hwsim = hw->priv; 886 struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1]; 887 struct sk_buff *skb; 888 int err, ps; 889 890 err = nla_parse(tb, HWSIM_TM_ATTR_MAX, data, len, 891 hwsim_testmode_policy); 892 if (err) 893 return err; 894 895 if (!tb[HWSIM_TM_ATTR_CMD]) 896 return -EINVAL; 897 898 switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) { 899 case HWSIM_TM_CMD_SET_PS: 900 if (!tb[HWSIM_TM_ATTR_PS]) 901 return -EINVAL; 902 ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]); 903 return hwsim_fops_ps_write(hwsim, ps); 904 case HWSIM_TM_CMD_GET_PS: 905 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 906 nla_total_size(sizeof(u32))); 907 if (!skb) 908 return -ENOMEM; 909 NLA_PUT_U32(skb, HWSIM_TM_ATTR_PS, hwsim->ps); 910 return cfg80211_testmode_reply(skb); 911 default: 912 return -EOPNOTSUPP; 913 } 914 915 nla_put_failure: 916 kfree_skb(skb); 917 return -ENOBUFS; 918} 919#endif 920 921static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw, 922 struct ieee80211_vif *vif, 923 enum ieee80211_ampdu_mlme_action action, 924 struct ieee80211_sta *sta, u16 tid, u16 *ssn) 925{ 926 switch (action) { 927 case IEEE80211_AMPDU_TX_START: 928 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 929 break; 930 case IEEE80211_AMPDU_TX_STOP: 931 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 932 break; 933 case IEEE80211_AMPDU_TX_OPERATIONAL: 934 break; 935 case IEEE80211_AMPDU_RX_START: 936 case IEEE80211_AMPDU_RX_STOP: 937 break; 938 default: 939 return -EOPNOTSUPP; 940 } 941 942 return 0; 943} 944 945static void mac80211_hwsim_flush(struct ieee80211_hw *hw, bool drop) 946{ 947 /* 948 * In this special case, there's nothing we need to 949 * do because hwsim does transmission synchronously. 950 * In the future, when it does transmissions via 951 * userspace, we may need to do something. 952 */ 953} 954 955struct hw_scan_done { 956 struct delayed_work w; 957 struct ieee80211_hw *hw; 958}; 959 960static void hw_scan_done(struct work_struct *work) 961{ 962 struct hw_scan_done *hsd = 963 container_of(work, struct hw_scan_done, w.work); 964 965 ieee80211_scan_completed(hsd->hw, false); 966 kfree(hsd); 967} 968 969static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw, 970 struct ieee80211_vif *vif, 971 struct cfg80211_scan_request *req) 972{ 973 struct hw_scan_done *hsd = kzalloc(sizeof(*hsd), GFP_KERNEL); 974 int i; 975 976 if (!hsd) 977 return -ENOMEM; 978 979 hsd->hw = hw; 980 INIT_DELAYED_WORK(&hsd->w, hw_scan_done); 981 982 printk(KERN_DEBUG "hwsim hw_scan request\n"); 983 for (i = 0; i < req->n_channels; i++) 984 printk(KERN_DEBUG "hwsim hw_scan freq %d\n", 985 req->channels[i]->center_freq); 986 987 ieee80211_queue_delayed_work(hw, &hsd->w, 2 * HZ); 988 989 return 0; 990} 991 992static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw) 993{ 994 struct mac80211_hwsim_data *hwsim = hw->priv; 995 996 mutex_lock(&hwsim->mutex); 997 998 if (hwsim->scanning) { 999 printk(KERN_DEBUG "two hwsim sw_scans detected!\n"); 1000 goto out; 1001 } 1002 1003 printk(KERN_DEBUG "hwsim sw_scan request, prepping stuff\n"); 1004 hwsim->scanning = true; 1005 1006out: 1007 mutex_unlock(&hwsim->mutex); 1008} 1009 1010static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw) 1011{ 1012 struct mac80211_hwsim_data *hwsim = hw->priv; 1013 1014 mutex_lock(&hwsim->mutex); 1015 1016 printk(KERN_DEBUG "hwsim sw_scan_complete\n"); 1017 hwsim->scanning = false; 1018 1019 mutex_unlock(&hwsim->mutex); 1020} 1021 1022static struct ieee80211_ops mac80211_hwsim_ops = 1023{ 1024 .tx = mac80211_hwsim_tx, 1025 .start = mac80211_hwsim_start, 1026 .stop = mac80211_hwsim_stop, 1027 .add_interface = mac80211_hwsim_add_interface, 1028 .remove_interface = mac80211_hwsim_remove_interface, 1029 .config = mac80211_hwsim_config, 1030 .configure_filter = mac80211_hwsim_configure_filter, 1031 .bss_info_changed = mac80211_hwsim_bss_info_changed, 1032 .sta_add = mac80211_hwsim_sta_add, 1033 .sta_remove = mac80211_hwsim_sta_remove, 1034 .sta_notify = mac80211_hwsim_sta_notify, 1035 .set_tim = mac80211_hwsim_set_tim, 1036 .conf_tx = mac80211_hwsim_conf_tx, 1037 .get_survey = mac80211_hwsim_get_survey, 1038 CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd) 1039 .ampdu_action = mac80211_hwsim_ampdu_action, 1040 .sw_scan_start = mac80211_hwsim_sw_scan, 1041 .sw_scan_complete = mac80211_hwsim_sw_scan_complete, 1042 .flush = mac80211_hwsim_flush, 1043}; 1044 1045 1046static void mac80211_hwsim_free(void) 1047{ 1048 struct list_head tmplist, *i, *tmp; 1049 struct mac80211_hwsim_data *data, *tmpdata; 1050 1051 INIT_LIST_HEAD(&tmplist); 1052 1053 spin_lock_bh(&hwsim_radio_lock); 1054 list_for_each_safe(i, tmp, &hwsim_radios) 1055 list_move(i, &tmplist); 1056 spin_unlock_bh(&hwsim_radio_lock); 1057 1058 list_for_each_entry_safe(data, tmpdata, &tmplist, list) { 1059 debugfs_remove(data->debugfs_group); 1060 debugfs_remove(data->debugfs_ps); 1061 debugfs_remove(data->debugfs); 1062 ieee80211_unregister_hw(data->hw); 1063 device_unregister(data->dev); 1064 ieee80211_free_hw(data->hw); 1065 } 1066 class_destroy(hwsim_class); 1067} 1068 1069 1070static struct device_driver mac80211_hwsim_driver = { 1071 .name = "mac80211_hwsim" 1072}; 1073 1074static const struct net_device_ops hwsim_netdev_ops = { 1075 .ndo_start_xmit = hwsim_mon_xmit, 1076 .ndo_change_mtu = eth_change_mtu, 1077 .ndo_set_mac_address = eth_mac_addr, 1078 .ndo_validate_addr = eth_validate_addr, 1079}; 1080 1081static void hwsim_mon_setup(struct net_device *dev) 1082{ 1083 dev->netdev_ops = &hwsim_netdev_ops; 1084 dev->destructor = free_netdev; 1085 ether_setup(dev); 1086 dev->tx_queue_len = 0; 1087 dev->type = ARPHRD_IEEE80211_RADIOTAP; 1088 memset(dev->dev_addr, 0, ETH_ALEN); 1089 dev->dev_addr[0] = 0x12; 1090} 1091 1092 1093static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif) 1094{ 1095 struct mac80211_hwsim_data *data = dat; 1096 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 1097 struct sk_buff *skb; 1098 struct ieee80211_pspoll *pspoll; 1099 1100 if (!vp->assoc) 1101 return; 1102 1103 wiphy_debug(data->hw->wiphy, 1104 "%s: send PS-Poll to %pM for aid %d\n", 1105 __func__, vp->bssid, vp->aid); 1106 1107 skb = dev_alloc_skb(sizeof(*pspoll)); 1108 if (!skb) 1109 return; 1110 pspoll = (void *) skb_put(skb, sizeof(*pspoll)); 1111 pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | 1112 IEEE80211_STYPE_PSPOLL | 1113 IEEE80211_FCTL_PM); 1114 pspoll->aid = cpu_to_le16(0xc000 | vp->aid); 1115 memcpy(pspoll->bssid, vp->bssid, ETH_ALEN); 1116 memcpy(pspoll->ta, mac, ETH_ALEN); 1117 if (!mac80211_hwsim_tx_frame(data->hw, skb)) 1118 printk(KERN_DEBUG "%s: PS-Poll frame not ack'ed\n", __func__); 1119 dev_kfree_skb(skb); 1120} 1121 1122 1123static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac, 1124 struct ieee80211_vif *vif, int ps) 1125{ 1126 struct hwsim_vif_priv *vp = (void *)vif->drv_priv; 1127 struct sk_buff *skb; 1128 struct ieee80211_hdr *hdr; 1129 1130 if (!vp->assoc) 1131 return; 1132 1133 wiphy_debug(data->hw->wiphy, 1134 "%s: send data::nullfunc to %pM ps=%d\n", 1135 __func__, vp->bssid, ps); 1136 1137 skb = dev_alloc_skb(sizeof(*hdr)); 1138 if (!skb) 1139 return; 1140 hdr = (void *) skb_put(skb, sizeof(*hdr) - ETH_ALEN); 1141 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 1142 IEEE80211_STYPE_NULLFUNC | 1143 (ps ? IEEE80211_FCTL_PM : 0)); 1144 hdr->duration_id = cpu_to_le16(0); 1145 memcpy(hdr->addr1, vp->bssid, ETH_ALEN); 1146 memcpy(hdr->addr2, mac, ETH_ALEN); 1147 memcpy(hdr->addr3, vp->bssid, ETH_ALEN); 1148 if (!mac80211_hwsim_tx_frame(data->hw, skb)) 1149 printk(KERN_DEBUG "%s: nullfunc frame not ack'ed\n", __func__); 1150 dev_kfree_skb(skb); 1151} 1152 1153 1154static void hwsim_send_nullfunc_ps(void *dat, u8 *mac, 1155 struct ieee80211_vif *vif) 1156{ 1157 struct mac80211_hwsim_data *data = dat; 1158 hwsim_send_nullfunc(data, mac, vif, 1); 1159} 1160 1161 1162static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac, 1163 struct ieee80211_vif *vif) 1164{ 1165 struct mac80211_hwsim_data *data = dat; 1166 hwsim_send_nullfunc(data, mac, vif, 0); 1167} 1168 1169 1170static int hwsim_fops_ps_read(void *dat, u64 *val) 1171{ 1172 struct mac80211_hwsim_data *data = dat; 1173 *val = data->ps; 1174 return 0; 1175} 1176 1177static int hwsim_fops_ps_write(void *dat, u64 val) 1178{ 1179 struct mac80211_hwsim_data *data = dat; 1180 enum ps_mode old_ps; 1181 1182 if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL && 1183 val != PS_MANUAL_POLL) 1184 return -EINVAL; 1185 1186 old_ps = data->ps; 1187 data->ps = val; 1188 1189 if (val == PS_MANUAL_POLL) { 1190 ieee80211_iterate_active_interfaces(data->hw, 1191 hwsim_send_ps_poll, data); 1192 data->ps_poll_pending = true; 1193 } else if (old_ps == PS_DISABLED && val != PS_DISABLED) { 1194 ieee80211_iterate_active_interfaces(data->hw, 1195 hwsim_send_nullfunc_ps, 1196 data); 1197 } else if (old_ps != PS_DISABLED && val == PS_DISABLED) { 1198 ieee80211_iterate_active_interfaces(data->hw, 1199 hwsim_send_nullfunc_no_ps, 1200 data); 1201 } 1202 1203 return 0; 1204} 1205 1206DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write, 1207 "%llu\n"); 1208 1209 1210static int hwsim_fops_group_read(void *dat, u64 *val) 1211{ 1212 struct mac80211_hwsim_data *data = dat; 1213 *val = data->group; 1214 return 0; 1215} 1216 1217static int hwsim_fops_group_write(void *dat, u64 val) 1218{ 1219 struct mac80211_hwsim_data *data = dat; 1220 data->group = val; 1221 return 0; 1222} 1223 1224DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_group, 1225 hwsim_fops_group_read, hwsim_fops_group_write, 1226 "%llx\n"); 1227 1228static int __init init_mac80211_hwsim(void) 1229{ 1230 int i, err = 0; 1231 u8 addr[ETH_ALEN]; 1232 struct mac80211_hwsim_data *data; 1233 struct ieee80211_hw *hw; 1234 enum ieee80211_band band; 1235 1236 if (radios < 1 || radios > 100) 1237 return -EINVAL; 1238 1239 if (fake_hw_scan) { 1240 mac80211_hwsim_ops.hw_scan = mac80211_hwsim_hw_scan; 1241 mac80211_hwsim_ops.sw_scan_start = NULL; 1242 mac80211_hwsim_ops.sw_scan_complete = NULL; 1243 } 1244 1245 spin_lock_init(&hwsim_radio_lock); 1246 INIT_LIST_HEAD(&hwsim_radios); 1247 1248 hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim"); 1249 if (IS_ERR(hwsim_class)) 1250 return PTR_ERR(hwsim_class); 1251 1252 memset(addr, 0, ETH_ALEN); 1253 addr[0] = 0x02; 1254 1255 for (i = 0; i < radios; i++) { 1256 printk(KERN_DEBUG "mac80211_hwsim: Initializing radio %d\n", 1257 i); 1258 hw = ieee80211_alloc_hw(sizeof(*data), &mac80211_hwsim_ops); 1259 if (!hw) { 1260 printk(KERN_DEBUG "mac80211_hwsim: ieee80211_alloc_hw " 1261 "failed\n"); 1262 err = -ENOMEM; 1263 goto failed; 1264 } 1265 data = hw->priv; 1266 data->hw = hw; 1267 1268 data->dev = device_create(hwsim_class, NULL, 0, hw, 1269 "hwsim%d", i); 1270 if (IS_ERR(data->dev)) { 1271 printk(KERN_DEBUG 1272 "mac80211_hwsim: device_create " 1273 "failed (%ld)\n", PTR_ERR(data->dev)); 1274 err = -ENOMEM; 1275 goto failed_drvdata; 1276 } 1277 data->dev->driver = &mac80211_hwsim_driver; 1278 1279 SET_IEEE80211_DEV(hw, data->dev); 1280 addr[3] = i >> 8; 1281 addr[4] = i; 1282 memcpy(data->addresses[0].addr, addr, ETH_ALEN); 1283 memcpy(data->addresses[1].addr, addr, ETH_ALEN); 1284 data->addresses[1].addr[0] |= 0x40; 1285 hw->wiphy->n_addresses = 2; 1286 hw->wiphy->addresses = data->addresses; 1287 1288 if (fake_hw_scan) { 1289 hw->wiphy->max_scan_ssids = 255; 1290 hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; 1291 } 1292 1293 hw->channel_change_time = 1; 1294 hw->queues = 4; 1295 hw->wiphy->interface_modes = 1296 BIT(NL80211_IFTYPE_STATION) | 1297 BIT(NL80211_IFTYPE_AP) | 1298 BIT(NL80211_IFTYPE_MESH_POINT); 1299 1300 hw->flags = IEEE80211_HW_MFP_CAPABLE | 1301 IEEE80211_HW_SIGNAL_DBM | 1302 IEEE80211_HW_SUPPORTS_STATIC_SMPS | 1303 IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS | 1304 IEEE80211_HW_AMPDU_AGGREGATION; 1305 1306 /* ask mac80211 to reserve space for magic */ 1307 hw->vif_data_size = sizeof(struct hwsim_vif_priv); 1308 hw->sta_data_size = sizeof(struct hwsim_sta_priv); 1309 1310 memcpy(data->channels_2ghz, hwsim_channels_2ghz, 1311 sizeof(hwsim_channels_2ghz)); 1312 memcpy(data->channels_5ghz, hwsim_channels_5ghz, 1313 sizeof(hwsim_channels_5ghz)); 1314 memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates)); 1315 1316 for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) { 1317 struct ieee80211_supported_band *sband = &data->bands[band]; 1318 switch (band) { 1319 case IEEE80211_BAND_2GHZ: 1320 sband->channels = data->channels_2ghz; 1321 sband->n_channels = 1322 ARRAY_SIZE(hwsim_channels_2ghz); 1323 sband->bitrates = data->rates; 1324 sband->n_bitrates = ARRAY_SIZE(hwsim_rates); 1325 break; 1326 case IEEE80211_BAND_5GHZ: 1327 sband->channels = data->channels_5ghz; 1328 sband->n_channels = 1329 ARRAY_SIZE(hwsim_channels_5ghz); 1330 sband->bitrates = data->rates + 4; 1331 sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4; 1332 break; 1333 default: 1334 break; 1335 } 1336 1337 sband->ht_cap.ht_supported = true; 1338 sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 1339 IEEE80211_HT_CAP_GRN_FLD | 1340 IEEE80211_HT_CAP_SGI_40 | 1341 IEEE80211_HT_CAP_DSSSCCK40; 1342 sband->ht_cap.ampdu_factor = 0x3; 1343 sband->ht_cap.ampdu_density = 0x6; 1344 memset(&sband->ht_cap.mcs, 0, 1345 sizeof(sband->ht_cap.mcs)); 1346 sband->ht_cap.mcs.rx_mask[0] = 0xff; 1347 sband->ht_cap.mcs.rx_mask[1] = 0xff; 1348 sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 1349 1350 hw->wiphy->bands[band] = sband; 1351 } 1352 /* By default all radios are belonging to the first group */ 1353 data->group = 1; 1354 mutex_init(&data->mutex); 1355 1356 /* Work to be done prior to ieee80211_register_hw() */ 1357 switch (regtest) { 1358 case HWSIM_REGTEST_DISABLED: 1359 case HWSIM_REGTEST_DRIVER_REG_FOLLOW: 1360 case HWSIM_REGTEST_DRIVER_REG_ALL: 1361 case HWSIM_REGTEST_DIFF_COUNTRY: 1362 /* 1363 * Nothing to be done for driver regulatory domain 1364 * hints prior to ieee80211_register_hw() 1365 */ 1366 break; 1367 case HWSIM_REGTEST_WORLD_ROAM: 1368 if (i == 0) { 1369 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY; 1370 wiphy_apply_custom_regulatory(hw->wiphy, 1371 &hwsim_world_regdom_custom_01); 1372 } 1373 break; 1374 case HWSIM_REGTEST_CUSTOM_WORLD: 1375 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY; 1376 wiphy_apply_custom_regulatory(hw->wiphy, 1377 &hwsim_world_regdom_custom_01); 1378 break; 1379 case HWSIM_REGTEST_CUSTOM_WORLD_2: 1380 if (i == 0) { 1381 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY; 1382 wiphy_apply_custom_regulatory(hw->wiphy, 1383 &hwsim_world_regdom_custom_01); 1384 } else if (i == 1) { 1385 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY; 1386 wiphy_apply_custom_regulatory(hw->wiphy, 1387 &hwsim_world_regdom_custom_02); 1388 } 1389 break; 1390 case HWSIM_REGTEST_STRICT_ALL: 1391 hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY; 1392 break; 1393 case HWSIM_REGTEST_STRICT_FOLLOW: 1394 case HWSIM_REGTEST_STRICT_AND_DRIVER_REG: 1395 if (i == 0) 1396 hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY; 1397 break; 1398 case HWSIM_REGTEST_ALL: 1399 if (i == 0) { 1400 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY; 1401 wiphy_apply_custom_regulatory(hw->wiphy, 1402 &hwsim_world_regdom_custom_01); 1403 } else if (i == 1) { 1404 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY; 1405 wiphy_apply_custom_regulatory(hw->wiphy, 1406 &hwsim_world_regdom_custom_02); 1407 } else if (i == 4) 1408 hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY; 1409 break; 1410 default: 1411 break; 1412 } 1413 1414 /* give the regulatory workqueue a chance to run */ 1415 if (regtest) 1416 schedule_timeout_interruptible(1); 1417 err = ieee80211_register_hw(hw); 1418 if (err < 0) { 1419 printk(KERN_DEBUG "mac80211_hwsim: " 1420 "ieee80211_register_hw failed (%d)\n", err); 1421 goto failed_hw; 1422 } 1423 1424 /* Work to be done after to ieee80211_register_hw() */ 1425 switch (regtest) { 1426 case HWSIM_REGTEST_WORLD_ROAM: 1427 case HWSIM_REGTEST_DISABLED: 1428 break; 1429 case HWSIM_REGTEST_DRIVER_REG_FOLLOW: 1430 if (!i) 1431 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]); 1432 break; 1433 case HWSIM_REGTEST_DRIVER_REG_ALL: 1434 case HWSIM_REGTEST_STRICT_ALL: 1435 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]); 1436 break; 1437 case HWSIM_REGTEST_DIFF_COUNTRY: 1438 if (i < ARRAY_SIZE(hwsim_alpha2s)) 1439 regulatory_hint(hw->wiphy, hwsim_alpha2s[i]); 1440 break; 1441 case HWSIM_REGTEST_CUSTOM_WORLD: 1442 case HWSIM_REGTEST_CUSTOM_WORLD_2: 1443 /* 1444 * Nothing to be done for custom world regulatory 1445 * domains after to ieee80211_register_hw 1446 */ 1447 break; 1448 case HWSIM_REGTEST_STRICT_FOLLOW: 1449 if (i == 0) 1450 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]); 1451 break; 1452 case HWSIM_REGTEST_STRICT_AND_DRIVER_REG: 1453 if (i == 0) 1454 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]); 1455 else if (i == 1) 1456 regulatory_hint(hw->wiphy, hwsim_alpha2s[1]); 1457 break; 1458 case HWSIM_REGTEST_ALL: 1459 if (i == 2) 1460 regulatory_hint(hw->wiphy, hwsim_alpha2s[0]); 1461 else if (i == 3) 1462 regulatory_hint(hw->wiphy, hwsim_alpha2s[1]); 1463 else if (i == 4) 1464 regulatory_hint(hw->wiphy, hwsim_alpha2s[2]); 1465 break; 1466 default: 1467 break; 1468 } 1469 1470 wiphy_debug(hw->wiphy, "hwaddr %pm registered\n", 1471 hw->wiphy->perm_addr); 1472 1473 data->debugfs = debugfs_create_dir("hwsim", 1474 hw->wiphy->debugfsdir); 1475 data->debugfs_ps = debugfs_create_file("ps", 0666, 1476 data->debugfs, data, 1477 &hwsim_fops_ps); 1478 data->debugfs_group = debugfs_create_file("group", 0666, 1479 data->debugfs, data, 1480 &hwsim_fops_group); 1481 1482 setup_timer(&data->beacon_timer, mac80211_hwsim_beacon, 1483 (unsigned long) hw); 1484 1485 list_add_tail(&data->list, &hwsim_radios); 1486 } 1487 1488 hwsim_mon = alloc_netdev(0, "hwsim%d", hwsim_mon_setup); 1489 if (hwsim_mon == NULL) 1490 goto failed; 1491 1492 rtnl_lock(); 1493 1494 err = dev_alloc_name(hwsim_mon, hwsim_mon->name); 1495 if (err < 0) 1496 goto failed_mon; 1497 1498 1499 err = register_netdevice(hwsim_mon); 1500 if (err < 0) 1501 goto failed_mon; 1502 1503 rtnl_unlock(); 1504 1505 return 0; 1506 1507failed_mon: 1508 rtnl_unlock(); 1509 free_netdev(hwsim_mon); 1510 mac80211_hwsim_free(); 1511 return err; 1512 1513failed_hw: 1514 device_unregister(data->dev); 1515failed_drvdata: 1516 ieee80211_free_hw(hw); 1517failed: 1518 mac80211_hwsim_free(); 1519 return err; 1520} 1521 1522 1523static void __exit exit_mac80211_hwsim(void) 1524{ 1525 printk(KERN_DEBUG "mac80211_hwsim: unregister radios\n"); 1526 1527 mac80211_hwsim_free(); 1528 unregister_netdev(hwsim_mon); 1529} 1530 1531 1532module_init(init_mac80211_hwsim); 1533module_exit(exit_mac80211_hwsim); 1534