2 * This is the linux wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2013-2014 Intel Mobile Communications GmbH
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <linux/module.h>
12 #include <linux/err.h>
13 #include <linux/list.h>
14 #include <linux/slab.h>
15 #include <linux/nl80211.h>
16 #include <linux/debugfs.h>
17 #include <linux/notifier.h>
18 #include <linux/device.h>
19 #include <linux/etherdevice.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/sched.h>
22 #include <net/genetlink.h>
23 #include <net/cfg80211.h>
24 #include <net/rtnetlink.h>
29 #include "wext-compat.h"
32 /* name for sysfs, %d is appended */
33 #define PHY_NAME "phy"
35 MODULE_AUTHOR("Johannes Berg");
36 MODULE_LICENSE("GPL");
37 MODULE_DESCRIPTION("wireless configuration support");
38 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME
);
40 /* RCU-protected (and RTNL for writers) */
41 LIST_HEAD(cfg80211_rdev_list
);
42 int cfg80211_rdev_list_generation
;
45 static struct dentry
*ieee80211_debugfs_dir
;
47 /* for the cleanup, scan and event works */
48 struct workqueue_struct
*cfg80211_wq
;
50 static bool cfg80211_disable_40mhz_24ghz
;
51 module_param(cfg80211_disable_40mhz_24ghz
, bool, 0644);
52 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz
,
53 "Disable 40MHz support in the 2.4GHz band");
55 struct cfg80211_registered_device
*cfg80211_rdev_by_wiphy_idx(int wiphy_idx
)
57 struct cfg80211_registered_device
*result
= NULL
, *rdev
;
61 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
62 if (rdev
->wiphy_idx
== wiphy_idx
) {
71 int get_wiphy_idx(struct wiphy
*wiphy
)
73 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
75 return rdev
->wiphy_idx
;
78 struct wiphy
*wiphy_idx_to_wiphy(int wiphy_idx
)
80 struct cfg80211_registered_device
*rdev
;
84 rdev
= cfg80211_rdev_by_wiphy_idx(wiphy_idx
);
90 static int cfg80211_dev_check_name(struct cfg80211_registered_device
*rdev
,
93 struct cfg80211_registered_device
*rdev2
;
94 int wiphy_idx
, taken
= -1, digits
;
98 /* prohibit calling the thing phy%d when %d is not its number */
99 sscanf(newname
, PHY_NAME
"%d%n", &wiphy_idx
, &taken
);
100 if (taken
== strlen(newname
) && wiphy_idx
!= rdev
->wiphy_idx
) {
101 /* count number of places needed to print wiphy_idx */
103 while (wiphy_idx
/= 10)
106 * deny the name if it is phy<idx> where <idx> is printed
107 * without leading zeroes. taken == strlen(newname) here
109 if (taken
== strlen(PHY_NAME
) + digits
)
113 /* Ensure another device does not already have this name. */
114 list_for_each_entry(rdev2
, &cfg80211_rdev_list
, list
)
115 if (strcmp(newname
, wiphy_name(&rdev2
->wiphy
)) == 0)
121 int cfg80211_dev_rename(struct cfg80211_registered_device
*rdev
,
128 /* Ignore nop renames */
129 if (strcmp(newname
, wiphy_name(&rdev
->wiphy
)) == 0)
132 result
= cfg80211_dev_check_name(rdev
, newname
);
136 result
= device_rename(&rdev
->wiphy
.dev
, newname
);
140 if (rdev
->wiphy
.debugfsdir
&&
141 !debugfs_rename(rdev
->wiphy
.debugfsdir
->d_parent
,
142 rdev
->wiphy
.debugfsdir
,
143 rdev
->wiphy
.debugfsdir
->d_parent
,
145 pr_err("failed to rename debugfs dir to %s!\n", newname
);
147 nl80211_notify_wiphy(rdev
, NL80211_CMD_NEW_WIPHY
);
152 int cfg80211_switch_netns(struct cfg80211_registered_device
*rdev
,
155 struct wireless_dev
*wdev
;
158 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
))
161 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
164 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
165 err
= dev_change_net_namespace(wdev
->netdev
, net
, "wlan%d");
168 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
172 /* failed -- clean up to old netns */
173 net
= wiphy_net(&rdev
->wiphy
);
175 list_for_each_entry_continue_reverse(wdev
, &rdev
->wdev_list
,
179 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
180 err
= dev_change_net_namespace(wdev
->netdev
, net
,
183 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
189 wiphy_net_set(&rdev
->wiphy
, net
);
191 err
= device_rename(&rdev
->wiphy
.dev
, dev_name(&rdev
->wiphy
.dev
));
197 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
199 struct cfg80211_registered_device
*rdev
= data
;
201 rdev_rfkill_poll(rdev
);
204 void cfg80211_stop_p2p_device(struct cfg80211_registered_device
*rdev
,
205 struct wireless_dev
*wdev
)
209 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
))
212 if (!wdev
->p2p_started
)
215 rdev_stop_p2p_device(rdev
, wdev
);
216 wdev
->p2p_started
= false;
220 if (rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
) {
221 if (WARN_ON(!rdev
->scan_req
->notified
))
222 rdev
->scan_req
->aborted
= true;
223 ___cfg80211_scan_done(rdev
, false);
227 void cfg80211_shutdown_all_interfaces(struct wiphy
*wiphy
)
229 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
230 struct wireless_dev
*wdev
;
234 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
236 dev_close(wdev
->netdev
);
239 /* otherwise, check iftype */
240 switch (wdev
->iftype
) {
241 case NL80211_IFTYPE_P2P_DEVICE
:
242 cfg80211_stop_p2p_device(rdev
, wdev
);
249 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces
);
251 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
253 struct cfg80211_registered_device
*rdev
= data
;
259 cfg80211_shutdown_all_interfaces(&rdev
->wiphy
);
265 static void cfg80211_rfkill_sync_work(struct work_struct
*work
)
267 struct cfg80211_registered_device
*rdev
;
269 rdev
= container_of(work
, struct cfg80211_registered_device
, rfkill_sync
);
270 cfg80211_rfkill_set_block(rdev
, rfkill_blocked(rdev
->rfkill
));
273 static void cfg80211_event_work(struct work_struct
*work
)
275 struct cfg80211_registered_device
*rdev
;
277 rdev
= container_of(work
, struct cfg80211_registered_device
,
281 cfg80211_process_rdev_events(rdev
);
285 void cfg80211_destroy_ifaces(struct cfg80211_registered_device
*rdev
)
287 struct cfg80211_iface_destroy
*item
;
291 spin_lock_irq(&rdev
->destroy_list_lock
);
292 while ((item
= list_first_entry_or_null(&rdev
->destroy_list
,
293 struct cfg80211_iface_destroy
,
295 struct wireless_dev
*wdev
, *tmp
;
296 u32 nlportid
= item
->nlportid
;
298 list_del(&item
->list
);
300 spin_unlock_irq(&rdev
->destroy_list_lock
);
302 list_for_each_entry_safe(wdev
, tmp
, &rdev
->wdev_list
, list
) {
303 if (nlportid
== wdev
->owner_nlportid
)
304 rdev_del_virtual_intf(rdev
, wdev
);
307 spin_lock_irq(&rdev
->destroy_list_lock
);
309 spin_unlock_irq(&rdev
->destroy_list_lock
);
312 static void cfg80211_destroy_iface_wk(struct work_struct
*work
)
314 struct cfg80211_registered_device
*rdev
;
316 rdev
= container_of(work
, struct cfg80211_registered_device
,
320 cfg80211_destroy_ifaces(rdev
);
324 static void cfg80211_sched_scan_stop_wk(struct work_struct
*work
)
326 struct cfg80211_registered_device
*rdev
;
328 rdev
= container_of(work
, struct cfg80211_registered_device
,
333 __cfg80211_stop_sched_scan(rdev
, false);
338 /* exported functions */
340 struct wiphy
*wiphy_new_nm(const struct cfg80211_ops
*ops
, int sizeof_priv
,
341 const char *requested_name
)
343 static atomic_t wiphy_counter
= ATOMIC_INIT(0);
345 struct cfg80211_registered_device
*rdev
;
348 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
349 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
350 WARN_ON(ops
->connect
&& !ops
->disconnect
);
351 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
352 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
353 WARN_ON(ops
->add_station
&& !ops
->del_station
);
354 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
355 WARN_ON(ops
->join_mesh
&& !ops
->leave_mesh
);
357 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
359 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
365 rdev
->wiphy_idx
= atomic_inc_return(&wiphy_counter
);
367 if (unlikely(rdev
->wiphy_idx
< 0)) {
369 atomic_dec(&wiphy_counter
);
374 /* atomic_inc_return makes it start at 1, make it start at 0 */
377 /* give it a proper name */
378 if (requested_name
&& requested_name
[0]) {
382 rv
= cfg80211_dev_check_name(rdev
, requested_name
);
386 goto use_default_name
;
389 rv
= dev_set_name(&rdev
->wiphy
.dev
, "%s", requested_name
);
392 goto use_default_name
;
395 /* NOTE: This is *probably* safe w/out holding rtnl because of
396 * the restrictions on phy names. Probably this call could
397 * fail if some other part of the kernel (re)named a device
398 * phyX. But, might should add some locking and check return
399 * value, and use a different name if this one exists?
401 dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
404 INIT_LIST_HEAD(&rdev
->wdev_list
);
405 INIT_LIST_HEAD(&rdev
->beacon_registrations
);
406 spin_lock_init(&rdev
->beacon_registrations_lock
);
407 spin_lock_init(&rdev
->bss_lock
);
408 INIT_LIST_HEAD(&rdev
->bss_list
);
409 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
410 INIT_WORK(&rdev
->sched_scan_results_wk
, __cfg80211_sched_scan_results
);
411 INIT_DELAYED_WORK(&rdev
->dfs_update_channels_wk
,
412 cfg80211_dfs_channels_update_work
);
413 #ifdef CONFIG_CFG80211_WEXT
414 rdev
->wiphy
.wext
= &cfg80211_wext_handler
;
417 device_initialize(&rdev
->wiphy
.dev
);
418 rdev
->wiphy
.dev
.class = &ieee80211_class
;
419 rdev
->wiphy
.dev
.platform_data
= rdev
;
421 INIT_LIST_HEAD(&rdev
->destroy_list
);
422 spin_lock_init(&rdev
->destroy_list_lock
);
423 INIT_WORK(&rdev
->destroy_work
, cfg80211_destroy_iface_wk
);
424 INIT_WORK(&rdev
->sched_scan_stop_wk
, cfg80211_sched_scan_stop_wk
);
426 #ifdef CONFIG_CFG80211_DEFAULT_PS
427 rdev
->wiphy
.flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
430 wiphy_net_set(&rdev
->wiphy
, &init_net
);
432 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
433 rdev
->rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
434 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
435 &rdev
->rfkill_ops
, rdev
);
442 INIT_WORK(&rdev
->rfkill_sync
, cfg80211_rfkill_sync_work
);
443 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
444 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
446 init_waitqueue_head(&rdev
->dev_wait
);
449 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
450 * Fragmentation and RTS threshold are disabled by default with the
453 rdev
->wiphy
.retry_short
= 7;
454 rdev
->wiphy
.retry_long
= 4;
455 rdev
->wiphy
.frag_threshold
= (u32
) -1;
456 rdev
->wiphy
.rts_threshold
= (u32
) -1;
457 rdev
->wiphy
.coverage_class
= 0;
459 rdev
->wiphy
.max_num_csa_counters
= 1;
463 EXPORT_SYMBOL(wiphy_new_nm
);
465 static int wiphy_verify_combinations(struct wiphy
*wiphy
)
467 const struct ieee80211_iface_combination
*c
;
470 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
474 c
= &wiphy
->iface_combinations
[i
];
477 * Combinations with just one interface aren't real,
478 * however we make an exception for DFS.
480 if (WARN_ON((c
->max_interfaces
< 2) && !c
->radar_detect_widths
))
483 /* Need at least one channel */
484 if (WARN_ON(!c
->num_different_channels
))
488 * Put a sane limit on maximum number of different
489 * channels to simplify channel accounting code.
491 if (WARN_ON(c
->num_different_channels
>
492 CFG80211_MAX_NUM_DIFFERENT_CHANNELS
))
495 /* DFS only works on one channel. */
496 if (WARN_ON(c
->radar_detect_widths
&&
497 (c
->num_different_channels
> 1)))
500 if (WARN_ON(!c
->n_limits
))
503 for (j
= 0; j
< c
->n_limits
; j
++) {
504 u16 types
= c
->limits
[j
].types
;
506 /* interface types shouldn't overlap */
507 if (WARN_ON(types
& all_iftypes
))
509 all_iftypes
|= types
;
511 if (WARN_ON(!c
->limits
[j
].max
))
514 /* Shouldn't list software iftypes in combinations! */
515 if (WARN_ON(wiphy
->software_iftypes
& types
))
518 /* Only a single P2P_DEVICE can be allowed */
519 if (WARN_ON(types
& BIT(NL80211_IFTYPE_P2P_DEVICE
) &&
520 c
->limits
[j
].max
> 1))
523 cnt
+= c
->limits
[j
].max
;
525 * Don't advertise an unsupported type
528 if (WARN_ON((wiphy
->interface_modes
& types
) != types
))
532 /* You can't even choose that many! */
533 if (WARN_ON(cnt
< c
->max_interfaces
))
540 int wiphy_register(struct wiphy
*wiphy
)
542 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
544 enum ieee80211_band band
;
545 struct ieee80211_supported_band
*sband
;
546 bool have_band
= false;
548 u16 ifmodes
= wiphy
->interface_modes
;
551 if (WARN_ON(wiphy
->wowlan
&&
552 (wiphy
->wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
553 !(wiphy
->wowlan
->flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
)))
555 if (WARN_ON(wiphy
->wowlan
&&
556 !wiphy
->wowlan
->flags
&& !wiphy
->wowlan
->n_patterns
&&
557 !wiphy
->wowlan
->tcp
))
560 if (WARN_ON((wiphy
->features
& NL80211_FEATURE_TDLS_CHANNEL_SWITCH
) &&
561 (!rdev
->ops
->tdls_channel_switch
||
562 !rdev
->ops
->tdls_cancel_channel_switch
)))
566 * if a wiphy has unsupported modes for regulatory channel enforcement,
567 * opt-out of enforcement checking
569 if (wiphy
->interface_modes
& ~(BIT(NL80211_IFTYPE_STATION
) |
570 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
571 BIT(NL80211_IFTYPE_AP
) |
572 BIT(NL80211_IFTYPE_P2P_GO
) |
573 BIT(NL80211_IFTYPE_ADHOC
) |
574 BIT(NL80211_IFTYPE_P2P_DEVICE
) |
575 BIT(NL80211_IFTYPE_AP_VLAN
) |
576 BIT(NL80211_IFTYPE_MONITOR
)))
577 wiphy
->regulatory_flags
|= REGULATORY_IGNORE_STALE_KICKOFF
;
579 if (WARN_ON((wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
) &&
580 (wiphy
->regulatory_flags
&
581 (REGULATORY_CUSTOM_REG
|
582 REGULATORY_STRICT_REG
|
583 REGULATORY_COUNTRY_IE_FOLLOW_POWER
|
584 REGULATORY_COUNTRY_IE_IGNORE
))))
587 if (WARN_ON(wiphy
->coalesce
&&
588 (!wiphy
->coalesce
->n_rules
||
589 !wiphy
->coalesce
->n_patterns
) &&
590 (!wiphy
->coalesce
->pattern_min_len
||
591 wiphy
->coalesce
->pattern_min_len
>
592 wiphy
->coalesce
->pattern_max_len
)))
595 if (WARN_ON(wiphy
->ap_sme_capa
&&
596 !(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
)))
599 if (WARN_ON(wiphy
->addresses
&& !wiphy
->n_addresses
))
602 if (WARN_ON(wiphy
->addresses
&&
603 !is_zero_ether_addr(wiphy
->perm_addr
) &&
604 memcmp(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
,
608 if (WARN_ON(wiphy
->max_acl_mac_addrs
&&
609 (!(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
) ||
610 !rdev
->ops
->set_mac_acl
)))
613 if (wiphy
->addresses
)
614 memcpy(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
, ETH_ALEN
);
616 /* sanity check ifmodes */
618 ifmodes
&= ((1 << NUM_NL80211_IFTYPES
) - 1) & ~1;
619 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
620 wiphy
->interface_modes
= ifmodes
;
622 res
= wiphy_verify_combinations(wiphy
);
626 /* sanity check supported bands/channels */
627 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
628 sband
= wiphy
->bands
[band
];
633 if (WARN_ON(!sband
->n_channels
))
636 * on 60gHz band, there are no legacy rates, so
639 if (WARN_ON(band
!= IEEE80211_BAND_60GHZ
&&
644 * Since cfg80211_disable_40mhz_24ghz is global, we can
645 * modify the sband's ht data even if the driver uses a
646 * global structure for that.
648 if (cfg80211_disable_40mhz_24ghz
&&
649 band
== IEEE80211_BAND_2GHZ
&&
650 sband
->ht_cap
.ht_supported
) {
651 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
652 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SGI_40
;
656 * Since we use a u32 for rate bitmaps in
657 * ieee80211_get_response_rate, we cannot
658 * have more than 32 legacy rates.
660 if (WARN_ON(sband
->n_bitrates
> 32))
663 for (i
= 0; i
< sband
->n_channels
; i
++) {
664 sband
->channels
[i
].orig_flags
=
665 sband
->channels
[i
].flags
;
666 sband
->channels
[i
].orig_mag
= INT_MAX
;
667 sband
->channels
[i
].orig_mpwr
=
668 sband
->channels
[i
].max_power
;
669 sband
->channels
[i
].band
= band
;
681 if (WARN_ON(rdev
->wiphy
.wowlan
&& rdev
->wiphy
.wowlan
->n_patterns
&&
682 (!rdev
->wiphy
.wowlan
->pattern_min_len
||
683 rdev
->wiphy
.wowlan
->pattern_min_len
>
684 rdev
->wiphy
.wowlan
->pattern_max_len
)))
688 /* check and set up bitrates */
689 ieee80211_set_bitrate_flags(wiphy
);
691 rdev
->wiphy
.features
|= NL80211_FEATURE_SCAN_FLUSH
;
694 res
= device_add(&rdev
->wiphy
.dev
);
700 /* set up regulatory info */
701 wiphy_regulatory_register(wiphy
);
703 list_add_rcu(&rdev
->list
, &cfg80211_rdev_list
);
704 cfg80211_rdev_list_generation
++;
707 rdev
->wiphy
.debugfsdir
=
708 debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
709 ieee80211_debugfs_dir
);
710 if (IS_ERR(rdev
->wiphy
.debugfsdir
))
711 rdev
->wiphy
.debugfsdir
= NULL
;
713 cfg80211_debugfs_rdev_add(rdev
);
714 nl80211_notify_wiphy(rdev
, NL80211_CMD_NEW_WIPHY
);
716 if (wiphy
->regulatory_flags
& REGULATORY_CUSTOM_REG
) {
717 struct regulatory_request request
;
719 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
720 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
721 request
.alpha2
[0] = '9';
722 request
.alpha2
[1] = '9';
724 nl80211_send_reg_change_event(&request
);
727 rdev
->wiphy
.registered
= true;
730 res
= rfkill_register(rdev
->rfkill
);
732 rfkill_destroy(rdev
->rfkill
);
734 wiphy_unregister(&rdev
->wiphy
);
740 EXPORT_SYMBOL(wiphy_register
);
742 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
744 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
746 if (!rdev
->ops
->rfkill_poll
)
748 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
749 rfkill_resume_polling(rdev
->rfkill
);
751 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
753 void wiphy_rfkill_stop_polling(struct wiphy
*wiphy
)
755 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
757 rfkill_pause_polling(rdev
->rfkill
);
759 EXPORT_SYMBOL(wiphy_rfkill_stop_polling
);
761 void wiphy_unregister(struct wiphy
*wiphy
)
763 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
765 wait_event(rdev
->dev_wait
, ({
768 __count
= rdev
->opencount
;
773 rfkill_unregister(rdev
->rfkill
);
776 nl80211_notify_wiphy(rdev
, NL80211_CMD_DEL_WIPHY
);
777 rdev
->wiphy
.registered
= false;
779 WARN_ON(!list_empty(&rdev
->wdev_list
));
782 * First remove the hardware from everywhere, this makes
783 * it impossible to find from userspace.
785 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
786 list_del_rcu(&rdev
->list
);
790 * If this device got a regulatory hint tell core its
791 * free to listen now to a new shiny device regulatory hint
793 wiphy_regulatory_deregister(wiphy
);
795 cfg80211_rdev_list_generation
++;
796 device_del(&rdev
->wiphy
.dev
);
800 flush_work(&rdev
->scan_done_wk
);
801 cancel_work_sync(&rdev
->conn_work
);
802 flush_work(&rdev
->event_work
);
803 cancel_delayed_work_sync(&rdev
->dfs_update_channels_wk
);
804 flush_work(&rdev
->destroy_work
);
805 flush_work(&rdev
->sched_scan_stop_wk
);
808 if (rdev
->wiphy
.wowlan_config
&& rdev
->ops
->set_wakeup
)
809 rdev_set_wakeup(rdev
, false);
811 cfg80211_rdev_free_wowlan(rdev
);
812 cfg80211_rdev_free_coalesce(rdev
);
814 EXPORT_SYMBOL(wiphy_unregister
);
816 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
818 struct cfg80211_internal_bss
*scan
, *tmp
;
819 struct cfg80211_beacon_registration
*reg
, *treg
;
820 rfkill_destroy(rdev
->rfkill
);
821 list_for_each_entry_safe(reg
, treg
, &rdev
->beacon_registrations
, list
) {
822 list_del(®
->list
);
825 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
826 cfg80211_put_bss(&rdev
->wiphy
, &scan
->pub
);
830 void wiphy_free(struct wiphy
*wiphy
)
832 put_device(&wiphy
->dev
);
834 EXPORT_SYMBOL(wiphy_free
);
836 void wiphy_rfkill_set_hw_state(struct wiphy
*wiphy
, bool blocked
)
838 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
840 if (rfkill_set_hw_state(rdev
->rfkill
, blocked
))
841 schedule_work(&rdev
->rfkill_sync
);
843 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state
);
845 void cfg80211_unregister_wdev(struct wireless_dev
*wdev
)
847 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
851 if (WARN_ON(wdev
->netdev
))
854 list_del_rcu(&wdev
->list
);
855 rdev
->devlist_generation
++;
857 switch (wdev
->iftype
) {
858 case NL80211_IFTYPE_P2P_DEVICE
:
859 cfg80211_stop_p2p_device(rdev
, wdev
);
866 EXPORT_SYMBOL(cfg80211_unregister_wdev
);
868 static const struct device_type wiphy_type
= {
872 void cfg80211_update_iface_num(struct cfg80211_registered_device
*rdev
,
873 enum nl80211_iftype iftype
, int num
)
877 rdev
->num_running_ifaces
+= num
;
878 if (iftype
== NL80211_IFTYPE_MONITOR
)
879 rdev
->num_running_monitor_ifaces
+= num
;
882 void __cfg80211_leave(struct cfg80211_registered_device
*rdev
,
883 struct wireless_dev
*wdev
)
885 struct net_device
*dev
= wdev
->netdev
;
886 struct cfg80211_sched_scan_request
*sched_scan_req
;
889 ASSERT_WDEV_LOCK(wdev
);
891 switch (wdev
->iftype
) {
892 case NL80211_IFTYPE_ADHOC
:
893 __cfg80211_leave_ibss(rdev
, dev
, true);
895 case NL80211_IFTYPE_P2P_CLIENT
:
896 case NL80211_IFTYPE_STATION
:
897 sched_scan_req
= rtnl_dereference(rdev
->sched_scan_req
);
898 if (sched_scan_req
&& dev
== sched_scan_req
->dev
)
899 __cfg80211_stop_sched_scan(rdev
, false);
901 #ifdef CONFIG_CFG80211_WEXT
902 kfree(wdev
->wext
.ie
);
903 wdev
->wext
.ie
= NULL
;
904 wdev
->wext
.ie_len
= 0;
905 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
907 cfg80211_disconnect(rdev
, dev
,
908 WLAN_REASON_DEAUTH_LEAVING
, true);
910 case NL80211_IFTYPE_MESH_POINT
:
911 __cfg80211_leave_mesh(rdev
, dev
);
913 case NL80211_IFTYPE_AP
:
914 case NL80211_IFTYPE_P2P_GO
:
915 __cfg80211_stop_ap(rdev
, dev
, true);
917 case NL80211_IFTYPE_OCB
:
918 __cfg80211_leave_ocb(rdev
, dev
);
920 case NL80211_IFTYPE_WDS
:
921 /* must be handled by mac80211/driver, has no APIs */
923 case NL80211_IFTYPE_P2P_DEVICE
:
924 /* cannot happen, has no netdev */
926 case NL80211_IFTYPE_AP_VLAN
:
927 case NL80211_IFTYPE_MONITOR
:
930 case NL80211_IFTYPE_UNSPECIFIED
:
931 case NUM_NL80211_IFTYPES
:
937 void cfg80211_leave(struct cfg80211_registered_device
*rdev
,
938 struct wireless_dev
*wdev
)
941 __cfg80211_leave(rdev
, wdev
);
945 void cfg80211_stop_iface(struct wiphy
*wiphy
, struct wireless_dev
*wdev
,
948 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
949 struct cfg80211_event
*ev
;
952 trace_cfg80211_stop_iface(wiphy
, wdev
);
954 ev
= kzalloc(sizeof(*ev
), gfp
);
958 ev
->type
= EVENT_STOPPED
;
960 spin_lock_irqsave(&wdev
->event_lock
, flags
);
961 list_add_tail(&ev
->list
, &wdev
->event_list
);
962 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
963 queue_work(cfg80211_wq
, &rdev
->event_work
);
965 EXPORT_SYMBOL(cfg80211_stop_iface
);
967 static const struct rtnl_link_ops wireless_link_ops
= {
971 static int cfg80211_netdev_notifier_call(struct notifier_block
*nb
,
972 unsigned long state
, void *ptr
)
974 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
975 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
976 struct cfg80211_registered_device
*rdev
;
977 struct cfg80211_sched_scan_request
*sched_scan_req
;
982 rdev
= wiphy_to_rdev(wdev
->wiphy
);
984 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
987 case NETDEV_POST_INIT
:
988 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
989 dev
->rtnl_link_ops
= &wireless_link_ops
;
991 case NETDEV_REGISTER
:
993 * NB: cannot take rdev->mtx here because this may be
994 * called within code protected by it when interfaces
995 * are added with nl80211.
997 mutex_init(&wdev
->mtx
);
998 INIT_LIST_HEAD(&wdev
->event_list
);
999 spin_lock_init(&wdev
->event_lock
);
1000 INIT_LIST_HEAD(&wdev
->mgmt_registrations
);
1001 spin_lock_init(&wdev
->mgmt_registrations_lock
);
1003 wdev
->identifier
= ++rdev
->wdev_id
;
1004 list_add_rcu(&wdev
->list
, &rdev
->wdev_list
);
1005 rdev
->devlist_generation
++;
1006 /* can only change netns with wiphy */
1007 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1009 if (sysfs_create_link(&dev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
1011 pr_err("failed to add phy80211 symlink to netdev!\n");
1014 #ifdef CONFIG_CFG80211_WEXT
1015 wdev
->wext
.default_key
= -1;
1016 wdev
->wext
.default_mgmt_key
= -1;
1017 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
1020 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
1024 /* allow mac80211 to determine the timeout */
1025 wdev
->ps_timeout
= -1;
1027 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
1028 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
||
1029 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
1030 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
1032 case NETDEV_GOING_DOWN
:
1033 cfg80211_leave(rdev
, wdev
);
1036 cfg80211_update_iface_num(rdev
, wdev
->iftype
, -1);
1037 if (rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
) {
1038 if (WARN_ON(!rdev
->scan_req
->notified
))
1039 rdev
->scan_req
->aborted
= true;
1040 ___cfg80211_scan_done(rdev
, false);
1043 sched_scan_req
= rtnl_dereference(rdev
->sched_scan_req
);
1044 if (WARN_ON(sched_scan_req
&&
1045 sched_scan_req
->dev
== wdev
->netdev
)) {
1046 __cfg80211_stop_sched_scan(rdev
, false);
1050 wake_up(&rdev
->dev_wait
);
1053 cfg80211_update_iface_num(rdev
, wdev
->iftype
, 1);
1055 switch (wdev
->iftype
) {
1056 #ifdef CONFIG_CFG80211_WEXT
1057 case NL80211_IFTYPE_ADHOC
:
1058 cfg80211_ibss_wext_join(rdev
, wdev
);
1060 case NL80211_IFTYPE_STATION
:
1061 cfg80211_mgd_wext_connect(rdev
, wdev
);
1064 #ifdef CONFIG_MAC80211_MESH
1065 case NL80211_IFTYPE_MESH_POINT
:
1067 /* backward compat code... */
1068 struct mesh_setup setup
;
1069 memcpy(&setup
, &default_mesh_setup
,
1071 /* back compat only needed for mesh_id */
1072 setup
.mesh_id
= wdev
->ssid
;
1073 setup
.mesh_id_len
= wdev
->mesh_id_up_len
;
1074 if (wdev
->mesh_id_up_len
)
1075 __cfg80211_join_mesh(rdev
, dev
,
1077 &default_mesh_config
);
1088 * Configure power management to the driver here so that its
1089 * correctly set also after interface type changes etc.
1091 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
1092 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
) &&
1093 rdev
->ops
->set_power_mgmt
)
1094 if (rdev_set_power_mgmt(rdev
, dev
, wdev
->ps
,
1095 wdev
->ps_timeout
)) {
1096 /* assume this means it's off */
1100 case NETDEV_UNREGISTER
:
1102 * It is possible to get NETDEV_UNREGISTER
1103 * multiple times. To detect that, check
1104 * that the interface is still on the list
1105 * of registered interfaces, and only then
1106 * remove and clean it up.
1108 if (!list_empty(&wdev
->list
)) {
1109 sysfs_remove_link(&dev
->dev
.kobj
, "phy80211");
1110 list_del_rcu(&wdev
->list
);
1111 rdev
->devlist_generation
++;
1112 cfg80211_mlme_purge_registrations(wdev
);
1113 #ifdef CONFIG_CFG80211_WEXT
1114 kzfree(wdev
->wext
.keys
);
1118 * synchronise (so that we won't find this netdev
1119 * from other code any more) and then clear the list
1120 * head so that the above code can safely check for
1121 * !list_empty() to avoid double-cleanup.
1124 INIT_LIST_HEAD(&wdev
->list
);
1126 * Ensure that all events have been processed and
1129 cfg80211_process_wdev_events(wdev
);
1131 if (WARN_ON(wdev
->current_bss
)) {
1132 cfg80211_unhold_bss(wdev
->current_bss
);
1133 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
1134 wdev
->current_bss
= NULL
;
1138 if (!(wdev
->wiphy
->interface_modes
& BIT(wdev
->iftype
)))
1139 return notifier_from_errno(-EOPNOTSUPP
);
1140 if (rfkill_blocked(rdev
->rfkill
))
1141 return notifier_from_errno(-ERFKILL
);
1150 static struct notifier_block cfg80211_netdev_notifier
= {
1151 .notifier_call
= cfg80211_netdev_notifier_call
,
1154 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
1156 struct cfg80211_registered_device
*rdev
;
1159 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
1160 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
1161 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
1166 static struct pernet_operations cfg80211_pernet_ops
= {
1167 .exit
= cfg80211_pernet_exit
,
1170 static int __init
cfg80211_init(void)
1174 err
= register_pernet_device(&cfg80211_pernet_ops
);
1176 goto out_fail_pernet
;
1178 err
= wiphy_sysfs_init();
1180 goto out_fail_sysfs
;
1182 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
1184 goto out_fail_notifier
;
1186 err
= nl80211_init();
1188 goto out_fail_nl80211
;
1190 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
1192 err
= regulatory_init();
1196 cfg80211_wq
= create_singlethread_workqueue("cfg80211");
1207 debugfs_remove(ieee80211_debugfs_dir
);
1209 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1213 unregister_pernet_device(&cfg80211_pernet_ops
);
1217 subsys_initcall(cfg80211_init
);
1219 static void __exit
cfg80211_exit(void)
1221 debugfs_remove(ieee80211_debugfs_dir
);
1223 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1226 unregister_pernet_device(&cfg80211_pernet_ops
);
1227 destroy_workqueue(cfg80211_wq
);
1229 module_exit(cfg80211_exit
);