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"
31 /* name for sysfs, %d is appended */
32 #define PHY_NAME "phy"
34 MODULE_AUTHOR("Johannes Berg");
35 MODULE_LICENSE("GPL");
36 MODULE_DESCRIPTION("wireless configuration support");
37 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME
);
39 /* RCU-protected (and RTNL for writers) */
40 LIST_HEAD(cfg80211_rdev_list
);
41 int cfg80211_rdev_list_generation
;
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 struct cfg80211_registered_device
*cfg80211_rdev_by_wiphy_idx(int wiphy_idx
)
56 struct cfg80211_registered_device
*result
= NULL
, *rdev
;
60 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
61 if (rdev
->wiphy_idx
== wiphy_idx
) {
70 int get_wiphy_idx(struct wiphy
*wiphy
)
72 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
74 return rdev
->wiphy_idx
;
77 struct wiphy
*wiphy_idx_to_wiphy(int wiphy_idx
)
79 struct cfg80211_registered_device
*rdev
;
83 rdev
= cfg80211_rdev_by_wiphy_idx(wiphy_idx
);
89 int cfg80211_dev_rename(struct cfg80211_registered_device
*rdev
,
92 struct cfg80211_registered_device
*rdev2
;
93 int wiphy_idx
, taken
= -1, result
, digits
;
97 /* prohibit calling the thing phy%d when %d is not its number */
98 sscanf(newname
, PHY_NAME
"%d%n", &wiphy_idx
, &taken
);
99 if (taken
== strlen(newname
) && wiphy_idx
!= rdev
->wiphy_idx
) {
100 /* count number of places needed to print wiphy_idx */
102 while (wiphy_idx
/= 10)
105 * deny the name if it is phy<idx> where <idx> is printed
106 * without leading zeroes. taken == strlen(newname) here
108 if (taken
== strlen(PHY_NAME
) + digits
)
113 /* Ignore nop renames */
114 if (strcmp(newname
, dev_name(&rdev
->wiphy
.dev
)) == 0)
117 /* Ensure another device does not already have this name. */
118 list_for_each_entry(rdev2
, &cfg80211_rdev_list
, list
)
119 if (strcmp(newname
, dev_name(&rdev2
->wiphy
.dev
)) == 0)
122 result
= device_rename(&rdev
->wiphy
.dev
, newname
);
126 if (rdev
->wiphy
.debugfsdir
&&
127 !debugfs_rename(rdev
->wiphy
.debugfsdir
->d_parent
,
128 rdev
->wiphy
.debugfsdir
,
129 rdev
->wiphy
.debugfsdir
->d_parent
,
131 pr_err("failed to rename debugfs dir to %s!\n", newname
);
133 nl80211_notify_dev_rename(rdev
);
138 int cfg80211_switch_netns(struct cfg80211_registered_device
*rdev
,
141 struct wireless_dev
*wdev
;
144 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
))
147 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
150 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
151 err
= dev_change_net_namespace(wdev
->netdev
, net
, "wlan%d");
154 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
158 /* failed -- clean up to old netns */
159 net
= wiphy_net(&rdev
->wiphy
);
161 list_for_each_entry_continue_reverse(wdev
, &rdev
->wdev_list
,
165 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
166 err
= dev_change_net_namespace(wdev
->netdev
, net
,
169 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
175 wiphy_net_set(&rdev
->wiphy
, net
);
177 err
= device_rename(&rdev
->wiphy
.dev
, dev_name(&rdev
->wiphy
.dev
));
183 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
185 struct cfg80211_registered_device
*rdev
= data
;
187 rdev_rfkill_poll(rdev
);
190 void cfg80211_stop_p2p_device(struct cfg80211_registered_device
*rdev
,
191 struct wireless_dev
*wdev
)
195 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
))
198 if (!wdev
->p2p_started
)
201 rdev_stop_p2p_device(rdev
, wdev
);
202 wdev
->p2p_started
= false;
206 if (rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
) {
208 * If the scan request wasn't notified as done, set it
209 * to aborted and leak it after a warning. The driver
210 * should have notified us that it ended at the latest
211 * during rdev_stop_p2p_device().
213 if (WARN_ON(!rdev
->scan_req
->notified
))
214 rdev
->scan_req
->aborted
= true;
215 ___cfg80211_scan_done(rdev
, !rdev
->scan_req
->notified
);
219 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
221 struct cfg80211_registered_device
*rdev
= data
;
222 struct wireless_dev
*wdev
;
229 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
231 dev_close(wdev
->netdev
);
234 /* otherwise, check iftype */
235 switch (wdev
->iftype
) {
236 case NL80211_IFTYPE_P2P_DEVICE
:
237 cfg80211_stop_p2p_device(rdev
, wdev
);
249 static void cfg80211_rfkill_sync_work(struct work_struct
*work
)
251 struct cfg80211_registered_device
*rdev
;
253 rdev
= container_of(work
, struct cfg80211_registered_device
, rfkill_sync
);
254 cfg80211_rfkill_set_block(rdev
, rfkill_blocked(rdev
->rfkill
));
257 static void cfg80211_event_work(struct work_struct
*work
)
259 struct cfg80211_registered_device
*rdev
;
261 rdev
= container_of(work
, struct cfg80211_registered_device
,
265 cfg80211_process_rdev_events(rdev
);
269 /* exported functions */
271 struct wiphy
*wiphy_new(const struct cfg80211_ops
*ops
, int sizeof_priv
)
273 static atomic_t wiphy_counter
= ATOMIC_INIT(0);
275 struct cfg80211_registered_device
*rdev
;
278 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
279 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
280 WARN_ON(ops
->connect
&& !ops
->disconnect
);
281 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
282 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
283 WARN_ON(ops
->add_station
&& !ops
->del_station
);
284 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
285 WARN_ON(ops
->join_mesh
&& !ops
->leave_mesh
);
287 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
289 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
295 rdev
->wiphy_idx
= atomic_inc_return(&wiphy_counter
);
297 if (unlikely(rdev
->wiphy_idx
< 0)) {
299 atomic_dec(&wiphy_counter
);
304 /* atomic_inc_return makes it start at 1, make it start at 0 */
307 /* give it a proper name */
308 dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
310 INIT_LIST_HEAD(&rdev
->wdev_list
);
311 INIT_LIST_HEAD(&rdev
->beacon_registrations
);
312 spin_lock_init(&rdev
->beacon_registrations_lock
);
313 spin_lock_init(&rdev
->bss_lock
);
314 INIT_LIST_HEAD(&rdev
->bss_list
);
315 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
316 INIT_WORK(&rdev
->sched_scan_results_wk
, __cfg80211_sched_scan_results
);
317 INIT_DELAYED_WORK(&rdev
->dfs_update_channels_wk
,
318 cfg80211_dfs_channels_update_work
);
319 #ifdef CONFIG_CFG80211_WEXT
320 rdev
->wiphy
.wext
= &cfg80211_wext_handler
;
323 device_initialize(&rdev
->wiphy
.dev
);
324 rdev
->wiphy
.dev
.class = &ieee80211_class
;
325 rdev
->wiphy
.dev
.platform_data
= rdev
;
327 #ifdef CONFIG_CFG80211_DEFAULT_PS
328 rdev
->wiphy
.flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
331 wiphy_net_set(&rdev
->wiphy
, &init_net
);
333 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
334 rdev
->rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
335 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
336 &rdev
->rfkill_ops
, rdev
);
343 INIT_WORK(&rdev
->rfkill_sync
, cfg80211_rfkill_sync_work
);
344 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
345 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
347 init_waitqueue_head(&rdev
->dev_wait
);
350 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
351 * Fragmentation and RTS threshold are disabled by default with the
354 rdev
->wiphy
.retry_short
= 7;
355 rdev
->wiphy
.retry_long
= 4;
356 rdev
->wiphy
.frag_threshold
= (u32
) -1;
357 rdev
->wiphy
.rts_threshold
= (u32
) -1;
358 rdev
->wiphy
.coverage_class
= 0;
360 rdev
->wiphy
.features
= NL80211_FEATURE_SCAN_FLUSH
;
364 EXPORT_SYMBOL(wiphy_new
);
366 static int wiphy_verify_combinations(struct wiphy
*wiphy
)
368 const struct ieee80211_iface_combination
*c
;
371 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
375 c
= &wiphy
->iface_combinations
[i
];
378 * Combinations with just one interface aren't real,
379 * however we make an exception for DFS.
381 if (WARN_ON((c
->max_interfaces
< 2) && !c
->radar_detect_widths
))
384 /* Need at least one channel */
385 if (WARN_ON(!c
->num_different_channels
))
389 * Put a sane limit on maximum number of different
390 * channels to simplify channel accounting code.
392 if (WARN_ON(c
->num_different_channels
>
393 CFG80211_MAX_NUM_DIFFERENT_CHANNELS
))
396 /* DFS only works on one channel. */
397 if (WARN_ON(c
->radar_detect_widths
&&
398 (c
->num_different_channels
> 1)))
401 if (WARN_ON(!c
->n_limits
))
404 for (j
= 0; j
< c
->n_limits
; j
++) {
405 u16 types
= c
->limits
[j
].types
;
408 * interface types shouldn't overlap, this is
409 * used in cfg80211_can_change_interface()
411 if (WARN_ON(types
& all_iftypes
))
413 all_iftypes
|= types
;
415 if (WARN_ON(!c
->limits
[j
].max
))
418 /* Shouldn't list software iftypes in combinations! */
419 if (WARN_ON(wiphy
->software_iftypes
& types
))
422 /* Only a single P2P_DEVICE can be allowed */
423 if (WARN_ON(types
& BIT(NL80211_IFTYPE_P2P_DEVICE
) &&
424 c
->limits
[j
].max
> 1))
427 cnt
+= c
->limits
[j
].max
;
429 * Don't advertise an unsupported type
432 if (WARN_ON((wiphy
->interface_modes
& types
) != types
))
436 /* You can't even choose that many! */
437 if (WARN_ON(cnt
< c
->max_interfaces
))
444 int wiphy_register(struct wiphy
*wiphy
)
446 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
448 enum ieee80211_band band
;
449 struct ieee80211_supported_band
*sband
;
450 bool have_band
= false;
452 u16 ifmodes
= wiphy
->interface_modes
;
454 /* support for 5/10 MHz is broken due to nl80211 API mess - disable */
455 wiphy
->flags
&= ~WIPHY_FLAG_SUPPORTS_5_10_MHZ
;
458 * There are major locking problems in nl80211/mac80211 for CSA,
459 * disable for all drivers until this has been reworked.
461 wiphy
->flags
&= ~WIPHY_FLAG_HAS_CHANNEL_SWITCH
;
464 if (WARN_ON(wiphy
->wowlan
&&
465 (wiphy
->wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
466 !(wiphy
->wowlan
->flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
)))
468 if (WARN_ON(wiphy
->wowlan
&&
469 !wiphy
->wowlan
->flags
&& !wiphy
->wowlan
->n_patterns
&&
470 !wiphy
->wowlan
->tcp
))
474 if (WARN_ON(wiphy
->coalesce
&&
475 (!wiphy
->coalesce
->n_rules
||
476 !wiphy
->coalesce
->n_patterns
) &&
477 (!wiphy
->coalesce
->pattern_min_len
||
478 wiphy
->coalesce
->pattern_min_len
>
479 wiphy
->coalesce
->pattern_max_len
)))
482 if (WARN_ON(wiphy
->ap_sme_capa
&&
483 !(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
)))
486 if (WARN_ON(wiphy
->addresses
&& !wiphy
->n_addresses
))
489 if (WARN_ON(wiphy
->addresses
&&
490 !is_zero_ether_addr(wiphy
->perm_addr
) &&
491 memcmp(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
,
495 if (WARN_ON(wiphy
->max_acl_mac_addrs
&&
496 (!(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
) ||
497 !rdev
->ops
->set_mac_acl
)))
500 if (wiphy
->addresses
)
501 memcpy(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
, ETH_ALEN
);
503 /* sanity check ifmodes */
505 ifmodes
&= ((1 << NUM_NL80211_IFTYPES
) - 1) & ~1;
506 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
507 wiphy
->interface_modes
= ifmodes
;
509 res
= wiphy_verify_combinations(wiphy
);
513 /* sanity check supported bands/channels */
514 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
515 sband
= wiphy
->bands
[band
];
520 if (WARN_ON(!sband
->n_channels
))
523 * on 60gHz band, there are no legacy rates, so
526 if (WARN_ON(band
!= IEEE80211_BAND_60GHZ
&&
531 * Since cfg80211_disable_40mhz_24ghz is global, we can
532 * modify the sband's ht data even if the driver uses a
533 * global structure for that.
535 if (cfg80211_disable_40mhz_24ghz
&&
536 band
== IEEE80211_BAND_2GHZ
&&
537 sband
->ht_cap
.ht_supported
) {
538 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
539 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SGI_40
;
543 * Since we use a u32 for rate bitmaps in
544 * ieee80211_get_response_rate, we cannot
545 * have more than 32 legacy rates.
547 if (WARN_ON(sband
->n_bitrates
> 32))
550 for (i
= 0; i
< sband
->n_channels
; i
++) {
551 sband
->channels
[i
].orig_flags
=
552 sband
->channels
[i
].flags
;
553 sband
->channels
[i
].orig_mag
= INT_MAX
;
554 sband
->channels
[i
].orig_mpwr
=
555 sband
->channels
[i
].max_power
;
556 sband
->channels
[i
].band
= band
;
568 if (WARN_ON(rdev
->wiphy
.wowlan
&& rdev
->wiphy
.wowlan
->n_patterns
&&
569 (!rdev
->wiphy
.wowlan
->pattern_min_len
||
570 rdev
->wiphy
.wowlan
->pattern_min_len
>
571 rdev
->wiphy
.wowlan
->pattern_max_len
)))
575 /* check and set up bitrates */
576 ieee80211_set_bitrate_flags(wiphy
);
579 res
= device_add(&rdev
->wiphy
.dev
);
585 /* set up regulatory info */
586 wiphy_regulatory_register(wiphy
);
588 list_add_rcu(&rdev
->list
, &cfg80211_rdev_list
);
589 cfg80211_rdev_list_generation
++;
592 rdev
->wiphy
.debugfsdir
=
593 debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
594 ieee80211_debugfs_dir
);
595 if (IS_ERR(rdev
->wiphy
.debugfsdir
))
596 rdev
->wiphy
.debugfsdir
= NULL
;
598 if (wiphy
->flags
& WIPHY_FLAG_CUSTOM_REGULATORY
) {
599 struct regulatory_request request
;
601 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
602 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
603 request
.alpha2
[0] = '9';
604 request
.alpha2
[1] = '9';
606 nl80211_send_reg_change_event(&request
);
609 cfg80211_debugfs_rdev_add(rdev
);
611 rdev
->wiphy
.registered
= true;
614 res
= rfkill_register(rdev
->rfkill
);
616 rfkill_destroy(rdev
->rfkill
);
618 wiphy_unregister(&rdev
->wiphy
);
624 EXPORT_SYMBOL(wiphy_register
);
626 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
628 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
630 if (!rdev
->ops
->rfkill_poll
)
632 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
633 rfkill_resume_polling(rdev
->rfkill
);
635 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
637 void wiphy_rfkill_stop_polling(struct wiphy
*wiphy
)
639 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
641 rfkill_pause_polling(rdev
->rfkill
);
643 EXPORT_SYMBOL(wiphy_rfkill_stop_polling
);
645 void wiphy_unregister(struct wiphy
*wiphy
)
647 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
649 wait_event(rdev
->dev_wait
, ({
652 __count
= rdev
->opencount
;
657 rfkill_unregister(rdev
->rfkill
);
660 rdev
->wiphy
.registered
= false;
662 BUG_ON(!list_empty(&rdev
->wdev_list
));
665 * First remove the hardware from everywhere, this makes
666 * it impossible to find from userspace.
668 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
669 list_del_rcu(&rdev
->list
);
673 * If this device got a regulatory hint tell core its
674 * free to listen now to a new shiny device regulatory hint
676 wiphy_regulatory_deregister(wiphy
);
678 cfg80211_rdev_list_generation
++;
679 device_del(&rdev
->wiphy
.dev
);
683 flush_work(&rdev
->scan_done_wk
);
684 cancel_work_sync(&rdev
->conn_work
);
685 flush_work(&rdev
->event_work
);
686 cancel_delayed_work_sync(&rdev
->dfs_update_channels_wk
);
689 if (rdev
->wiphy
.wowlan_config
&& rdev
->ops
->set_wakeup
)
690 rdev_set_wakeup(rdev
, false);
692 cfg80211_rdev_free_wowlan(rdev
);
693 cfg80211_rdev_free_coalesce(rdev
);
695 EXPORT_SYMBOL(wiphy_unregister
);
697 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
699 struct cfg80211_internal_bss
*scan
, *tmp
;
700 struct cfg80211_beacon_registration
*reg
, *treg
;
701 rfkill_destroy(rdev
->rfkill
);
702 list_for_each_entry_safe(reg
, treg
, &rdev
->beacon_registrations
, list
) {
703 list_del(®
->list
);
706 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
707 cfg80211_put_bss(&rdev
->wiphy
, &scan
->pub
);
711 void wiphy_free(struct wiphy
*wiphy
)
713 put_device(&wiphy
->dev
);
715 EXPORT_SYMBOL(wiphy_free
);
717 void wiphy_rfkill_set_hw_state(struct wiphy
*wiphy
, bool blocked
)
719 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
721 if (rfkill_set_hw_state(rdev
->rfkill
, blocked
))
722 schedule_work(&rdev
->rfkill_sync
);
724 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state
);
726 void cfg80211_unregister_wdev(struct wireless_dev
*wdev
)
728 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
732 if (WARN_ON(wdev
->netdev
))
735 list_del_rcu(&wdev
->list
);
736 rdev
->devlist_generation
++;
738 switch (wdev
->iftype
) {
739 case NL80211_IFTYPE_P2P_DEVICE
:
740 cfg80211_stop_p2p_device(rdev
, wdev
);
747 EXPORT_SYMBOL(cfg80211_unregister_wdev
);
749 static struct device_type wiphy_type
= {
753 void cfg80211_update_iface_num(struct cfg80211_registered_device
*rdev
,
754 enum nl80211_iftype iftype
, int num
)
758 rdev
->num_running_ifaces
+= num
;
759 if (iftype
== NL80211_IFTYPE_MONITOR
)
760 rdev
->num_running_monitor_ifaces
+= num
;
763 void cfg80211_leave(struct cfg80211_registered_device
*rdev
,
764 struct wireless_dev
*wdev
)
766 struct net_device
*dev
= wdev
->netdev
;
768 switch (wdev
->iftype
) {
769 case NL80211_IFTYPE_ADHOC
:
770 cfg80211_leave_ibss(rdev
, dev
, true);
772 case NL80211_IFTYPE_P2P_CLIENT
:
773 case NL80211_IFTYPE_STATION
:
774 __cfg80211_stop_sched_scan(rdev
, false);
777 #ifdef CONFIG_CFG80211_WEXT
778 kfree(wdev
->wext
.ie
);
779 wdev
->wext
.ie
= NULL
;
780 wdev
->wext
.ie_len
= 0;
781 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
783 cfg80211_disconnect(rdev
, dev
,
784 WLAN_REASON_DEAUTH_LEAVING
, true);
787 case NL80211_IFTYPE_MESH_POINT
:
788 cfg80211_leave_mesh(rdev
, dev
);
790 case NL80211_IFTYPE_AP
:
791 case NL80211_IFTYPE_P2P_GO
:
792 cfg80211_stop_ap(rdev
, dev
);
798 wdev
->beacon_interval
= 0;
801 static int cfg80211_netdev_notifier_call(struct notifier_block
*nb
,
802 unsigned long state
, void *ptr
)
804 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
805 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
806 struct cfg80211_registered_device
*rdev
;
812 rdev
= wiphy_to_dev(wdev
->wiphy
);
814 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
817 case NETDEV_POST_INIT
:
818 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
820 case NETDEV_REGISTER
:
822 * NB: cannot take rdev->mtx here because this may be
823 * called within code protected by it when interfaces
824 * are added with nl80211.
826 mutex_init(&wdev
->mtx
);
827 INIT_LIST_HEAD(&wdev
->event_list
);
828 spin_lock_init(&wdev
->event_lock
);
829 INIT_LIST_HEAD(&wdev
->mgmt_registrations
);
830 spin_lock_init(&wdev
->mgmt_registrations_lock
);
832 wdev
->identifier
= ++rdev
->wdev_id
;
833 list_add_rcu(&wdev
->list
, &rdev
->wdev_list
);
834 rdev
->devlist_generation
++;
835 /* can only change netns with wiphy */
836 dev
->features
|= NETIF_F_NETNS_LOCAL
;
838 if (sysfs_create_link(&dev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
840 pr_err("failed to add phy80211 symlink to netdev!\n");
843 #ifdef CONFIG_CFG80211_WEXT
844 wdev
->wext
.default_key
= -1;
845 wdev
->wext
.default_mgmt_key
= -1;
846 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
849 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
853 /* allow mac80211 to determine the timeout */
854 wdev
->ps_timeout
= -1;
856 netdev_set_default_ethtool_ops(dev
, &cfg80211_ethtool_ops
);
858 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
859 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
||
860 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
861 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
863 case NETDEV_GOING_DOWN
:
864 cfg80211_leave(rdev
, wdev
);
867 cfg80211_update_iface_num(rdev
, wdev
->iftype
, -1);
868 if (rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
) {
869 if (WARN_ON(!rdev
->scan_req
->notified
))
870 rdev
->scan_req
->aborted
= true;
871 ___cfg80211_scan_done(rdev
, true);
874 if (WARN_ON(rdev
->sched_scan_req
&&
875 rdev
->sched_scan_req
->dev
== wdev
->netdev
)) {
876 __cfg80211_stop_sched_scan(rdev
, false);
880 wake_up(&rdev
->dev_wait
);
883 cfg80211_update_iface_num(rdev
, wdev
->iftype
, 1);
885 switch (wdev
->iftype
) {
886 #ifdef CONFIG_CFG80211_WEXT
887 case NL80211_IFTYPE_ADHOC
:
888 cfg80211_ibss_wext_join(rdev
, wdev
);
890 case NL80211_IFTYPE_STATION
:
891 cfg80211_mgd_wext_connect(rdev
, wdev
);
894 #ifdef CONFIG_MAC80211_MESH
895 case NL80211_IFTYPE_MESH_POINT
:
897 /* backward compat code... */
898 struct mesh_setup setup
;
899 memcpy(&setup
, &default_mesh_setup
,
901 /* back compat only needed for mesh_id */
902 setup
.mesh_id
= wdev
->ssid
;
903 setup
.mesh_id_len
= wdev
->mesh_id_up_len
;
904 if (wdev
->mesh_id_up_len
)
905 __cfg80211_join_mesh(rdev
, dev
,
907 &default_mesh_config
);
918 * Configure power management to the driver here so that its
919 * correctly set also after interface type changes etc.
921 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
922 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
) &&
923 rdev
->ops
->set_power_mgmt
)
924 if (rdev_set_power_mgmt(rdev
, dev
, wdev
->ps
,
926 /* assume this means it's off */
930 case NETDEV_UNREGISTER
:
932 * It is possible to get NETDEV_UNREGISTER
933 * multiple times. To detect that, check
934 * that the interface is still on the list
935 * of registered interfaces, and only then
936 * remove and clean it up.
938 if (!list_empty(&wdev
->list
)) {
939 sysfs_remove_link(&dev
->dev
.kobj
, "phy80211");
940 list_del_rcu(&wdev
->list
);
941 rdev
->devlist_generation
++;
942 cfg80211_mlme_purge_registrations(wdev
);
943 #ifdef CONFIG_CFG80211_WEXT
944 kfree(wdev
->wext
.keys
);
948 * synchronise (so that we won't find this netdev
949 * from other code any more) and then clear the list
950 * head so that the above code can safely check for
951 * !list_empty() to avoid double-cleanup.
954 INIT_LIST_HEAD(&wdev
->list
);
956 * Ensure that all events have been processed and
959 cfg80211_process_wdev_events(wdev
);
961 if (WARN_ON(wdev
->current_bss
)) {
962 cfg80211_unhold_bss(wdev
->current_bss
);
963 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
964 wdev
->current_bss
= NULL
;
968 if (!(wdev
->wiphy
->interface_modes
& BIT(wdev
->iftype
)))
969 return notifier_from_errno(-EOPNOTSUPP
);
970 ret
= cfg80211_can_add_interface(rdev
, wdev
->iftype
);
972 return notifier_from_errno(ret
);
979 static struct notifier_block cfg80211_netdev_notifier
= {
980 .notifier_call
= cfg80211_netdev_notifier_call
,
983 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
985 struct cfg80211_registered_device
*rdev
;
988 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
989 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
990 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
995 static struct pernet_operations cfg80211_pernet_ops
= {
996 .exit
= cfg80211_pernet_exit
,
999 static int __init
cfg80211_init(void)
1003 err
= register_pernet_device(&cfg80211_pernet_ops
);
1005 goto out_fail_pernet
;
1007 err
= wiphy_sysfs_init();
1009 goto out_fail_sysfs
;
1011 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
1013 goto out_fail_notifier
;
1015 err
= nl80211_init();
1017 goto out_fail_nl80211
;
1019 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
1021 err
= regulatory_init();
1025 cfg80211_wq
= create_singlethread_workqueue("cfg80211");
1036 debugfs_remove(ieee80211_debugfs_dir
);
1038 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1042 unregister_pernet_device(&cfg80211_pernet_ops
);
1046 subsys_initcall(cfg80211_init
);
1048 static void __exit
cfg80211_exit(void)
1050 debugfs_remove(ieee80211_debugfs_dir
);
1052 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1055 unregister_pernet_device(&cfg80211_pernet_ops
);
1056 destroy_workqueue(cfg80211_wq
);
1058 module_exit(cfg80211_exit
);