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/wireless.h> 21 #include <linux/rtnetlink.h> 22 #include <linux/bitmap.h> 23 #include <linux/pm_qos_params.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 #include "debugfs_netdev.h" 36 37 void ieee80211_configure_filter(struct ieee80211_local *local) 38 { 39 u64 mc; 40 unsigned int changed_flags; 41 unsigned int new_flags = 0; 42 43 if (atomic_read(&local->iff_promiscs)) 44 new_flags |= FIF_PROMISC_IN_BSS; 45 46 if (atomic_read(&local->iff_allmultis)) 47 new_flags |= FIF_ALLMULTI; 48 49 if (local->monitors || local->scanning) 50 new_flags |= FIF_BCN_PRBRESP_PROMISC; 51 52 if (local->fif_fcsfail) 53 new_flags |= FIF_FCSFAIL; 54 55 if (local->fif_plcpfail) 56 new_flags |= FIF_PLCPFAIL; 57 58 if (local->fif_control) 59 new_flags |= FIF_CONTROL; 60 61 if (local->fif_other_bss) 62 new_flags |= FIF_OTHER_BSS; 63 64 if (local->fif_pspoll) 65 new_flags |= FIF_PSPOLL; 66 67 spin_lock_bh(&local->filter_lock); 68 changed_flags = local->filter_flags ^ new_flags; 69 70 mc = drv_prepare_multicast(local, local->mc_count, local->mc_list); 71 spin_unlock_bh(&local->filter_lock); 72 73 /* be a bit nasty */ 74 new_flags |= (1<<31); 75 76 drv_configure_filter(local, changed_flags, &new_flags, mc); 77 78 WARN_ON(new_flags & (1<<31)); 79 80 local->filter_flags = new_flags & ~(1<<31); 81 } 82 83 static void ieee80211_reconfig_filter(struct work_struct *work) 84 { 85 struct ieee80211_local *local = 86 container_of(work, struct ieee80211_local, reconfig_filter); 87 88 ieee80211_configure_filter(local); 89 } 90 91 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed) 92 { 93 struct ieee80211_channel *chan, *scan_chan; 94 int ret = 0; 95 int power; 96 enum nl80211_channel_type channel_type; 97 98 might_sleep(); 99 100 scan_chan = local->scan_channel; 101 102 if (scan_chan) { 103 chan = scan_chan; 104 channel_type = NL80211_CHAN_NO_HT; 105 } else { 106 chan = local->oper_channel; 107 channel_type = local->oper_channel_type; 108 } 109 110 if (chan != local->hw.conf.channel || 111 channel_type != local->hw.conf.channel_type) { 112 local->hw.conf.channel = chan; 113 local->hw.conf.channel_type = channel_type; 114 changed |= IEEE80211_CONF_CHANGE_CHANNEL; 115 } 116 117 if (scan_chan) 118 power = chan->max_power; 119 else 120 power = local->power_constr_level ? 121 (chan->max_power - local->power_constr_level) : 122 chan->max_power; 123 124 if (local->user_power_level >= 0) 125 power = min(power, local->user_power_level); 126 127 if (local->hw.conf.power_level != power) { 128 changed |= IEEE80211_CONF_CHANGE_POWER; 129 local->hw.conf.power_level = power; 130 } 131 132 if (changed && local->open_count) { 133 ret = drv_config(local, changed); 134 /* 135 * Goal: 136 * HW reconfiguration should never fail, the driver has told 137 * us what it can support so it should live up to that promise. 138 * 139 * Current status: 140 * rfkill is not integrated with mac80211 and a 141 * configuration command can thus fail if hardware rfkill 142 * is enabled 143 * 144 * FIXME: integrate rfkill with mac80211 and then add this 145 * WARN_ON() back 146 * 147 */ 148 /* WARN_ON(ret); */ 149 } 150 151 return ret; 152 } 153 154 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 155 u32 changed) 156 { 157 struct ieee80211_local *local = sdata->local; 158 static const u8 zero[ETH_ALEN] = { 0 }; 159 160 if (!changed) 161 return; 162 163 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 164 /* 165 * While not associated, claim a BSSID of all-zeroes 166 * so that drivers don't do any weird things with the 167 * BSSID at that time. 168 */ 169 if (sdata->vif.bss_conf.assoc) 170 sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid; 171 else 172 sdata->vif.bss_conf.bssid = zero; 173 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) 174 sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid; 175 else if (sdata->vif.type == NL80211_IFTYPE_AP) 176 sdata->vif.bss_conf.bssid = sdata->dev->dev_addr; 177 else if (ieee80211_vif_is_mesh(&sdata->vif)) { 178 sdata->vif.bss_conf.bssid = zero; 179 } else { 180 WARN_ON(1); 181 return; 182 } 183 184 switch (sdata->vif.type) { 185 case NL80211_IFTYPE_AP: 186 case NL80211_IFTYPE_ADHOC: 187 case NL80211_IFTYPE_MESH_POINT: 188 break; 189 default: 190 /* do not warn to simplify caller in scan.c */ 191 changed &= ~BSS_CHANGED_BEACON_ENABLED; 192 if (WARN_ON(changed & BSS_CHANGED_BEACON)) 193 return; 194 break; 195 } 196 197 if (changed & BSS_CHANGED_BEACON_ENABLED) { 198 if (local->quiescing || !netif_running(sdata->dev) || 199 test_bit(SCAN_SW_SCANNING, &local->scanning)) { 200 sdata->vif.bss_conf.enable_beacon = false; 201 } else { 202 /* 203 * Beacon should be enabled, but AP mode must 204 * check whether there is a beacon configured. 205 */ 206 switch (sdata->vif.type) { 207 case NL80211_IFTYPE_AP: 208 sdata->vif.bss_conf.enable_beacon = 209 !!rcu_dereference(sdata->u.ap.beacon); 210 break; 211 case NL80211_IFTYPE_ADHOC: 212 sdata->vif.bss_conf.enable_beacon = 213 !!rcu_dereference(sdata->u.ibss.presp); 214 break; 215 case NL80211_IFTYPE_MESH_POINT: 216 sdata->vif.bss_conf.enable_beacon = true; 217 break; 218 default: 219 /* not reached */ 220 WARN_ON(1); 221 break; 222 } 223 } 224 } 225 226 drv_bss_info_changed(local, &sdata->vif, 227 &sdata->vif.bss_conf, changed); 228 } 229 230 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 231 { 232 sdata->vif.bss_conf.use_cts_prot = false; 233 sdata->vif.bss_conf.use_short_preamble = false; 234 sdata->vif.bss_conf.use_short_slot = false; 235 return BSS_CHANGED_ERP_CTS_PROT | 236 BSS_CHANGED_ERP_PREAMBLE | 237 BSS_CHANGED_ERP_SLOT; 238 } 239 240 static void ieee80211_tasklet_handler(unsigned long data) 241 { 242 struct ieee80211_local *local = (struct ieee80211_local *) data; 243 struct sk_buff *skb; 244 struct ieee80211_ra_tid *ra_tid; 245 246 while ((skb = skb_dequeue(&local->skb_queue)) || 247 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 248 switch (skb->pkt_type) { 249 case IEEE80211_RX_MSG: 250 /* Clear skb->pkt_type in order to not confuse kernel 251 * netstack. */ 252 skb->pkt_type = 0; 253 ieee80211_rx(local_to_hw(local), skb); 254 break; 255 case IEEE80211_TX_STATUS_MSG: 256 skb->pkt_type = 0; 257 ieee80211_tx_status(local_to_hw(local), skb); 258 break; 259 case IEEE80211_DELBA_MSG: 260 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 261 ieee80211_stop_tx_ba_cb(ra_tid->vif, ra_tid->ra, 262 ra_tid->tid); 263 dev_kfree_skb(skb); 264 break; 265 case IEEE80211_ADDBA_MSG: 266 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 267 ieee80211_start_tx_ba_cb(ra_tid->vif, ra_tid->ra, 268 ra_tid->tid); 269 dev_kfree_skb(skb); 270 break ; 271 default: 272 WARN(1, "mac80211: Packet is of unknown type %d\n", 273 skb->pkt_type); 274 dev_kfree_skb(skb); 275 break; 276 } 277 } 278 } 279 280 static void ieee80211_restart_work(struct work_struct *work) 281 { 282 struct ieee80211_local *local = 283 container_of(work, struct ieee80211_local, restart_work); 284 285 rtnl_lock(); 286 ieee80211_reconfig(local); 287 rtnl_unlock(); 288 } 289 290 void ieee80211_restart_hw(struct ieee80211_hw *hw) 291 { 292 struct ieee80211_local *local = hw_to_local(hw); 293 294 /* use this reason, __ieee80211_resume will unblock it */ 295 ieee80211_stop_queues_by_reason(hw, 296 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 297 298 schedule_work(&local->restart_work); 299 } 300 EXPORT_SYMBOL(ieee80211_restart_hw); 301 302 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 303 const struct ieee80211_ops *ops) 304 { 305 struct ieee80211_local *local; 306 int priv_size, i; 307 struct wiphy *wiphy; 308 309 /* Ensure 32-byte alignment of our private data and hw private data. 310 * We use the wiphy priv data for both our ieee80211_local and for 311 * the driver's private data 312 * 313 * In memory it'll be like this: 314 * 315 * +-------------------------+ 316 * | struct wiphy | 317 * +-------------------------+ 318 * | struct ieee80211_local | 319 * +-------------------------+ 320 * | driver's private data | 321 * +-------------------------+ 322 * 323 */ 324 priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len; 325 326 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 327 328 if (!wiphy) 329 return NULL; 330 331 wiphy->flags |= WIPHY_FLAG_NETNS_OK | 332 WIPHY_FLAG_4ADDR_AP | 333 WIPHY_FLAG_4ADDR_STATION; 334 wiphy->privid = mac80211_wiphy_privid; 335 336 /* Yes, putting cfg80211_bss into ieee80211_bss is a hack */ 337 wiphy->bss_priv_size = sizeof(struct ieee80211_bss) - 338 sizeof(struct cfg80211_bss); 339 340 local = wiphy_priv(wiphy); 341 342 local->hw.wiphy = wiphy; 343 344 local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN); 345 346 BUG_ON(!ops->tx); 347 BUG_ON(!ops->start); 348 BUG_ON(!ops->stop); 349 BUG_ON(!ops->config); 350 BUG_ON(!ops->add_interface); 351 BUG_ON(!ops->remove_interface); 352 BUG_ON(!ops->configure_filter); 353 local->ops = ops; 354 355 /* set up some defaults */ 356 local->hw.queues = 1; 357 local->hw.max_rates = 1; 358 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 359 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 360 local->user_power_level = -1; 361 362 INIT_LIST_HEAD(&local->interfaces); 363 mutex_init(&local->iflist_mtx); 364 mutex_init(&local->scan_mtx); 365 366 spin_lock_init(&local->key_lock); 367 spin_lock_init(&local->filter_lock); 368 spin_lock_init(&local->queue_stop_reason_lock); 369 370 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 371 372 INIT_WORK(&local->restart_work, ieee80211_restart_work); 373 374 INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter); 375 376 INIT_WORK(&local->dynamic_ps_enable_work, 377 ieee80211_dynamic_ps_enable_work); 378 INIT_WORK(&local->dynamic_ps_disable_work, 379 ieee80211_dynamic_ps_disable_work); 380 setup_timer(&local->dynamic_ps_timer, 381 ieee80211_dynamic_ps_timer, (unsigned long) local); 382 383 sta_info_init(local); 384 385 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) 386 skb_queue_head_init(&local->pending[i]); 387 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 388 (unsigned long)local); 389 390 tasklet_init(&local->tasklet, 391 ieee80211_tasklet_handler, 392 (unsigned long) local); 393 394 skb_queue_head_init(&local->skb_queue); 395 skb_queue_head_init(&local->skb_queue_unreliable); 396 397 spin_lock_init(&local->ampdu_lock); 398 399 return local_to_hw(local); 400 } 401 EXPORT_SYMBOL(ieee80211_alloc_hw); 402 403 int ieee80211_register_hw(struct ieee80211_hw *hw) 404 { 405 struct ieee80211_local *local = hw_to_local(hw); 406 int result; 407 enum ieee80211_band band; 408 int channels, i, j, max_bitrates; 409 bool supp_ht; 410 static const u32 cipher_suites[] = { 411 WLAN_CIPHER_SUITE_WEP40, 412 WLAN_CIPHER_SUITE_WEP104, 413 WLAN_CIPHER_SUITE_TKIP, 414 WLAN_CIPHER_SUITE_CCMP, 415 416 /* keep last -- depends on hw flags! */ 417 WLAN_CIPHER_SUITE_AES_CMAC 418 }; 419 420 /* 421 * generic code guarantees at least one band, 422 * set this very early because much code assumes 423 * that hw.conf.channel is assigned 424 */ 425 channels = 0; 426 max_bitrates = 0; 427 supp_ht = false; 428 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 429 struct ieee80211_supported_band *sband; 430 431 sband = local->hw.wiphy->bands[band]; 432 if (!sband) 433 continue; 434 if (!local->oper_channel) { 435 /* init channel we're on */ 436 local->hw.conf.channel = 437 local->oper_channel = &sband->channels[0]; 438 local->hw.conf.channel_type = NL80211_CHAN_NO_HT; 439 } 440 channels += sband->n_channels; 441 442 if (max_bitrates < sband->n_bitrates) 443 max_bitrates = sband->n_bitrates; 444 supp_ht = supp_ht || sband->ht_cap.ht_supported; 445 } 446 447 local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) + 448 sizeof(void *) * channels, GFP_KERNEL); 449 if (!local->int_scan_req) 450 return -ENOMEM; 451 452 /* if low-level driver supports AP, we also support VLAN */ 453 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) 454 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 455 456 /* mac80211 always supports monitor */ 457 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 458 459 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 460 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 461 else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC) 462 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC; 463 464 /* 465 * Calculate scan IE length -- we need this to alloc 466 * memory and to subtract from the driver limit. It 467 * includes the (extended) supported rates and HT 468 * information -- SSID is the driver's responsibility. 469 */ 470 local->scan_ies_len = 4 + max_bitrates; /* (ext) supp rates */ 471 if (supp_ht) 472 local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap); 473 474 if (!local->ops->hw_scan) { 475 /* For hw_scan, driver needs to set these up. */ 476 local->hw.wiphy->max_scan_ssids = 4; 477 local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; 478 } 479 480 /* 481 * If the driver supports any scan IEs, then assume the 482 * limit includes the IEs mac80211 will add, otherwise 483 * leave it at zero and let the driver sort it out; we 484 * still pass our IEs to the driver but userspace will 485 * not be allowed to in that case. 486 */ 487 if (local->hw.wiphy->max_scan_ie_len) 488 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len; 489 490 local->hw.wiphy->cipher_suites = cipher_suites; 491 local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 492 if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE)) 493 local->hw.wiphy->n_cipher_suites--; 494 495 result = wiphy_register(local->hw.wiphy); 496 if (result < 0) 497 goto fail_wiphy_register; 498 499 /* 500 * We use the number of queues for feature tests (QoS, HT) internally 501 * so restrict them appropriately. 502 */ 503 if (hw->queues > IEEE80211_MAX_QUEUES) 504 hw->queues = IEEE80211_MAX_QUEUES; 505 506 local->workqueue = 507 create_singlethread_workqueue(wiphy_name(local->hw.wiphy)); 508 if (!local->workqueue) { 509 result = -ENOMEM; 510 goto fail_workqueue; 511 } 512 513 /* 514 * The hardware needs headroom for sending the frame, 515 * and we need some headroom for passing the frame to monitor 516 * interfaces, but never both at the same time. 517 */ 518 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 519 sizeof(struct ieee80211_tx_status_rtap_hdr)); 520 521 debugfs_hw_add(local); 522 523 if (local->hw.max_listen_interval == 0) 524 local->hw.max_listen_interval = 1; 525 526 local->hw.conf.listen_interval = local->hw.max_listen_interval; 527 528 result = sta_info_start(local); 529 if (result < 0) 530 goto fail_sta_info; 531 532 result = ieee80211_wep_init(local); 533 if (result < 0) { 534 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n", 535 wiphy_name(local->hw.wiphy), result); 536 goto fail_wep; 537 } 538 539 rtnl_lock(); 540 541 result = ieee80211_init_rate_ctrl_alg(local, 542 hw->rate_control_algorithm); 543 if (result < 0) { 544 printk(KERN_DEBUG "%s: Failed to initialize rate control " 545 "algorithm\n", wiphy_name(local->hw.wiphy)); 546 goto fail_rate; 547 } 548 549 /* add one default STA interface if supported */ 550 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) { 551 result = ieee80211_if_add(local, "wlan%d", NULL, 552 NL80211_IFTYPE_STATION, NULL); 553 if (result) 554 printk(KERN_WARNING "%s: Failed to add default virtual iface\n", 555 wiphy_name(local->hw.wiphy)); 556 } 557 558 rtnl_unlock(); 559 560 ieee80211_led_init(local); 561 562 /* alloc internal scan request */ 563 i = 0; 564 local->int_scan_req->ssids = &local->scan_ssid; 565 local->int_scan_req->n_ssids = 1; 566 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 567 if (!hw->wiphy->bands[band]) 568 continue; 569 for (j = 0; j < hw->wiphy->bands[band]->n_channels; j++) { 570 local->int_scan_req->channels[i] = 571 &hw->wiphy->bands[band]->channels[j]; 572 i++; 573 } 574 } 575 local->int_scan_req->n_channels = i; 576 577 local->network_latency_notifier.notifier_call = 578 ieee80211_max_network_latency; 579 result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY, 580 &local->network_latency_notifier); 581 582 if (result) { 583 rtnl_lock(); 584 goto fail_pm_qos; 585 } 586 587 return 0; 588 589 fail_pm_qos: 590 ieee80211_led_exit(local); 591 ieee80211_remove_interfaces(local); 592 fail_rate: 593 rtnl_unlock(); 594 ieee80211_wep_free(local); 595 fail_wep: 596 sta_info_stop(local); 597 fail_sta_info: 598 destroy_workqueue(local->workqueue); 599 fail_workqueue: 600 wiphy_unregister(local->hw.wiphy); 601 fail_wiphy_register: 602 kfree(local->int_scan_req); 603 return result; 604 } 605 EXPORT_SYMBOL(ieee80211_register_hw); 606 607 void ieee80211_unregister_hw(struct ieee80211_hw *hw) 608 { 609 struct ieee80211_local *local = hw_to_local(hw); 610 611 tasklet_kill(&local->tx_pending_tasklet); 612 tasklet_kill(&local->tasklet); 613 614 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 615 &local->network_latency_notifier); 616 617 rtnl_lock(); 618 619 /* 620 * At this point, interface list manipulations are fine 621 * because the driver cannot be handing us frames any 622 * more and the tasklet is killed. 623 */ 624 ieee80211_remove_interfaces(local); 625 626 rtnl_unlock(); 627 628 cancel_work_sync(&local->reconfig_filter); 629 630 ieee80211_clear_tx_pending(local); 631 sta_info_stop(local); 632 rate_control_deinitialize(local); 633 634 if (skb_queue_len(&local->skb_queue) || 635 skb_queue_len(&local->skb_queue_unreliable)) 636 printk(KERN_WARNING "%s: skb_queue not empty\n", 637 wiphy_name(local->hw.wiphy)); 638 skb_queue_purge(&local->skb_queue); 639 skb_queue_purge(&local->skb_queue_unreliable); 640 641 destroy_workqueue(local->workqueue); 642 wiphy_unregister(local->hw.wiphy); 643 ieee80211_wep_free(local); 644 ieee80211_led_exit(local); 645 kfree(local->int_scan_req); 646 } 647 EXPORT_SYMBOL(ieee80211_unregister_hw); 648 649 void ieee80211_free_hw(struct ieee80211_hw *hw) 650 { 651 struct ieee80211_local *local = hw_to_local(hw); 652 653 mutex_destroy(&local->iflist_mtx); 654 mutex_destroy(&local->scan_mtx); 655 656 wiphy_free(local->hw.wiphy); 657 } 658 EXPORT_SYMBOL(ieee80211_free_hw); 659 660 static int __init ieee80211_init(void) 661 { 662 struct sk_buff *skb; 663 int ret; 664 665 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 666 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 667 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 668 669 ret = rc80211_minstrel_init(); 670 if (ret) 671 return ret; 672 673 ret = rc80211_pid_init(); 674 if (ret) 675 return ret; 676 677 ieee80211_debugfs_netdev_init(); 678 679 return 0; 680 } 681 682 static void __exit ieee80211_exit(void) 683 { 684 rc80211_pid_exit(); 685 rc80211_minstrel_exit(); 686 687 /* 688 * For key todo, it'll be empty by now but the work 689 * might still be scheduled. 690 */ 691 flush_scheduled_work(); 692 693 if (mesh_allocated) 694 ieee80211s_stop(); 695 696 ieee80211_debugfs_netdev_exit(); 697 } 698 699 700 subsys_initcall(ieee80211_init); 701 module_exit(ieee80211_exit); 702 703 MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 704 MODULE_LICENSE("GPL"); 705