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");
38 /* RCU-protected (and cfg80211_mutex for writers) */
39 LIST_HEAD(cfg80211_rdev_list
);
40 int cfg80211_rdev_list_generation
;
42 DEFINE_MUTEX(cfg80211_mutex
);
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 /* requires cfg80211_mutex to be held! */
56 struct cfg80211_registered_device
*cfg80211_rdev_by_wiphy_idx(int wiphy_idx
)
58 struct cfg80211_registered_device
*result
= NULL
, *rdev
;
60 assert_cfg80211_lock();
62 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
63 if (rdev
->wiphy_idx
== wiphy_idx
) {
72 int get_wiphy_idx(struct wiphy
*wiphy
)
74 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
76 return rdev
->wiphy_idx
;
79 /* requires cfg80211_rdev_mutex to be held! */
80 struct wiphy
*wiphy_idx_to_wiphy(int wiphy_idx
)
82 struct cfg80211_registered_device
*rdev
;
84 assert_cfg80211_lock();
86 rdev
= cfg80211_rdev_by_wiphy_idx(wiphy_idx
);
92 struct cfg80211_registered_device
*
93 cfg80211_get_dev_from_ifindex(struct net
*net
, int ifindex
)
95 struct cfg80211_registered_device
*rdev
= ERR_PTR(-ENODEV
);
96 struct net_device
*dev
;
98 mutex_lock(&cfg80211_mutex
);
99 dev
= dev_get_by_index(net
, ifindex
);
102 if (dev
->ieee80211_ptr
) {
103 rdev
= wiphy_to_dev(dev
->ieee80211_ptr
->wiphy
);
104 mutex_lock(&rdev
->mtx
);
106 rdev
= ERR_PTR(-ENODEV
);
109 mutex_unlock(&cfg80211_mutex
);
113 /* requires cfg80211_mutex to be held */
114 int cfg80211_dev_rename(struct cfg80211_registered_device
*rdev
,
117 struct cfg80211_registered_device
*rdev2
;
118 int wiphy_idx
, taken
= -1, result
, digits
;
120 assert_cfg80211_lock();
122 /* prohibit calling the thing phy%d when %d is not its number */
123 sscanf(newname
, PHY_NAME
"%d%n", &wiphy_idx
, &taken
);
124 if (taken
== strlen(newname
) && wiphy_idx
!= rdev
->wiphy_idx
) {
125 /* count number of places needed to print wiphy_idx */
127 while (wiphy_idx
/= 10)
130 * deny the name if it is phy<idx> where <idx> is printed
131 * without leading zeroes. taken == strlen(newname) here
133 if (taken
== strlen(PHY_NAME
) + digits
)
138 /* Ignore nop renames */
139 if (strcmp(newname
, dev_name(&rdev
->wiphy
.dev
)) == 0)
142 /* Ensure another device does not already have this name. */
143 list_for_each_entry(rdev2
, &cfg80211_rdev_list
, list
)
144 if (strcmp(newname
, dev_name(&rdev2
->wiphy
.dev
)) == 0)
147 result
= device_rename(&rdev
->wiphy
.dev
, newname
);
151 if (rdev
->wiphy
.debugfsdir
&&
152 !debugfs_rename(rdev
->wiphy
.debugfsdir
->d_parent
,
153 rdev
->wiphy
.debugfsdir
,
154 rdev
->wiphy
.debugfsdir
->d_parent
,
156 pr_err("failed to rename debugfs dir to %s!\n", newname
);
158 nl80211_notify_dev_rename(rdev
);
163 int cfg80211_switch_netns(struct cfg80211_registered_device
*rdev
,
166 struct wireless_dev
*wdev
;
169 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
))
172 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
175 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
176 err
= dev_change_net_namespace(wdev
->netdev
, net
, "wlan%d");
179 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
183 /* failed -- clean up to old netns */
184 net
= wiphy_net(&rdev
->wiphy
);
186 list_for_each_entry_continue_reverse(wdev
, &rdev
->wdev_list
,
190 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
191 err
= dev_change_net_namespace(wdev
->netdev
, net
,
194 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
200 wiphy_net_set(&rdev
->wiphy
, net
);
202 err
= device_rename(&rdev
->wiphy
.dev
, dev_name(&rdev
->wiphy
.dev
));
208 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
210 struct cfg80211_registered_device
*rdev
= data
;
212 rdev_rfkill_poll(rdev
);
215 void cfg80211_stop_p2p_device(struct cfg80211_registered_device
*rdev
,
216 struct wireless_dev
*wdev
)
218 lockdep_assert_held(&rdev
->devlist_mtx
);
219 lockdep_assert_held(&rdev
->sched_scan_mtx
);
221 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
))
224 if (!wdev
->p2p_started
)
227 rdev_stop_p2p_device(rdev
, wdev
);
228 wdev
->p2p_started
= false;
232 if (rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
) {
233 bool busy
= work_busy(&rdev
->scan_done_wk
);
236 * If the work isn't pending or running (in which case it would
237 * be waiting for the lock we hold) the driver didn't properly
238 * cancel the scan when the interface was removed. In this case
239 * warn and leak the scan request object to not crash later.
243 rdev
->scan_req
->aborted
= true;
244 ___cfg80211_scan_done(rdev
, !busy
);
248 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
250 struct cfg80211_registered_device
*rdev
= data
;
251 struct wireless_dev
*wdev
;
258 /* read-only iteration need not hold the devlist_mtx */
260 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
262 dev_close(wdev
->netdev
);
265 /* otherwise, check iftype */
266 switch (wdev
->iftype
) {
267 case NL80211_IFTYPE_P2P_DEVICE
:
268 /* but this requires it */
269 mutex_lock(&rdev
->devlist_mtx
);
270 mutex_lock(&rdev
->sched_scan_mtx
);
271 cfg80211_stop_p2p_device(rdev
, wdev
);
272 mutex_unlock(&rdev
->sched_scan_mtx
);
273 mutex_unlock(&rdev
->devlist_mtx
);
285 static void cfg80211_rfkill_sync_work(struct work_struct
*work
)
287 struct cfg80211_registered_device
*rdev
;
289 rdev
= container_of(work
, struct cfg80211_registered_device
, rfkill_sync
);
290 cfg80211_rfkill_set_block(rdev
, rfkill_blocked(rdev
->rfkill
));
293 static void cfg80211_event_work(struct work_struct
*work
)
295 struct cfg80211_registered_device
*rdev
;
297 rdev
= container_of(work
, struct cfg80211_registered_device
,
301 cfg80211_lock_rdev(rdev
);
303 cfg80211_process_rdev_events(rdev
);
304 cfg80211_unlock_rdev(rdev
);
308 /* exported functions */
310 struct wiphy
*wiphy_new(const struct cfg80211_ops
*ops
, int sizeof_priv
)
312 static int wiphy_counter
;
314 struct cfg80211_registered_device
*rdev
;
317 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
318 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
319 WARN_ON(ops
->connect
&& !ops
->disconnect
);
320 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
321 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
322 WARN_ON(ops
->add_station
&& !ops
->del_station
);
323 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
324 WARN_ON(ops
->join_mesh
&& !ops
->leave_mesh
);
326 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
328 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
334 mutex_lock(&cfg80211_mutex
);
336 rdev
->wiphy_idx
= wiphy_counter
++;
338 if (unlikely(rdev
->wiphy_idx
< 0)) {
340 mutex_unlock(&cfg80211_mutex
);
346 mutex_unlock(&cfg80211_mutex
);
348 /* give it a proper name */
349 dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
351 mutex_init(&rdev
->mtx
);
352 mutex_init(&rdev
->devlist_mtx
);
353 mutex_init(&rdev
->sched_scan_mtx
);
354 INIT_LIST_HEAD(&rdev
->wdev_list
);
355 INIT_LIST_HEAD(&rdev
->beacon_registrations
);
356 spin_lock_init(&rdev
->beacon_registrations_lock
);
357 spin_lock_init(&rdev
->bss_lock
);
358 INIT_LIST_HEAD(&rdev
->bss_list
);
359 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
360 INIT_WORK(&rdev
->sched_scan_results_wk
, __cfg80211_sched_scan_results
);
361 INIT_DELAYED_WORK(&rdev
->dfs_update_channels_wk
,
362 cfg80211_dfs_channels_update_work
);
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 wiphy_net_set(&rdev
->wiphy
, &init_net
);
377 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
378 rdev
->rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
379 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
380 &rdev
->rfkill_ops
, rdev
);
387 INIT_WORK(&rdev
->rfkill_sync
, cfg80211_rfkill_sync_work
);
388 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
389 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
391 init_waitqueue_head(&rdev
->dev_wait
);
394 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
395 * Fragmentation and RTS threshold are disabled by default with the
398 rdev
->wiphy
.retry_short
= 7;
399 rdev
->wiphy
.retry_long
= 4;
400 rdev
->wiphy
.frag_threshold
= (u32
) -1;
401 rdev
->wiphy
.rts_threshold
= (u32
) -1;
402 rdev
->wiphy
.coverage_class
= 0;
404 rdev
->wiphy
.features
= NL80211_FEATURE_SCAN_FLUSH
;
408 EXPORT_SYMBOL(wiphy_new
);
410 static int wiphy_verify_combinations(struct wiphy
*wiphy
)
412 const struct ieee80211_iface_combination
*c
;
415 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
419 c
= &wiphy
->iface_combinations
[i
];
422 * Combinations with just one interface aren't real,
423 * however we make an exception for DFS.
425 if (WARN_ON((c
->max_interfaces
< 2) && !c
->radar_detect_widths
))
428 /* Need at least one channel */
429 if (WARN_ON(!c
->num_different_channels
))
433 * Put a sane limit on maximum number of different
434 * channels to simplify channel accounting code.
436 if (WARN_ON(c
->num_different_channels
>
437 CFG80211_MAX_NUM_DIFFERENT_CHANNELS
))
440 /* DFS only works on one channel. */
441 if (WARN_ON(c
->radar_detect_widths
&&
442 (c
->num_different_channels
> 1)))
445 if (WARN_ON(!c
->n_limits
))
448 for (j
= 0; j
< c
->n_limits
; j
++) {
449 u16 types
= c
->limits
[j
].types
;
452 * interface types shouldn't overlap, this is
453 * used in cfg80211_can_change_interface()
455 if (WARN_ON(types
& all_iftypes
))
457 all_iftypes
|= types
;
459 if (WARN_ON(!c
->limits
[j
].max
))
462 /* Shouldn't list software iftypes in combinations! */
463 if (WARN_ON(wiphy
->software_iftypes
& types
))
466 /* Only a single P2P_DEVICE can be allowed */
467 if (WARN_ON(types
& BIT(NL80211_IFTYPE_P2P_DEVICE
) &&
468 c
->limits
[j
].max
> 1))
471 cnt
+= c
->limits
[j
].max
;
473 * Don't advertise an unsupported type
476 if (WARN_ON((wiphy
->interface_modes
& types
) != types
))
480 /* You can't even choose that many! */
481 if (WARN_ON(cnt
< c
->max_interfaces
))
488 int wiphy_register(struct wiphy
*wiphy
)
490 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
492 enum ieee80211_band band
;
493 struct ieee80211_supported_band
*sband
;
494 bool have_band
= false;
496 u16 ifmodes
= wiphy
->interface_modes
;
499 if (WARN_ON((wiphy
->wowlan
.flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
500 !(wiphy
->wowlan
.flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
)))
504 if (WARN_ON(wiphy
->ap_sme_capa
&&
505 !(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
)))
508 if (WARN_ON(wiphy
->addresses
&& !wiphy
->n_addresses
))
511 if (WARN_ON(wiphy
->addresses
&&
512 !is_zero_ether_addr(wiphy
->perm_addr
) &&
513 memcmp(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
,
517 if (WARN_ON(wiphy
->max_acl_mac_addrs
&&
518 (!(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
) ||
519 !rdev
->ops
->set_mac_acl
)))
522 if (wiphy
->addresses
)
523 memcpy(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
, ETH_ALEN
);
525 /* sanity check ifmodes */
527 ifmodes
&= ((1 << NUM_NL80211_IFTYPES
) - 1) & ~1;
528 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
529 wiphy
->interface_modes
= ifmodes
;
531 res
= wiphy_verify_combinations(wiphy
);
535 /* sanity check supported bands/channels */
536 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
537 sband
= wiphy
->bands
[band
];
542 if (WARN_ON(!sband
->n_channels
))
545 * on 60gHz band, there are no legacy rates, so
548 if (WARN_ON(band
!= IEEE80211_BAND_60GHZ
&&
553 * Since cfg80211_disable_40mhz_24ghz is global, we can
554 * modify the sband's ht data even if the driver uses a
555 * global structure for that.
557 if (cfg80211_disable_40mhz_24ghz
&&
558 band
== IEEE80211_BAND_2GHZ
&&
559 sband
->ht_cap
.ht_supported
) {
560 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
561 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SGI_40
;
565 * Since we use a u32 for rate bitmaps in
566 * ieee80211_get_response_rate, we cannot
567 * have more than 32 legacy rates.
569 if (WARN_ON(sband
->n_bitrates
> 32))
572 for (i
= 0; i
< sband
->n_channels
; i
++) {
573 sband
->channels
[i
].orig_flags
=
574 sband
->channels
[i
].flags
;
575 sband
->channels
[i
].orig_mag
= INT_MAX
;
576 sband
->channels
[i
].orig_mpwr
=
577 sband
->channels
[i
].max_power
;
578 sband
->channels
[i
].band
= band
;
590 if (rdev
->wiphy
.wowlan
.n_patterns
) {
591 if (WARN_ON(!rdev
->wiphy
.wowlan
.pattern_min_len
||
592 rdev
->wiphy
.wowlan
.pattern_min_len
>
593 rdev
->wiphy
.wowlan
.pattern_max_len
))
598 /* check and set up bitrates */
599 ieee80211_set_bitrate_flags(wiphy
);
601 mutex_lock(&cfg80211_mutex
);
603 res
= device_add(&rdev
->wiphy
.dev
);
605 mutex_unlock(&cfg80211_mutex
);
609 /* set up regulatory info */
610 wiphy_regulatory_register(wiphy
);
612 list_add_rcu(&rdev
->list
, &cfg80211_rdev_list
);
613 cfg80211_rdev_list_generation
++;
616 rdev
->wiphy
.debugfsdir
=
617 debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
618 ieee80211_debugfs_dir
);
619 if (IS_ERR(rdev
->wiphy
.debugfsdir
))
620 rdev
->wiphy
.debugfsdir
= NULL
;
622 if (wiphy
->flags
& WIPHY_FLAG_CUSTOM_REGULATORY
) {
623 struct regulatory_request request
;
625 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
626 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
627 request
.alpha2
[0] = '9';
628 request
.alpha2
[1] = '9';
630 nl80211_send_reg_change_event(&request
);
633 cfg80211_debugfs_rdev_add(rdev
);
634 mutex_unlock(&cfg80211_mutex
);
637 * due to a locking dependency this has to be outside of the
638 * cfg80211_mutex lock
640 res
= rfkill_register(rdev
->rfkill
);
642 device_del(&rdev
->wiphy
.dev
);
644 mutex_lock(&cfg80211_mutex
);
645 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
646 list_del_rcu(&rdev
->list
);
647 wiphy_regulatory_deregister(wiphy
);
648 mutex_unlock(&cfg80211_mutex
);
653 rdev
->wiphy
.registered
= true;
657 EXPORT_SYMBOL(wiphy_register
);
659 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
661 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
663 if (!rdev
->ops
->rfkill_poll
)
665 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
666 rfkill_resume_polling(rdev
->rfkill
);
668 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
670 void wiphy_rfkill_stop_polling(struct wiphy
*wiphy
)
672 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
674 rfkill_pause_polling(rdev
->rfkill
);
676 EXPORT_SYMBOL(wiphy_rfkill_stop_polling
);
678 void wiphy_unregister(struct wiphy
*wiphy
)
680 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
683 rdev
->wiphy
.registered
= false;
686 rfkill_unregister(rdev
->rfkill
);
688 /* protect the device list */
689 mutex_lock(&cfg80211_mutex
);
691 wait_event(rdev
->dev_wait
, ({
693 mutex_lock(&rdev
->devlist_mtx
);
694 __count
= rdev
->opencount
;
695 mutex_unlock(&rdev
->devlist_mtx
);
698 mutex_lock(&rdev
->devlist_mtx
);
699 BUG_ON(!list_empty(&rdev
->wdev_list
));
700 mutex_unlock(&rdev
->devlist_mtx
);
703 * First remove the hardware from everywhere, this makes
704 * it impossible to find from userspace.
706 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
707 list_del_rcu(&rdev
->list
);
711 * Try to grab rdev->mtx. If a command is still in progress,
712 * hopefully the driver will refuse it since it's tearing
713 * down the device already. We wait for this command to complete
714 * before unlinking the item from the list.
715 * Note: as codified by the BUG_ON above we cannot get here if
716 * a virtual interface is still present. Hence, we can only get
717 * to lock contention here if userspace issues a command that
718 * identified the hardware by wiphy index.
720 cfg80211_lock_rdev(rdev
);
722 cfg80211_unlock_rdev(rdev
);
725 * If this device got a regulatory hint tell core its
726 * free to listen now to a new shiny device regulatory hint
728 wiphy_regulatory_deregister(wiphy
);
730 cfg80211_rdev_list_generation
++;
731 device_del(&rdev
->wiphy
.dev
);
733 mutex_unlock(&cfg80211_mutex
);
735 flush_work(&rdev
->scan_done_wk
);
736 cancel_work_sync(&rdev
->conn_work
);
737 flush_work(&rdev
->event_work
);
738 cancel_delayed_work_sync(&rdev
->dfs_update_channels_wk
);
740 if (rdev
->wowlan
&& rdev
->ops
->set_wakeup
)
741 rdev_set_wakeup(rdev
, false);
742 cfg80211_rdev_free_wowlan(rdev
);
744 EXPORT_SYMBOL(wiphy_unregister
);
746 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
748 struct cfg80211_internal_bss
*scan
, *tmp
;
749 struct cfg80211_beacon_registration
*reg
, *treg
;
750 rfkill_destroy(rdev
->rfkill
);
751 mutex_destroy(&rdev
->mtx
);
752 mutex_destroy(&rdev
->devlist_mtx
);
753 mutex_destroy(&rdev
->sched_scan_mtx
);
754 list_for_each_entry_safe(reg
, treg
, &rdev
->beacon_registrations
, list
) {
755 list_del(®
->list
);
758 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
759 cfg80211_put_bss(&rdev
->wiphy
, &scan
->pub
);
763 void wiphy_free(struct wiphy
*wiphy
)
765 put_device(&wiphy
->dev
);
767 EXPORT_SYMBOL(wiphy_free
);
769 void wiphy_rfkill_set_hw_state(struct wiphy
*wiphy
, bool blocked
)
771 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
773 if (rfkill_set_hw_state(rdev
->rfkill
, blocked
))
774 schedule_work(&rdev
->rfkill_sync
);
776 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state
);
778 static void wdev_cleanup_work(struct work_struct
*work
)
780 struct wireless_dev
*wdev
;
781 struct cfg80211_registered_device
*rdev
;
783 wdev
= container_of(work
, struct wireless_dev
, cleanup_work
);
784 rdev
= wiphy_to_dev(wdev
->wiphy
);
786 mutex_lock(&rdev
->sched_scan_mtx
);
788 if (WARN_ON(rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
)) {
789 rdev
->scan_req
->aborted
= true;
790 ___cfg80211_scan_done(rdev
, true);
793 if (WARN_ON(rdev
->sched_scan_req
&&
794 rdev
->sched_scan_req
->dev
== wdev
->netdev
)) {
795 __cfg80211_stop_sched_scan(rdev
, false);
798 mutex_unlock(&rdev
->sched_scan_mtx
);
800 mutex_lock(&rdev
->devlist_mtx
);
802 mutex_unlock(&rdev
->devlist_mtx
);
803 wake_up(&rdev
->dev_wait
);
805 dev_put(wdev
->netdev
);
808 void cfg80211_unregister_wdev(struct wireless_dev
*wdev
)
810 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
814 if (WARN_ON(wdev
->netdev
))
817 mutex_lock(&rdev
->devlist_mtx
);
818 mutex_lock(&rdev
->sched_scan_mtx
);
819 list_del_rcu(&wdev
->list
);
820 rdev
->devlist_generation
++;
822 switch (wdev
->iftype
) {
823 case NL80211_IFTYPE_P2P_DEVICE
:
824 cfg80211_stop_p2p_device(rdev
, wdev
);
830 mutex_unlock(&rdev
->sched_scan_mtx
);
831 mutex_unlock(&rdev
->devlist_mtx
);
833 EXPORT_SYMBOL(cfg80211_unregister_wdev
);
835 static struct device_type wiphy_type
= {
839 void cfg80211_update_iface_num(struct cfg80211_registered_device
*rdev
,
840 enum nl80211_iftype iftype
, int num
)
844 rdev
->num_running_ifaces
+= num
;
845 if (iftype
== NL80211_IFTYPE_MONITOR
)
846 rdev
->num_running_monitor_ifaces
+= num
;
849 void cfg80211_leave(struct cfg80211_registered_device
*rdev
,
850 struct wireless_dev
*wdev
)
852 struct net_device
*dev
= wdev
->netdev
;
854 switch (wdev
->iftype
) {
855 case NL80211_IFTYPE_ADHOC
:
856 cfg80211_leave_ibss(rdev
, dev
, true);
858 case NL80211_IFTYPE_P2P_CLIENT
:
859 case NL80211_IFTYPE_STATION
:
860 mutex_lock(&rdev
->sched_scan_mtx
);
861 __cfg80211_stop_sched_scan(rdev
, false);
862 mutex_unlock(&rdev
->sched_scan_mtx
);
865 #ifdef CONFIG_CFG80211_WEXT
866 kfree(wdev
->wext
.ie
);
867 wdev
->wext
.ie
= NULL
;
868 wdev
->wext
.ie_len
= 0;
869 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
871 __cfg80211_disconnect(rdev
, dev
,
872 WLAN_REASON_DEAUTH_LEAVING
, true);
875 case NL80211_IFTYPE_MESH_POINT
:
876 cfg80211_leave_mesh(rdev
, dev
);
878 case NL80211_IFTYPE_AP
:
879 case NL80211_IFTYPE_P2P_GO
:
880 cfg80211_stop_ap(rdev
, dev
);
886 wdev
->beacon_interval
= 0;
889 static int cfg80211_netdev_notifier_call(struct notifier_block
*nb
,
893 struct net_device
*dev
= ndev
;
894 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
895 struct cfg80211_registered_device
*rdev
;
901 rdev
= wiphy_to_dev(wdev
->wiphy
);
903 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
906 case NETDEV_POST_INIT
:
907 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
909 case NETDEV_REGISTER
:
911 * NB: cannot take rdev->mtx here because this may be
912 * called within code protected by it when interfaces
913 * are added with nl80211.
915 mutex_init(&wdev
->mtx
);
916 INIT_WORK(&wdev
->cleanup_work
, wdev_cleanup_work
);
917 INIT_LIST_HEAD(&wdev
->event_list
);
918 spin_lock_init(&wdev
->event_lock
);
919 INIT_LIST_HEAD(&wdev
->mgmt_registrations
);
920 spin_lock_init(&wdev
->mgmt_registrations_lock
);
922 mutex_lock(&rdev
->devlist_mtx
);
923 wdev
->identifier
= ++rdev
->wdev_id
;
924 list_add_rcu(&wdev
->list
, &rdev
->wdev_list
);
925 rdev
->devlist_generation
++;
926 /* can only change netns with wiphy */
927 dev
->features
|= NETIF_F_NETNS_LOCAL
;
929 if (sysfs_create_link(&dev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
931 pr_err("failed to add phy80211 symlink to netdev!\n");
934 wdev
->sme_state
= CFG80211_SME_IDLE
;
935 mutex_unlock(&rdev
->devlist_mtx
);
936 #ifdef CONFIG_CFG80211_WEXT
937 wdev
->wext
.default_key
= -1;
938 wdev
->wext
.default_mgmt_key
= -1;
939 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
942 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
946 /* allow mac80211 to determine the timeout */
947 wdev
->ps_timeout
= -1;
949 netdev_set_default_ethtool_ops(dev
, &cfg80211_ethtool_ops
);
951 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
952 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
||
953 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
954 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
956 case NETDEV_GOING_DOWN
:
957 cfg80211_leave(rdev
, wdev
);
960 cfg80211_update_iface_num(rdev
, wdev
->iftype
, -1);
962 queue_work(cfg80211_wq
, &wdev
->cleanup_work
);
966 * If we have a really quick DOWN/UP succession we may
967 * have this work still pending ... cancel it and see
968 * if it was pending, in which case we need to account
969 * for some of the work it would have done.
971 if (cancel_work_sync(&wdev
->cleanup_work
)) {
972 mutex_lock(&rdev
->devlist_mtx
);
974 mutex_unlock(&rdev
->devlist_mtx
);
977 cfg80211_update_iface_num(rdev
, wdev
->iftype
, 1);
978 cfg80211_lock_rdev(rdev
);
979 mutex_lock(&rdev
->devlist_mtx
);
980 mutex_lock(&rdev
->sched_scan_mtx
);
982 switch (wdev
->iftype
) {
983 #ifdef CONFIG_CFG80211_WEXT
984 case NL80211_IFTYPE_ADHOC
:
985 cfg80211_ibss_wext_join(rdev
, wdev
);
987 case NL80211_IFTYPE_STATION
:
988 cfg80211_mgd_wext_connect(rdev
, wdev
);
991 #ifdef CONFIG_MAC80211_MESH
992 case NL80211_IFTYPE_MESH_POINT
:
994 /* backward compat code... */
995 struct mesh_setup setup
;
996 memcpy(&setup
, &default_mesh_setup
,
998 /* back compat only needed for mesh_id */
999 setup
.mesh_id
= wdev
->ssid
;
1000 setup
.mesh_id_len
= wdev
->mesh_id_up_len
;
1001 if (wdev
->mesh_id_up_len
)
1002 __cfg80211_join_mesh(rdev
, dev
,
1004 &default_mesh_config
);
1012 mutex_unlock(&rdev
->sched_scan_mtx
);
1014 mutex_unlock(&rdev
->devlist_mtx
);
1015 cfg80211_unlock_rdev(rdev
);
1018 * Configure power management to the driver here so that its
1019 * correctly set also after interface type changes etc.
1021 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
1022 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
) &&
1023 rdev
->ops
->set_power_mgmt
)
1024 if (rdev_set_power_mgmt(rdev
, dev
, wdev
->ps
,
1025 wdev
->ps_timeout
)) {
1026 /* assume this means it's off */
1030 case NETDEV_UNREGISTER
:
1032 * NB: cannot take rdev->mtx here because this may be
1033 * called within code protected by it when interfaces
1034 * are removed with nl80211.
1036 mutex_lock(&rdev
->devlist_mtx
);
1038 * It is possible to get NETDEV_UNREGISTER
1039 * multiple times. To detect that, check
1040 * that the interface is still on the list
1041 * of registered interfaces, and only then
1042 * remove and clean it up.
1044 if (!list_empty(&wdev
->list
)) {
1045 sysfs_remove_link(&dev
->dev
.kobj
, "phy80211");
1046 list_del_rcu(&wdev
->list
);
1047 rdev
->devlist_generation
++;
1048 cfg80211_mlme_purge_registrations(wdev
);
1049 #ifdef CONFIG_CFG80211_WEXT
1050 kfree(wdev
->wext
.keys
);
1053 mutex_unlock(&rdev
->devlist_mtx
);
1055 * synchronise (so that we won't find this netdev
1056 * from other code any more) and then clear the list
1057 * head so that the above code can safely check for
1058 * !list_empty() to avoid double-cleanup.
1061 INIT_LIST_HEAD(&wdev
->list
);
1063 * Ensure that all events have been processed and
1066 cfg80211_process_wdev_events(wdev
);
1069 if (!(wdev
->wiphy
->interface_modes
& BIT(wdev
->iftype
)))
1070 return notifier_from_errno(-EOPNOTSUPP
);
1071 if (rfkill_blocked(rdev
->rfkill
))
1072 return notifier_from_errno(-ERFKILL
);
1073 mutex_lock(&rdev
->devlist_mtx
);
1074 ret
= cfg80211_can_add_interface(rdev
, wdev
->iftype
);
1075 mutex_unlock(&rdev
->devlist_mtx
);
1077 return notifier_from_errno(ret
);
1084 static struct notifier_block cfg80211_netdev_notifier
= {
1085 .notifier_call
= cfg80211_netdev_notifier_call
,
1088 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
1090 struct cfg80211_registered_device
*rdev
;
1093 mutex_lock(&cfg80211_mutex
);
1094 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
1095 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
1096 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
1098 mutex_unlock(&cfg80211_mutex
);
1102 static struct pernet_operations cfg80211_pernet_ops
= {
1103 .exit
= cfg80211_pernet_exit
,
1106 static int __init
cfg80211_init(void)
1110 err
= register_pernet_device(&cfg80211_pernet_ops
);
1112 goto out_fail_pernet
;
1114 err
= wiphy_sysfs_init();
1116 goto out_fail_sysfs
;
1118 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
1120 goto out_fail_notifier
;
1122 err
= nl80211_init();
1124 goto out_fail_nl80211
;
1126 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
1128 err
= regulatory_init();
1132 cfg80211_wq
= create_singlethread_workqueue("cfg80211");
1143 debugfs_remove(ieee80211_debugfs_dir
);
1145 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1149 unregister_pernet_device(&cfg80211_pernet_ops
);
1153 subsys_initcall(cfg80211_init
);
1155 static void __exit
cfg80211_exit(void)
1157 debugfs_remove(ieee80211_debugfs_dir
);
1159 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1162 unregister_pernet_device(&cfg80211_pernet_ops
);
1163 destroy_workqueue(cfg80211_wq
);
1165 module_exit(cfg80211_exit
);