main.c revision bc0784d951470ca6597239f1bae6e59caf49fb10
1/* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 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#include <net/mac80211.h> 12#include <linux/module.h> 13#include <linux/init.h> 14#include <linux/netdevice.h> 15#include <linux/types.h> 16#include <linux/slab.h> 17#include <linux/skbuff.h> 18#include <linux/etherdevice.h> 19#include <linux/if_arp.h> 20#include <linux/rtnetlink.h> 21#include <linux/bitmap.h> 22#include <linux/pm_qos.h> 23#include <linux/inetdevice.h> 24#include <net/net_namespace.h> 25#include <net/cfg80211.h> 26 27#include "ieee80211_i.h" 28#include "driver-ops.h" 29#include "rate.h" 30#include "mesh.h" 31#include "wep.h" 32#include "led.h" 33#include "cfg.h" 34#include "debugfs.h" 35 36static struct lock_class_key ieee80211_rx_skb_queue_class; 37 38void ieee80211_configure_filter(struct ieee80211_local *local) 39{ 40 u64 mc; 41 unsigned int changed_flags; 42 unsigned int new_flags = 0; 43 44 if (atomic_read(&local->iff_promiscs)) 45 new_flags |= FIF_PROMISC_IN_BSS; 46 47 if (atomic_read(&local->iff_allmultis)) 48 new_flags |= FIF_ALLMULTI; 49 50 if (local->monitors || test_bit(SCAN_SW_SCANNING, &local->scanning) || 51 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning)) 52 new_flags |= FIF_BCN_PRBRESP_PROMISC; 53 54 if (local->fif_probe_req || local->probe_req_reg) 55 new_flags |= FIF_PROBE_REQ; 56 57 if (local->fif_fcsfail) 58 new_flags |= FIF_FCSFAIL; 59 60 if (local->fif_plcpfail) 61 new_flags |= FIF_PLCPFAIL; 62 63 if (local->fif_control) 64 new_flags |= FIF_CONTROL; 65 66 if (local->fif_other_bss) 67 new_flags |= FIF_OTHER_BSS; 68 69 if (local->fif_pspoll) 70 new_flags |= FIF_PSPOLL; 71 72 spin_lock_bh(&local->filter_lock); 73 changed_flags = local->filter_flags ^ new_flags; 74 75 mc = drv_prepare_multicast(local, &local->mc_list); 76 spin_unlock_bh(&local->filter_lock); 77 78 /* be a bit nasty */ 79 new_flags |= (1<<31); 80 81 drv_configure_filter(local, changed_flags, &new_flags, mc); 82 83 WARN_ON(new_flags & (1<<31)); 84 85 local->filter_flags = new_flags & ~(1<<31); 86} 87 88static void ieee80211_reconfig_filter(struct work_struct *work) 89{ 90 struct ieee80211_local *local = 91 container_of(work, struct ieee80211_local, reconfig_filter); 92 93 ieee80211_configure_filter(local); 94} 95 96static u32 ieee80211_hw_conf_chan(struct ieee80211_local *local) 97{ 98 struct ieee80211_sub_if_data *sdata; 99 struct ieee80211_channel *chan; 100 u32 changed = 0; 101 int power; 102 enum nl80211_channel_type channel_type; 103 u32 offchannel_flag; 104 bool scanning = false; 105 106 offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; 107 if (local->scan_channel) { 108 chan = local->scan_channel; 109 /* If scanning on oper channel, use whatever channel-type 110 * is currently in use. 111 */ 112 if (chan == local->_oper_channel) 113 channel_type = local->_oper_channel_type; 114 else 115 channel_type = NL80211_CHAN_NO_HT; 116 } else if (local->tmp_channel) { 117 chan = local->tmp_channel; 118 channel_type = NL80211_CHAN_NO_HT; 119 } else { 120 chan = local->_oper_channel; 121 channel_type = local->_oper_channel_type; 122 } 123 124 if (chan != local->_oper_channel || 125 channel_type != local->_oper_channel_type) 126 local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL; 127 else 128 local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL; 129 130 offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; 131 132 if (offchannel_flag || chan != local->hw.conf.channel || 133 channel_type != local->hw.conf.channel_type) { 134 local->hw.conf.channel = chan; 135 local->hw.conf.channel_type = channel_type; 136 changed |= IEEE80211_CONF_CHANGE_CHANNEL; 137 } 138 139 if (!conf_is_ht(&local->hw.conf)) { 140 /* 141 * mac80211.h documents that this is only valid 142 * when the channel is set to an HT type, and 143 * that otherwise STATIC is used. 144 */ 145 local->hw.conf.smps_mode = IEEE80211_SMPS_STATIC; 146 } else if (local->hw.conf.smps_mode != local->smps_mode) { 147 local->hw.conf.smps_mode = local->smps_mode; 148 changed |= IEEE80211_CONF_CHANGE_SMPS; 149 } 150 151 scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) || 152 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning) || 153 test_bit(SCAN_HW_SCANNING, &local->scanning); 154 power = chan->max_power; 155 156 rcu_read_lock(); 157 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 158 if (!rcu_access_pointer(sdata->vif.chanctx_conf)) 159 continue; 160 power = min(power, sdata->vif.bss_conf.txpower); 161 } 162 rcu_read_unlock(); 163 164 if (local->hw.conf.power_level != power) { 165 changed |= IEEE80211_CONF_CHANGE_POWER; 166 local->hw.conf.power_level = power; 167 } 168 169 return changed; 170} 171 172int ieee80211_hw_config(struct ieee80211_local *local, u32 changed) 173{ 174 int ret = 0; 175 176 might_sleep(); 177 178 if (!local->use_chanctx) 179 changed |= ieee80211_hw_conf_chan(local); 180 else 181 changed &= ~(IEEE80211_CONF_CHANGE_CHANNEL | 182 IEEE80211_CONF_CHANGE_POWER); 183 184 if (changed && local->open_count) { 185 ret = drv_config(local, changed); 186 /* 187 * Goal: 188 * HW reconfiguration should never fail, the driver has told 189 * us what it can support so it should live up to that promise. 190 * 191 * Current status: 192 * rfkill is not integrated with mac80211 and a 193 * configuration command can thus fail if hardware rfkill 194 * is enabled 195 * 196 * FIXME: integrate rfkill with mac80211 and then add this 197 * WARN_ON() back 198 * 199 */ 200 /* WARN_ON(ret); */ 201 } 202 203 return ret; 204} 205 206void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 207 u32 changed) 208{ 209 struct ieee80211_local *local = sdata->local; 210 static const u8 zero[ETH_ALEN] = { 0 }; 211 212 if (!changed) 213 return; 214 215 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 216 sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid; 217 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) 218 sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid; 219 else if (sdata->vif.type == NL80211_IFTYPE_AP) 220 sdata->vif.bss_conf.bssid = sdata->vif.addr; 221 else if (sdata->vif.type == NL80211_IFTYPE_WDS) 222 sdata->vif.bss_conf.bssid = NULL; 223 else if (ieee80211_vif_is_mesh(&sdata->vif)) { 224 sdata->vif.bss_conf.bssid = zero; 225 } else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) { 226 sdata->vif.bss_conf.bssid = sdata->vif.addr; 227 WARN_ONCE(changed & ~(BSS_CHANGED_IDLE), 228 "P2P Device BSS changed %#x", changed); 229 } else { 230 WARN_ON(1); 231 return; 232 } 233 234 switch (sdata->vif.type) { 235 case NL80211_IFTYPE_AP: 236 case NL80211_IFTYPE_ADHOC: 237 case NL80211_IFTYPE_WDS: 238 case NL80211_IFTYPE_MESH_POINT: 239 break; 240 default: 241 /* do not warn to simplify caller in scan.c */ 242 changed &= ~BSS_CHANGED_BEACON_ENABLED; 243 if (WARN_ON(changed & BSS_CHANGED_BEACON)) 244 return; 245 break; 246 } 247 248 if (changed & BSS_CHANGED_BEACON_ENABLED) { 249 if (local->quiescing || !ieee80211_sdata_running(sdata) || 250 test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state)) { 251 sdata->vif.bss_conf.enable_beacon = false; 252 } else { 253 /* 254 * Beacon should be enabled, but AP mode must 255 * check whether there is a beacon configured. 256 */ 257 switch (sdata->vif.type) { 258 case NL80211_IFTYPE_AP: 259 sdata->vif.bss_conf.enable_beacon = 260 !!sdata->u.ap.beacon; 261 break; 262 case NL80211_IFTYPE_ADHOC: 263 sdata->vif.bss_conf.enable_beacon = 264 !!sdata->u.ibss.presp; 265 break; 266#ifdef CONFIG_MAC80211_MESH 267 case NL80211_IFTYPE_MESH_POINT: 268 sdata->vif.bss_conf.enable_beacon = 269 !!sdata->u.mesh.mesh_id_len; 270 break; 271#endif 272 default: 273 /* not reached */ 274 WARN_ON(1); 275 break; 276 } 277 } 278 } 279 280 drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed); 281} 282 283u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 284{ 285 sdata->vif.bss_conf.use_cts_prot = false; 286 sdata->vif.bss_conf.use_short_preamble = false; 287 sdata->vif.bss_conf.use_short_slot = false; 288 return BSS_CHANGED_ERP_CTS_PROT | 289 BSS_CHANGED_ERP_PREAMBLE | 290 BSS_CHANGED_ERP_SLOT; 291} 292 293static void ieee80211_tasklet_handler(unsigned long data) 294{ 295 struct ieee80211_local *local = (struct ieee80211_local *) data; 296 struct sta_info *sta, *tmp; 297 struct skb_eosp_msg_data *eosp_data; 298 struct sk_buff *skb; 299 300 while ((skb = skb_dequeue(&local->skb_queue)) || 301 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 302 switch (skb->pkt_type) { 303 case IEEE80211_RX_MSG: 304 /* Clear skb->pkt_type in order to not confuse kernel 305 * netstack. */ 306 skb->pkt_type = 0; 307 ieee80211_rx(&local->hw, skb); 308 break; 309 case IEEE80211_TX_STATUS_MSG: 310 skb->pkt_type = 0; 311 ieee80211_tx_status(&local->hw, skb); 312 break; 313 case IEEE80211_EOSP_MSG: 314 eosp_data = (void *)skb->cb; 315 for_each_sta_info(local, eosp_data->sta, sta, tmp) { 316 /* skip wrong virtual interface */ 317 if (memcmp(eosp_data->iface, 318 sta->sdata->vif.addr, ETH_ALEN)) 319 continue; 320 clear_sta_flag(sta, WLAN_STA_SP); 321 break; 322 } 323 dev_kfree_skb(skb); 324 break; 325 default: 326 WARN(1, "mac80211: Packet is of unknown type %d\n", 327 skb->pkt_type); 328 dev_kfree_skb(skb); 329 break; 330 } 331 } 332} 333 334static void ieee80211_restart_work(struct work_struct *work) 335{ 336 struct ieee80211_local *local = 337 container_of(work, struct ieee80211_local, restart_work); 338 339 /* wait for scan work complete */ 340 flush_workqueue(local->workqueue); 341 342 mutex_lock(&local->mtx); 343 WARN(test_bit(SCAN_HW_SCANNING, &local->scanning) || 344 rcu_dereference_protected(local->sched_scan_sdata, 345 lockdep_is_held(&local->mtx)), 346 "%s called with hardware scan in progress\n", __func__); 347 mutex_unlock(&local->mtx); 348 349 rtnl_lock(); 350 ieee80211_scan_cancel(local); 351 ieee80211_reconfig(local); 352 rtnl_unlock(); 353} 354 355void ieee80211_restart_hw(struct ieee80211_hw *hw) 356{ 357 struct ieee80211_local *local = hw_to_local(hw); 358 359 trace_api_restart_hw(local); 360 361 wiphy_info(hw->wiphy, 362 "Hardware restart was requested\n"); 363 364 /* use this reason, ieee80211_reconfig will unblock it */ 365 ieee80211_stop_queues_by_reason(hw, 366 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 367 368 /* 369 * Stop all Rx during the reconfig. We don't want state changes 370 * or driver callbacks while this is in progress. 371 */ 372 local->in_reconfig = true; 373 barrier(); 374 375 schedule_work(&local->restart_work); 376} 377EXPORT_SYMBOL(ieee80211_restart_hw); 378 379#ifdef CONFIG_INET 380static int ieee80211_ifa_changed(struct notifier_block *nb, 381 unsigned long data, void *arg) 382{ 383 struct in_ifaddr *ifa = arg; 384 struct ieee80211_local *local = 385 container_of(nb, struct ieee80211_local, 386 ifa_notifier); 387 struct net_device *ndev = ifa->ifa_dev->dev; 388 struct wireless_dev *wdev = ndev->ieee80211_ptr; 389 struct in_device *idev; 390 struct ieee80211_sub_if_data *sdata; 391 struct ieee80211_bss_conf *bss_conf; 392 struct ieee80211_if_managed *ifmgd; 393 int c = 0; 394 395 /* Make sure it's our interface that got changed */ 396 if (!wdev) 397 return NOTIFY_DONE; 398 399 if (wdev->wiphy != local->hw.wiphy) 400 return NOTIFY_DONE; 401 402 sdata = IEEE80211_DEV_TO_SUB_IF(ndev); 403 bss_conf = &sdata->vif.bss_conf; 404 405 /* ARP filtering is only supported in managed mode */ 406 if (sdata->vif.type != NL80211_IFTYPE_STATION) 407 return NOTIFY_DONE; 408 409 idev = __in_dev_get_rtnl(sdata->dev); 410 if (!idev) 411 return NOTIFY_DONE; 412 413 ifmgd = &sdata->u.mgd; 414 mutex_lock(&ifmgd->mtx); 415 416 /* Copy the addresses to the bss_conf list */ 417 ifa = idev->ifa_list; 418 while (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN && ifa) { 419 bss_conf->arp_addr_list[c] = ifa->ifa_address; 420 ifa = ifa->ifa_next; 421 c++; 422 } 423 424 /* If not all addresses fit the list, disable filtering */ 425 if (ifa) { 426 sdata->arp_filter_state = false; 427 c = 0; 428 } else { 429 sdata->arp_filter_state = true; 430 } 431 bss_conf->arp_addr_cnt = c; 432 433 /* Configure driver only if associated (which also implies it is up) */ 434 if (ifmgd->associated) { 435 bss_conf->arp_filter_enabled = sdata->arp_filter_state; 436 ieee80211_bss_info_change_notify(sdata, 437 BSS_CHANGED_ARP_FILTER); 438 } 439 440 mutex_unlock(&ifmgd->mtx); 441 442 return NOTIFY_DONE; 443} 444#endif 445 446static int ieee80211_napi_poll(struct napi_struct *napi, int budget) 447{ 448 struct ieee80211_local *local = 449 container_of(napi, struct ieee80211_local, napi); 450 451 return local->ops->napi_poll(&local->hw, budget); 452} 453 454void ieee80211_napi_schedule(struct ieee80211_hw *hw) 455{ 456 struct ieee80211_local *local = hw_to_local(hw); 457 458 napi_schedule(&local->napi); 459} 460EXPORT_SYMBOL(ieee80211_napi_schedule); 461 462void ieee80211_napi_complete(struct ieee80211_hw *hw) 463{ 464 struct ieee80211_local *local = hw_to_local(hw); 465 466 napi_complete(&local->napi); 467} 468EXPORT_SYMBOL(ieee80211_napi_complete); 469 470/* There isn't a lot of sense in it, but you can transmit anything you like */ 471static const struct ieee80211_txrx_stypes 472ieee80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = { 473 [NL80211_IFTYPE_ADHOC] = { 474 .tx = 0xffff, 475 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 476 BIT(IEEE80211_STYPE_AUTH >> 4) | 477 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 478 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 479 }, 480 [NL80211_IFTYPE_STATION] = { 481 .tx = 0xffff, 482 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 483 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 484 }, 485 [NL80211_IFTYPE_AP] = { 486 .tx = 0xffff, 487 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 488 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 489 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 490 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 491 BIT(IEEE80211_STYPE_AUTH >> 4) | 492 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 493 BIT(IEEE80211_STYPE_ACTION >> 4), 494 }, 495 [NL80211_IFTYPE_AP_VLAN] = { 496 /* copy AP */ 497 .tx = 0xffff, 498 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 499 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 500 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 501 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 502 BIT(IEEE80211_STYPE_AUTH >> 4) | 503 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 504 BIT(IEEE80211_STYPE_ACTION >> 4), 505 }, 506 [NL80211_IFTYPE_P2P_CLIENT] = { 507 .tx = 0xffff, 508 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 509 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 510 }, 511 [NL80211_IFTYPE_P2P_GO] = { 512 .tx = 0xffff, 513 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 514 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 515 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 516 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 517 BIT(IEEE80211_STYPE_AUTH >> 4) | 518 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 519 BIT(IEEE80211_STYPE_ACTION >> 4), 520 }, 521 [NL80211_IFTYPE_MESH_POINT] = { 522 .tx = 0xffff, 523 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 524 BIT(IEEE80211_STYPE_AUTH >> 4) | 525 BIT(IEEE80211_STYPE_DEAUTH >> 4), 526 }, 527 [NL80211_IFTYPE_P2P_DEVICE] = { 528 .tx = 0xffff, 529 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 530 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 531 }, 532}; 533 534static const struct ieee80211_ht_cap mac80211_ht_capa_mod_mask = { 535 .ampdu_params_info = IEEE80211_HT_AMPDU_PARM_FACTOR | 536 IEEE80211_HT_AMPDU_PARM_DENSITY, 537 538 .cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 539 IEEE80211_HT_CAP_MAX_AMSDU | 540 IEEE80211_HT_CAP_SGI_20 | 541 IEEE80211_HT_CAP_SGI_40), 542 .mcs = { 543 .rx_mask = { 0xff, 0xff, 0xff, 0xff, 0xff, 544 0xff, 0xff, 0xff, 0xff, 0xff, }, 545 }, 546}; 547 548struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 549 const struct ieee80211_ops *ops) 550{ 551 struct ieee80211_local *local; 552 int priv_size, i; 553 struct wiphy *wiphy; 554 bool use_chanctx; 555 556 if (WARN_ON(!ops->tx || !ops->start || !ops->stop || !ops->config || 557 !ops->add_interface || !ops->remove_interface || 558 !ops->configure_filter)) 559 return NULL; 560 561 if (WARN_ON(ops->sta_state && (ops->sta_add || ops->sta_remove))) 562 return NULL; 563 564 /* check all or no channel context operations exist */ 565 i = !!ops->add_chanctx + !!ops->remove_chanctx + 566 !!ops->change_chanctx + !!ops->assign_vif_chanctx + 567 !!ops->unassign_vif_chanctx; 568 if (WARN_ON(i != 0 && i != 5)) 569 return NULL; 570 use_chanctx = i == 5; 571 572 /* Ensure 32-byte alignment of our private data and hw private data. 573 * We use the wiphy priv data for both our ieee80211_local and for 574 * the driver's private data 575 * 576 * In memory it'll be like this: 577 * 578 * +-------------------------+ 579 * | struct wiphy | 580 * +-------------------------+ 581 * | struct ieee80211_local | 582 * +-------------------------+ 583 * | driver's private data | 584 * +-------------------------+ 585 * 586 */ 587 priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len; 588 589 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 590 591 if (!wiphy) 592 return NULL; 593 594 wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes; 595 596 wiphy->privid = mac80211_wiphy_privid; 597 598 wiphy->flags |= WIPHY_FLAG_NETNS_OK | 599 WIPHY_FLAG_4ADDR_AP | 600 WIPHY_FLAG_4ADDR_STATION | 601 WIPHY_FLAG_REPORTS_OBSS | 602 WIPHY_FLAG_OFFCHAN_TX; 603 604 if (ops->remain_on_channel) 605 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 606 607 wiphy->features |= NL80211_FEATURE_SK_TX_STATUS | 608 NL80211_FEATURE_SAE | 609 NL80211_FEATURE_HT_IBSS | 610 NL80211_FEATURE_VIF_TXPOWER; 611 612 if (!ops->hw_scan) 613 wiphy->features |= NL80211_FEATURE_LOW_PRIORITY_SCAN | 614 NL80211_FEATURE_AP_SCAN; 615 616 617 if (!ops->set_key) 618 wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 619 620 wiphy->bss_priv_size = sizeof(struct ieee80211_bss); 621 622 local = wiphy_priv(wiphy); 623 624 local->hw.wiphy = wiphy; 625 626 local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN); 627 628 local->ops = ops; 629 local->use_chanctx = use_chanctx; 630 631 /* set up some defaults */ 632 local->hw.queues = 1; 633 local->hw.max_rates = 1; 634 local->hw.max_report_rates = 0; 635 local->hw.max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF; 636 local->hw.max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF; 637 local->hw.offchannel_tx_hw_queue = IEEE80211_INVAL_HW_QUEUE; 638 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 639 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 640 local->hw.radiotap_mcs_details = IEEE80211_RADIOTAP_MCS_HAVE_MCS | 641 IEEE80211_RADIOTAP_MCS_HAVE_GI | 642 IEEE80211_RADIOTAP_MCS_HAVE_BW; 643 local->hw.radiotap_vht_details = IEEE80211_RADIOTAP_VHT_KNOWN_GI | 644 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH; 645 local->user_power_level = IEEE80211_UNSET_POWER_LEVEL; 646 wiphy->ht_capa_mod_mask = &mac80211_ht_capa_mod_mask; 647 648 INIT_LIST_HEAD(&local->interfaces); 649 650 __hw_addr_init(&local->mc_list); 651 652 mutex_init(&local->iflist_mtx); 653 mutex_init(&local->mtx); 654 655 mutex_init(&local->key_mtx); 656 spin_lock_init(&local->filter_lock); 657 spin_lock_init(&local->queue_stop_reason_lock); 658 659 INIT_LIST_HEAD(&local->chanctx_list); 660 mutex_init(&local->chanctx_mtx); 661 662 /* 663 * The rx_skb_queue is only accessed from tasklets, 664 * but other SKB queues are used from within IRQ 665 * context. Therefore, this one needs a different 666 * locking class so our direct, non-irq-safe use of 667 * the queue's lock doesn't throw lockdep warnings. 668 */ 669 skb_queue_head_init_class(&local->rx_skb_queue, 670 &ieee80211_rx_skb_queue_class); 671 672 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 673 674 INIT_WORK(&local->restart_work, ieee80211_restart_work); 675 676 INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter); 677 local->smps_mode = IEEE80211_SMPS_OFF; 678 679 INIT_WORK(&local->dynamic_ps_enable_work, 680 ieee80211_dynamic_ps_enable_work); 681 INIT_WORK(&local->dynamic_ps_disable_work, 682 ieee80211_dynamic_ps_disable_work); 683 setup_timer(&local->dynamic_ps_timer, 684 ieee80211_dynamic_ps_timer, (unsigned long) local); 685 686 INIT_WORK(&local->sched_scan_stopped_work, 687 ieee80211_sched_scan_stopped_work); 688 689 spin_lock_init(&local->ack_status_lock); 690 idr_init(&local->ack_status_frames); 691 /* preallocate at least one entry */ 692 idr_pre_get(&local->ack_status_frames, GFP_KERNEL); 693 694 sta_info_init(local); 695 696 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) { 697 skb_queue_head_init(&local->pending[i]); 698 atomic_set(&local->agg_queue_stop[i], 0); 699 } 700 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 701 (unsigned long)local); 702 703 tasklet_init(&local->tasklet, 704 ieee80211_tasklet_handler, 705 (unsigned long) local); 706 707 skb_queue_head_init(&local->skb_queue); 708 skb_queue_head_init(&local->skb_queue_unreliable); 709 710 /* init dummy netdev for use w/ NAPI */ 711 init_dummy_netdev(&local->napi_dev); 712 713 ieee80211_led_names(local); 714 715 ieee80211_roc_setup(local); 716 717 return &local->hw; 718} 719EXPORT_SYMBOL(ieee80211_alloc_hw); 720 721int ieee80211_register_hw(struct ieee80211_hw *hw) 722{ 723 struct ieee80211_local *local = hw_to_local(hw); 724 int result, i; 725 enum ieee80211_band band; 726 int channels, max_bitrates; 727 bool supp_ht, supp_vht; 728 netdev_features_t feature_whitelist; 729 static const u32 cipher_suites[] = { 730 /* keep WEP first, it may be removed below */ 731 WLAN_CIPHER_SUITE_WEP40, 732 WLAN_CIPHER_SUITE_WEP104, 733 WLAN_CIPHER_SUITE_TKIP, 734 WLAN_CIPHER_SUITE_CCMP, 735 736 /* keep last -- depends on hw flags! */ 737 WLAN_CIPHER_SUITE_AES_CMAC 738 }; 739 740 if (hw->flags & IEEE80211_HW_QUEUE_CONTROL && 741 (local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE || 742 local->hw.offchannel_tx_hw_queue >= local->hw.queues)) 743 return -EINVAL; 744 745#ifdef CONFIG_PM 746 if ((hw->wiphy->wowlan.flags || hw->wiphy->wowlan.n_patterns) && 747 (!local->ops->suspend || !local->ops->resume)) 748 return -EINVAL; 749#endif 750 751 if ((hw->flags & IEEE80211_HW_SCAN_WHILE_IDLE) && !local->ops->hw_scan) 752 return -EINVAL; 753 754 if (!local->use_chanctx) { 755 for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) { 756 const struct ieee80211_iface_combination *comb; 757 758 comb = &local->hw.wiphy->iface_combinations[i]; 759 760 if (comb->num_different_channels > 1) 761 return -EINVAL; 762 } 763 } else { 764 /* 765 * WDS is currently prohibited when channel contexts are used 766 * because there's no clear definition of which channel WDS 767 * type interfaces use 768 */ 769 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)) 770 return -EINVAL; 771 } 772 773 /* Only HW csum features are currently compatible with mac80211 */ 774 feature_whitelist = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 775 NETIF_F_HW_CSUM; 776 if (WARN_ON(hw->netdev_features & ~feature_whitelist)) 777 return -EINVAL; 778 779 if (hw->max_report_rates == 0) 780 hw->max_report_rates = hw->max_rates; 781 782 local->rx_chains = 1; 783 784 /* 785 * generic code guarantees at least one band, 786 * set this very early because much code assumes 787 * that hw.conf.channel is assigned 788 */ 789 channels = 0; 790 max_bitrates = 0; 791 supp_ht = false; 792 supp_vht = false; 793 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 794 struct ieee80211_supported_band *sband; 795 796 sband = local->hw.wiphy->bands[band]; 797 if (!sband) 798 continue; 799 if (!local->use_chanctx && !local->_oper_channel) { 800 /* init channel we're on */ 801 local->hw.conf.channel = 802 local->_oper_channel = &sband->channels[0]; 803 local->hw.conf.channel_type = NL80211_CHAN_NO_HT; 804 } 805 cfg80211_chandef_create(&local->monitor_chandef, 806 &sband->channels[0], 807 NL80211_CHAN_NO_HT); 808 channels += sband->n_channels; 809 810 if (max_bitrates < sband->n_bitrates) 811 max_bitrates = sband->n_bitrates; 812 supp_ht = supp_ht || sband->ht_cap.ht_supported; 813 supp_vht = supp_vht || sband->vht_cap.vht_supported; 814 815 if (sband->ht_cap.ht_supported) 816 local->rx_chains = 817 max(ieee80211_mcs_to_chains(&sband->ht_cap.mcs), 818 local->rx_chains); 819 820 /* TODO: consider VHT for RX chains, hopefully it's the same */ 821 } 822 823 local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) + 824 sizeof(void *) * channels, GFP_KERNEL); 825 if (!local->int_scan_req) 826 return -ENOMEM; 827 828 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 829 if (!local->hw.wiphy->bands[band]) 830 continue; 831 local->int_scan_req->rates[band] = (u32) -1; 832 } 833 834 /* if low-level driver supports AP, we also support VLAN */ 835 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) { 836 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 837 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN); 838 } 839 840 /* mac80211 always supports monitor */ 841 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 842 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR); 843 844 /* mac80211 doesn't support more than one IBSS interface right now */ 845 for (i = 0; i < hw->wiphy->n_iface_combinations; i++) { 846 const struct ieee80211_iface_combination *c; 847 int j; 848 849 c = &hw->wiphy->iface_combinations[i]; 850 851 for (j = 0; j < c->n_limits; j++) 852 if ((c->limits[j].types & BIT(NL80211_IFTYPE_ADHOC)) && 853 c->limits[j].max > 1) 854 return -EINVAL; 855 } 856 857#ifndef CONFIG_MAC80211_MESH 858 /* mesh depends on Kconfig, but drivers should set it if they want */ 859 local->hw.wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MESH_POINT); 860#endif 861 862 /* if the underlying driver supports mesh, mac80211 will (at least) 863 * provide routing of mesh authentication frames to userspace */ 864 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT)) 865 local->hw.wiphy->flags |= WIPHY_FLAG_MESH_AUTH; 866 867 /* mac80211 supports control port protocol changing */ 868 local->hw.wiphy->flags |= WIPHY_FLAG_CONTROL_PORT_PROTOCOL; 869 870 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 871 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 872 else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC) 873 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC; 874 875 WARN((local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD) 876 && (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK), 877 "U-APSD not supported with HW_PS_NULLFUNC_STACK\n"); 878 879 /* 880 * Calculate scan IE length -- we need this to alloc 881 * memory and to subtract from the driver limit. It 882 * includes the DS Params, (extended) supported rates, and HT 883 * information -- SSID is the driver's responsibility. 884 */ 885 local->scan_ies_len = 4 + max_bitrates /* (ext) supp rates */ + 886 3 /* DS Params */; 887 if (supp_ht) 888 local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap); 889 890 if (supp_vht) { 891 local->scan_ies_len += 892 2 + sizeof(struct ieee80211_vht_cap); 893 894 /* 895 * (for now at least), drivers wanting to use VHT must 896 * support channel contexts, as they contain all the 897 * necessary VHT information and the global hw config 898 * doesn't (yet) 899 */ 900 if (WARN_ON(!local->use_chanctx)) { 901 result = -EINVAL; 902 goto fail_wiphy_register; 903 } 904 } 905 906 if (!local->ops->hw_scan) { 907 /* For hw_scan, driver needs to set these up. */ 908 local->hw.wiphy->max_scan_ssids = 4; 909 local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; 910 } 911 912 /* 913 * If the driver supports any scan IEs, then assume the 914 * limit includes the IEs mac80211 will add, otherwise 915 * leave it at zero and let the driver sort it out; we 916 * still pass our IEs to the driver but userspace will 917 * not be allowed to in that case. 918 */ 919 if (local->hw.wiphy->max_scan_ie_len) 920 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len; 921 922 /* Set up cipher suites unless driver already did */ 923 if (!local->hw.wiphy->cipher_suites) { 924 local->hw.wiphy->cipher_suites = cipher_suites; 925 local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 926 if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE)) 927 local->hw.wiphy->n_cipher_suites--; 928 } 929 if (IS_ERR(local->wep_tx_tfm) || IS_ERR(local->wep_rx_tfm)) { 930 if (local->hw.wiphy->cipher_suites == cipher_suites) { 931 local->hw.wiphy->cipher_suites += 2; 932 local->hw.wiphy->n_cipher_suites -= 2; 933 } else { 934 u32 *suites; 935 int r, w = 0; 936 937 /* Filter out WEP */ 938 939 suites = kmemdup( 940 local->hw.wiphy->cipher_suites, 941 sizeof(u32) * local->hw.wiphy->n_cipher_suites, 942 GFP_KERNEL); 943 if (!suites) { 944 result = -ENOMEM; 945 goto fail_wiphy_register; 946 } 947 for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) { 948 u32 suite = local->hw.wiphy->cipher_suites[r]; 949 if (suite == WLAN_CIPHER_SUITE_WEP40 || 950 suite == WLAN_CIPHER_SUITE_WEP104) 951 continue; 952 suites[w++] = suite; 953 } 954 local->hw.wiphy->cipher_suites = suites; 955 local->hw.wiphy->n_cipher_suites = w; 956 local->wiphy_ciphers_allocated = true; 957 } 958 } 959 960 if (!local->ops->remain_on_channel) 961 local->hw.wiphy->max_remain_on_channel_duration = 5000; 962 963 if (local->ops->sched_scan_start) 964 local->hw.wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN; 965 966 /* mac80211 based drivers don't support internal TDLS setup */ 967 if (local->hw.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) 968 local->hw.wiphy->flags |= WIPHY_FLAG_TDLS_EXTERNAL_SETUP; 969 970 result = wiphy_register(local->hw.wiphy); 971 if (result < 0) 972 goto fail_wiphy_register; 973 974 /* 975 * We use the number of queues for feature tests (QoS, HT) internally 976 * so restrict them appropriately. 977 */ 978 if (hw->queues > IEEE80211_MAX_QUEUES) 979 hw->queues = IEEE80211_MAX_QUEUES; 980 981 local->workqueue = 982 alloc_ordered_workqueue(wiphy_name(local->hw.wiphy), 0); 983 if (!local->workqueue) { 984 result = -ENOMEM; 985 goto fail_workqueue; 986 } 987 988 /* 989 * The hardware needs headroom for sending the frame, 990 * and we need some headroom for passing the frame to monitor 991 * interfaces, but never both at the same time. 992 */ 993 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 994 IEEE80211_TX_STATUS_HEADROOM); 995 996 debugfs_hw_add(local); 997 998 /* 999 * if the driver doesn't specify a max listen interval we 1000 * use 5 which should be a safe default 1001 */ 1002 if (local->hw.max_listen_interval == 0) 1003 local->hw.max_listen_interval = 5; 1004 1005 local->hw.conf.listen_interval = local->hw.max_listen_interval; 1006 1007 local->dynamic_ps_forced_timeout = -1; 1008 1009 result = ieee80211_wep_init(local); 1010 if (result < 0) 1011 wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n", 1012 result); 1013 1014 ieee80211_led_init(local); 1015 1016 rtnl_lock(); 1017 1018 result = ieee80211_init_rate_ctrl_alg(local, 1019 hw->rate_control_algorithm); 1020 if (result < 0) { 1021 wiphy_debug(local->hw.wiphy, 1022 "Failed to initialize rate control algorithm\n"); 1023 goto fail_rate; 1024 } 1025 1026 /* add one default STA interface if supported */ 1027 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) { 1028 result = ieee80211_if_add(local, "wlan%d", NULL, 1029 NL80211_IFTYPE_STATION, NULL); 1030 if (result) 1031 wiphy_warn(local->hw.wiphy, 1032 "Failed to add default virtual iface\n"); 1033 } 1034 1035 rtnl_unlock(); 1036 1037 local->network_latency_notifier.notifier_call = 1038 ieee80211_max_network_latency; 1039 result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY, 1040 &local->network_latency_notifier); 1041 if (result) { 1042 rtnl_lock(); 1043 goto fail_pm_qos; 1044 } 1045 1046#ifdef CONFIG_INET 1047 local->ifa_notifier.notifier_call = ieee80211_ifa_changed; 1048 result = register_inetaddr_notifier(&local->ifa_notifier); 1049 if (result) 1050 goto fail_ifa; 1051#endif 1052 1053 netif_napi_add(&local->napi_dev, &local->napi, ieee80211_napi_poll, 1054 local->hw.napi_weight); 1055 1056 return 0; 1057 1058#ifdef CONFIG_INET 1059 fail_ifa: 1060 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 1061 &local->network_latency_notifier); 1062 rtnl_lock(); 1063#endif 1064 fail_pm_qos: 1065 ieee80211_led_exit(local); 1066 ieee80211_remove_interfaces(local); 1067 fail_rate: 1068 rtnl_unlock(); 1069 ieee80211_wep_free(local); 1070 sta_info_stop(local); 1071 destroy_workqueue(local->workqueue); 1072 fail_workqueue: 1073 wiphy_unregister(local->hw.wiphy); 1074 fail_wiphy_register: 1075 if (local->wiphy_ciphers_allocated) 1076 kfree(local->hw.wiphy->cipher_suites); 1077 kfree(local->int_scan_req); 1078 return result; 1079} 1080EXPORT_SYMBOL(ieee80211_register_hw); 1081 1082void ieee80211_unregister_hw(struct ieee80211_hw *hw) 1083{ 1084 struct ieee80211_local *local = hw_to_local(hw); 1085 1086 tasklet_kill(&local->tx_pending_tasklet); 1087 tasklet_kill(&local->tasklet); 1088 1089 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 1090 &local->network_latency_notifier); 1091#ifdef CONFIG_INET 1092 unregister_inetaddr_notifier(&local->ifa_notifier); 1093#endif 1094 1095 rtnl_lock(); 1096 1097 /* 1098 * At this point, interface list manipulations are fine 1099 * because the driver cannot be handing us frames any 1100 * more and the tasklet is killed. 1101 */ 1102 ieee80211_remove_interfaces(local); 1103 1104 rtnl_unlock(); 1105 1106 cancel_work_sync(&local->restart_work); 1107 cancel_work_sync(&local->reconfig_filter); 1108 1109 ieee80211_clear_tx_pending(local); 1110 rate_control_deinitialize(local); 1111 1112 if (skb_queue_len(&local->skb_queue) || 1113 skb_queue_len(&local->skb_queue_unreliable)) 1114 wiphy_warn(local->hw.wiphy, "skb_queue not empty\n"); 1115 skb_queue_purge(&local->skb_queue); 1116 skb_queue_purge(&local->skb_queue_unreliable); 1117 skb_queue_purge(&local->rx_skb_queue); 1118 1119 destroy_workqueue(local->workqueue); 1120 wiphy_unregister(local->hw.wiphy); 1121 sta_info_stop(local); 1122 ieee80211_wep_free(local); 1123 ieee80211_led_exit(local); 1124 kfree(local->int_scan_req); 1125} 1126EXPORT_SYMBOL(ieee80211_unregister_hw); 1127 1128static int ieee80211_free_ack_frame(int id, void *p, void *data) 1129{ 1130 WARN_ONCE(1, "Have pending ack frames!\n"); 1131 kfree_skb(p); 1132 return 0; 1133} 1134 1135void ieee80211_free_hw(struct ieee80211_hw *hw) 1136{ 1137 struct ieee80211_local *local = hw_to_local(hw); 1138 1139 mutex_destroy(&local->iflist_mtx); 1140 mutex_destroy(&local->mtx); 1141 1142 if (local->wiphy_ciphers_allocated) 1143 kfree(local->hw.wiphy->cipher_suites); 1144 1145 idr_for_each(&local->ack_status_frames, 1146 ieee80211_free_ack_frame, NULL); 1147 idr_destroy(&local->ack_status_frames); 1148 1149 wiphy_free(local->hw.wiphy); 1150} 1151EXPORT_SYMBOL(ieee80211_free_hw); 1152 1153static int __init ieee80211_init(void) 1154{ 1155 struct sk_buff *skb; 1156 int ret; 1157 1158 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 1159 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 1160 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 1161 1162 ret = rc80211_minstrel_init(); 1163 if (ret) 1164 return ret; 1165 1166 ret = rc80211_minstrel_ht_init(); 1167 if (ret) 1168 goto err_minstrel; 1169 1170 ret = rc80211_pid_init(); 1171 if (ret) 1172 goto err_pid; 1173 1174 ret = ieee80211_iface_init(); 1175 if (ret) 1176 goto err_netdev; 1177 1178 return 0; 1179 err_netdev: 1180 rc80211_pid_exit(); 1181 err_pid: 1182 rc80211_minstrel_ht_exit(); 1183 err_minstrel: 1184 rc80211_minstrel_exit(); 1185 1186 return ret; 1187} 1188 1189static void __exit ieee80211_exit(void) 1190{ 1191 rc80211_pid_exit(); 1192 rc80211_minstrel_ht_exit(); 1193 rc80211_minstrel_exit(); 1194 1195 if (mesh_allocated) 1196 ieee80211s_stop(); 1197 1198 ieee80211_iface_exit(); 1199 1200 rcu_barrier(); 1201} 1202 1203 1204subsys_initcall(ieee80211_init); 1205module_exit(ieee80211_exit); 1206 1207MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 1208MODULE_LICENSE("GPL"); 1209