1 // SPDX-License-Identifier: GPL-2.0-only
3 * This is the linux wireless configuration interface.
5 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2013-2014 Intel Mobile Communications GmbH
7 * Copyright 2015-2017 Intel Deutschland GmbH
8 * Copyright (C) 2018-2021 Intel Corporation
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/module.h>
15 #include <linux/err.h>
16 #include <linux/list.h>
17 #include <linux/slab.h>
18 #include <linux/nl80211.h>
19 #include <linux/debugfs.h>
20 #include <linux/notifier.h>
21 #include <linux/device.h>
22 #include <linux/etherdevice.h>
23 #include <linux/rtnetlink.h>
24 #include <linux/sched.h>
25 #include <net/genetlink.h>
26 #include <net/cfg80211.h>
31 #include "wext-compat.h"
34 /* name for sysfs, %d is appended */
35 #define PHY_NAME "phy"
37 MODULE_AUTHOR("Johannes Berg");
38 MODULE_LICENSE("GPL");
39 MODULE_DESCRIPTION("wireless configuration support");
40 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME
);
42 /* RCU-protected (and RTNL for writers) */
43 LIST_HEAD(cfg80211_rdev_list
);
44 int cfg80211_rdev_list_generation
;
47 static struct dentry
*ieee80211_debugfs_dir
;
49 /* for the cleanup, scan and event works */
50 struct workqueue_struct
*cfg80211_wq
;
52 static bool cfg80211_disable_40mhz_24ghz
;
53 module_param(cfg80211_disable_40mhz_24ghz
, bool, 0644);
54 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz
,
55 "Disable 40MHz support in the 2.4GHz band");
57 struct cfg80211_registered_device
*cfg80211_rdev_by_wiphy_idx(int wiphy_idx
)
59 struct cfg80211_registered_device
*result
= NULL
, *rdev
;
63 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
64 if (rdev
->wiphy_idx
== wiphy_idx
) {
73 int get_wiphy_idx(struct wiphy
*wiphy
)
75 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
77 return rdev
->wiphy_idx
;
80 struct wiphy
*wiphy_idx_to_wiphy(int wiphy_idx
)
82 struct cfg80211_registered_device
*rdev
;
86 rdev
= cfg80211_rdev_by_wiphy_idx(wiphy_idx
);
92 static int cfg80211_dev_check_name(struct cfg80211_registered_device
*rdev
,
95 struct cfg80211_registered_device
*rdev2
;
96 int wiphy_idx
, taken
= -1, digits
;
100 if (strlen(newname
) > NL80211_WIPHY_NAME_MAXLEN
)
103 /* prohibit calling the thing phy%d when %d is not its number */
104 sscanf(newname
, PHY_NAME
"%d%n", &wiphy_idx
, &taken
);
105 if (taken
== strlen(newname
) && wiphy_idx
!= rdev
->wiphy_idx
) {
106 /* count number of places needed to print wiphy_idx */
108 while (wiphy_idx
/= 10)
111 * deny the name if it is phy<idx> where <idx> is printed
112 * without leading zeroes. taken == strlen(newname) here
114 if (taken
== strlen(PHY_NAME
) + digits
)
118 /* Ensure another device does not already have this name. */
119 list_for_each_entry(rdev2
, &cfg80211_rdev_list
, list
)
120 if (strcmp(newname
, wiphy_name(&rdev2
->wiphy
)) == 0)
126 int cfg80211_dev_rename(struct cfg80211_registered_device
*rdev
,
133 /* Ignore nop renames */
134 if (strcmp(newname
, wiphy_name(&rdev
->wiphy
)) == 0)
137 result
= cfg80211_dev_check_name(rdev
, newname
);
141 result
= device_rename(&rdev
->wiphy
.dev
, newname
);
145 if (!IS_ERR_OR_NULL(rdev
->wiphy
.debugfsdir
))
146 debugfs_rename(rdev
->wiphy
.debugfsdir
->d_parent
,
147 rdev
->wiphy
.debugfsdir
,
148 rdev
->wiphy
.debugfsdir
->d_parent
, newname
);
150 nl80211_notify_wiphy(rdev
, NL80211_CMD_NEW_WIPHY
);
155 int cfg80211_switch_netns(struct cfg80211_registered_device
*rdev
,
158 struct wireless_dev
*wdev
;
161 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
))
164 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
167 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
168 err
= dev_change_net_namespace(wdev
->netdev
, net
, "wlan%d");
171 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
175 /* failed -- clean up to old netns */
176 net
= wiphy_net(&rdev
->wiphy
);
178 list_for_each_entry_continue_reverse(wdev
,
179 &rdev
->wiphy
.wdev_list
,
183 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
184 err
= dev_change_net_namespace(wdev
->netdev
, net
,
187 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
193 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
196 nl80211_notify_iface(rdev
, wdev
, NL80211_CMD_DEL_INTERFACE
);
198 nl80211_notify_wiphy(rdev
, NL80211_CMD_DEL_WIPHY
);
200 wiphy_net_set(&rdev
->wiphy
, net
);
202 err
= device_rename(&rdev
->wiphy
.dev
, dev_name(&rdev
->wiphy
.dev
));
205 nl80211_notify_wiphy(rdev
, NL80211_CMD_NEW_WIPHY
);
206 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
209 nl80211_notify_iface(rdev
, wdev
, NL80211_CMD_NEW_INTERFACE
);
215 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
217 struct cfg80211_registered_device
*rdev
= data
;
219 rdev_rfkill_poll(rdev
);
222 void cfg80211_stop_p2p_device(struct cfg80211_registered_device
*rdev
,
223 struct wireless_dev
*wdev
)
225 lockdep_assert_held(&rdev
->wiphy
.mtx
);
227 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
))
230 if (!wdev_running(wdev
))
233 rdev_stop_p2p_device(rdev
, wdev
);
234 wdev
->is_running
= false;
238 if (rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
) {
239 if (WARN_ON(!rdev
->scan_req
->notified
&&
240 (!rdev
->int_scan_req
||
241 !rdev
->int_scan_req
->notified
)))
242 rdev
->scan_req
->info
.aborted
= true;
243 ___cfg80211_scan_done(rdev
, false);
247 void cfg80211_stop_nan(struct cfg80211_registered_device
*rdev
,
248 struct wireless_dev
*wdev
)
250 lockdep_assert_held(&rdev
->wiphy
.mtx
);
252 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_NAN
))
255 if (!wdev_running(wdev
))
258 rdev_stop_nan(rdev
, wdev
);
259 wdev
->is_running
= false;
264 void cfg80211_shutdown_all_interfaces(struct wiphy
*wiphy
)
266 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
267 struct wireless_dev
*wdev
;
271 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
273 dev_close(wdev
->netdev
);
277 /* otherwise, check iftype */
281 switch (wdev
->iftype
) {
282 case NL80211_IFTYPE_P2P_DEVICE
:
283 cfg80211_stop_p2p_device(rdev
, wdev
);
285 case NL80211_IFTYPE_NAN
:
286 cfg80211_stop_nan(rdev
, wdev
);
295 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces
);
297 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
299 struct cfg80211_registered_device
*rdev
= data
;
305 cfg80211_shutdown_all_interfaces(&rdev
->wiphy
);
311 static void cfg80211_rfkill_block_work(struct work_struct
*work
)
313 struct cfg80211_registered_device
*rdev
;
315 rdev
= container_of(work
, struct cfg80211_registered_device
,
317 cfg80211_rfkill_set_block(rdev
, true);
320 static void cfg80211_event_work(struct work_struct
*work
)
322 struct cfg80211_registered_device
*rdev
;
324 rdev
= container_of(work
, struct cfg80211_registered_device
,
327 wiphy_lock(&rdev
->wiphy
);
328 cfg80211_process_rdev_events(rdev
);
329 wiphy_unlock(&rdev
->wiphy
);
332 void cfg80211_destroy_ifaces(struct cfg80211_registered_device
*rdev
)
334 struct wireless_dev
*wdev
, *tmp
;
339 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
340 if (wdev
->nl_owner_dead
) {
342 dev_close(wdev
->netdev
);
350 wiphy_lock(&rdev
->wiphy
);
351 list_for_each_entry_safe(wdev
, tmp
, &rdev
->wiphy
.wdev_list
, list
) {
352 if (wdev
->nl_owner_dead
) {
353 cfg80211_leave(rdev
, wdev
);
354 rdev_del_virtual_intf(rdev
, wdev
);
357 wiphy_unlock(&rdev
->wiphy
);
360 static void cfg80211_destroy_iface_wk(struct work_struct
*work
)
362 struct cfg80211_registered_device
*rdev
;
364 rdev
= container_of(work
, struct cfg80211_registered_device
,
368 cfg80211_destroy_ifaces(rdev
);
372 static void cfg80211_sched_scan_stop_wk(struct work_struct
*work
)
374 struct cfg80211_registered_device
*rdev
;
375 struct cfg80211_sched_scan_request
*req
, *tmp
;
377 rdev
= container_of(work
, struct cfg80211_registered_device
,
381 list_for_each_entry_safe(req
, tmp
, &rdev
->sched_scan_req_list
, list
) {
382 if (req
->nl_owner_dead
)
383 cfg80211_stop_sched_scan_req(rdev
, req
, false);
388 static void cfg80211_propagate_radar_detect_wk(struct work_struct
*work
)
390 struct cfg80211_registered_device
*rdev
;
392 rdev
= container_of(work
, struct cfg80211_registered_device
,
393 propagate_radar_detect_wk
);
397 regulatory_propagate_dfs_state(&rdev
->wiphy
, &rdev
->radar_chandef
,
398 NL80211_DFS_UNAVAILABLE
,
399 NL80211_RADAR_DETECTED
);
404 static void cfg80211_propagate_cac_done_wk(struct work_struct
*work
)
406 struct cfg80211_registered_device
*rdev
;
408 rdev
= container_of(work
, struct cfg80211_registered_device
,
409 propagate_cac_done_wk
);
413 regulatory_propagate_dfs_state(&rdev
->wiphy
, &rdev
->cac_done_chandef
,
414 NL80211_DFS_AVAILABLE
,
415 NL80211_RADAR_CAC_FINISHED
);
420 /* exported functions */
422 struct wiphy
*wiphy_new_nm(const struct cfg80211_ops
*ops
, int sizeof_priv
,
423 const char *requested_name
)
425 static atomic_t wiphy_counter
= ATOMIC_INIT(0);
427 struct cfg80211_registered_device
*rdev
;
430 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
431 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
432 WARN_ON(ops
->connect
&& !ops
->disconnect
);
433 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
434 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
435 WARN_ON(ops
->add_station
&& !ops
->del_station
);
436 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
437 WARN_ON(ops
->join_mesh
&& !ops
->leave_mesh
);
438 WARN_ON(ops
->start_p2p_device
&& !ops
->stop_p2p_device
);
439 WARN_ON(ops
->start_ap
&& !ops
->stop_ap
);
440 WARN_ON(ops
->join_ocb
&& !ops
->leave_ocb
);
441 WARN_ON(ops
->suspend
&& !ops
->resume
);
442 WARN_ON(ops
->sched_scan_start
&& !ops
->sched_scan_stop
);
443 WARN_ON(ops
->remain_on_channel
&& !ops
->cancel_remain_on_channel
);
444 WARN_ON(ops
->tdls_channel_switch
&& !ops
->tdls_cancel_channel_switch
);
445 WARN_ON(ops
->add_tx_ts
&& !ops
->del_tx_ts
);
447 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
449 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
455 rdev
->wiphy_idx
= atomic_inc_return(&wiphy_counter
);
457 if (unlikely(rdev
->wiphy_idx
< 0)) {
459 atomic_dec(&wiphy_counter
);
464 /* atomic_inc_return makes it start at 1, make it start at 0 */
467 /* give it a proper name */
468 if (requested_name
&& requested_name
[0]) {
472 rv
= cfg80211_dev_check_name(rdev
, requested_name
);
476 goto use_default_name
;
479 rv
= dev_set_name(&rdev
->wiphy
.dev
, "%s", requested_name
);
482 goto use_default_name
;
487 /* NOTE: This is *probably* safe w/out holding rtnl because of
488 * the restrictions on phy names. Probably this call could
489 * fail if some other part of the kernel (re)named a device
490 * phyX. But, might should add some locking and check return
491 * value, and use a different name if this one exists?
493 rv
= dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
500 mutex_init(&rdev
->wiphy
.mtx
);
501 INIT_LIST_HEAD(&rdev
->wiphy
.wdev_list
);
502 INIT_LIST_HEAD(&rdev
->beacon_registrations
);
503 spin_lock_init(&rdev
->beacon_registrations_lock
);
504 spin_lock_init(&rdev
->bss_lock
);
505 INIT_LIST_HEAD(&rdev
->bss_list
);
506 INIT_LIST_HEAD(&rdev
->sched_scan_req_list
);
507 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
508 INIT_DELAYED_WORK(&rdev
->dfs_update_channels_wk
,
509 cfg80211_dfs_channels_update_work
);
510 #ifdef CONFIG_CFG80211_WEXT
511 rdev
->wiphy
.wext
= &cfg80211_wext_handler
;
514 device_initialize(&rdev
->wiphy
.dev
);
515 rdev
->wiphy
.dev
.class = &ieee80211_class
;
516 rdev
->wiphy
.dev
.platform_data
= rdev
;
517 device_enable_async_suspend(&rdev
->wiphy
.dev
);
519 INIT_WORK(&rdev
->destroy_work
, cfg80211_destroy_iface_wk
);
520 INIT_WORK(&rdev
->sched_scan_stop_wk
, cfg80211_sched_scan_stop_wk
);
521 INIT_WORK(&rdev
->sched_scan_res_wk
, cfg80211_sched_scan_results_wk
);
522 INIT_WORK(&rdev
->propagate_radar_detect_wk
,
523 cfg80211_propagate_radar_detect_wk
);
524 INIT_WORK(&rdev
->propagate_cac_done_wk
, cfg80211_propagate_cac_done_wk
);
525 INIT_WORK(&rdev
->mgmt_registrations_update_wk
,
526 cfg80211_mgmt_registrations_update_wk
);
528 #ifdef CONFIG_CFG80211_DEFAULT_PS
529 rdev
->wiphy
.flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
532 wiphy_net_set(&rdev
->wiphy
, &init_net
);
534 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
535 rdev
->wiphy
.rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
536 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
537 &rdev
->rfkill_ops
, rdev
);
539 if (!rdev
->wiphy
.rfkill
) {
540 wiphy_free(&rdev
->wiphy
);
544 INIT_WORK(&rdev
->rfkill_block
, cfg80211_rfkill_block_work
);
545 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
546 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
548 init_waitqueue_head(&rdev
->dev_wait
);
551 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
552 * Fragmentation and RTS threshold are disabled by default with the
555 rdev
->wiphy
.retry_short
= 7;
556 rdev
->wiphy
.retry_long
= 4;
557 rdev
->wiphy
.frag_threshold
= (u32
) -1;
558 rdev
->wiphy
.rts_threshold
= (u32
) -1;
559 rdev
->wiphy
.coverage_class
= 0;
561 rdev
->wiphy
.max_num_csa_counters
= 1;
563 rdev
->wiphy
.max_sched_scan_plans
= 1;
564 rdev
->wiphy
.max_sched_scan_plan_interval
= U32_MAX
;
568 EXPORT_SYMBOL(wiphy_new_nm
);
570 static int wiphy_verify_combinations(struct wiphy
*wiphy
)
572 const struct ieee80211_iface_combination
*c
;
575 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
579 c
= &wiphy
->iface_combinations
[i
];
582 * Combinations with just one interface aren't real,
583 * however we make an exception for DFS.
585 if (WARN_ON((c
->max_interfaces
< 2) && !c
->radar_detect_widths
))
588 /* Need at least one channel */
589 if (WARN_ON(!c
->num_different_channels
))
592 /* DFS only works on one channel. */
593 if (WARN_ON(c
->radar_detect_widths
&&
594 (c
->num_different_channels
> 1)))
597 if (WARN_ON(!c
->n_limits
))
600 for (j
= 0; j
< c
->n_limits
; j
++) {
601 u16 types
= c
->limits
[j
].types
;
603 /* interface types shouldn't overlap */
604 if (WARN_ON(types
& all_iftypes
))
606 all_iftypes
|= types
;
608 if (WARN_ON(!c
->limits
[j
].max
))
611 /* Shouldn't list software iftypes in combinations! */
612 if (WARN_ON(wiphy
->software_iftypes
& types
))
615 /* Only a single P2P_DEVICE can be allowed */
616 if (WARN_ON(types
& BIT(NL80211_IFTYPE_P2P_DEVICE
) &&
617 c
->limits
[j
].max
> 1))
620 /* Only a single NAN can be allowed */
621 if (WARN_ON(types
& BIT(NL80211_IFTYPE_NAN
) &&
622 c
->limits
[j
].max
> 1))
626 * This isn't well-defined right now. If you have an
627 * IBSS interface, then its beacon interval may change
628 * by joining other networks, and nothing prevents it
630 * So technically we probably shouldn't even allow AP
631 * and IBSS in the same interface, but it seems that
632 * some drivers support that, possibly only with fixed
633 * beacon intervals for IBSS.
635 if (WARN_ON(types
& BIT(NL80211_IFTYPE_ADHOC
) &&
636 c
->beacon_int_min_gcd
)) {
640 cnt
+= c
->limits
[j
].max
;
642 * Don't advertise an unsupported type
645 if (WARN_ON((wiphy
->interface_modes
& types
) != types
))
649 if (WARN_ON(all_iftypes
& BIT(NL80211_IFTYPE_WDS
)))
652 /* You can't even choose that many! */
653 if (WARN_ON(cnt
< c
->max_interfaces
))
660 int wiphy_register(struct wiphy
*wiphy
)
662 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
664 enum nl80211_band band
;
665 struct ieee80211_supported_band
*sband
;
666 bool have_band
= false;
668 u16 ifmodes
= wiphy
->interface_modes
;
671 if (WARN_ON(wiphy
->wowlan
&&
672 (wiphy
->wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
673 !(wiphy
->wowlan
->flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
)))
675 if (WARN_ON(wiphy
->wowlan
&&
676 !wiphy
->wowlan
->flags
&& !wiphy
->wowlan
->n_patterns
&&
677 !wiphy
->wowlan
->tcp
))
680 if (WARN_ON((wiphy
->features
& NL80211_FEATURE_TDLS_CHANNEL_SWITCH
) &&
681 (!rdev
->ops
->tdls_channel_switch
||
682 !rdev
->ops
->tdls_cancel_channel_switch
)))
685 if (WARN_ON((wiphy
->interface_modes
& BIT(NL80211_IFTYPE_NAN
)) &&
686 (!rdev
->ops
->start_nan
|| !rdev
->ops
->stop_nan
||
687 !rdev
->ops
->add_nan_func
|| !rdev
->ops
->del_nan_func
||
688 !(wiphy
->nan_supported_bands
& BIT(NL80211_BAND_2GHZ
)))))
691 if (WARN_ON(wiphy
->interface_modes
& BIT(NL80211_IFTYPE_WDS
)))
694 if (WARN_ON(wiphy
->pmsr_capa
&& !wiphy
->pmsr_capa
->ftm
.supported
))
697 if (wiphy
->pmsr_capa
&& wiphy
->pmsr_capa
->ftm
.supported
) {
698 if (WARN_ON(!wiphy
->pmsr_capa
->ftm
.asap
&&
699 !wiphy
->pmsr_capa
->ftm
.non_asap
))
701 if (WARN_ON(!wiphy
->pmsr_capa
->ftm
.preambles
||
702 !wiphy
->pmsr_capa
->ftm
.bandwidths
))
704 if (WARN_ON(wiphy
->pmsr_capa
->ftm
.preambles
&
705 ~(BIT(NL80211_PREAMBLE_LEGACY
) |
706 BIT(NL80211_PREAMBLE_HT
) |
707 BIT(NL80211_PREAMBLE_VHT
) |
708 BIT(NL80211_PREAMBLE_HE
) |
709 BIT(NL80211_PREAMBLE_DMG
))))
711 if (WARN_ON((wiphy
->pmsr_capa
->ftm
.trigger_based
||
712 wiphy
->pmsr_capa
->ftm
.non_trigger_based
) &&
713 !(wiphy
->pmsr_capa
->ftm
.preambles
&
714 BIT(NL80211_PREAMBLE_HE
))))
716 if (WARN_ON(wiphy
->pmsr_capa
->ftm
.bandwidths
&
717 ~(BIT(NL80211_CHAN_WIDTH_20_NOHT
) |
718 BIT(NL80211_CHAN_WIDTH_20
) |
719 BIT(NL80211_CHAN_WIDTH_40
) |
720 BIT(NL80211_CHAN_WIDTH_80
) |
721 BIT(NL80211_CHAN_WIDTH_80P80
) |
722 BIT(NL80211_CHAN_WIDTH_160
) |
723 BIT(NL80211_CHAN_WIDTH_5
) |
724 BIT(NL80211_CHAN_WIDTH_10
))))
729 * if a wiphy has unsupported modes for regulatory channel enforcement,
730 * opt-out of enforcement checking
732 if (wiphy
->interface_modes
& ~(BIT(NL80211_IFTYPE_STATION
) |
733 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
734 BIT(NL80211_IFTYPE_AP
) |
735 BIT(NL80211_IFTYPE_P2P_GO
) |
736 BIT(NL80211_IFTYPE_ADHOC
) |
737 BIT(NL80211_IFTYPE_P2P_DEVICE
) |
738 BIT(NL80211_IFTYPE_NAN
) |
739 BIT(NL80211_IFTYPE_AP_VLAN
) |
740 BIT(NL80211_IFTYPE_MONITOR
)))
741 wiphy
->regulatory_flags
|= REGULATORY_IGNORE_STALE_KICKOFF
;
743 if (WARN_ON((wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
) &&
744 (wiphy
->regulatory_flags
&
745 (REGULATORY_CUSTOM_REG
|
746 REGULATORY_STRICT_REG
|
747 REGULATORY_COUNTRY_IE_FOLLOW_POWER
|
748 REGULATORY_COUNTRY_IE_IGNORE
))))
751 if (WARN_ON(wiphy
->coalesce
&&
752 (!wiphy
->coalesce
->n_rules
||
753 !wiphy
->coalesce
->n_patterns
) &&
754 (!wiphy
->coalesce
->pattern_min_len
||
755 wiphy
->coalesce
->pattern_min_len
>
756 wiphy
->coalesce
->pattern_max_len
)))
759 if (WARN_ON(wiphy
->ap_sme_capa
&&
760 !(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
)))
763 if (WARN_ON(wiphy
->addresses
&& !wiphy
->n_addresses
))
766 if (WARN_ON(wiphy
->addresses
&&
767 !is_zero_ether_addr(wiphy
->perm_addr
) &&
768 memcmp(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
,
772 if (WARN_ON(wiphy
->max_acl_mac_addrs
&&
773 (!(wiphy
->flags
& WIPHY_FLAG_HAVE_AP_SME
) ||
774 !rdev
->ops
->set_mac_acl
)))
777 /* assure only valid behaviours are flagged by driver
778 * hence subtract 2 as bit 0 is invalid.
780 if (WARN_ON(wiphy
->bss_select_support
&&
781 (wiphy
->bss_select_support
& ~(BIT(__NL80211_BSS_SELECT_ATTR_AFTER_LAST
) - 2))))
784 if (WARN_ON(wiphy_ext_feature_isset(&rdev
->wiphy
,
785 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X
) &&
786 (!rdev
->ops
->set_pmk
|| !rdev
->ops
->del_pmk
)))
789 if (WARN_ON(!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_FW_ROAM
) &&
790 rdev
->ops
->update_connect_params
))
793 if (wiphy
->addresses
)
794 memcpy(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
, ETH_ALEN
);
796 /* sanity check ifmodes */
798 ifmodes
&= ((1 << NUM_NL80211_IFTYPES
) - 1) & ~1;
799 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
800 wiphy
->interface_modes
= ifmodes
;
802 res
= wiphy_verify_combinations(wiphy
);
806 /* sanity check supported bands/channels */
807 for (band
= 0; band
< NUM_NL80211_BANDS
; band
++) {
809 bool have_he
= false;
811 sband
= wiphy
->bands
[band
];
816 if (WARN_ON(!sband
->n_channels
))
819 * on 60GHz or sub-1Ghz band, there are no legacy rates, so
822 if (WARN_ON((band
!= NL80211_BAND_60GHZ
&&
823 band
!= NL80211_BAND_S1GHZ
) &&
827 if (WARN_ON(band
== NL80211_BAND_6GHZ
&&
828 (sband
->ht_cap
.ht_supported
||
829 sband
->vht_cap
.vht_supported
)))
833 * Since cfg80211_disable_40mhz_24ghz is global, we can
834 * modify the sband's ht data even if the driver uses a
835 * global structure for that.
837 if (cfg80211_disable_40mhz_24ghz
&&
838 band
== NL80211_BAND_2GHZ
&&
839 sband
->ht_cap
.ht_supported
) {
840 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
841 sband
->ht_cap
.cap
&= ~IEEE80211_HT_CAP_SGI_40
;
845 * Since we use a u32 for rate bitmaps in
846 * ieee80211_get_response_rate, we cannot
847 * have more than 32 legacy rates.
849 if (WARN_ON(sband
->n_bitrates
> 32))
852 for (i
= 0; i
< sband
->n_channels
; i
++) {
853 sband
->channels
[i
].orig_flags
=
854 sband
->channels
[i
].flags
;
855 sband
->channels
[i
].orig_mag
= INT_MAX
;
856 sband
->channels
[i
].orig_mpwr
=
857 sband
->channels
[i
].max_power
;
858 sband
->channels
[i
].band
= band
;
860 if (WARN_ON(sband
->channels
[i
].freq_offset
>= 1000))
864 for (i
= 0; i
< sband
->n_iftype_data
; i
++) {
865 const struct ieee80211_sband_iftype_data
*iftd
;
867 iftd
= &sband
->iftype_data
[i
];
869 if (WARN_ON(!iftd
->types_mask
))
871 if (WARN_ON(types
& iftd
->types_mask
))
874 /* at least one piece of information must be present */
875 if (WARN_ON(!iftd
->he_cap
.has_he
))
878 types
|= iftd
->types_mask
;
881 have_he
= iftd
->he_cap
.has_he
;
887 if (WARN_ON(!have_he
&& band
== NL80211_BAND_6GHZ
))
898 for (i
= 0; i
< rdev
->wiphy
.n_vendor_commands
; i
++) {
900 * Validate we have a policy (can be explicitly set to
901 * VENDOR_CMD_RAW_DATA which is non-NULL) and also that
902 * we have at least one of doit/dumpit.
904 if (WARN_ON(!rdev
->wiphy
.vendor_commands
[i
].policy
))
906 if (WARN_ON(!rdev
->wiphy
.vendor_commands
[i
].doit
&&
907 !rdev
->wiphy
.vendor_commands
[i
].dumpit
))
912 if (WARN_ON(rdev
->wiphy
.wowlan
&& rdev
->wiphy
.wowlan
->n_patterns
&&
913 (!rdev
->wiphy
.wowlan
->pattern_min_len
||
914 rdev
->wiphy
.wowlan
->pattern_min_len
>
915 rdev
->wiphy
.wowlan
->pattern_max_len
)))
919 /* check and set up bitrates */
920 ieee80211_set_bitrate_flags(wiphy
);
922 rdev
->wiphy
.features
|= NL80211_FEATURE_SCAN_FLUSH
;
925 res
= device_add(&rdev
->wiphy
.dev
);
931 list_add_rcu(&rdev
->list
, &cfg80211_rdev_list
);
932 cfg80211_rdev_list_generation
++;
935 rdev
->wiphy
.debugfsdir
= debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
936 ieee80211_debugfs_dir
);
938 cfg80211_debugfs_rdev_add(rdev
);
939 nl80211_notify_wiphy(rdev
, NL80211_CMD_NEW_WIPHY
);
941 /* set up regulatory info */
942 wiphy_regulatory_register(wiphy
);
944 if (wiphy
->regulatory_flags
& REGULATORY_CUSTOM_REG
) {
945 struct regulatory_request request
;
947 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
948 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
949 request
.alpha2
[0] = '9';
950 request
.alpha2
[1] = '9';
952 nl80211_send_reg_change_event(&request
);
955 /* Check that nobody globally advertises any capabilities they do not
956 * advertise on all possible interface types.
958 if (wiphy
->extended_capabilities_len
&&
959 wiphy
->num_iftype_ext_capab
&&
960 wiphy
->iftype_ext_capab
) {
961 u8 supported_on_all
, j
;
962 const struct wiphy_iftype_ext_capab
*capab
;
964 capab
= wiphy
->iftype_ext_capab
;
965 for (j
= 0; j
< wiphy
->extended_capabilities_len
; j
++) {
966 if (capab
[0].extended_capabilities_len
> j
)
968 capab
[0].extended_capabilities
[j
];
970 supported_on_all
= 0x00;
971 for (i
= 1; i
< wiphy
->num_iftype_ext_capab
; i
++) {
972 if (j
>= capab
[i
].extended_capabilities_len
) {
973 supported_on_all
= 0x00;
977 capab
[i
].extended_capabilities
[j
];
979 if (WARN_ON(wiphy
->extended_capabilities
[j
] &
985 rdev
->wiphy
.registered
= true;
988 res
= rfkill_register(rdev
->wiphy
.rfkill
);
990 rfkill_destroy(rdev
->wiphy
.rfkill
);
991 rdev
->wiphy
.rfkill
= NULL
;
992 wiphy_unregister(&rdev
->wiphy
);
998 EXPORT_SYMBOL(wiphy_register
);
1000 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
1002 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
1004 if (!rdev
->ops
->rfkill_poll
)
1006 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
1007 rfkill_resume_polling(wiphy
->rfkill
);
1009 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
1011 void wiphy_unregister(struct wiphy
*wiphy
)
1013 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
1015 wait_event(rdev
->dev_wait
, ({
1017 wiphy_lock(&rdev
->wiphy
);
1018 __count
= rdev
->opencount
;
1019 wiphy_unlock(&rdev
->wiphy
);
1022 if (rdev
->wiphy
.rfkill
)
1023 rfkill_unregister(rdev
->wiphy
.rfkill
);
1026 wiphy_lock(&rdev
->wiphy
);
1027 nl80211_notify_wiphy(rdev
, NL80211_CMD_DEL_WIPHY
);
1028 rdev
->wiphy
.registered
= false;
1030 WARN_ON(!list_empty(&rdev
->wiphy
.wdev_list
));
1033 * First remove the hardware from everywhere, this makes
1034 * it impossible to find from userspace.
1036 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
1037 list_del_rcu(&rdev
->list
);
1041 * If this device got a regulatory hint tell core its
1042 * free to listen now to a new shiny device regulatory hint
1044 wiphy_regulatory_deregister(wiphy
);
1046 cfg80211_rdev_list_generation
++;
1047 device_del(&rdev
->wiphy
.dev
);
1049 wiphy_unlock(&rdev
->wiphy
);
1052 flush_work(&rdev
->scan_done_wk
);
1053 cancel_work_sync(&rdev
->conn_work
);
1054 flush_work(&rdev
->event_work
);
1055 cancel_delayed_work_sync(&rdev
->dfs_update_channels_wk
);
1056 flush_work(&rdev
->destroy_work
);
1057 flush_work(&rdev
->sched_scan_stop_wk
);
1058 flush_work(&rdev
->propagate_radar_detect_wk
);
1059 flush_work(&rdev
->propagate_cac_done_wk
);
1060 flush_work(&rdev
->mgmt_registrations_update_wk
);
1063 if (rdev
->wiphy
.wowlan_config
&& rdev
->ops
->set_wakeup
)
1064 rdev_set_wakeup(rdev
, false);
1066 cfg80211_rdev_free_wowlan(rdev
);
1067 cfg80211_rdev_free_coalesce(rdev
);
1069 EXPORT_SYMBOL(wiphy_unregister
);
1071 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
1073 struct cfg80211_internal_bss
*scan
, *tmp
;
1074 struct cfg80211_beacon_registration
*reg
, *treg
;
1075 rfkill_destroy(rdev
->wiphy
.rfkill
);
1076 list_for_each_entry_safe(reg
, treg
, &rdev
->beacon_registrations
, list
) {
1077 list_del(®
->list
);
1080 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
1081 cfg80211_put_bss(&rdev
->wiphy
, &scan
->pub
);
1082 mutex_destroy(&rdev
->wiphy
.mtx
);
1086 void wiphy_free(struct wiphy
*wiphy
)
1088 put_device(&wiphy
->dev
);
1090 EXPORT_SYMBOL(wiphy_free
);
1092 void wiphy_rfkill_set_hw_state_reason(struct wiphy
*wiphy
, bool blocked
,
1093 enum rfkill_hard_block_reasons reason
)
1095 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
1097 if (rfkill_set_hw_state_reason(wiphy
->rfkill
, blocked
, reason
))
1098 schedule_work(&rdev
->rfkill_block
);
1100 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state_reason
);
1102 void cfg80211_cqm_config_free(struct wireless_dev
*wdev
)
1104 kfree(wdev
->cqm_config
);
1105 wdev
->cqm_config
= NULL
;
1108 static void _cfg80211_unregister_wdev(struct wireless_dev
*wdev
,
1109 bool unregister_netdev
)
1111 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
1114 lockdep_assert_held(&rdev
->wiphy
.mtx
);
1116 flush_work(&wdev
->pmsr_free_wk
);
1118 nl80211_notify_iface(rdev
, wdev
, NL80211_CMD_DEL_INTERFACE
);
1120 wdev
->registered
= false;
1123 sysfs_remove_link(&wdev
->netdev
->dev
.kobj
, "phy80211");
1124 if (unregister_netdev
)
1125 unregister_netdevice(wdev
->netdev
);
1128 list_del_rcu(&wdev
->list
);
1130 rdev
->devlist_generation
++;
1132 cfg80211_mlme_purge_registrations(wdev
);
1134 switch (wdev
->iftype
) {
1135 case NL80211_IFTYPE_P2P_DEVICE
:
1136 cfg80211_stop_p2p_device(rdev
, wdev
);
1138 case NL80211_IFTYPE_NAN
:
1139 cfg80211_stop_nan(rdev
, wdev
);
1145 #ifdef CONFIG_CFG80211_WEXT
1146 kfree_sensitive(wdev
->wext
.keys
);
1147 wdev
->wext
.keys
= NULL
;
1149 /* only initialized if we have a netdev */
1151 flush_work(&wdev
->disconnect_wk
);
1153 cfg80211_cqm_config_free(wdev
);
1156 * Ensure that all events have been processed and
1159 cfg80211_process_wdev_events(wdev
);
1161 if (WARN_ON(wdev
->current_bss
)) {
1162 cfg80211_unhold_bss(wdev
->current_bss
);
1163 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
1164 wdev
->current_bss
= NULL
;
1168 void cfg80211_unregister_wdev(struct wireless_dev
*wdev
)
1170 _cfg80211_unregister_wdev(wdev
, true);
1172 EXPORT_SYMBOL(cfg80211_unregister_wdev
);
1174 static const struct device_type wiphy_type
= {
1178 void cfg80211_update_iface_num(struct cfg80211_registered_device
*rdev
,
1179 enum nl80211_iftype iftype
, int num
)
1181 lockdep_assert_held(&rdev
->wiphy
.mtx
);
1183 rdev
->num_running_ifaces
+= num
;
1184 if (iftype
== NL80211_IFTYPE_MONITOR
)
1185 rdev
->num_running_monitor_ifaces
+= num
;
1188 void __cfg80211_leave(struct cfg80211_registered_device
*rdev
,
1189 struct wireless_dev
*wdev
)
1191 struct net_device
*dev
= wdev
->netdev
;
1192 struct cfg80211_sched_scan_request
*pos
, *tmp
;
1194 lockdep_assert_held(&rdev
->wiphy
.mtx
);
1195 ASSERT_WDEV_LOCK(wdev
);
1197 cfg80211_pmsr_wdev_down(wdev
);
1199 switch (wdev
->iftype
) {
1200 case NL80211_IFTYPE_ADHOC
:
1201 __cfg80211_leave_ibss(rdev
, dev
, true);
1203 case NL80211_IFTYPE_P2P_CLIENT
:
1204 case NL80211_IFTYPE_STATION
:
1205 list_for_each_entry_safe(pos
, tmp
, &rdev
->sched_scan_req_list
,
1207 if (dev
== pos
->dev
)
1208 cfg80211_stop_sched_scan_req(rdev
, pos
, false);
1211 #ifdef CONFIG_CFG80211_WEXT
1212 kfree(wdev
->wext
.ie
);
1213 wdev
->wext
.ie
= NULL
;
1214 wdev
->wext
.ie_len
= 0;
1215 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
1217 cfg80211_disconnect(rdev
, dev
,
1218 WLAN_REASON_DEAUTH_LEAVING
, true);
1220 case NL80211_IFTYPE_MESH_POINT
:
1221 __cfg80211_leave_mesh(rdev
, dev
);
1223 case NL80211_IFTYPE_AP
:
1224 case NL80211_IFTYPE_P2P_GO
:
1225 __cfg80211_stop_ap(rdev
, dev
, true);
1227 case NL80211_IFTYPE_OCB
:
1228 __cfg80211_leave_ocb(rdev
, dev
);
1230 case NL80211_IFTYPE_P2P_DEVICE
:
1231 case NL80211_IFTYPE_NAN
:
1232 /* cannot happen, has no netdev */
1234 case NL80211_IFTYPE_AP_VLAN
:
1235 case NL80211_IFTYPE_MONITOR
:
1238 case NL80211_IFTYPE_UNSPECIFIED
:
1239 case NL80211_IFTYPE_WDS
:
1240 case NUM_NL80211_IFTYPES
:
1246 void cfg80211_leave(struct cfg80211_registered_device
*rdev
,
1247 struct wireless_dev
*wdev
)
1250 __cfg80211_leave(rdev
, wdev
);
1254 void cfg80211_stop_iface(struct wiphy
*wiphy
, struct wireless_dev
*wdev
,
1257 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
1258 struct cfg80211_event
*ev
;
1259 unsigned long flags
;
1261 trace_cfg80211_stop_iface(wiphy
, wdev
);
1263 ev
= kzalloc(sizeof(*ev
), gfp
);
1267 ev
->type
= EVENT_STOPPED
;
1269 spin_lock_irqsave(&wdev
->event_lock
, flags
);
1270 list_add_tail(&ev
->list
, &wdev
->event_list
);
1271 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
1272 queue_work(cfg80211_wq
, &rdev
->event_work
);
1274 EXPORT_SYMBOL(cfg80211_stop_iface
);
1276 void cfg80211_init_wdev(struct wireless_dev
*wdev
)
1278 mutex_init(&wdev
->mtx
);
1279 INIT_LIST_HEAD(&wdev
->event_list
);
1280 spin_lock_init(&wdev
->event_lock
);
1281 INIT_LIST_HEAD(&wdev
->mgmt_registrations
);
1282 spin_lock_init(&wdev
->mgmt_registrations_lock
);
1283 INIT_LIST_HEAD(&wdev
->pmsr_list
);
1284 spin_lock_init(&wdev
->pmsr_lock
);
1285 INIT_WORK(&wdev
->pmsr_free_wk
, cfg80211_pmsr_free_wk
);
1287 #ifdef CONFIG_CFG80211_WEXT
1288 wdev
->wext
.default_key
= -1;
1289 wdev
->wext
.default_mgmt_key
= -1;
1290 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
1293 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
1297 /* allow mac80211 to determine the timeout */
1298 wdev
->ps_timeout
= -1;
1300 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
1301 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
||
1302 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
1303 wdev
->netdev
->priv_flags
|= IFF_DONT_BRIDGE
;
1305 INIT_WORK(&wdev
->disconnect_wk
, cfg80211_autodisconnect_wk
);
1308 void cfg80211_register_wdev(struct cfg80211_registered_device
*rdev
,
1309 struct wireless_dev
*wdev
)
1312 lockdep_assert_held(&rdev
->wiphy
.mtx
);
1315 * We get here also when the interface changes network namespaces,
1316 * as it's registered into the new one, but we don't want it to
1317 * change ID in that case. Checking if the ID is already assigned
1318 * works, because 0 isn't considered a valid ID and the memory is
1321 if (!wdev
->identifier
)
1322 wdev
->identifier
= ++rdev
->wdev_id
;
1323 list_add_rcu(&wdev
->list
, &rdev
->wiphy
.wdev_list
);
1324 rdev
->devlist_generation
++;
1325 wdev
->registered
= true;
1328 sysfs_create_link(&wdev
->netdev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
1330 pr_err("failed to add phy80211 symlink to netdev!\n");
1332 nl80211_notify_iface(rdev
, wdev
, NL80211_CMD_NEW_INTERFACE
);
1335 int cfg80211_register_netdevice(struct net_device
*dev
)
1337 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1338 struct cfg80211_registered_device
*rdev
;
1346 rdev
= wiphy_to_rdev(wdev
->wiphy
);
1348 lockdep_assert_held(&rdev
->wiphy
.mtx
);
1350 /* we'll take care of this */
1351 wdev
->registered
= true;
1352 wdev
->registering
= true;
1353 ret
= register_netdevice(dev
);
1357 cfg80211_register_wdev(rdev
, wdev
);
1360 wdev
->registering
= false;
1362 wdev
->registered
= false;
1365 EXPORT_SYMBOL(cfg80211_register_netdevice
);
1367 static int cfg80211_netdev_notifier_call(struct notifier_block
*nb
,
1368 unsigned long state
, void *ptr
)
1370 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1371 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1372 struct cfg80211_registered_device
*rdev
;
1373 struct cfg80211_sched_scan_request
*pos
, *tmp
;
1378 rdev
= wiphy_to_rdev(wdev
->wiphy
);
1380 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
1383 case NETDEV_POST_INIT
:
1384 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
1386 /* can only change netns with wiphy */
1387 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1389 cfg80211_init_wdev(wdev
);
1391 case NETDEV_REGISTER
:
1392 if (!wdev
->registered
) {
1393 wiphy_lock(&rdev
->wiphy
);
1394 cfg80211_register_wdev(rdev
, wdev
);
1395 wiphy_unlock(&rdev
->wiphy
);
1398 case NETDEV_UNREGISTER
:
1400 * It is possible to get NETDEV_UNREGISTER multiple times,
1401 * so check wdev->registered.
1403 if (wdev
->registered
&& !wdev
->registering
) {
1404 wiphy_lock(&rdev
->wiphy
);
1405 _cfg80211_unregister_wdev(wdev
, false);
1406 wiphy_unlock(&rdev
->wiphy
);
1409 case NETDEV_GOING_DOWN
:
1410 wiphy_lock(&rdev
->wiphy
);
1411 cfg80211_leave(rdev
, wdev
);
1412 wiphy_unlock(&rdev
->wiphy
);
1415 wiphy_lock(&rdev
->wiphy
);
1416 cfg80211_update_iface_num(rdev
, wdev
->iftype
, -1);
1417 if (rdev
->scan_req
&& rdev
->scan_req
->wdev
== wdev
) {
1418 if (WARN_ON(!rdev
->scan_req
->notified
&&
1419 (!rdev
->int_scan_req
||
1420 !rdev
->int_scan_req
->notified
)))
1421 rdev
->scan_req
->info
.aborted
= true;
1422 ___cfg80211_scan_done(rdev
, false);
1425 list_for_each_entry_safe(pos
, tmp
,
1426 &rdev
->sched_scan_req_list
, list
) {
1427 if (WARN_ON(pos
->dev
== wdev
->netdev
))
1428 cfg80211_stop_sched_scan_req(rdev
, pos
, false);
1432 wiphy_unlock(&rdev
->wiphy
);
1433 wake_up(&rdev
->dev_wait
);
1436 wiphy_lock(&rdev
->wiphy
);
1437 cfg80211_update_iface_num(rdev
, wdev
->iftype
, 1);
1439 switch (wdev
->iftype
) {
1440 #ifdef CONFIG_CFG80211_WEXT
1441 case NL80211_IFTYPE_ADHOC
:
1442 cfg80211_ibss_wext_join(rdev
, wdev
);
1444 case NL80211_IFTYPE_STATION
:
1445 cfg80211_mgd_wext_connect(rdev
, wdev
);
1448 #ifdef CONFIG_MAC80211_MESH
1449 case NL80211_IFTYPE_MESH_POINT
:
1451 /* backward compat code... */
1452 struct mesh_setup setup
;
1453 memcpy(&setup
, &default_mesh_setup
,
1455 /* back compat only needed for mesh_id */
1456 setup
.mesh_id
= wdev
->ssid
;
1457 setup
.mesh_id_len
= wdev
->mesh_id_up_len
;
1458 if (wdev
->mesh_id_up_len
)
1459 __cfg80211_join_mesh(rdev
, dev
,
1461 &default_mesh_config
);
1472 * Configure power management to the driver here so that its
1473 * correctly set also after interface type changes etc.
1475 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
1476 wdev
->iftype
== NL80211_IFTYPE_P2P_CLIENT
) &&
1477 rdev
->ops
->set_power_mgmt
&&
1478 rdev_set_power_mgmt(rdev
, dev
, wdev
->ps
,
1479 wdev
->ps_timeout
)) {
1480 /* assume this means it's off */
1483 wiphy_unlock(&rdev
->wiphy
);
1486 if (!cfg80211_iftype_allowed(wdev
->wiphy
, wdev
->iftype
,
1487 wdev
->use_4addr
, 0))
1488 return notifier_from_errno(-EOPNOTSUPP
);
1490 if (rfkill_blocked(rdev
->wiphy
.rfkill
))
1491 return notifier_from_errno(-ERFKILL
);
1497 wireless_nlevent_flush();
1502 static struct notifier_block cfg80211_netdev_notifier
= {
1503 .notifier_call
= cfg80211_netdev_notifier_call
,
1506 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
1508 struct cfg80211_registered_device
*rdev
;
1511 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
1512 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
1513 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
1518 static struct pernet_operations cfg80211_pernet_ops
= {
1519 .exit
= cfg80211_pernet_exit
,
1522 static int __init
cfg80211_init(void)
1526 err
= register_pernet_device(&cfg80211_pernet_ops
);
1528 goto out_fail_pernet
;
1530 err
= wiphy_sysfs_init();
1532 goto out_fail_sysfs
;
1534 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
1536 goto out_fail_notifier
;
1538 err
= nl80211_init();
1540 goto out_fail_nl80211
;
1542 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
1544 err
= regulatory_init();
1548 cfg80211_wq
= alloc_ordered_workqueue("cfg80211", WQ_MEM_RECLAIM
);
1559 debugfs_remove(ieee80211_debugfs_dir
);
1562 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1566 unregister_pernet_device(&cfg80211_pernet_ops
);
1570 fs_initcall(cfg80211_init
);
1572 static void __exit
cfg80211_exit(void)
1574 debugfs_remove(ieee80211_debugfs_dir
);
1576 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
1579 unregister_pernet_device(&cfg80211_pernet_ops
);
1580 destroy_workqueue(cfg80211_wq
);
1582 module_exit(cfg80211_exit
);