2 * This is the linux wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.h>
10 #include <linux/list.h>
11 #include <linux/nl80211.h>
12 #include <linux/debugfs.h>
13 #include <linux/notifier.h>
14 #include <linux/device.h>
15 #include <linux/etherdevice.h>
16 #include <linux/rtnetlink.h>
17 #include <linux/sched.h>
18 #include <net/genetlink.h>
19 #include <net/cfg80211.h>
24 #include "wext-compat.h"
27 /* name for sysfs, %d is appended */
28 #define PHY_NAME "phy"
30 MODULE_AUTHOR("Johannes Berg");
31 MODULE_LICENSE("GPL");
32 MODULE_DESCRIPTION("wireless configuration support");
34 /* RCU-protected (and cfg80211_mutex for writers) */
35 LIST_HEAD(cfg80211_rdev_list);
36 int cfg80211_rdev_list_generation;
38 DEFINE_MUTEX(cfg80211_mutex);
41 static struct dentry *ieee80211_debugfs_dir;
43 /* for the cleanup, scan and event works */
44 struct workqueue_struct *cfg80211_wq;
46 /* requires cfg80211_mutex to be held! */
47 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
49 struct cfg80211_registered_device *result = NULL, *rdev;
51 if (!wiphy_idx_valid(wiphy_idx))
54 assert_cfg80211_lock();
56 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
57 if (rdev->wiphy_idx == wiphy_idx) {
66 int get_wiphy_idx(struct wiphy *wiphy)
68 struct cfg80211_registered_device *rdev;
70 return WIPHY_IDX_STALE;
71 rdev = wiphy_to_dev(wiphy);
72 return rdev->wiphy_idx;
75 /* requires cfg80211_rdev_mutex to be held! */
76 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
78 struct cfg80211_registered_device *rdev;
80 if (!wiphy_idx_valid(wiphy_idx))
83 assert_cfg80211_lock();
85 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
91 /* requires cfg80211_mutex to be held! */
92 struct cfg80211_registered_device *
93 __cfg80211_rdev_from_info(struct genl_info *info)
96 struct cfg80211_registered_device *bywiphyidx = NULL, *byifidx = NULL;
97 struct net_device *dev;
100 assert_cfg80211_lock();
102 if (info->attrs[NL80211_ATTR_WIPHY]) {
103 bywiphyidx = cfg80211_rdev_by_wiphy_idx(
104 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
108 if (info->attrs[NL80211_ATTR_IFINDEX]) {
109 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
110 dev = dev_get_by_index(genl_info_net(info), ifindex);
112 if (dev->ieee80211_ptr)
114 wiphy_to_dev(dev->ieee80211_ptr->wiphy);
120 if (bywiphyidx && byifidx) {
121 if (bywiphyidx != byifidx)
122 return ERR_PTR(-EINVAL);
124 return bywiphyidx; /* == byifidx */
135 struct cfg80211_registered_device *
136 cfg80211_get_dev_from_info(struct genl_info *info)
138 struct cfg80211_registered_device *rdev;
140 mutex_lock(&cfg80211_mutex);
141 rdev = __cfg80211_rdev_from_info(info);
143 /* if it is not an error we grab the lock on
144 * it to assure it won't be going away while
145 * we operate on it */
147 mutex_lock(&rdev->mtx);
149 mutex_unlock(&cfg80211_mutex);
154 struct cfg80211_registered_device *
155 cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
157 struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
158 struct net_device *dev;
160 mutex_lock(&cfg80211_mutex);
161 dev = dev_get_by_index(net, ifindex);
164 if (dev->ieee80211_ptr) {
165 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
166 mutex_lock(&rdev->mtx);
168 rdev = ERR_PTR(-ENODEV);
171 mutex_unlock(&cfg80211_mutex);
175 /* requires cfg80211_mutex to be held */
176 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
179 struct cfg80211_registered_device *rdev2;
180 int wiphy_idx, taken = -1, result, digits;
182 assert_cfg80211_lock();
184 /* prohibit calling the thing phy%d when %d is not its number */
185 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
186 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
187 /* count number of places needed to print wiphy_idx */
189 while (wiphy_idx /= 10)
192 * deny the name if it is phy<idx> where <idx> is printed
193 * without leading zeroes. taken == strlen(newname) here
195 if (taken == strlen(PHY_NAME) + digits)
200 /* Ignore nop renames */
201 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
204 /* Ensure another device does not already have this name. */
205 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
206 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
209 result = device_rename(&rdev->wiphy.dev, newname);
213 if (rdev->wiphy.debugfsdir &&
214 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
215 rdev->wiphy.debugfsdir,
216 rdev->wiphy.debugfsdir->d_parent,
218 printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n",
221 nl80211_notify_dev_rename(rdev);
226 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
227 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
230 struct wireless_dev *wdev;
233 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
236 list_for_each_entry(wdev, &rdev->netdev_list, list) {
237 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
238 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
241 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
245 /* failed -- clean up to old netns */
246 net = wiphy_net(&rdev->wiphy);
248 list_for_each_entry_continue_reverse(wdev, &rdev->netdev_list,
250 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
251 err = dev_change_net_namespace(wdev->netdev, net,
254 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
258 wiphy_net_set(&rdev->wiphy, net);
264 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
266 struct cfg80211_registered_device *rdev = data;
268 rdev->ops->rfkill_poll(&rdev->wiphy);
271 static int cfg80211_rfkill_set_block(void *data, bool blocked)
273 struct cfg80211_registered_device *rdev = data;
274 struct wireless_dev *wdev;
280 mutex_lock(&rdev->devlist_mtx);
282 list_for_each_entry(wdev, &rdev->netdev_list, list)
283 dev_close(wdev->netdev);
285 mutex_unlock(&rdev->devlist_mtx);
291 static void cfg80211_rfkill_sync_work(struct work_struct *work)
293 struct cfg80211_registered_device *rdev;
295 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
296 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
299 static void cfg80211_event_work(struct work_struct *work)
301 struct cfg80211_registered_device *rdev;
303 rdev = container_of(work, struct cfg80211_registered_device,
307 cfg80211_lock_rdev(rdev);
309 cfg80211_process_rdev_events(rdev);
310 cfg80211_unlock_rdev(rdev);
314 /* exported functions */
316 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
318 static int wiphy_counter;
320 struct cfg80211_registered_device *rdev;
323 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
324 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
325 WARN_ON(ops->connect && !ops->disconnect);
326 WARN_ON(ops->join_ibss && !ops->leave_ibss);
327 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
328 WARN_ON(ops->add_station && !ops->del_station);
329 WARN_ON(ops->add_mpath && !ops->del_mpath);
331 alloc_size = sizeof(*rdev) + sizeof_priv;
333 rdev = kzalloc(alloc_size, GFP_KERNEL);
339 mutex_lock(&cfg80211_mutex);
341 rdev->wiphy_idx = wiphy_counter++;
343 if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
345 mutex_unlock(&cfg80211_mutex);
351 mutex_unlock(&cfg80211_mutex);
353 /* give it a proper name */
354 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
356 mutex_init(&rdev->mtx);
357 mutex_init(&rdev->devlist_mtx);
358 INIT_LIST_HEAD(&rdev->netdev_list);
359 spin_lock_init(&rdev->bss_lock);
360 INIT_LIST_HEAD(&rdev->bss_list);
361 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
363 #ifdef CONFIG_CFG80211_WEXT
364 rdev->wiphy.wext = &cfg80211_wext_handler;
367 device_initialize(&rdev->wiphy.dev);
368 rdev->wiphy.dev.class = &ieee80211_class;
369 rdev->wiphy.dev.platform_data = rdev;
371 #ifdef CONFIG_CFG80211_DEFAULT_PS
372 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
375 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
376 wiphy_net_set(&rdev->wiphy, &init_net);
379 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
380 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
381 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
382 &rdev->rfkill_ops, rdev);
389 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
390 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
391 INIT_WORK(&rdev->event_work, cfg80211_event_work);
393 init_waitqueue_head(&rdev->dev_wait);
396 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
397 * Fragmentation and RTS threshold are disabled by default with the
400 rdev->wiphy.retry_short = 7;
401 rdev->wiphy.retry_long = 4;
402 rdev->wiphy.frag_threshold = (u32) -1;
403 rdev->wiphy.rts_threshold = (u32) -1;
404 rdev->wiphy.coverage_class = 0;
408 EXPORT_SYMBOL(wiphy_new);
410 int wiphy_register(struct wiphy *wiphy)
412 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
414 enum ieee80211_band band;
415 struct ieee80211_supported_band *sband;
416 bool have_band = false;
418 u16 ifmodes = wiphy->interface_modes;
420 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
423 if (WARN_ON(wiphy->addresses &&
424 !is_zero_ether_addr(wiphy->perm_addr) &&
425 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
429 if (wiphy->addresses)
430 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
432 /* sanity check ifmodes */
434 ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
435 if (WARN_ON(ifmodes != wiphy->interface_modes))
436 wiphy->interface_modes = ifmodes;
438 /* sanity check supported bands/channels */
439 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
440 sband = wiphy->bands[band];
446 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
450 * Since we use a u32 for rate bitmaps in
451 * ieee80211_get_response_rate, we cannot
452 * have more than 32 legacy rates.
454 if (WARN_ON(sband->n_bitrates > 32))
457 for (i = 0; i < sband->n_channels; i++) {
458 sband->channels[i].orig_flags =
459 sband->channels[i].flags;
460 sband->channels[i].orig_mag =
461 sband->channels[i].max_antenna_gain;
462 sband->channels[i].orig_mpwr =
463 sband->channels[i].max_power;
464 sband->channels[i].band = band;
475 /* check and set up bitrates */
476 ieee80211_set_bitrate_flags(wiphy);
478 res = device_add(&rdev->wiphy.dev);
482 res = rfkill_register(rdev->rfkill);
486 mutex_lock(&cfg80211_mutex);
488 /* set up regulatory info */
489 wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
491 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
492 cfg80211_rdev_list_generation++;
494 mutex_unlock(&cfg80211_mutex);
497 rdev->wiphy.debugfsdir =
498 debugfs_create_dir(wiphy_name(&rdev->wiphy),
499 ieee80211_debugfs_dir);
500 if (IS_ERR(rdev->wiphy.debugfsdir))
501 rdev->wiphy.debugfsdir = NULL;
503 if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
504 struct regulatory_request request;
506 request.wiphy_idx = get_wiphy_idx(wiphy);
507 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
508 request.alpha2[0] = '9';
509 request.alpha2[1] = '9';
511 nl80211_send_reg_change_event(&request);
514 cfg80211_debugfs_rdev_add(rdev);
519 device_del(&rdev->wiphy.dev);
522 EXPORT_SYMBOL(wiphy_register);
524 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
526 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
528 if (!rdev->ops->rfkill_poll)
530 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
531 rfkill_resume_polling(rdev->rfkill);
533 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
535 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
537 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
539 rfkill_pause_polling(rdev->rfkill);
541 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
543 void wiphy_unregister(struct wiphy *wiphy)
545 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
547 rfkill_unregister(rdev->rfkill);
549 /* protect the device list */
550 mutex_lock(&cfg80211_mutex);
552 wait_event(rdev->dev_wait, ({
554 mutex_lock(&rdev->devlist_mtx);
555 __count = rdev->opencount;
556 mutex_unlock(&rdev->devlist_mtx);
559 mutex_lock(&rdev->devlist_mtx);
560 BUG_ON(!list_empty(&rdev->netdev_list));
561 mutex_unlock(&rdev->devlist_mtx);
564 * First remove the hardware from everywhere, this makes
565 * it impossible to find from userspace.
567 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
568 list_del_rcu(&rdev->list);
572 * Try to grab rdev->mtx. If a command is still in progress,
573 * hopefully the driver will refuse it since it's tearing
574 * down the device already. We wait for this command to complete
575 * before unlinking the item from the list.
576 * Note: as codified by the BUG_ON above we cannot get here if
577 * a virtual interface is still present. Hence, we can only get
578 * to lock contention here if userspace issues a command that
579 * identified the hardware by wiphy index.
581 cfg80211_lock_rdev(rdev);
583 cfg80211_unlock_rdev(rdev);
585 /* If this device got a regulatory hint tell core its
586 * free to listen now to a new shiny device regulatory hint */
587 reg_device_remove(wiphy);
589 cfg80211_rdev_list_generation++;
590 device_del(&rdev->wiphy.dev);
592 mutex_unlock(&cfg80211_mutex);
594 flush_work(&rdev->scan_done_wk);
595 cancel_work_sync(&rdev->conn_work);
596 flush_work(&rdev->event_work);
598 EXPORT_SYMBOL(wiphy_unregister);
600 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
602 struct cfg80211_internal_bss *scan, *tmp;
603 rfkill_destroy(rdev->rfkill);
604 mutex_destroy(&rdev->mtx);
605 mutex_destroy(&rdev->devlist_mtx);
606 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
607 cfg80211_put_bss(&scan->pub);
611 void wiphy_free(struct wiphy *wiphy)
613 put_device(&wiphy->dev);
615 EXPORT_SYMBOL(wiphy_free);
617 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
619 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
621 if (rfkill_set_hw_state(rdev->rfkill, blocked))
622 schedule_work(&rdev->rfkill_sync);
624 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
626 static void wdev_cleanup_work(struct work_struct *work)
628 struct wireless_dev *wdev;
629 struct cfg80211_registered_device *rdev;
631 wdev = container_of(work, struct wireless_dev, cleanup_work);
632 rdev = wiphy_to_dev(wdev->wiphy);
634 cfg80211_lock_rdev(rdev);
636 if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) {
637 rdev->scan_req->aborted = true;
638 ___cfg80211_scan_done(rdev, true);
641 cfg80211_unlock_rdev(rdev);
643 mutex_lock(&rdev->devlist_mtx);
645 mutex_unlock(&rdev->devlist_mtx);
646 wake_up(&rdev->dev_wait);
648 dev_put(wdev->netdev);
651 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
652 static struct device_type wiphy_type = {
657 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
661 struct net_device *dev = ndev;
662 struct wireless_dev *wdev = dev->ieee80211_ptr;
663 struct cfg80211_registered_device *rdev;
668 rdev = wiphy_to_dev(wdev->wiphy);
670 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
673 case NETDEV_POST_INIT:
674 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
676 case NETDEV_REGISTER:
678 * NB: cannot take rdev->mtx here because this may be
679 * called within code protected by it when interfaces
680 * are added with nl80211.
682 mutex_init(&wdev->mtx);
683 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
684 INIT_LIST_HEAD(&wdev->event_list);
685 spin_lock_init(&wdev->event_lock);
686 INIT_LIST_HEAD(&wdev->action_registrations);
687 spin_lock_init(&wdev->action_registrations_lock);
689 mutex_lock(&rdev->devlist_mtx);
690 list_add_rcu(&wdev->list, &rdev->netdev_list);
691 rdev->devlist_generation++;
692 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
693 /* can only change netns with wiphy */
694 dev->features |= NETIF_F_NETNS_LOCAL;
697 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
699 printk(KERN_ERR "wireless: failed to add phy80211 "
700 "symlink to netdev!\n");
703 wdev->sme_state = CFG80211_SME_IDLE;
704 mutex_unlock(&rdev->devlist_mtx);
705 #ifdef CONFIG_CFG80211_WEXT
706 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,32))
707 if (!dev->wireless_handlers)
708 dev->wireless_handlers = &cfg80211_wext_handler;
710 wdev->wext.default_key = -1;
711 wdev->wext.default_mgmt_key = -1;
712 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
715 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
719 wdev->ps_timeout = 100;
720 if (rdev->ops->set_power_mgmt)
721 if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
724 /* assume this means it's off */
728 if (!dev->ethtool_ops)
729 dev->ethtool_ops = &cfg80211_ethtool_ops;
731 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
732 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
733 dev->priv_flags |= IFF_DONT_BRIDGE;
735 case NETDEV_GOING_DOWN:
736 switch (wdev->iftype) {
737 case NL80211_IFTYPE_ADHOC:
738 cfg80211_leave_ibss(rdev, dev, true);
740 case NL80211_IFTYPE_STATION:
742 #ifdef CONFIG_CFG80211_WEXT
743 kfree(wdev->wext.ie);
744 wdev->wext.ie = NULL;
745 wdev->wext.ie_len = 0;
746 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
748 __cfg80211_disconnect(rdev, dev,
749 WLAN_REASON_DEAUTH_LEAVING, true);
750 cfg80211_mlme_down(rdev, dev);
759 queue_work(cfg80211_wq, &wdev->cleanup_work);
763 * If we have a really quick DOWN/UP succession we may
764 * have this work still pending ... cancel it and see
765 * if it was pending, in which case we need to account
766 * for some of the work it would have done.
768 if (cancel_work_sync(&wdev->cleanup_work)) {
769 mutex_lock(&rdev->devlist_mtx);
771 mutex_unlock(&rdev->devlist_mtx);
774 cfg80211_lock_rdev(rdev);
775 mutex_lock(&rdev->devlist_mtx);
776 #ifdef CONFIG_CFG80211_WEXT
778 switch (wdev->iftype) {
779 case NL80211_IFTYPE_ADHOC:
780 cfg80211_ibss_wext_join(rdev, wdev);
782 case NL80211_IFTYPE_STATION:
783 cfg80211_mgd_wext_connect(rdev, wdev);
791 mutex_unlock(&rdev->devlist_mtx);
792 cfg80211_unlock_rdev(rdev);
794 case NETDEV_UNREGISTER:
796 * NB: cannot take rdev->mtx here because this may be
797 * called within code protected by it when interfaces
798 * are removed with nl80211.
800 mutex_lock(&rdev->devlist_mtx);
802 * It is possible to get NETDEV_UNREGISTER
803 * multiple times. To detect that, check
804 * that the interface is still on the list
805 * of registered interfaces, and only then
806 * remove and clean it up.
808 if (!list_empty(&wdev->list)) {
809 sysfs_remove_link(&dev->dev.kobj, "phy80211");
810 list_del_rcu(&wdev->list);
811 rdev->devlist_generation++;
812 cfg80211_mlme_purge_actions(wdev);
813 #ifdef CONFIG_CFG80211_WEXT
814 kfree(wdev->wext.keys);
817 mutex_unlock(&rdev->devlist_mtx);
819 * synchronise (so that we won't find this netdev
820 * from other code any more) and then clear the list
821 * head so that the above code can safely check for
822 * !list_empty() to avoid double-cleanup.
825 INIT_LIST_HEAD(&wdev->list);
828 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
829 return notifier_from_errno(-EOPNOTSUPP);
830 if (rfkill_blocked(rdev->rfkill))
831 return notifier_from_errno(-ERFKILL);
838 static struct notifier_block cfg80211_netdev_notifier = {
839 .notifier_call = cfg80211_netdev_notifier_call,
842 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
843 static void __net_exit cfg80211_pernet_exit(struct net *net)
845 struct cfg80211_registered_device *rdev;
848 mutex_lock(&cfg80211_mutex);
849 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
850 if (net_eq(wiphy_net(&rdev->wiphy), net))
851 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
853 mutex_unlock(&cfg80211_mutex);
857 static struct pernet_operations cfg80211_pernet_ops = {
858 .exit = cfg80211_pernet_exit,
862 static int __init cfg80211_init(void)
866 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
867 err = register_pernet_device(&cfg80211_pernet_ops);
869 goto out_fail_pernet;
872 err = wiphy_sysfs_init();
876 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
878 goto out_fail_notifier;
880 err = nl80211_init();
882 goto out_fail_nl80211;
884 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
886 err = regulatory_init();
890 cfg80211_wq = create_singlethread_workqueue("cfg80211");
899 debugfs_remove(ieee80211_debugfs_dir);
901 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
905 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
906 unregister_pernet_device(&cfg80211_pernet_ops);
911 subsys_initcall(cfg80211_init);
913 static void cfg80211_exit(void)
915 debugfs_remove(ieee80211_debugfs_dir);
917 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
920 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
921 unregister_pernet_device(&cfg80211_pernet_ops);
923 destroy_workqueue(cfg80211_wq);
925 module_exit(cfg80211_exit);