2 * This is the linux wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/module.h>
11 #include <linux/err.h>
12 #include <linux/list.h>
13 #include <linux/slab.h>
14 #include <linux/nl80211.h>
15 #include <linux/debugfs.h>
16 #include <linux/notifier.h>
17 #include <linux/device.h>
18 #include <linux/etherdevice.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/sched.h>
21 #include <net/genetlink.h>
22 #include <net/cfg80211.h>
27 #include "wext-compat.h"
30 /* name for sysfs, %d is appended */
31 #define PHY_NAME "phy"
33 MODULE_AUTHOR("Johannes Berg");
34 MODULE_LICENSE("GPL");
35 MODULE_DESCRIPTION("wireless configuration support");
37 /* RCU-protected (and cfg80211_mutex for writers) */
38 LIST_HEAD(cfg80211_rdev_list);
39 int cfg80211_rdev_list_generation;
41 DEFINE_MUTEX(cfg80211_mutex);
44 static struct dentry *ieee80211_debugfs_dir;
46 /* for the cleanup, scan and event works */
47 struct workqueue_struct *cfg80211_wq;
49 static bool cfg80211_disable_40mhz_24ghz;
50 module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
51 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
52 "Disable 40MHz support in the 2.4GHz band");
54 /* requires cfg80211_mutex to be held! */
55 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
57 struct cfg80211_registered_device *result = NULL, *rdev;
59 if (!wiphy_idx_valid(wiphy_idx))
62 assert_cfg80211_lock();
64 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
65 if (rdev->wiphy_idx == wiphy_idx) {
74 int get_wiphy_idx(struct wiphy *wiphy)
76 struct cfg80211_registered_device *rdev;
78 return WIPHY_IDX_STALE;
79 rdev = wiphy_to_dev(wiphy);
80 return rdev->wiphy_idx;
83 /* requires cfg80211_rdev_mutex to be held! */
84 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
86 struct cfg80211_registered_device *rdev;
88 if (!wiphy_idx_valid(wiphy_idx))
91 assert_cfg80211_lock();
93 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
99 /* requires cfg80211_mutex to be held! */
100 struct cfg80211_registered_device *
101 __cfg80211_rdev_from_info(struct genl_info *info)
104 struct cfg80211_registered_device *bywiphyidx = NULL, *byifidx = NULL;
105 struct net_device *dev;
108 assert_cfg80211_lock();
110 if (info->attrs[NL80211_ATTR_WIPHY]) {
111 bywiphyidx = cfg80211_rdev_by_wiphy_idx(
112 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
116 if (info->attrs[NL80211_ATTR_IFINDEX]) {
117 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
118 dev = dev_get_by_index(genl_info_net(info), ifindex);
120 if (dev->ieee80211_ptr)
122 wiphy_to_dev(dev->ieee80211_ptr->wiphy);
128 if (bywiphyidx && byifidx) {
129 if (bywiphyidx != byifidx)
130 return ERR_PTR(-EINVAL);
132 return bywiphyidx; /* == byifidx */
143 struct cfg80211_registered_device *
144 cfg80211_get_dev_from_info(struct genl_info *info)
146 struct cfg80211_registered_device *rdev;
148 mutex_lock(&cfg80211_mutex);
149 rdev = __cfg80211_rdev_from_info(info);
151 /* if it is not an error we grab the lock on
152 * it to assure it won't be going away while
153 * we operate on it */
155 mutex_lock(&rdev->mtx);
157 mutex_unlock(&cfg80211_mutex);
162 struct cfg80211_registered_device *
163 cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
165 struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
166 struct net_device *dev;
168 mutex_lock(&cfg80211_mutex);
169 dev = dev_get_by_index(net, ifindex);
172 if (dev->ieee80211_ptr) {
173 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
174 mutex_lock(&rdev->mtx);
176 rdev = ERR_PTR(-ENODEV);
179 mutex_unlock(&cfg80211_mutex);
183 /* requires cfg80211_mutex to be held */
184 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
187 struct cfg80211_registered_device *rdev2;
188 int wiphy_idx, taken = -1, result, digits;
190 assert_cfg80211_lock();
192 /* prohibit calling the thing phy%d when %d is not its number */
193 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
194 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
195 /* count number of places needed to print wiphy_idx */
197 while (wiphy_idx /= 10)
200 * deny the name if it is phy<idx> where <idx> is printed
201 * without leading zeroes. taken == strlen(newname) here
203 if (taken == strlen(PHY_NAME) + digits)
208 /* Ignore nop renames */
209 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
212 /* Ensure another device does not already have this name. */
213 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
214 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
217 result = device_rename(&rdev->wiphy.dev, newname);
221 if (rdev->wiphy.debugfsdir &&
222 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
223 rdev->wiphy.debugfsdir,
224 rdev->wiphy.debugfsdir->d_parent,
226 pr_err("failed to rename debugfs dir to %s!\n", newname);
228 nl80211_notify_dev_rename(rdev);
233 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
236 struct wireless_dev *wdev;
239 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
242 list_for_each_entry(wdev, &rdev->netdev_list, list) {
243 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
244 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
247 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
251 /* failed -- clean up to old netns */
252 net = wiphy_net(&rdev->wiphy);
254 list_for_each_entry_continue_reverse(wdev, &rdev->netdev_list,
256 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
257 err = dev_change_net_namespace(wdev->netdev, net,
260 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
266 wiphy_net_set(&rdev->wiphy, net);
268 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
274 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
276 struct cfg80211_registered_device *rdev = data;
278 rdev->ops->rfkill_poll(&rdev->wiphy);
281 static int cfg80211_rfkill_set_block(void *data, bool blocked)
283 struct cfg80211_registered_device *rdev = data;
284 struct wireless_dev *wdev;
290 mutex_lock(&rdev->devlist_mtx);
292 list_for_each_entry(wdev, &rdev->netdev_list, list)
293 dev_close(wdev->netdev);
295 mutex_unlock(&rdev->devlist_mtx);
301 static void cfg80211_rfkill_sync_work(struct work_struct *work)
303 struct cfg80211_registered_device *rdev;
305 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
306 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
309 static void cfg80211_event_work(struct work_struct *work)
311 struct cfg80211_registered_device *rdev;
313 rdev = container_of(work, struct cfg80211_registered_device,
317 cfg80211_lock_rdev(rdev);
319 cfg80211_process_rdev_events(rdev);
320 cfg80211_unlock_rdev(rdev);
324 /* exported functions */
326 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
328 static int wiphy_counter;
330 struct cfg80211_registered_device *rdev;
333 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
334 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
335 WARN_ON(ops->connect && !ops->disconnect);
336 WARN_ON(ops->join_ibss && !ops->leave_ibss);
337 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
338 WARN_ON(ops->add_station && !ops->del_station);
339 WARN_ON(ops->add_mpath && !ops->del_mpath);
340 WARN_ON(ops->join_mesh && !ops->leave_mesh);
342 alloc_size = sizeof(*rdev) + sizeof_priv;
344 rdev = kzalloc(alloc_size, GFP_KERNEL);
350 mutex_lock(&cfg80211_mutex);
352 rdev->wiphy_idx = wiphy_counter++;
354 if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
356 mutex_unlock(&cfg80211_mutex);
362 mutex_unlock(&cfg80211_mutex);
364 /* give it a proper name */
365 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
367 mutex_init(&rdev->mtx);
368 mutex_init(&rdev->devlist_mtx);
369 INIT_LIST_HEAD(&rdev->netdev_list);
370 spin_lock_init(&rdev->bss_lock);
371 INIT_LIST_HEAD(&rdev->bss_list);
372 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
374 #ifdef CONFIG_CFG80211_WEXT
375 rdev->wiphy.wext = &cfg80211_wext_handler;
378 device_initialize(&rdev->wiphy.dev);
379 rdev->wiphy.dev.class = &ieee80211_class;
380 rdev->wiphy.dev.platform_data = rdev;
382 #ifdef CONFIG_CFG80211_DEFAULT_PS
383 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
386 wiphy_net_set(&rdev->wiphy, &init_net);
388 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
389 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
390 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
391 &rdev->rfkill_ops, rdev);
398 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
399 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
400 INIT_WORK(&rdev->event_work, cfg80211_event_work);
402 init_waitqueue_head(&rdev->dev_wait);
405 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
406 * Fragmentation and RTS threshold are disabled by default with the
409 rdev->wiphy.retry_short = 7;
410 rdev->wiphy.retry_long = 4;
411 rdev->wiphy.frag_threshold = (u32) -1;
412 rdev->wiphy.rts_threshold = (u32) -1;
413 rdev->wiphy.coverage_class = 0;
417 EXPORT_SYMBOL(wiphy_new);
419 int wiphy_register(struct wiphy *wiphy)
421 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
423 enum ieee80211_band band;
424 struct ieee80211_supported_band *sband;
425 bool have_band = false;
427 u16 ifmodes = wiphy->interface_modes;
429 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
432 if (WARN_ON(wiphy->addresses &&
433 !is_zero_ether_addr(wiphy->perm_addr) &&
434 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
438 if (wiphy->addresses)
439 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
441 /* sanity check ifmodes */
443 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
444 if (WARN_ON(ifmodes != wiphy->interface_modes))
445 wiphy->interface_modes = ifmodes;
447 /* sanity check supported bands/channels */
448 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
449 sband = wiphy->bands[band];
455 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
459 * Since cfg80211_disable_40mhz_24ghz is global, we can
460 * modify the sband's ht data even if the driver uses a
461 * global structure for that.
463 if (cfg80211_disable_40mhz_24ghz &&
464 band == IEEE80211_BAND_2GHZ &&
465 sband->ht_cap.ht_supported) {
466 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
467 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
471 * Since we use a u32 for rate bitmaps in
472 * ieee80211_get_response_rate, we cannot
473 * have more than 32 legacy rates.
475 if (WARN_ON(sband->n_bitrates > 32))
478 for (i = 0; i < sband->n_channels; i++) {
479 sband->channels[i].orig_flags =
480 sband->channels[i].flags;
481 sband->channels[i].orig_mag =
482 sband->channels[i].max_antenna_gain;
483 sband->channels[i].orig_mpwr =
484 sband->channels[i].max_power;
485 sband->channels[i].band = band;
496 if (rdev->wiphy.wowlan.n_patterns) {
497 if (WARN_ON(!rdev->wiphy.wowlan.pattern_min_len ||
498 rdev->wiphy.wowlan.pattern_min_len >
499 rdev->wiphy.wowlan.pattern_max_len))
503 /* check and set up bitrates */
504 ieee80211_set_bitrate_flags(wiphy);
506 mutex_lock(&cfg80211_mutex);
508 res = device_add(&rdev->wiphy.dev);
510 mutex_unlock(&cfg80211_mutex);
514 /* set up regulatory info */
515 wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
517 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
518 cfg80211_rdev_list_generation++;
521 rdev->wiphy.debugfsdir =
522 debugfs_create_dir(wiphy_name(&rdev->wiphy),
523 ieee80211_debugfs_dir);
524 if (IS_ERR(rdev->wiphy.debugfsdir))
525 rdev->wiphy.debugfsdir = NULL;
527 if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
528 struct regulatory_request request;
530 request.wiphy_idx = get_wiphy_idx(wiphy);
531 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
532 request.alpha2[0] = '9';
533 request.alpha2[1] = '9';
535 nl80211_send_reg_change_event(&request);
538 cfg80211_debugfs_rdev_add(rdev);
539 mutex_unlock(&cfg80211_mutex);
542 * due to a locking dependency this has to be outside of the
543 * cfg80211_mutex lock
545 res = rfkill_register(rdev->rfkill);
552 device_del(&rdev->wiphy.dev);
555 EXPORT_SYMBOL(wiphy_register);
557 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
559 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
561 if (!rdev->ops->rfkill_poll)
563 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
564 rfkill_resume_polling(rdev->rfkill);
566 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
568 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
570 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
572 rfkill_pause_polling(rdev->rfkill);
574 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
576 void wiphy_unregister(struct wiphy *wiphy)
578 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
580 rfkill_unregister(rdev->rfkill);
582 /* protect the device list */
583 mutex_lock(&cfg80211_mutex);
585 wait_event(rdev->dev_wait, ({
587 mutex_lock(&rdev->devlist_mtx);
588 __count = rdev->opencount;
589 mutex_unlock(&rdev->devlist_mtx);
592 mutex_lock(&rdev->devlist_mtx);
593 BUG_ON(!list_empty(&rdev->netdev_list));
594 mutex_unlock(&rdev->devlist_mtx);
597 * First remove the hardware from everywhere, this makes
598 * it impossible to find from userspace.
600 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
601 list_del_rcu(&rdev->list);
605 * Try to grab rdev->mtx. If a command is still in progress,
606 * hopefully the driver will refuse it since it's tearing
607 * down the device already. We wait for this command to complete
608 * before unlinking the item from the list.
609 * Note: as codified by the BUG_ON above we cannot get here if
610 * a virtual interface is still present. Hence, we can only get
611 * to lock contention here if userspace issues a command that
612 * identified the hardware by wiphy index.
614 cfg80211_lock_rdev(rdev);
616 cfg80211_unlock_rdev(rdev);
618 /* If this device got a regulatory hint tell core its
619 * free to listen now to a new shiny device regulatory hint */
620 reg_device_remove(wiphy);
622 cfg80211_rdev_list_generation++;
623 device_del(&rdev->wiphy.dev);
625 mutex_unlock(&cfg80211_mutex);
627 flush_work(&rdev->scan_done_wk);
628 cancel_work_sync(&rdev->conn_work);
629 flush_work(&rdev->event_work);
631 EXPORT_SYMBOL(wiphy_unregister);
633 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
635 struct cfg80211_internal_bss *scan, *tmp;
636 rfkill_destroy(rdev->rfkill);
637 mutex_destroy(&rdev->mtx);
638 mutex_destroy(&rdev->devlist_mtx);
639 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
640 cfg80211_put_bss(&scan->pub);
641 cfg80211_rdev_free_wowlan(rdev);
645 void wiphy_free(struct wiphy *wiphy)
647 put_device(&wiphy->dev);
649 EXPORT_SYMBOL(wiphy_free);
651 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
653 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
655 if (rfkill_set_hw_state(rdev->rfkill, blocked))
656 schedule_work(&rdev->rfkill_sync);
658 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
660 static void wdev_cleanup_work(struct work_struct *work)
662 struct wireless_dev *wdev;
663 struct cfg80211_registered_device *rdev;
665 wdev = container_of(work, struct wireless_dev, cleanup_work);
666 rdev = wiphy_to_dev(wdev->wiphy);
668 cfg80211_lock_rdev(rdev);
670 if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) {
671 rdev->scan_req->aborted = true;
672 ___cfg80211_scan_done(rdev, true);
675 cfg80211_unlock_rdev(rdev);
677 mutex_lock(&rdev->devlist_mtx);
679 mutex_unlock(&rdev->devlist_mtx);
680 wake_up(&rdev->dev_wait);
682 dev_put(wdev->netdev);
685 static struct device_type wiphy_type = {
689 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
693 struct net_device *dev = ndev;
694 struct wireless_dev *wdev = dev->ieee80211_ptr;
695 struct cfg80211_registered_device *rdev;
700 rdev = wiphy_to_dev(wdev->wiphy);
702 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
705 case NETDEV_POST_INIT:
706 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
708 case NETDEV_REGISTER:
710 * NB: cannot take rdev->mtx here because this may be
711 * called within code protected by it when interfaces
712 * are added with nl80211.
714 mutex_init(&wdev->mtx);
715 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
716 INIT_LIST_HEAD(&wdev->event_list);
717 spin_lock_init(&wdev->event_lock);
718 INIT_LIST_HEAD(&wdev->mgmt_registrations);
719 spin_lock_init(&wdev->mgmt_registrations_lock);
721 mutex_lock(&rdev->devlist_mtx);
722 list_add_rcu(&wdev->list, &rdev->netdev_list);
723 rdev->devlist_generation++;
724 /* can only change netns with wiphy */
725 dev->features |= NETIF_F_NETNS_LOCAL;
727 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
729 pr_err("failed to add phy80211 symlink to netdev!\n");
732 wdev->sme_state = CFG80211_SME_IDLE;
733 mutex_unlock(&rdev->devlist_mtx);
734 #ifdef CONFIG_CFG80211_WEXT
735 wdev->wext.default_key = -1;
736 wdev->wext.default_mgmt_key = -1;
737 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
740 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
744 /* allow mac80211 to determine the timeout */
745 wdev->ps_timeout = -1;
747 if (!dev->ethtool_ops)
748 dev->ethtool_ops = &cfg80211_ethtool_ops;
750 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
751 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
752 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
753 dev->priv_flags |= IFF_DONT_BRIDGE;
755 case NETDEV_GOING_DOWN:
756 switch (wdev->iftype) {
757 case NL80211_IFTYPE_ADHOC:
758 cfg80211_leave_ibss(rdev, dev, true);
760 case NL80211_IFTYPE_P2P_CLIENT:
761 case NL80211_IFTYPE_STATION:
763 #ifdef CONFIG_CFG80211_WEXT
764 kfree(wdev->wext.ie);
765 wdev->wext.ie = NULL;
766 wdev->wext.ie_len = 0;
767 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
769 __cfg80211_disconnect(rdev, dev,
770 WLAN_REASON_DEAUTH_LEAVING, true);
771 cfg80211_mlme_down(rdev, dev);
774 case NL80211_IFTYPE_MESH_POINT:
775 cfg80211_leave_mesh(rdev, dev);
783 queue_work(cfg80211_wq, &wdev->cleanup_work);
787 * If we have a really quick DOWN/UP succession we may
788 * have this work still pending ... cancel it and see
789 * if it was pending, in which case we need to account
790 * for some of the work it would have done.
792 if (cancel_work_sync(&wdev->cleanup_work)) {
793 mutex_lock(&rdev->devlist_mtx);
795 mutex_unlock(&rdev->devlist_mtx);
798 cfg80211_lock_rdev(rdev);
799 mutex_lock(&rdev->devlist_mtx);
801 switch (wdev->iftype) {
802 #ifdef CONFIG_CFG80211_WEXT
803 case NL80211_IFTYPE_ADHOC:
804 cfg80211_ibss_wext_join(rdev, wdev);
806 case NL80211_IFTYPE_STATION:
807 cfg80211_mgd_wext_connect(rdev, wdev);
810 #ifdef CONFIG_MAC80211_MESH
811 case NL80211_IFTYPE_MESH_POINT:
813 /* backward compat code... */
814 struct mesh_setup setup;
815 memcpy(&setup, &default_mesh_setup,
817 /* back compat only needed for mesh_id */
818 setup.mesh_id = wdev->ssid;
819 setup.mesh_id_len = wdev->mesh_id_up_len;
820 if (wdev->mesh_id_up_len)
821 __cfg80211_join_mesh(rdev, dev,
823 &default_mesh_config);
832 mutex_unlock(&rdev->devlist_mtx);
833 cfg80211_unlock_rdev(rdev);
836 * Configure power management to the driver here so that its
837 * correctly set also after interface type changes etc.
839 if (wdev->iftype == NL80211_IFTYPE_STATION &&
840 rdev->ops->set_power_mgmt)
841 if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
844 /* assume this means it's off */
848 case NETDEV_UNREGISTER:
850 * NB: cannot take rdev->mtx here because this may be
851 * called within code protected by it when interfaces
852 * are removed with nl80211.
854 mutex_lock(&rdev->devlist_mtx);
856 * It is possible to get NETDEV_UNREGISTER
857 * multiple times. To detect that, check
858 * that the interface is still on the list
859 * of registered interfaces, and only then
860 * remove and clean it up.
862 if (!list_empty(&wdev->list)) {
863 sysfs_remove_link(&dev->dev.kobj, "phy80211");
864 list_del_rcu(&wdev->list);
865 rdev->devlist_generation++;
866 cfg80211_mlme_purge_registrations(wdev);
867 #ifdef CONFIG_CFG80211_WEXT
868 kfree(wdev->wext.keys);
871 mutex_unlock(&rdev->devlist_mtx);
873 * synchronise (so that we won't find this netdev
874 * from other code any more) and then clear the list
875 * head so that the above code can safely check for
876 * !list_empty() to avoid double-cleanup.
879 INIT_LIST_HEAD(&wdev->list);
882 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
883 return notifier_from_errno(-EOPNOTSUPP);
884 if (rfkill_blocked(rdev->rfkill))
885 return notifier_from_errno(-ERFKILL);
892 static struct notifier_block cfg80211_netdev_notifier = {
893 .notifier_call = cfg80211_netdev_notifier_call,
896 static void __net_exit cfg80211_pernet_exit(struct net *net)
898 struct cfg80211_registered_device *rdev;
901 mutex_lock(&cfg80211_mutex);
902 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
903 if (net_eq(wiphy_net(&rdev->wiphy), net))
904 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
906 mutex_unlock(&cfg80211_mutex);
910 static struct pernet_operations cfg80211_pernet_ops = {
911 .exit = cfg80211_pernet_exit,
914 static int __init cfg80211_init(void)
918 err = register_pernet_device(&cfg80211_pernet_ops);
920 goto out_fail_pernet;
922 err = wiphy_sysfs_init();
926 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
928 goto out_fail_notifier;
930 err = nl80211_init();
932 goto out_fail_nl80211;
934 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
936 err = regulatory_init();
940 cfg80211_wq = create_singlethread_workqueue("cfg80211");
949 debugfs_remove(ieee80211_debugfs_dir);
951 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
955 unregister_pernet_device(&cfg80211_pernet_ops);
959 subsys_initcall(cfg80211_init);
961 static void __exit cfg80211_exit(void)
963 debugfs_remove(ieee80211_debugfs_dir);
965 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
968 unregister_pernet_device(&cfg80211_pernet_ops);
969 destroy_workqueue(cfg80211_wq);
971 module_exit(cfg80211_exit);