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_params.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 36 37 bool ieee80211_disable_40mhz_24ghz; 38 module_param(ieee80211_disable_40mhz_24ghz, bool, 0644); 39 MODULE_PARM_DESC(ieee80211_disable_40mhz_24ghz, 40 "Disable 40MHz support in the 2.4GHz band"); 41 42 void ieee80211_configure_filter(struct ieee80211_local *local) 43 { 44 u64 mc; 45 unsigned int changed_flags; 46 unsigned int new_flags = 0; 47 48 if (atomic_read(&local->iff_promiscs)) 49 new_flags |= FIF_PROMISC_IN_BSS; 50 51 if (atomic_read(&local->iff_allmultis)) 52 new_flags |= FIF_ALLMULTI; 53 54 if (local->monitors || local->scanning) 55 new_flags |= FIF_BCN_PRBRESP_PROMISC; 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 88 static 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 96 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed) 97 { 98 struct ieee80211_channel *chan, *scan_chan; 99 int ret = 0; 100 int power; 101 enum nl80211_channel_type channel_type; 102 103 might_sleep(); 104 105 scan_chan = local->scan_channel; 106 107 if (scan_chan) { 108 chan = scan_chan; 109 channel_type = NL80211_CHAN_NO_HT; 110 local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL; 111 } else if (local->tmp_channel) { 112 chan = scan_chan = local->tmp_channel; 113 channel_type = local->tmp_channel_type; 114 local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL; 115 } else { 116 chan = local->oper_channel; 117 channel_type = local->_oper_channel_type; 118 local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL; 119 } 120 121 if (chan != local->hw.conf.channel || 122 channel_type != local->hw.conf.channel_type) { 123 local->hw.conf.channel = chan; 124 local->hw.conf.channel_type = channel_type; 125 changed |= IEEE80211_CONF_CHANGE_CHANNEL; 126 } 127 128 if (!conf_is_ht(&local->hw.conf)) { 129 /* 130 * mac80211.h documents that this is only valid 131 * when the channel is set to an HT type, and 132 * that otherwise STATIC is used. 133 */ 134 local->hw.conf.smps_mode = IEEE80211_SMPS_STATIC; 135 } else if (local->hw.conf.smps_mode != local->smps_mode) { 136 local->hw.conf.smps_mode = local->smps_mode; 137 changed |= IEEE80211_CONF_CHANGE_SMPS; 138 } 139 140 if (scan_chan) 141 power = chan->max_power; 142 else 143 power = local->power_constr_level ? 144 (chan->max_power - local->power_constr_level) : 145 chan->max_power; 146 147 if (local->user_power_level >= 0) 148 power = min(power, local->user_power_level); 149 150 if (local->hw.conf.power_level != power) { 151 changed |= IEEE80211_CONF_CHANGE_POWER; 152 local->hw.conf.power_level = power; 153 } 154 155 if (changed && local->open_count) { 156 ret = drv_config(local, changed); 157 /* 158 * Goal: 159 * HW reconfiguration should never fail, the driver has told 160 * us what it can support so it should live up to that promise. 161 * 162 * Current status: 163 * rfkill is not integrated with mac80211 and a 164 * configuration command can thus fail if hardware rfkill 165 * is enabled 166 * 167 * FIXME: integrate rfkill with mac80211 and then add this 168 * WARN_ON() back 169 * 170 */ 171 /* WARN_ON(ret); */ 172 } 173 174 return ret; 175 } 176 177 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 178 u32 changed) 179 { 180 struct ieee80211_local *local = sdata->local; 181 static const u8 zero[ETH_ALEN] = { 0 }; 182 183 if (!changed) 184 return; 185 186 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 187 /* 188 * While not associated, claim a BSSID of all-zeroes 189 * so that drivers don't do any weird things with the 190 * BSSID at that time. 191 */ 192 if (sdata->vif.bss_conf.assoc) 193 sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid; 194 else 195 sdata->vif.bss_conf.bssid = zero; 196 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) 197 sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid; 198 else if (sdata->vif.type == NL80211_IFTYPE_AP) 199 sdata->vif.bss_conf.bssid = sdata->vif.addr; 200 else if (ieee80211_vif_is_mesh(&sdata->vif)) { 201 sdata->vif.bss_conf.bssid = zero; 202 } else { 203 WARN_ON(1); 204 return; 205 } 206 207 switch (sdata->vif.type) { 208 case NL80211_IFTYPE_AP: 209 case NL80211_IFTYPE_ADHOC: 210 case NL80211_IFTYPE_MESH_POINT: 211 break; 212 default: 213 /* do not warn to simplify caller in scan.c */ 214 changed &= ~BSS_CHANGED_BEACON_ENABLED; 215 if (WARN_ON(changed & BSS_CHANGED_BEACON)) 216 return; 217 break; 218 } 219 220 if (changed & BSS_CHANGED_BEACON_ENABLED) { 221 if (local->quiescing || !ieee80211_sdata_running(sdata) || 222 test_bit(SCAN_SW_SCANNING, &local->scanning)) { 223 sdata->vif.bss_conf.enable_beacon = false; 224 } else { 225 /* 226 * Beacon should be enabled, but AP mode must 227 * check whether there is a beacon configured. 228 */ 229 switch (sdata->vif.type) { 230 case NL80211_IFTYPE_AP: 231 sdata->vif.bss_conf.enable_beacon = 232 !!sdata->u.ap.beacon; 233 break; 234 case NL80211_IFTYPE_ADHOC: 235 sdata->vif.bss_conf.enable_beacon = 236 !!sdata->u.ibss.presp; 237 break; 238 case NL80211_IFTYPE_MESH_POINT: 239 sdata->vif.bss_conf.enable_beacon = true; 240 break; 241 default: 242 /* not reached */ 243 WARN_ON(1); 244 break; 245 } 246 } 247 } 248 249 drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed); 250 } 251 252 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 253 { 254 sdata->vif.bss_conf.use_cts_prot = false; 255 sdata->vif.bss_conf.use_short_preamble = false; 256 sdata->vif.bss_conf.use_short_slot = false; 257 return BSS_CHANGED_ERP_CTS_PROT | 258 BSS_CHANGED_ERP_PREAMBLE | 259 BSS_CHANGED_ERP_SLOT; 260 } 261 262 static void ieee80211_tasklet_handler(unsigned long data) 263 { 264 struct ieee80211_local *local = (struct ieee80211_local *) data; 265 struct sk_buff *skb; 266 267 while ((skb = skb_dequeue(&local->skb_queue)) || 268 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 269 switch (skb->pkt_type) { 270 case IEEE80211_RX_MSG: 271 /* Clear skb->pkt_type in order to not confuse kernel 272 * netstack. */ 273 skb->pkt_type = 0; 274 ieee80211_rx(local_to_hw(local), skb); 275 break; 276 case IEEE80211_TX_STATUS_MSG: 277 skb->pkt_type = 0; 278 ieee80211_tx_status(local_to_hw(local), skb); 279 break; 280 default: 281 WARN(1, "mac80211: Packet is of unknown type %d\n", 282 skb->pkt_type); 283 dev_kfree_skb(skb); 284 break; 285 } 286 } 287 } 288 289 static void ieee80211_restart_work(struct work_struct *work) 290 { 291 struct ieee80211_local *local = 292 container_of(work, struct ieee80211_local, restart_work); 293 294 rtnl_lock(); 295 ieee80211_reconfig(local); 296 rtnl_unlock(); 297 } 298 299 void ieee80211_restart_hw(struct ieee80211_hw *hw) 300 { 301 struct ieee80211_local *local = hw_to_local(hw); 302 303 trace_api_restart_hw(local); 304 305 /* use this reason, __ieee80211_resume will unblock it */ 306 ieee80211_stop_queues_by_reason(hw, 307 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 308 309 schedule_work(&local->restart_work); 310 } 311 EXPORT_SYMBOL(ieee80211_restart_hw); 312 313 static void ieee80211_recalc_smps_work(struct work_struct *work) 314 { 315 struct ieee80211_local *local = 316 container_of(work, struct ieee80211_local, recalc_smps); 317 318 mutex_lock(&local->iflist_mtx); 319 ieee80211_recalc_smps(local, NULL); 320 mutex_unlock(&local->iflist_mtx); 321 } 322 323 #ifdef CONFIG_INET 324 static int ieee80211_ifa_changed(struct notifier_block *nb, 325 unsigned long data, void *arg) 326 { 327 struct in_ifaddr *ifa = arg; 328 struct ieee80211_local *local = 329 container_of(nb, struct ieee80211_local, 330 ifa_notifier); 331 struct net_device *ndev = ifa->ifa_dev->dev; 332 struct wireless_dev *wdev = ndev->ieee80211_ptr; 333 struct in_device *idev; 334 struct ieee80211_sub_if_data *sdata; 335 struct ieee80211_bss_conf *bss_conf; 336 struct ieee80211_if_managed *ifmgd; 337 int c = 0; 338 339 if (!netif_running(ndev)) 340 return NOTIFY_DONE; 341 342 /* Make sure it's our interface that got changed */ 343 if (!wdev) 344 return NOTIFY_DONE; 345 346 if (wdev->wiphy != local->hw.wiphy) 347 return NOTIFY_DONE; 348 349 sdata = IEEE80211_DEV_TO_SUB_IF(ndev); 350 bss_conf = &sdata->vif.bss_conf; 351 352 /* ARP filtering is only supported in managed mode */ 353 if (sdata->vif.type != NL80211_IFTYPE_STATION) 354 return NOTIFY_DONE; 355 356 idev = sdata->dev->ip_ptr; 357 if (!idev) 358 return NOTIFY_DONE; 359 360 ifmgd = &sdata->u.mgd; 361 mutex_lock(&ifmgd->mtx); 362 363 /* Copy the addresses to the bss_conf list */ 364 ifa = idev->ifa_list; 365 while (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN && ifa) { 366 bss_conf->arp_addr_list[c] = ifa->ifa_address; 367 ifa = ifa->ifa_next; 368 c++; 369 } 370 371 /* If not all addresses fit the list, disable filtering */ 372 if (ifa) { 373 sdata->arp_filter_state = false; 374 c = 0; 375 } else { 376 sdata->arp_filter_state = true; 377 } 378 bss_conf->arp_addr_cnt = c; 379 380 /* Configure driver only if associated */ 381 if (ifmgd->associated) { 382 bss_conf->arp_filter_enabled = sdata->arp_filter_state; 383 ieee80211_bss_info_change_notify(sdata, 384 BSS_CHANGED_ARP_FILTER); 385 } 386 387 mutex_unlock(&ifmgd->mtx); 388 389 return NOTIFY_DONE; 390 } 391 #endif 392 393 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 394 const struct ieee80211_ops *ops) 395 { 396 struct ieee80211_local *local; 397 int priv_size, i; 398 struct wiphy *wiphy; 399 400 /* Ensure 32-byte alignment of our private data and hw private data. 401 * We use the wiphy priv data for both our ieee80211_local and for 402 * the driver's private data 403 * 404 * In memory it'll be like this: 405 * 406 * +-------------------------+ 407 * | struct wiphy | 408 * +-------------------------+ 409 * | struct ieee80211_local | 410 * +-------------------------+ 411 * | driver's private data | 412 * +-------------------------+ 413 * 414 */ 415 priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len; 416 417 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 418 419 if (!wiphy) 420 return NULL; 421 422 wiphy->flags |= WIPHY_FLAG_NETNS_OK | 423 WIPHY_FLAG_4ADDR_AP | 424 WIPHY_FLAG_4ADDR_STATION; 425 wiphy->privid = mac80211_wiphy_privid; 426 427 wiphy->bss_priv_size = sizeof(struct ieee80211_bss); 428 429 local = wiphy_priv(wiphy); 430 431 local->hw.wiphy = wiphy; 432 433 local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN); 434 435 BUG_ON(!ops->tx); 436 BUG_ON(!ops->start); 437 BUG_ON(!ops->stop); 438 BUG_ON(!ops->config); 439 BUG_ON(!ops->add_interface); 440 BUG_ON(!ops->remove_interface); 441 BUG_ON(!ops->configure_filter); 442 local->ops = ops; 443 444 /* set up some defaults */ 445 local->hw.queues = 1; 446 local->hw.max_rates = 1; 447 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 448 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 449 local->user_power_level = -1; 450 local->uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES; 451 local->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN; 452 453 INIT_LIST_HEAD(&local->interfaces); 454 455 __hw_addr_init(&local->mc_list); 456 457 mutex_init(&local->iflist_mtx); 458 mutex_init(&local->scan_mtx); 459 460 mutex_init(&local->key_mtx); 461 spin_lock_init(&local->filter_lock); 462 spin_lock_init(&local->queue_stop_reason_lock); 463 464 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 465 466 ieee80211_work_init(local); 467 468 INIT_WORK(&local->restart_work, ieee80211_restart_work); 469 470 INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter); 471 INIT_WORK(&local->recalc_smps, ieee80211_recalc_smps_work); 472 local->smps_mode = IEEE80211_SMPS_OFF; 473 474 INIT_WORK(&local->dynamic_ps_enable_work, 475 ieee80211_dynamic_ps_enable_work); 476 INIT_WORK(&local->dynamic_ps_disable_work, 477 ieee80211_dynamic_ps_disable_work); 478 setup_timer(&local->dynamic_ps_timer, 479 ieee80211_dynamic_ps_timer, (unsigned long) local); 480 481 sta_info_init(local); 482 483 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) { 484 skb_queue_head_init(&local->pending[i]); 485 atomic_set(&local->agg_queue_stop[i], 0); 486 } 487 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 488 (unsigned long)local); 489 490 tasklet_init(&local->tasklet, 491 ieee80211_tasklet_handler, 492 (unsigned long) local); 493 494 skb_queue_head_init(&local->skb_queue); 495 skb_queue_head_init(&local->skb_queue_unreliable); 496 497 return local_to_hw(local); 498 } 499 EXPORT_SYMBOL(ieee80211_alloc_hw); 500 501 int ieee80211_register_hw(struct ieee80211_hw *hw) 502 { 503 struct ieee80211_local *local = hw_to_local(hw); 504 int result; 505 enum ieee80211_band band; 506 int channels, max_bitrates; 507 bool supp_ht; 508 static const u32 cipher_suites[] = { 509 WLAN_CIPHER_SUITE_WEP40, 510 WLAN_CIPHER_SUITE_WEP104, 511 WLAN_CIPHER_SUITE_TKIP, 512 WLAN_CIPHER_SUITE_CCMP, 513 514 /* keep last -- depends on hw flags! */ 515 WLAN_CIPHER_SUITE_AES_CMAC 516 }; 517 518 /* 519 * generic code guarantees at least one band, 520 * set this very early because much code assumes 521 * that hw.conf.channel is assigned 522 */ 523 channels = 0; 524 max_bitrates = 0; 525 supp_ht = false; 526 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 527 struct ieee80211_supported_band *sband; 528 529 sband = local->hw.wiphy->bands[band]; 530 if (!sband) 531 continue; 532 if (!local->oper_channel) { 533 /* init channel we're on */ 534 local->hw.conf.channel = 535 local->oper_channel = &sband->channels[0]; 536 local->hw.conf.channel_type = NL80211_CHAN_NO_HT; 537 } 538 channels += sband->n_channels; 539 540 if (max_bitrates < sband->n_bitrates) 541 max_bitrates = sband->n_bitrates; 542 supp_ht = supp_ht || sband->ht_cap.ht_supported; 543 } 544 545 local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) + 546 sizeof(void *) * channels, GFP_KERNEL); 547 if (!local->int_scan_req) 548 return -ENOMEM; 549 550 /* if low-level driver supports AP, we also support VLAN */ 551 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) 552 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 553 554 /* mac80211 always supports monitor */ 555 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 556 557 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 558 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 559 else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC) 560 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC; 561 562 WARN((local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD) 563 && (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK), 564 "U-APSD not supported with HW_PS_NULLFUNC_STACK\n"); 565 566 /* 567 * Calculate scan IE length -- we need this to alloc 568 * memory and to subtract from the driver limit. It 569 * includes the (extended) supported rates and HT 570 * information -- SSID is the driver's responsibility. 571 */ 572 local->scan_ies_len = 4 + max_bitrates; /* (ext) supp rates */ 573 if (supp_ht) 574 local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap); 575 576 if (!local->ops->hw_scan) { 577 /* For hw_scan, driver needs to set these up. */ 578 local->hw.wiphy->max_scan_ssids = 4; 579 local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; 580 } 581 582 /* 583 * If the driver supports any scan IEs, then assume the 584 * limit includes the IEs mac80211 will add, otherwise 585 * leave it at zero and let the driver sort it out; we 586 * still pass our IEs to the driver but userspace will 587 * not be allowed to in that case. 588 */ 589 if (local->hw.wiphy->max_scan_ie_len) 590 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len; 591 592 local->hw.wiphy->cipher_suites = cipher_suites; 593 local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 594 if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE)) 595 local->hw.wiphy->n_cipher_suites--; 596 597 result = wiphy_register(local->hw.wiphy); 598 if (result < 0) 599 goto fail_wiphy_register; 600 601 /* 602 * We use the number of queues for feature tests (QoS, HT) internally 603 * so restrict them appropriately. 604 */ 605 if (hw->queues > IEEE80211_MAX_QUEUES) 606 hw->queues = IEEE80211_MAX_QUEUES; 607 608 local->workqueue = 609 create_singlethread_workqueue(wiphy_name(local->hw.wiphy)); 610 if (!local->workqueue) { 611 result = -ENOMEM; 612 goto fail_workqueue; 613 } 614 615 /* 616 * The hardware needs headroom for sending the frame, 617 * and we need some headroom for passing the frame to monitor 618 * interfaces, but never both at the same time. 619 */ 620 BUILD_BUG_ON(IEEE80211_TX_STATUS_HEADROOM != 621 sizeof(struct ieee80211_tx_status_rtap_hdr)); 622 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 623 sizeof(struct ieee80211_tx_status_rtap_hdr)); 624 625 debugfs_hw_add(local); 626 627 /* 628 * if the driver doesn't specify a max listen interval we 629 * use 5 which should be a safe default 630 */ 631 if (local->hw.max_listen_interval == 0) 632 local->hw.max_listen_interval = 5; 633 634 local->hw.conf.listen_interval = local->hw.max_listen_interval; 635 636 local->dynamic_ps_forced_timeout = -1; 637 638 result = sta_info_start(local); 639 if (result < 0) 640 goto fail_sta_info; 641 642 result = ieee80211_wep_init(local); 643 if (result < 0) 644 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n", 645 wiphy_name(local->hw.wiphy), result); 646 647 rtnl_lock(); 648 649 result = ieee80211_init_rate_ctrl_alg(local, 650 hw->rate_control_algorithm); 651 if (result < 0) { 652 printk(KERN_DEBUG "%s: Failed to initialize rate control " 653 "algorithm\n", wiphy_name(local->hw.wiphy)); 654 goto fail_rate; 655 } 656 657 /* add one default STA interface if supported */ 658 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) { 659 result = ieee80211_if_add(local, "wlan%d", NULL, 660 NL80211_IFTYPE_STATION, NULL); 661 if (result) 662 printk(KERN_WARNING "%s: Failed to add default virtual iface\n", 663 wiphy_name(local->hw.wiphy)); 664 } 665 666 rtnl_unlock(); 667 668 ieee80211_led_init(local); 669 670 local->network_latency_notifier.notifier_call = 671 ieee80211_max_network_latency; 672 result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY, 673 &local->network_latency_notifier); 674 if (result) { 675 rtnl_lock(); 676 goto fail_pm_qos; 677 } 678 679 #ifdef CONFIG_INET 680 local->ifa_notifier.notifier_call = ieee80211_ifa_changed; 681 result = register_inetaddr_notifier(&local->ifa_notifier); 682 if (result) 683 goto fail_ifa; 684 #endif 685 686 return 0; 687 688 #ifdef CONFIG_INET 689 fail_ifa: 690 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 691 &local->network_latency_notifier); 692 rtnl_lock(); 693 #endif 694 fail_pm_qos: 695 ieee80211_led_exit(local); 696 ieee80211_remove_interfaces(local); 697 fail_rate: 698 rtnl_unlock(); 699 ieee80211_wep_free(local); 700 sta_info_stop(local); 701 fail_sta_info: 702 destroy_workqueue(local->workqueue); 703 fail_workqueue: 704 wiphy_unregister(local->hw.wiphy); 705 fail_wiphy_register: 706 kfree(local->int_scan_req); 707 return result; 708 } 709 EXPORT_SYMBOL(ieee80211_register_hw); 710 711 void ieee80211_unregister_hw(struct ieee80211_hw *hw) 712 { 713 struct ieee80211_local *local = hw_to_local(hw); 714 715 tasklet_kill(&local->tx_pending_tasklet); 716 tasklet_kill(&local->tasklet); 717 718 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 719 &local->network_latency_notifier); 720 #ifdef CONFIG_INET 721 unregister_inetaddr_notifier(&local->ifa_notifier); 722 #endif 723 724 rtnl_lock(); 725 726 /* 727 * At this point, interface list manipulations are fine 728 * because the driver cannot be handing us frames any 729 * more and the tasklet is killed. 730 */ 731 ieee80211_remove_interfaces(local); 732 733 rtnl_unlock(); 734 735 cancel_work_sync(&local->reconfig_filter); 736 737 ieee80211_clear_tx_pending(local); 738 sta_info_stop(local); 739 rate_control_deinitialize(local); 740 741 if (skb_queue_len(&local->skb_queue) || 742 skb_queue_len(&local->skb_queue_unreliable)) 743 printk(KERN_WARNING "%s: skb_queue not empty\n", 744 wiphy_name(local->hw.wiphy)); 745 skb_queue_purge(&local->skb_queue); 746 skb_queue_purge(&local->skb_queue_unreliable); 747 748 destroy_workqueue(local->workqueue); 749 wiphy_unregister(local->hw.wiphy); 750 ieee80211_wep_free(local); 751 ieee80211_led_exit(local); 752 kfree(local->int_scan_req); 753 } 754 EXPORT_SYMBOL(ieee80211_unregister_hw); 755 756 void ieee80211_free_hw(struct ieee80211_hw *hw) 757 { 758 struct ieee80211_local *local = hw_to_local(hw); 759 760 mutex_destroy(&local->iflist_mtx); 761 mutex_destroy(&local->scan_mtx); 762 763 wiphy_free(local->hw.wiphy); 764 } 765 EXPORT_SYMBOL(ieee80211_free_hw); 766 767 static int __init ieee80211_init(void) 768 { 769 struct sk_buff *skb; 770 int ret; 771 772 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 773 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 774 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 775 776 ret = rc80211_minstrel_init(); 777 if (ret) 778 return ret; 779 780 ret = rc80211_minstrel_ht_init(); 781 if (ret) 782 goto err_minstrel; 783 784 ret = rc80211_pid_init(); 785 if (ret) 786 goto err_pid; 787 788 ret = ieee80211_iface_init(); 789 if (ret) 790 goto err_netdev; 791 792 return 0; 793 err_netdev: 794 rc80211_pid_exit(); 795 err_pid: 796 rc80211_minstrel_ht_exit(); 797 err_minstrel: 798 rc80211_minstrel_exit(); 799 800 return ret; 801 } 802 803 static void __exit ieee80211_exit(void) 804 { 805 rc80211_pid_exit(); 806 rc80211_minstrel_ht_exit(); 807 rc80211_minstrel_exit(); 808 809 /* 810 * For key todo, it'll be empty by now but the work 811 * might still be scheduled. 812 */ 813 flush_scheduled_work(); 814 815 if (mesh_allocated) 816 ieee80211s_stop(); 817 818 ieee80211_iface_exit(); 819 } 820 821 822 subsys_initcall(ieee80211_init); 823 module_exit(ieee80211_exit); 824 825 MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 826 MODULE_LICENSE("GPL"); 827