main.c revision d24deb2580823ab0b8425790c6f5d18e2ff749d8
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 37void 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 83static 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 91int 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 154void 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 230u32 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 240static 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 280static 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 290void 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} 300EXPORT_SYMBOL(ieee80211_restart_hw); 301 302struct 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} 401EXPORT_SYMBOL(ieee80211_alloc_hw); 402 403int 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 BUILD_BUG_ON(IEEE80211_TX_STATUS_HEADROOM != 519 sizeof(struct ieee80211_tx_status_rtap_hdr)); 520 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 521 sizeof(struct ieee80211_tx_status_rtap_hdr)); 522 523 debugfs_hw_add(local); 524 525 if (local->hw.max_listen_interval == 0) 526 local->hw.max_listen_interval = 1; 527 528 local->hw.conf.listen_interval = local->hw.max_listen_interval; 529 530 result = sta_info_start(local); 531 if (result < 0) 532 goto fail_sta_info; 533 534 result = ieee80211_wep_init(local); 535 if (result < 0) { 536 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n", 537 wiphy_name(local->hw.wiphy), result); 538 goto fail_wep; 539 } 540 541 rtnl_lock(); 542 543 result = ieee80211_init_rate_ctrl_alg(local, 544 hw->rate_control_algorithm); 545 if (result < 0) { 546 printk(KERN_DEBUG "%s: Failed to initialize rate control " 547 "algorithm\n", wiphy_name(local->hw.wiphy)); 548 goto fail_rate; 549 } 550 551 /* add one default STA interface if supported */ 552 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) { 553 result = ieee80211_if_add(local, "wlan%d", NULL, 554 NL80211_IFTYPE_STATION, NULL); 555 if (result) 556 printk(KERN_WARNING "%s: Failed to add default virtual iface\n", 557 wiphy_name(local->hw.wiphy)); 558 } 559 560 rtnl_unlock(); 561 562 ieee80211_led_init(local); 563 564 /* alloc internal scan request */ 565 i = 0; 566 local->int_scan_req->ssids = &local->scan_ssid; 567 local->int_scan_req->n_ssids = 1; 568 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 569 if (!hw->wiphy->bands[band]) 570 continue; 571 for (j = 0; j < hw->wiphy->bands[band]->n_channels; j++) { 572 local->int_scan_req->channels[i] = 573 &hw->wiphy->bands[band]->channels[j]; 574 i++; 575 } 576 } 577 local->int_scan_req->n_channels = i; 578 579 local->network_latency_notifier.notifier_call = 580 ieee80211_max_network_latency; 581 result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY, 582 &local->network_latency_notifier); 583 584 if (result) { 585 rtnl_lock(); 586 goto fail_pm_qos; 587 } 588 589 return 0; 590 591 fail_pm_qos: 592 ieee80211_led_exit(local); 593 ieee80211_remove_interfaces(local); 594 fail_rate: 595 rtnl_unlock(); 596 ieee80211_wep_free(local); 597 fail_wep: 598 sta_info_stop(local); 599 fail_sta_info: 600 destroy_workqueue(local->workqueue); 601 fail_workqueue: 602 wiphy_unregister(local->hw.wiphy); 603 fail_wiphy_register: 604 kfree(local->int_scan_req); 605 return result; 606} 607EXPORT_SYMBOL(ieee80211_register_hw); 608 609void ieee80211_unregister_hw(struct ieee80211_hw *hw) 610{ 611 struct ieee80211_local *local = hw_to_local(hw); 612 613 tasklet_kill(&local->tx_pending_tasklet); 614 tasklet_kill(&local->tasklet); 615 616 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 617 &local->network_latency_notifier); 618 619 rtnl_lock(); 620 621 /* 622 * At this point, interface list manipulations are fine 623 * because the driver cannot be handing us frames any 624 * more and the tasklet is killed. 625 */ 626 ieee80211_remove_interfaces(local); 627 628 rtnl_unlock(); 629 630 cancel_work_sync(&local->reconfig_filter); 631 632 ieee80211_clear_tx_pending(local); 633 sta_info_stop(local); 634 rate_control_deinitialize(local); 635 636 if (skb_queue_len(&local->skb_queue) || 637 skb_queue_len(&local->skb_queue_unreliable)) 638 printk(KERN_WARNING "%s: skb_queue not empty\n", 639 wiphy_name(local->hw.wiphy)); 640 skb_queue_purge(&local->skb_queue); 641 skb_queue_purge(&local->skb_queue_unreliable); 642 643 destroy_workqueue(local->workqueue); 644 wiphy_unregister(local->hw.wiphy); 645 ieee80211_wep_free(local); 646 ieee80211_led_exit(local); 647 kfree(local->int_scan_req); 648} 649EXPORT_SYMBOL(ieee80211_unregister_hw); 650 651void ieee80211_free_hw(struct ieee80211_hw *hw) 652{ 653 struct ieee80211_local *local = hw_to_local(hw); 654 655 mutex_destroy(&local->iflist_mtx); 656 mutex_destroy(&local->scan_mtx); 657 658 wiphy_free(local->hw.wiphy); 659} 660EXPORT_SYMBOL(ieee80211_free_hw); 661 662static int __init ieee80211_init(void) 663{ 664 struct sk_buff *skb; 665 int ret; 666 667 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 668 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 669 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 670 671 ret = rc80211_minstrel_init(); 672 if (ret) 673 return ret; 674 675 ret = rc80211_pid_init(); 676 if (ret) 677 return ret; 678 679 ieee80211_debugfs_netdev_init(); 680 681 return 0; 682} 683 684static void __exit ieee80211_exit(void) 685{ 686 rc80211_pid_exit(); 687 rc80211_minstrel_exit(); 688 689 /* 690 * For key todo, it'll be empty by now but the work 691 * might still be scheduled. 692 */ 693 flush_scheduled_work(); 694 695 if (mesh_allocated) 696 ieee80211s_stop(); 697 698 ieee80211_debugfs_netdev_exit(); 699} 700 701 702subsys_initcall(ieee80211_init); 703module_exit(ieee80211_exit); 704 705MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 706MODULE_LICENSE("GPL"); 707