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 struct cfg80211_registered_device
*
100 cfg80211_get_dev_from_ifindex(struct net
*net
, int ifindex
)
102 struct cfg80211_registered_device
*rdev
= ERR_PTR(-ENODEV
);
103 struct net_device
*dev
;
105 mutex_lock(&cfg80211_mutex
);
106 dev
= dev_get_by_index(net
, ifindex
);
109 if (dev
->ieee80211_ptr
) {
110 rdev
= wiphy_to_dev(dev
->ieee80211_ptr
->wiphy
);
111 mutex_lock(&rdev
->mtx
);
113 rdev
= ERR_PTR(-ENODEV
);
116 mutex_unlock(&cfg80211_mutex
);
120 /* requires cfg80211_mutex to be held */
121 int cfg80211_dev_rename(struct cfg80211_registered_device
*rdev
,
124 struct cfg80211_registered_device
*rdev2
;
125 int wiphy_idx
, taken
= -1, result
, digits
;
127 assert_cfg80211_lock();
129 /* prohibit calling the thing phy%d when %d is not its number */
130 sscanf(newname
, PHY_NAME
"%d%n", &wiphy_idx
, &taken
);
131 if (taken
== strlen(newname
) && wiphy_idx
!= rdev
->wiphy_idx
) {
132 /* count number of places needed to print wiphy_idx */
134 while (wiphy_idx
/= 10)
137 * deny the name if it is phy<idx> where <idx> is printed
138 * without leading zeroes. taken == strlen(newname) here
140 if (taken
== strlen(PHY_NAME
) + digits
)
145 /* Ignore nop renames */
146 if (strcmp(newname
, dev_name(&rdev
->wiphy
.dev
)) == 0)
149 /* Ensure another device does not already have this name. */
150 list_for_each_entry(rdev2
, &cfg80211_rdev_list
, list
)
151 if (strcmp(newname
, dev_name(&rdev2
->wiphy
.dev
)) == 0)
154 result
= device_rename(&rdev
->wiphy
.dev
, newname
);
158 if (rdev
->wiphy
.debugfsdir
&&
159 !debugfs_rename(rdev
->wiphy
.debugfsdir
->d_parent
,
160 rdev
->wiphy
.debugfsdir
,
161 rdev
->wiphy
.debugfsdir
->d_parent
,
163 pr_err("failed to rename debugfs dir to %s!\n", newname
);
165 nl80211_notify_dev_rename(rdev
);
170 int cfg80211_switch_netns(struct cfg80211_registered_device
*rdev
,
173 struct wireless_dev
*wdev
;
176 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
))
179 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
) {
180 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
181 err
= dev_change_net_namespace(wdev
->netdev
, net
, "wlan%d");
184 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
188 /* failed -- clean up to old netns */
189 net
= wiphy_net(&rdev
->wiphy
);
191 list_for_each_entry_continue_reverse(wdev
, &rdev
->netdev_list
,
193 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
194 err
= dev_change_net_namespace(wdev
->netdev
, net
,
197 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
203 wiphy_net_set(&rdev
->wiphy
, net
);
205 err
= device_rename(&rdev
->wiphy
.dev
, dev_name(&rdev
->wiphy
.dev
));
211 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
213 struct cfg80211_registered_device
*rdev
= data
;
215 rdev
->ops
->rfkill_poll(&rdev
->wiphy
);
218 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
220 struct cfg80211_registered_device
*rdev
= data
;
221 struct wireless_dev
*wdev
;
227 mutex_lock(&rdev
->devlist_mtx
);
229 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
)
230 dev_close(wdev
->netdev
);
232 mutex_unlock(&rdev
->devlist_mtx
);
238 static void cfg80211_rfkill_sync_work(struct work_struct
*work
)
240 struct cfg80211_registered_device
*rdev
;
242 rdev
= container_of(work
, struct cfg80211_registered_device
, rfkill_sync
);
243 cfg80211_rfkill_set_block(rdev
, rfkill_blocked(rdev
->rfkill
));
246 static void cfg80211_event_work(struct work_struct
*work
)
248 struct cfg80211_registered_device
*rdev
;
250 rdev
= container_of(work
, struct cfg80211_registered_device
,
254 cfg80211_lock_rdev(rdev
);
256 cfg80211_process_rdev_events(rdev
);
257 cfg80211_unlock_rdev(rdev
);
261 /* exported functions */
263 struct wiphy
*wiphy_new(const struct cfg80211_ops
*ops
, int sizeof_priv
)
265 static int wiphy_counter
;
267 struct cfg80211_registered_device
*rdev
;
270 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
271 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
272 WARN_ON(ops
->connect
&& !ops
->disconnect
);
273 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
274 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
275 WARN_ON(ops
->add_station
&& !ops
->del_station
);
276 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
277 WARN_ON(ops
->join_mesh
&& !ops
->leave_mesh
);
279 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
281 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
287 mutex_lock(&cfg80211_mutex
);
289 rdev
->wiphy_idx
= wiphy_counter
++;
291 if (unlikely(!wiphy_idx_valid(rdev
->wiphy_idx
))) {
293 mutex_unlock(&cfg80211_mutex
);
299 mutex_unlock(&cfg80211_mutex
);
301 /* give it a proper name */
302 dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
304 mutex_init(&rdev
->mtx
);
305 mutex_init(&rdev
->devlist_mtx
);
306 mutex_init(&rdev
->sched_scan_mtx
);
307 INIT_LIST_HEAD(&rdev
->netdev_list
);
308 spin_lock_init(&rdev
->bss_lock
);
309 INIT_LIST_HEAD(&rdev
->bss_list
);
310 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
311 INIT_WORK(&rdev
->sched_scan_results_wk
, __cfg80211_sched_scan_results
);
312 #ifdef CONFIG_CFG80211_WEXT
313 rdev
->wiphy
.wext
= &cfg80211_wext_handler
;
316 device_initialize(&rdev
->wiphy
.dev
);
317 rdev
->wiphy
.dev
.class = &ieee80211_class
;
318 rdev
->wiphy
.dev
.platform_data
= rdev
;
320 #ifdef CONFIG_CFG80211_DEFAULT_PS
321 rdev
->wiphy
.flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
324 wiphy_net_set(&rdev
->wiphy
, &init_net
);
326 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
327 rdev
->rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
328 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
329 &rdev
->rfkill_ops
, rdev
);
336 INIT_WORK(&rdev
->rfkill_sync
, cfg80211_rfkill_sync_work
);
337 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
338 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
340 init_waitqueue_head(&rdev
->dev_wait
);
343 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
344 * Fragmentation and RTS threshold are disabled by default with the
347 rdev
->wiphy
.retry_short
= 7;
348 rdev
->wiphy
.retry_long
= 4;
349 rdev
->wiphy
.frag_threshold
= (u32
) -1;
350 rdev
->wiphy
.rts_threshold
= (u32
) -1;
351 rdev
->wiphy
.coverage_class
= 0;
355 EXPORT_SYMBOL(wiphy_new
);
357 static int wiphy_verify_combinations(struct wiphy
*wiphy
)
359 const struct ieee80211_iface_combination
*c
;
362 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
366 c
= &wiphy
->iface_combinations
[i
];
368 /* Combinations with just one interface aren't real */
369 if (WARN_ON(c
->max_interfaces
< 2))
372 /* Need at least one channel */
373 if (WARN_ON(!c
->num_different_channels
))
377 * Put a sane limit on maximum number of different
378 * channels to simplify channel accounting code.
380 if (WARN_ON(c
->num_different_channels
>
381 CFG80211_MAX_NUM_DIFFERENT_CHANNELS
))
384 if (WARN_ON(!c
->n_limits
))
387 for (j
= 0; j
< c
->n_limits
; j
++) {
388 u16 types
= c
->limits
[j
].types
;
391 * interface types shouldn't overlap, this is
392 * used in cfg80211_can_change_interface()
394 if (WARN_ON(types
& all_iftypes
))
396 all_iftypes
|= types
;
398 if (WARN_ON(!c
->limits
[j
].max
))
401 /* Shouldn't list software iftypes in combinations! */
402 if (WARN_ON(wiphy
->software_iftypes
& types
))
405 cnt
+= c
->limits
[j
].max
;
407 * Don't advertise an unsupported type
410 if (WARN_ON((wiphy
->interface_modes
& types
) != types
))
414 /* You can't even choose that many! */
415 if (WARN_ON(cnt
< c
->max_interfaces
))
422 int wiphy_register(struct wiphy
*wiphy
)
424 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
426 enum ieee80211_band band
;
427 struct ieee80211_supported_band
*sband
;
428 bool have_band
= false;
430 u16 ifmodes
= wiphy
->interface_modes
;
433 if (WARN_ON((wiphy
->wowlan
.flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
434 !(wiphy
->wowlan
.flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
)))
438 if (WARN_ON(wiphy
->ap_sme_capa
&&
439 !(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
)))
442 if (WARN_ON(wiphy
->addresses
&& !wiphy
->n_addresses
))
445 if (WARN_ON(wiphy
->addresses
&&
446 !is_zero_ether_addr(wiphy
->perm_addr
) &&
447 memcmp(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
,
451 if (wiphy
->addresses
)
452 memcpy(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
, ETH_ALEN
);
454 /* sanity check ifmodes */
456 ifmodes
&= ((1 << NUM_NL80211_IFTYPES
) - 1) & ~1;
457 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
458 wiphy
->interface_modes
= ifmodes
;
460 res
= wiphy_verify_combinations(wiphy
);
464 /* sanity check supported bands/channels */
465 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
466 sband
= wiphy
->bands
[band
];
472 if (WARN_ON(!sband
->n_channels
|| !sband
->n_bitrates
))
476 * Since cfg80211_disable_40mhz_24ghz is global, we can
477 * modify the sband's ht data even if the driver uses a
478 * global structure for that.
480 if (cfg80211_disable_40mhz_24ghz
&&
481 band
== IEEE80211_BAND_2GHZ
&&
482 sband
->ht_cap
.ht_supported
) {
483 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
484 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SGI_40
;
488 * Since we use a u32 for rate bitmaps in
489 * ieee80211_get_response_rate, we cannot
490 * have more than 32 legacy rates.
492 if (WARN_ON(sband
->n_bitrates
> 32))
495 for (i
= 0; i
< sband
->n_channels
; i
++) {
496 sband
->channels
[i
].orig_flags
=
497 sband
->channels
[i
].flags
;
498 sband
->channels
[i
].orig_mag
=
499 sband
->channels
[i
].max_antenna_gain
;
500 sband
->channels
[i
].orig_mpwr
=
501 sband
->channels
[i
].max_power
;
502 sband
->channels
[i
].band
= band
;
514 if (rdev
->wiphy
.wowlan
.n_patterns
) {
515 if (WARN_ON(!rdev
->wiphy
.wowlan
.pattern_min_len
||
516 rdev
->wiphy
.wowlan
.pattern_min_len
>
517 rdev
->wiphy
.wowlan
.pattern_max_len
))
522 /* check and set up bitrates */
523 ieee80211_set_bitrate_flags(wiphy
);
525 mutex_lock(&cfg80211_mutex
);
527 res
= device_add(&rdev
->wiphy
.dev
);
529 mutex_unlock(&cfg80211_mutex
);
533 /* set up regulatory info */
534 regulatory_update(wiphy
, NL80211_REGDOM_SET_BY_CORE
);
536 list_add_rcu(&rdev
->list
, &cfg80211_rdev_list
);
537 cfg80211_rdev_list_generation
++;
540 rdev
->wiphy
.debugfsdir
=
541 debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
542 ieee80211_debugfs_dir
);
543 if (IS_ERR(rdev
->wiphy
.debugfsdir
))
544 rdev
->wiphy
.debugfsdir
= NULL
;
546 if (wiphy
->flags
& WIPHY_FLAG_CUSTOM_REGULATORY
) {
547 struct regulatory_request request
;
549 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
550 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
551 request
.alpha2
[0] = '9';
552 request
.alpha2
[1] = '9';
554 nl80211_send_reg_change_event(&request
);
557 cfg80211_debugfs_rdev_add(rdev
);
558 mutex_unlock(&cfg80211_mutex
);
561 * due to a locking dependency this has to be outside of the
562 * cfg80211_mutex lock
564 res
= rfkill_register(rdev
->rfkill
);
569 rdev
->wiphy
.registered
= true;
574 device_del(&rdev
->wiphy
.dev
);
577 EXPORT_SYMBOL(wiphy_register
);
579 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
581 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
583 if (!rdev
->ops
->rfkill_poll
)
585 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
586 rfkill_resume_polling(rdev
->rfkill
);
588 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
590 void wiphy_rfkill_stop_polling(struct wiphy
*wiphy
)
592 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
594 rfkill_pause_polling(rdev
->rfkill
);
596 EXPORT_SYMBOL(wiphy_rfkill_stop_polling
);
598 void wiphy_unregister(struct wiphy
*wiphy
)
600 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
603 rdev
->wiphy
.registered
= false;
606 rfkill_unregister(rdev
->rfkill
);
608 /* protect the device list */
609 mutex_lock(&cfg80211_mutex
);
611 wait_event(rdev
->dev_wait
, ({
613 mutex_lock(&rdev
->devlist_mtx
);
614 __count
= rdev
->opencount
;
615 mutex_unlock(&rdev
->devlist_mtx
);
618 mutex_lock(&rdev
->devlist_mtx
);
619 BUG_ON(!list_empty(&rdev
->netdev_list
));
620 mutex_unlock(&rdev
->devlist_mtx
);
623 * First remove the hardware from everywhere, this makes
624 * it impossible to find from userspace.
626 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
627 list_del_rcu(&rdev
->list
);
631 * Try to grab rdev->mtx. If a command is still in progress,
632 * hopefully the driver will refuse it since it's tearing
633 * down the device already. We wait for this command to complete
634 * before unlinking the item from the list.
635 * Note: as codified by the BUG_ON above we cannot get here if
636 * a virtual interface is still present. Hence, we can only get
637 * to lock contention here if userspace issues a command that
638 * identified the hardware by wiphy index.
640 cfg80211_lock_rdev(rdev
);
642 cfg80211_unlock_rdev(rdev
);
644 /* If this device got a regulatory hint tell core its
645 * free to listen now to a new shiny device regulatory hint */
646 reg_device_remove(wiphy
);
648 cfg80211_rdev_list_generation
++;
649 device_del(&rdev
->wiphy
.dev
);
651 mutex_unlock(&cfg80211_mutex
);
653 flush_work(&rdev
->scan_done_wk
);
654 cancel_work_sync(&rdev
->conn_work
);
655 flush_work(&rdev
->event_work
);
657 if (rdev
->wowlan
&& rdev
->ops
->set_wakeup
)
658 rdev
->ops
->set_wakeup(&rdev
->wiphy
, false);
659 cfg80211_rdev_free_wowlan(rdev
);
661 EXPORT_SYMBOL(wiphy_unregister
);
663 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
665 struct cfg80211_internal_bss
*scan
, *tmp
;
666 rfkill_destroy(rdev
->rfkill
);
667 mutex_destroy(&rdev
->mtx
);
668 mutex_destroy(&rdev
->devlist_mtx
);
669 mutex_destroy(&rdev
->sched_scan_mtx
);
670 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
671 cfg80211_put_bss(&scan
->pub
);
675 void wiphy_free(struct wiphy
*wiphy
)
677 put_device(&wiphy
->dev
);
679 EXPORT_SYMBOL(wiphy_free
);
681 void wiphy_rfkill_set_hw_state(struct wiphy
*wiphy
, bool blocked
)
683 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
685 if (rfkill_set_hw_state(rdev
->rfkill
, blocked
))
686 schedule_work(&rdev
->rfkill_sync
);
688 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state
);
690 static void wdev_cleanup_work(struct work_struct
*work
)
692 struct wireless_dev
*wdev
;
693 struct cfg80211_registered_device
*rdev
;
695 wdev
= container_of(work
, struct wireless_dev
, cleanup_work
);
696 rdev
= wiphy_to_dev(wdev
->wiphy
);
698 cfg80211_lock_rdev(rdev
);
700 if (WARN_ON(rdev
->scan_req
&& rdev
->scan_req
->dev
== wdev
->netdev
)) {
701 rdev
->scan_req
->aborted
= true;
702 ___cfg80211_scan_done(rdev
, true);
705 cfg80211_unlock_rdev(rdev
);
707 mutex_lock(&rdev
->sched_scan_mtx
);
709 if (WARN_ON(rdev
->sched_scan_req
&&
710 rdev
->sched_scan_req
->dev
== wdev
->netdev
)) {
711 __cfg80211_stop_sched_scan(rdev
, false);
714 mutex_unlock(&rdev
->sched_scan_mtx
);
716 mutex_lock(&rdev
->devlist_mtx
);
718 mutex_unlock(&rdev
->devlist_mtx
);
719 wake_up(&rdev
->dev_wait
);
721 dev_put(wdev
->netdev
);
724 static struct device_type wiphy_type
= {
728 static struct ieee80211_channel
*
729 cfg80211_get_any_chan(struct cfg80211_registered_device
*rdev
)
731 struct ieee80211_supported_band
*sband
;
734 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
735 sband
= rdev
->wiphy
.bands
[i
];
736 if (sband
&& sband
->n_channels
> 0)
737 return &sband
->channels
[0];
743 static void cfg80211_init_mon_chan(struct cfg80211_registered_device
*rdev
)
745 struct ieee80211_channel
*chan
;
747 chan
= cfg80211_get_any_chan(rdev
);
751 mutex_lock(&rdev
->devlist_mtx
);
752 WARN_ON(cfg80211_set_monitor_channel(rdev
, chan
->center_freq
,
753 NL80211_CHAN_NO_HT
));
754 mutex_unlock(&rdev
->devlist_mtx
);
757 void cfg80211_update_iface_num(struct cfg80211_registered_device
*rdev
,
758 enum nl80211_iftype iftype
, int num
)
760 bool has_monitors_only_old
= cfg80211_has_monitors_only(rdev
);
761 bool has_monitors_only_new
;
763 ASSERT_RDEV_LOCK(rdev
);
765 rdev
->num_running_ifaces
+= num
;
766 if (iftype
== NL80211_IFTYPE_MONITOR
)
767 rdev
->num_running_monitor_ifaces
+= num
;
769 has_monitors_only_new
= cfg80211_has_monitors_only(rdev
);
770 if (has_monitors_only_new
!= has_monitors_only_old
) {
771 rdev
->ops
->set_monitor_enabled(&rdev
->wiphy
,
772 has_monitors_only_new
);
774 if (!has_monitors_only_new
) {
775 rdev
->monitor_channel
= NULL
;
776 rdev
->monitor_channel_type
= NL80211_CHAN_NO_HT
;
778 cfg80211_init_mon_chan(rdev
);
783 static int cfg80211_netdev_notifier_call(struct notifier_block
*nb
,
787 struct net_device
*dev
= ndev
;
788 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
789 struct cfg80211_registered_device
*rdev
;
795 rdev
= wiphy_to_dev(wdev
->wiphy
);
797 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
800 case NETDEV_POST_INIT
:
801 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
803 case NETDEV_REGISTER
:
805 * NB: cannot take rdev->mtx here because this may be
806 * called within code protected by it when interfaces
807 * are added with nl80211.
809 mutex_init(&wdev
->mtx
);
810 INIT_WORK(&wdev
->cleanup_work
, wdev_cleanup_work
);
811 INIT_LIST_HEAD(&wdev
->event_list
);
812 spin_lock_init(&wdev
->event_lock
);
813 INIT_LIST_HEAD(&wdev
->mgmt_registrations
);
814 spin_lock_init(&wdev
->mgmt_registrations_lock
);
816 mutex_lock(&rdev
->devlist_mtx
);
817 list_add_rcu(&wdev
->list
, &rdev
->netdev_list
);
818 rdev
->devlist_generation
++;
819 /* can only change netns with wiphy */
820 dev
->features
|= NETIF_F_NETNS_LOCAL
;
822 if (sysfs_create_link(&dev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
824 pr_err("failed to add phy80211 symlink to netdev!\n");
827 wdev
->sme_state
= CFG80211_SME_IDLE
;
828 mutex_unlock(&rdev
->devlist_mtx
);
829 #ifdef CONFIG_CFG80211_WEXT
830 wdev
->wext
.default_key
= -1;
831 wdev
->wext
.default_mgmt_key
= -1;
832 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
835 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
839 /* allow mac80211 to determine the timeout */
840 wdev
->ps_timeout
= -1;
842 if (!dev
->ethtool_ops
)
843 dev
->ethtool_ops
= &cfg80211_ethtool_ops
;
845 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
846 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
||
847 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
848 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
850 case NETDEV_GOING_DOWN
:
851 switch (wdev
->iftype
) {
852 case NL80211_IFTYPE_ADHOC
:
853 cfg80211_leave_ibss(rdev
, dev
, true);
855 case NL80211_IFTYPE_P2P_CLIENT
:
856 case NL80211_IFTYPE_STATION
:
857 mutex_lock(&rdev
->sched_scan_mtx
);
858 __cfg80211_stop_sched_scan(rdev
, false);
859 mutex_unlock(&rdev
->sched_scan_mtx
);
862 #ifdef CONFIG_CFG80211_WEXT
863 kfree(wdev
->wext
.ie
);
864 wdev
->wext
.ie
= NULL
;
865 wdev
->wext
.ie_len
= 0;
866 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
868 __cfg80211_disconnect(rdev
, dev
,
869 WLAN_REASON_DEAUTH_LEAVING
, true);
870 cfg80211_mlme_down(rdev
, dev
);
873 case NL80211_IFTYPE_MESH_POINT
:
874 cfg80211_leave_mesh(rdev
, dev
);
876 case NL80211_IFTYPE_AP
:
877 cfg80211_stop_ap(rdev
, dev
);
882 wdev
->beacon_interval
= 0;
886 cfg80211_lock_rdev(rdev
);
887 cfg80211_update_iface_num(rdev
, wdev
->iftype
, -1);
888 cfg80211_unlock_rdev(rdev
);
889 queue_work(cfg80211_wq
, &wdev
->cleanup_work
);
893 * If we have a really quick DOWN/UP succession we may
894 * have this work still pending ... cancel it and see
895 * if it was pending, in which case we need to account
896 * for some of the work it would have done.
898 if (cancel_work_sync(&wdev
->cleanup_work
)) {
899 mutex_lock(&rdev
->devlist_mtx
);
901 mutex_unlock(&rdev
->devlist_mtx
);
904 cfg80211_lock_rdev(rdev
);
905 mutex_lock(&rdev
->devlist_mtx
);
907 switch (wdev
->iftype
) {
908 #ifdef CONFIG_CFG80211_WEXT
909 case NL80211_IFTYPE_ADHOC
:
910 cfg80211_ibss_wext_join(rdev
, wdev
);
912 case NL80211_IFTYPE_STATION
:
913 cfg80211_mgd_wext_connect(rdev
, wdev
);
916 #ifdef CONFIG_MAC80211_MESH
917 case NL80211_IFTYPE_MESH_POINT
:
919 /* backward compat code... */
920 struct mesh_setup setup
;
921 memcpy(&setup
, &default_mesh_setup
,
923 /* back compat only needed for mesh_id */
924 setup
.mesh_id
= wdev
->ssid
;
925 setup
.mesh_id_len
= wdev
->mesh_id_up_len
;
926 if (wdev
->mesh_id_up_len
)
927 __cfg80211_join_mesh(rdev
, dev
,
929 &default_mesh_config
);
938 mutex_unlock(&rdev
->devlist_mtx
);
939 cfg80211_unlock_rdev(rdev
);
942 * Configure power management to the driver here so that its
943 * correctly set also after interface type changes etc.
945 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
946 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
) &&
947 rdev
->ops
->set_power_mgmt
)
948 if (rdev
->ops
->set_power_mgmt(wdev
->wiphy
, dev
,
951 /* assume this means it's off */
955 case NETDEV_UNREGISTER
:
957 * NB: cannot take rdev->mtx here because this may be
958 * called within code protected by it when interfaces
959 * are removed with nl80211.
961 mutex_lock(&rdev
->devlist_mtx
);
963 * It is possible to get NETDEV_UNREGISTER
964 * multiple times. To detect that, check
965 * that the interface is still on the list
966 * of registered interfaces, and only then
967 * remove and clean it up.
969 if (!list_empty(&wdev
->list
)) {
970 sysfs_remove_link(&dev
->dev
.kobj
, "phy80211");
971 list_del_rcu(&wdev
->list
);
972 rdev
->devlist_generation
++;
973 cfg80211_mlme_purge_registrations(wdev
);
974 #ifdef CONFIG_CFG80211_WEXT
975 kfree(wdev
->wext
.keys
);
978 mutex_unlock(&rdev
->devlist_mtx
);
980 * synchronise (so that we won't find this netdev
981 * from other code any more) and then clear the list
982 * head so that the above code can safely check for
983 * !list_empty() to avoid double-cleanup.
986 INIT_LIST_HEAD(&wdev
->list
);
989 if (!(wdev
->wiphy
->interface_modes
& BIT(wdev
->iftype
)))
990 return notifier_from_errno(-EOPNOTSUPP
);
991 if (rfkill_blocked(rdev
->rfkill
))
992 return notifier_from_errno(-ERFKILL
);
993 ret
= cfg80211_can_add_interface(rdev
, wdev
->iftype
);
995 return notifier_from_errno(ret
);
996 cfg80211_lock_rdev(rdev
);
997 cfg80211_update_iface_num(rdev
, wdev
->iftype
, 1);
998 cfg80211_unlock_rdev(rdev
);
1005 static struct notifier_block cfg80211_netdev_notifier
= {
1006 .notifier_call
= cfg80211_netdev_notifier_call
,
1009 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
1011 struct cfg80211_registered_device
*rdev
;
1014 mutex_lock(&cfg80211_mutex
);
1015 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
1016 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
1017 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
1019 mutex_unlock(&cfg80211_mutex
);
1023 static struct pernet_operations cfg80211_pernet_ops
= {
1024 .exit
= cfg80211_pernet_exit
,
1027 static int __init
cfg80211_init(void)
1031 err
= register_pernet_device(&cfg80211_pernet_ops
);
1033 goto out_fail_pernet
;
1035 err
= wiphy_sysfs_init();
1037 goto out_fail_sysfs
;
1039 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
1041 goto out_fail_notifier
;
1043 err
= nl80211_init();
1045 goto out_fail_nl80211
;
1047 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
1049 err
= regulatory_init();
1053 cfg80211_wq
= create_singlethread_workqueue("cfg80211");
1062 debugfs_remove(ieee80211_debugfs_dir
);
1064 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1068 unregister_pernet_device(&cfg80211_pernet_ops
);
1072 subsys_initcall(cfg80211_init
);
1074 static void __exit
cfg80211_exit(void)
1076 debugfs_remove(ieee80211_debugfs_dir
);
1078 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1081 unregister_pernet_device(&cfg80211_pernet_ops
);
1082 destroy_workqueue(cfg80211_wq
);
1084 module_exit(cfg80211_exit
);