1
2
3
4
5
6
7
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#include <linux/if.h>
12#include <linux/module.h>
13#include <linux/err.h>
14#include <linux/list.h>
15#include <linux/slab.h>
16#include <linux/nl80211.h>
17#include <linux/debugfs.h>
18#include <linux/notifier.h>
19#include <linux/device.h>
20#include <linux/etherdevice.h>
21#include <linux/rtnetlink.h>
22#include <linux/sched.h>
23#include <net/genetlink.h>
24#include <net/cfg80211.h>
25#include "nl80211.h"
26#include "core.h"
27#include "sysfs.h"
28#include "debugfs.h"
29#include "wext-compat.h"
30#include "rdev-ops.h"
31
32
33#define PHY_NAME "phy"
34
35MODULE_AUTHOR("Johannes Berg");
36MODULE_LICENSE("GPL");
37MODULE_DESCRIPTION("wireless configuration support");
38MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
39
40
41LIST_HEAD(cfg80211_rdev_list);
42int cfg80211_rdev_list_generation;
43
44
45static struct dentry *ieee80211_debugfs_dir;
46
47
48struct workqueue_struct *cfg80211_wq;
49
50static bool cfg80211_disable_40mhz_24ghz;
51module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
52MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
53 "Disable 40MHz support in the 2.4GHz band");
54
55struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
56{
57 struct cfg80211_registered_device *result = NULL, *rdev;
58
59 ASSERT_RTNL();
60
61 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
62 if (rdev->wiphy_idx == wiphy_idx) {
63 result = rdev;
64 break;
65 }
66 }
67
68 return result;
69}
70
71int get_wiphy_idx(struct wiphy *wiphy)
72{
73 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
74
75 return rdev->wiphy_idx;
76}
77
78struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
79{
80 struct cfg80211_registered_device *rdev;
81
82 ASSERT_RTNL();
83
84 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
85 if (!rdev)
86 return NULL;
87 return &rdev->wiphy;
88}
89
90static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
91 const char *newname)
92{
93 struct cfg80211_registered_device *rdev2;
94 int wiphy_idx, taken = -1, digits;
95
96 ASSERT_RTNL();
97
98
99 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
100 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
101
102 digits = 1;
103 while (wiphy_idx /= 10)
104 digits++;
105
106
107
108
109 if (taken == strlen(PHY_NAME) + digits)
110 return -EINVAL;
111 }
112
113
114 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
115 if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
116 return -EINVAL;
117
118 return 0;
119}
120
121int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
122 char *newname)
123{
124 int result;
125
126 ASSERT_RTNL();
127
128
129 if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
130 return 0;
131
132 result = cfg80211_dev_check_name(rdev, newname);
133 if (result < 0)
134 return result;
135
136 result = device_rename(&rdev->wiphy.dev, newname);
137 if (result)
138 return result;
139
140 if (rdev->wiphy.debugfsdir &&
141 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
142 rdev->wiphy.debugfsdir,
143 rdev->wiphy.debugfsdir->d_parent,
144 newname))
145 pr_err("failed to rename debugfs dir to %s!\n", newname);
146
147 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
148
149 return 0;
150}
151
152int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
153 struct net *net)
154{
155 struct wireless_dev *wdev;
156 int err = 0;
157
158 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
159 return -EOPNOTSUPP;
160
161 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
162 if (!wdev->netdev)
163 continue;
164 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
165 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
166 if (err)
167 break;
168 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
169 }
170
171 if (err) {
172
173 net = wiphy_net(&rdev->wiphy);
174
175 list_for_each_entry_continue_reverse(wdev,
176 &rdev->wiphy.wdev_list,
177 list) {
178 if (!wdev->netdev)
179 continue;
180 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
181 err = dev_change_net_namespace(wdev->netdev, net,
182 "wlan%d");
183 WARN_ON(err);
184 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
185 }
186
187 return err;
188 }
189
190 wiphy_net_set(&rdev->wiphy, net);
191
192 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
193 WARN_ON(err);
194
195 return 0;
196}
197
198static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
199{
200 struct cfg80211_registered_device *rdev = data;
201
202 rdev_rfkill_poll(rdev);
203}
204
205void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
206 struct wireless_dev *wdev)
207{
208 ASSERT_RTNL();
209
210 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
211 return;
212
213 if (!wdev_running(wdev))
214 return;
215
216 rdev_stop_p2p_device(rdev, wdev);
217 wdev->is_running = false;
218
219 rdev->opencount--;
220
221 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
222 if (WARN_ON(!rdev->scan_req->notified))
223 rdev->scan_req->info.aborted = true;
224 ___cfg80211_scan_done(rdev, false);
225 }
226}
227
228void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
229 struct wireless_dev *wdev)
230{
231 ASSERT_RTNL();
232
233 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_NAN))
234 return;
235
236 if (!wdev_running(wdev))
237 return;
238
239 rdev_stop_nan(rdev, wdev);
240 wdev->is_running = false;
241
242 rdev->opencount--;
243}
244
245void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
246{
247 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
248 struct wireless_dev *wdev;
249
250 ASSERT_RTNL();
251
252 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
253 if (wdev->netdev) {
254 dev_close(wdev->netdev);
255 continue;
256 }
257
258 switch (wdev->iftype) {
259 case NL80211_IFTYPE_P2P_DEVICE:
260 cfg80211_stop_p2p_device(rdev, wdev);
261 break;
262 case NL80211_IFTYPE_NAN:
263 cfg80211_stop_nan(rdev, wdev);
264 break;
265 default:
266 break;
267 }
268 }
269}
270EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
271
272static int cfg80211_rfkill_set_block(void *data, bool blocked)
273{
274 struct cfg80211_registered_device *rdev = data;
275
276 if (!blocked)
277 return 0;
278
279 rtnl_lock();
280 cfg80211_shutdown_all_interfaces(&rdev->wiphy);
281 rtnl_unlock();
282
283 return 0;
284}
285
286static void cfg80211_rfkill_sync_work(struct work_struct *work)
287{
288 struct cfg80211_registered_device *rdev;
289
290 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
291 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
292}
293
294static void cfg80211_event_work(struct work_struct *work)
295{
296 struct cfg80211_registered_device *rdev;
297
298 rdev = container_of(work, struct cfg80211_registered_device,
299 event_work);
300
301 rtnl_lock();
302 cfg80211_process_rdev_events(rdev);
303 rtnl_unlock();
304}
305
306void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
307{
308 struct wireless_dev *wdev, *tmp;
309
310 ASSERT_RTNL();
311
312 list_for_each_entry_safe(wdev, tmp, &rdev->wiphy.wdev_list, list) {
313 if (wdev->nl_owner_dead)
314 rdev_del_virtual_intf(rdev, wdev);
315 }
316}
317
318static void cfg80211_destroy_iface_wk(struct work_struct *work)
319{
320 struct cfg80211_registered_device *rdev;
321
322 rdev = container_of(work, struct cfg80211_registered_device,
323 destroy_work);
324
325 rtnl_lock();
326 cfg80211_destroy_ifaces(rdev);
327 rtnl_unlock();
328}
329
330static void cfg80211_sched_scan_stop_wk(struct work_struct *work)
331{
332 struct cfg80211_registered_device *rdev;
333 struct cfg80211_sched_scan_request *req, *tmp;
334
335 rdev = container_of(work, struct cfg80211_registered_device,
336 sched_scan_stop_wk);
337
338 rtnl_lock();
339 list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
340 if (req->nl_owner_dead)
341 cfg80211_stop_sched_scan_req(rdev, req, false);
342 }
343 rtnl_unlock();
344}
345
346static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
347{
348 struct cfg80211_registered_device *rdev;
349
350 rdev = container_of(work, struct cfg80211_registered_device,
351 propagate_radar_detect_wk);
352
353 rtnl_lock();
354
355 regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->radar_chandef,
356 NL80211_DFS_UNAVAILABLE,
357 NL80211_RADAR_DETECTED);
358
359 rtnl_unlock();
360}
361
362static void cfg80211_propagate_cac_done_wk(struct work_struct *work)
363{
364 struct cfg80211_registered_device *rdev;
365
366 rdev = container_of(work, struct cfg80211_registered_device,
367 propagate_cac_done_wk);
368
369 rtnl_lock();
370
371 regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
372 NL80211_DFS_AVAILABLE,
373 NL80211_RADAR_CAC_FINISHED);
374
375 rtnl_unlock();
376}
377
378
379
380struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
381 const char *requested_name)
382{
383 static atomic_t wiphy_counter = ATOMIC_INIT(0);
384
385 struct cfg80211_registered_device *rdev;
386 int alloc_size;
387
388 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
389 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
390 WARN_ON(ops->connect && !ops->disconnect);
391 WARN_ON(ops->join_ibss && !ops->leave_ibss);
392 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
393 WARN_ON(ops->add_station && !ops->del_station);
394 WARN_ON(ops->add_mpath && !ops->del_mpath);
395 WARN_ON(ops->join_mesh && !ops->leave_mesh);
396 WARN_ON(ops->start_p2p_device && !ops->stop_p2p_device);
397 WARN_ON(ops->start_ap && !ops->stop_ap);
398 WARN_ON(ops->join_ocb && !ops->leave_ocb);
399 WARN_ON(ops->suspend && !ops->resume);
400 WARN_ON(ops->sched_scan_start && !ops->sched_scan_stop);
401 WARN_ON(ops->remain_on_channel && !ops->cancel_remain_on_channel);
402 WARN_ON(ops->tdls_channel_switch && !ops->tdls_cancel_channel_switch);
403 WARN_ON(ops->add_tx_ts && !ops->del_tx_ts);
404
405 alloc_size = sizeof(*rdev) + sizeof_priv;
406
407 rdev = kzalloc(alloc_size, GFP_KERNEL);
408 if (!rdev)
409 return NULL;
410
411 rdev->ops = ops;
412
413 rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
414
415 if (unlikely(rdev->wiphy_idx < 0)) {
416
417 atomic_dec(&wiphy_counter);
418 kfree(rdev);
419 return NULL;
420 }
421
422
423 rdev->wiphy_idx--;
424
425
426 if (requested_name && requested_name[0]) {
427 int rv;
428
429 rtnl_lock();
430 rv = cfg80211_dev_check_name(rdev, requested_name);
431
432 if (rv < 0) {
433 rtnl_unlock();
434 goto use_default_name;
435 }
436
437 rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
438 rtnl_unlock();
439 if (rv)
440 goto use_default_name;
441 } else {
442 int rv;
443
444use_default_name:
445
446
447
448
449
450
451 rv = dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
452 if (rv < 0) {
453 kfree(rdev);
454 return NULL;
455 }
456 }
457
458 INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
459 INIT_LIST_HEAD(&rdev->beacon_registrations);
460 spin_lock_init(&rdev->beacon_registrations_lock);
461 spin_lock_init(&rdev->bss_lock);
462 INIT_LIST_HEAD(&rdev->bss_list);
463 INIT_LIST_HEAD(&rdev->sched_scan_req_list);
464 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
465 INIT_LIST_HEAD(&rdev->mlme_unreg);
466 spin_lock_init(&rdev->mlme_unreg_lock);
467 INIT_WORK(&rdev->mlme_unreg_wk, cfg80211_mlme_unreg_wk);
468 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
469 cfg80211_dfs_channels_update_work);
470#ifdef CONFIG_CFG80211_WEXT
471 rdev->wiphy.wext = &cfg80211_wext_handler;
472#endif
473
474 device_initialize(&rdev->wiphy.dev);
475 rdev->wiphy.dev.class = &ieee80211_class;
476 rdev->wiphy.dev.platform_data = rdev;
477 device_enable_async_suspend(&rdev->wiphy.dev);
478
479 INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
480 INIT_WORK(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
481 INIT_WORK(&rdev->sched_scan_res_wk, cfg80211_sched_scan_results_wk);
482 INIT_WORK(&rdev->propagate_radar_detect_wk,
483 cfg80211_propagate_radar_detect_wk);
484 INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
485
486#ifdef CONFIG_CFG80211_DEFAULT_PS
487 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
488#endif
489
490 wiphy_net_set(&rdev->wiphy, &init_net);
491
492 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
493 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
494 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
495 &rdev->rfkill_ops, rdev);
496
497 if (!rdev->rfkill) {
498 kfree(rdev);
499 return NULL;
500 }
501
502 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
503 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
504 INIT_WORK(&rdev->event_work, cfg80211_event_work);
505
506 init_waitqueue_head(&rdev->dev_wait);
507
508
509
510
511
512
513 rdev->wiphy.retry_short = 7;
514 rdev->wiphy.retry_long = 4;
515 rdev->wiphy.frag_threshold = (u32) -1;
516 rdev->wiphy.rts_threshold = (u32) -1;
517 rdev->wiphy.coverage_class = 0;
518
519 rdev->wiphy.max_num_csa_counters = 1;
520
521 rdev->wiphy.max_sched_scan_plans = 1;
522 rdev->wiphy.max_sched_scan_plan_interval = U32_MAX;
523
524 return &rdev->wiphy;
525}
526EXPORT_SYMBOL(wiphy_new_nm);
527
528static int wiphy_verify_combinations(struct wiphy *wiphy)
529{
530 const struct ieee80211_iface_combination *c;
531 int i, j;
532
533 for (i = 0; i < wiphy->n_iface_combinations; i++) {
534 u32 cnt = 0;
535 u16 all_iftypes = 0;
536
537 c = &wiphy->iface_combinations[i];
538
539
540
541
542
543 if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
544 return -EINVAL;
545
546
547 if (WARN_ON(!c->num_different_channels))
548 return -EINVAL;
549
550
551
552
553
554 if (WARN_ON(c->num_different_channels >
555 CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
556 return -EINVAL;
557
558
559 if (WARN_ON(c->radar_detect_widths &&
560 (c->num_different_channels > 1)))
561 return -EINVAL;
562
563 if (WARN_ON(!c->n_limits))
564 return -EINVAL;
565
566 for (j = 0; j < c->n_limits; j++) {
567 u16 types = c->limits[j].types;
568
569
570 if (WARN_ON(types & all_iftypes))
571 return -EINVAL;
572 all_iftypes |= types;
573
574 if (WARN_ON(!c->limits[j].max))
575 return -EINVAL;
576
577
578 if (WARN_ON(wiphy->software_iftypes & types))
579 return -EINVAL;
580
581
582 if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
583 c->limits[j].max > 1))
584 return -EINVAL;
585
586
587 if (WARN_ON(types & BIT(NL80211_IFTYPE_NAN) &&
588 c->limits[j].max > 1))
589 return -EINVAL;
590
591
592
593
594
595
596
597
598
599
600
601 if (WARN_ON(types & BIT(NL80211_IFTYPE_ADHOC) &&
602 c->beacon_int_min_gcd)) {
603 return -EINVAL;
604 }
605
606 cnt += c->limits[j].max;
607
608
609
610
611 if (WARN_ON((wiphy->interface_modes & types) != types))
612 return -EINVAL;
613 }
614
615#ifndef CONFIG_WIRELESS_WDS
616 if (WARN_ON(all_iftypes & BIT(NL80211_IFTYPE_WDS)))
617 return -EINVAL;
618#endif
619
620
621 if (WARN_ON(cnt < c->max_interfaces))
622 return -EINVAL;
623 }
624
625 return 0;
626}
627
628int wiphy_register(struct wiphy *wiphy)
629{
630 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
631 int res;
632 enum nl80211_band band;
633 struct ieee80211_supported_band *sband;
634 bool have_band = false;
635 int i;
636 u16 ifmodes = wiphy->interface_modes;
637
638#ifdef CONFIG_PM
639 if (WARN_ON(wiphy->wowlan &&
640 (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
641 !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
642 return -EINVAL;
643 if (WARN_ON(wiphy->wowlan &&
644 !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
645 !wiphy->wowlan->tcp))
646 return -EINVAL;
647#endif
648 if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
649 (!rdev->ops->tdls_channel_switch ||
650 !rdev->ops->tdls_cancel_channel_switch)))
651 return -EINVAL;
652
653 if (WARN_ON((wiphy->interface_modes & BIT(NL80211_IFTYPE_NAN)) &&
654 (!rdev->ops->start_nan || !rdev->ops->stop_nan ||
655 !rdev->ops->add_nan_func || !rdev->ops->del_nan_func ||
656 !(wiphy->nan_supported_bands & BIT(NL80211_BAND_2GHZ)))))
657 return -EINVAL;
658
659#ifndef CONFIG_WIRELESS_WDS
660 if (WARN_ON(wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)))
661 return -EINVAL;
662#endif
663
664
665
666
667
668 if (wiphy->interface_modes & ~(BIT(NL80211_IFTYPE_STATION) |
669 BIT(NL80211_IFTYPE_P2P_CLIENT) |
670 BIT(NL80211_IFTYPE_AP) |
671 BIT(NL80211_IFTYPE_P2P_GO) |
672 BIT(NL80211_IFTYPE_ADHOC) |
673 BIT(NL80211_IFTYPE_P2P_DEVICE) |
674 BIT(NL80211_IFTYPE_NAN) |
675 BIT(NL80211_IFTYPE_AP_VLAN) |
676 BIT(NL80211_IFTYPE_MONITOR)))
677 wiphy->regulatory_flags |= REGULATORY_IGNORE_STALE_KICKOFF;
678
679 if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
680 (wiphy->regulatory_flags &
681 (REGULATORY_CUSTOM_REG |
682 REGULATORY_STRICT_REG |
683 REGULATORY_COUNTRY_IE_FOLLOW_POWER |
684 REGULATORY_COUNTRY_IE_IGNORE))))
685 return -EINVAL;
686
687 if (WARN_ON(wiphy->coalesce &&
688 (!wiphy->coalesce->n_rules ||
689 !wiphy->coalesce->n_patterns) &&
690 (!wiphy->coalesce->pattern_min_len ||
691 wiphy->coalesce->pattern_min_len >
692 wiphy->coalesce->pattern_max_len)))
693 return -EINVAL;
694
695 if (WARN_ON(wiphy->ap_sme_capa &&
696 !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
697 return -EINVAL;
698
699 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
700 return -EINVAL;
701
702 if (WARN_ON(wiphy->addresses &&
703 !is_zero_ether_addr(wiphy->perm_addr) &&
704 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
705 ETH_ALEN)))
706 return -EINVAL;
707
708 if (WARN_ON(wiphy->max_acl_mac_addrs &&
709 (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
710 !rdev->ops->set_mac_acl)))
711 return -EINVAL;
712
713
714
715
716 if (WARN_ON(wiphy->bss_select_support &&
717 (wiphy->bss_select_support & ~(BIT(__NL80211_BSS_SELECT_ATTR_AFTER_LAST) - 2))))
718 return -EINVAL;
719
720 if (WARN_ON(wiphy_ext_feature_isset(&rdev->wiphy,
721 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X) &&
722 (!rdev->ops->set_pmk || !rdev->ops->del_pmk)))
723 return -EINVAL;
724
725 if (wiphy->addresses)
726 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
727
728
729 WARN_ON(!ifmodes);
730 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
731 if (WARN_ON(ifmodes != wiphy->interface_modes))
732 wiphy->interface_modes = ifmodes;
733
734 res = wiphy_verify_combinations(wiphy);
735 if (res)
736 return res;
737
738
739 for (band = 0; band < NUM_NL80211_BANDS; band++) {
740 sband = wiphy->bands[band];
741 if (!sband)
742 continue;
743
744 sband->band = band;
745 if (WARN_ON(!sband->n_channels))
746 return -EINVAL;
747
748
749
750
751 if (WARN_ON(band != NL80211_BAND_60GHZ &&
752 !sband->n_bitrates))
753 return -EINVAL;
754
755
756
757
758
759
760 if (cfg80211_disable_40mhz_24ghz &&
761 band == NL80211_BAND_2GHZ &&
762 sband->ht_cap.ht_supported) {
763 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
764 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
765 }
766
767
768
769
770
771
772 if (WARN_ON(sband->n_bitrates > 32))
773 return -EINVAL;
774
775 for (i = 0; i < sband->n_channels; i++) {
776 sband->channels[i].orig_flags =
777 sband->channels[i].flags;
778 sband->channels[i].orig_mag = INT_MAX;
779 sband->channels[i].orig_mpwr =
780 sband->channels[i].max_power;
781 sband->channels[i].band = band;
782 }
783
784 have_band = true;
785 }
786
787 if (!have_band) {
788 WARN_ON(1);
789 return -EINVAL;
790 }
791
792#ifdef CONFIG_PM
793 if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
794 (!rdev->wiphy.wowlan->pattern_min_len ||
795 rdev->wiphy.wowlan->pattern_min_len >
796 rdev->wiphy.wowlan->pattern_max_len)))
797 return -EINVAL;
798#endif
799
800
801 ieee80211_set_bitrate_flags(wiphy);
802
803 rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
804
805 rtnl_lock();
806 res = device_add(&rdev->wiphy.dev);
807 if (res) {
808 rtnl_unlock();
809 return res;
810 }
811
812
813 wiphy_regulatory_register(wiphy);
814
815 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
816 cfg80211_rdev_list_generation++;
817
818
819 rdev->wiphy.debugfsdir =
820 debugfs_create_dir(wiphy_name(&rdev->wiphy),
821 ieee80211_debugfs_dir);
822 if (IS_ERR(rdev->wiphy.debugfsdir))
823 rdev->wiphy.debugfsdir = NULL;
824
825 cfg80211_debugfs_rdev_add(rdev);
826 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
827
828 if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
829 struct regulatory_request request;
830
831 request.wiphy_idx = get_wiphy_idx(wiphy);
832 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
833 request.alpha2[0] = '9';
834 request.alpha2[1] = '9';
835
836 nl80211_send_reg_change_event(&request);
837 }
838
839
840
841
842 if (wiphy->extended_capabilities_len &&
843 wiphy->num_iftype_ext_capab &&
844 wiphy->iftype_ext_capab) {
845 u8 supported_on_all, j;
846 const struct wiphy_iftype_ext_capab *capab;
847
848 capab = wiphy->iftype_ext_capab;
849 for (j = 0; j < wiphy->extended_capabilities_len; j++) {
850 if (capab[0].extended_capabilities_len > j)
851 supported_on_all =
852 capab[0].extended_capabilities[j];
853 else
854 supported_on_all = 0x00;
855 for (i = 1; i < wiphy->num_iftype_ext_capab; i++) {
856 if (j >= capab[i].extended_capabilities_len) {
857 supported_on_all = 0x00;
858 break;
859 }
860 supported_on_all &=
861 capab[i].extended_capabilities[j];
862 }
863 if (WARN_ON(wiphy->extended_capabilities[j] &
864 ~supported_on_all))
865 break;
866 }
867 }
868
869 rdev->wiphy.registered = true;
870 rtnl_unlock();
871
872 res = rfkill_register(rdev->rfkill);
873 if (res) {
874 rfkill_destroy(rdev->rfkill);
875 rdev->rfkill = NULL;
876 wiphy_unregister(&rdev->wiphy);
877 return res;
878 }
879
880 return 0;
881}
882EXPORT_SYMBOL(wiphy_register);
883
884void wiphy_rfkill_start_polling(struct wiphy *wiphy)
885{
886 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
887
888 if (!rdev->ops->rfkill_poll)
889 return;
890 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
891 rfkill_resume_polling(rdev->rfkill);
892}
893EXPORT_SYMBOL(wiphy_rfkill_start_polling);
894
895void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
896{
897 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
898
899 rfkill_pause_polling(rdev->rfkill);
900}
901EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
902
903void wiphy_unregister(struct wiphy *wiphy)
904{
905 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
906
907 wait_event(rdev->dev_wait, ({
908 int __count;
909 rtnl_lock();
910 __count = rdev->opencount;
911 rtnl_unlock();
912 __count == 0; }));
913
914 if (rdev->rfkill)
915 rfkill_unregister(rdev->rfkill);
916
917 rtnl_lock();
918 nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
919 rdev->wiphy.registered = false;
920
921 WARN_ON(!list_empty(&rdev->wiphy.wdev_list));
922
923
924
925
926
927 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
928 list_del_rcu(&rdev->list);
929 synchronize_rcu();
930
931
932
933
934
935 wiphy_regulatory_deregister(wiphy);
936
937 cfg80211_rdev_list_generation++;
938 device_del(&rdev->wiphy.dev);
939
940 rtnl_unlock();
941
942 flush_work(&rdev->scan_done_wk);
943 cancel_work_sync(&rdev->conn_work);
944 flush_work(&rdev->event_work);
945 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
946 flush_work(&rdev->destroy_work);
947 flush_work(&rdev->sched_scan_stop_wk);
948 flush_work(&rdev->mlme_unreg_wk);
949 flush_work(&rdev->propagate_radar_detect_wk);
950 flush_work(&rdev->propagate_cac_done_wk);
951
952#ifdef CONFIG_PM
953 if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
954 rdev_set_wakeup(rdev, false);
955#endif
956 cfg80211_rdev_free_wowlan(rdev);
957 cfg80211_rdev_free_coalesce(rdev);
958}
959EXPORT_SYMBOL(wiphy_unregister);
960
961void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
962{
963 struct cfg80211_internal_bss *scan, *tmp;
964 struct cfg80211_beacon_registration *reg, *treg;
965 rfkill_destroy(rdev->rfkill);
966 list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
967 list_del(®->list);
968 kfree(reg);
969 }
970 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
971 cfg80211_put_bss(&rdev->wiphy, &scan->pub);
972 kfree(rdev);
973}
974
975void wiphy_free(struct wiphy *wiphy)
976{
977 put_device(&wiphy->dev);
978}
979EXPORT_SYMBOL(wiphy_free);
980
981void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
982{
983 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
984
985 if (rfkill_set_hw_state(rdev->rfkill, blocked))
986 schedule_work(&rdev->rfkill_sync);
987}
988EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
989
990void cfg80211_cqm_config_free(struct wireless_dev *wdev)
991{
992 kfree(wdev->cqm_config);
993 wdev->cqm_config = NULL;
994}
995
996void cfg80211_unregister_wdev(struct wireless_dev *wdev)
997{
998 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
999
1000 ASSERT_RTNL();
1001
1002 if (WARN_ON(wdev->netdev))
1003 return;
1004
1005 nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
1006
1007 list_del_rcu(&wdev->list);
1008 rdev->devlist_generation++;
1009
1010 switch (wdev->iftype) {
1011 case NL80211_IFTYPE_P2P_DEVICE:
1012 cfg80211_mlme_purge_registrations(wdev);
1013 cfg80211_stop_p2p_device(rdev, wdev);
1014 break;
1015 case NL80211_IFTYPE_NAN:
1016 cfg80211_stop_nan(rdev, wdev);
1017 break;
1018 default:
1019 WARN_ON_ONCE(1);
1020 break;
1021 }
1022
1023 cfg80211_cqm_config_free(wdev);
1024}
1025EXPORT_SYMBOL(cfg80211_unregister_wdev);
1026
1027static const struct device_type wiphy_type = {
1028 .name = "wlan",
1029};
1030
1031void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
1032 enum nl80211_iftype iftype, int num)
1033{
1034 ASSERT_RTNL();
1035
1036 rdev->num_running_ifaces += num;
1037 if (iftype == NL80211_IFTYPE_MONITOR)
1038 rdev->num_running_monitor_ifaces += num;
1039}
1040
1041void __cfg80211_leave(struct cfg80211_registered_device *rdev,
1042 struct wireless_dev *wdev)
1043{
1044 struct net_device *dev = wdev->netdev;
1045 struct cfg80211_sched_scan_request *pos, *tmp;
1046
1047 ASSERT_RTNL();
1048 ASSERT_WDEV_LOCK(wdev);
1049
1050 switch (wdev->iftype) {
1051 case NL80211_IFTYPE_ADHOC:
1052 __cfg80211_leave_ibss(rdev, dev, true);
1053 break;
1054 case NL80211_IFTYPE_P2P_CLIENT:
1055 case NL80211_IFTYPE_STATION:
1056 list_for_each_entry_safe(pos, tmp, &rdev->sched_scan_req_list,
1057 list) {
1058 if (dev == pos->dev)
1059 cfg80211_stop_sched_scan_req(rdev, pos, false);
1060 }
1061
1062#ifdef CONFIG_CFG80211_WEXT
1063 kfree(wdev->wext.ie);
1064 wdev->wext.ie = NULL;
1065 wdev->wext.ie_len = 0;
1066 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1067#endif
1068 cfg80211_disconnect(rdev, dev,
1069 WLAN_REASON_DEAUTH_LEAVING, true);
1070 break;
1071 case NL80211_IFTYPE_MESH_POINT:
1072 __cfg80211_leave_mesh(rdev, dev);
1073 break;
1074 case NL80211_IFTYPE_AP:
1075 case NL80211_IFTYPE_P2P_GO:
1076 __cfg80211_stop_ap(rdev, dev, true);
1077 break;
1078 case NL80211_IFTYPE_OCB:
1079 __cfg80211_leave_ocb(rdev, dev);
1080 break;
1081 case NL80211_IFTYPE_WDS:
1082
1083 break;
1084 case NL80211_IFTYPE_P2P_DEVICE:
1085 case NL80211_IFTYPE_NAN:
1086
1087 break;
1088 case NL80211_IFTYPE_AP_VLAN:
1089 case NL80211_IFTYPE_MONITOR:
1090
1091 break;
1092 case NL80211_IFTYPE_UNSPECIFIED:
1093 case NUM_NL80211_IFTYPES:
1094
1095 break;
1096 }
1097}
1098
1099void cfg80211_leave(struct cfg80211_registered_device *rdev,
1100 struct wireless_dev *wdev)
1101{
1102 wdev_lock(wdev);
1103 __cfg80211_leave(rdev, wdev);
1104 wdev_unlock(wdev);
1105}
1106
1107void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
1108 gfp_t gfp)
1109{
1110 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1111 struct cfg80211_event *ev;
1112 unsigned long flags;
1113
1114 trace_cfg80211_stop_iface(wiphy, wdev);
1115
1116 ev = kzalloc(sizeof(*ev), gfp);
1117 if (!ev)
1118 return;
1119
1120 ev->type = EVENT_STOPPED;
1121
1122 spin_lock_irqsave(&wdev->event_lock, flags);
1123 list_add_tail(&ev->list, &wdev->event_list);
1124 spin_unlock_irqrestore(&wdev->event_lock, flags);
1125 queue_work(cfg80211_wq, &rdev->event_work);
1126}
1127EXPORT_SYMBOL(cfg80211_stop_iface);
1128
1129static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
1130 unsigned long state, void *ptr)
1131{
1132 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1133 struct wireless_dev *wdev = dev->ieee80211_ptr;
1134 struct cfg80211_registered_device *rdev;
1135 struct cfg80211_sched_scan_request *pos, *tmp;
1136
1137 if (!wdev)
1138 return NOTIFY_DONE;
1139
1140 rdev = wiphy_to_rdev(wdev->wiphy);
1141
1142 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
1143
1144 switch (state) {
1145 case NETDEV_POST_INIT:
1146 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
1147 break;
1148 case NETDEV_REGISTER:
1149
1150
1151
1152
1153
1154 mutex_init(&wdev->mtx);
1155 INIT_LIST_HEAD(&wdev->event_list);
1156 spin_lock_init(&wdev->event_lock);
1157 INIT_LIST_HEAD(&wdev->mgmt_registrations);
1158 spin_lock_init(&wdev->mgmt_registrations_lock);
1159
1160
1161
1162
1163
1164
1165
1166
1167 if (!wdev->identifier)
1168 wdev->identifier = ++rdev->wdev_id;
1169 list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
1170 rdev->devlist_generation++;
1171
1172 dev->features |= NETIF_F_NETNS_LOCAL;
1173
1174 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
1175 "phy80211")) {
1176 pr_err("failed to add phy80211 symlink to netdev!\n");
1177 }
1178 wdev->netdev = dev;
1179#ifdef CONFIG_CFG80211_WEXT
1180 wdev->wext.default_key = -1;
1181 wdev->wext.default_mgmt_key = -1;
1182 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1183#endif
1184
1185 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
1186 wdev->ps = true;
1187 else
1188 wdev->ps = false;
1189
1190 wdev->ps_timeout = -1;
1191
1192 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1193 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
1194 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
1195 dev->priv_flags |= IFF_DONT_BRIDGE;
1196
1197 INIT_WORK(&wdev->disconnect_wk, cfg80211_autodisconnect_wk);
1198
1199 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
1200 break;
1201 case NETDEV_GOING_DOWN:
1202 cfg80211_leave(rdev, wdev);
1203 break;
1204 case NETDEV_DOWN:
1205 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1206 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1207 if (WARN_ON(!rdev->scan_req->notified))
1208 rdev->scan_req->info.aborted = true;
1209 ___cfg80211_scan_done(rdev, false);
1210 }
1211
1212 list_for_each_entry_safe(pos, tmp,
1213 &rdev->sched_scan_req_list, list) {
1214 if (WARN_ON(pos && pos->dev == wdev->netdev))
1215 cfg80211_stop_sched_scan_req(rdev, pos, false);
1216 }
1217
1218 rdev->opencount--;
1219 wake_up(&rdev->dev_wait);
1220 break;
1221 case NETDEV_UP:
1222 cfg80211_update_iface_num(rdev, wdev->iftype, 1);
1223 wdev_lock(wdev);
1224 switch (wdev->iftype) {
1225#ifdef CONFIG_CFG80211_WEXT
1226 case NL80211_IFTYPE_ADHOC:
1227 cfg80211_ibss_wext_join(rdev, wdev);
1228 break;
1229 case NL80211_IFTYPE_STATION:
1230 cfg80211_mgd_wext_connect(rdev, wdev);
1231 break;
1232#endif
1233#ifdef CONFIG_MAC80211_MESH
1234 case NL80211_IFTYPE_MESH_POINT:
1235 {
1236
1237 struct mesh_setup setup;
1238 memcpy(&setup, &default_mesh_setup,
1239 sizeof(setup));
1240
1241 setup.mesh_id = wdev->ssid;
1242 setup.mesh_id_len = wdev->mesh_id_up_len;
1243 if (wdev->mesh_id_up_len)
1244 __cfg80211_join_mesh(rdev, dev,
1245 &setup,
1246 &default_mesh_config);
1247 break;
1248 }
1249#endif
1250 default:
1251 break;
1252 }
1253 wdev_unlock(wdev);
1254 rdev->opencount++;
1255
1256
1257
1258
1259
1260 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1261 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
1262 rdev->ops->set_power_mgmt &&
1263 rdev_set_power_mgmt(rdev, dev, wdev->ps,
1264 wdev->ps_timeout)) {
1265
1266 wdev->ps = false;
1267 }
1268 break;
1269 case NETDEV_UNREGISTER:
1270
1271
1272
1273
1274
1275
1276
1277 if (!list_empty(&wdev->list)) {
1278 nl80211_notify_iface(rdev, wdev,
1279 NL80211_CMD_DEL_INTERFACE);
1280 sysfs_remove_link(&dev->dev.kobj, "phy80211");
1281 list_del_rcu(&wdev->list);
1282 rdev->devlist_generation++;
1283 cfg80211_mlme_purge_registrations(wdev);
1284#ifdef CONFIG_CFG80211_WEXT
1285 kzfree(wdev->wext.keys);
1286#endif
1287 flush_work(&wdev->disconnect_wk);
1288 cfg80211_cqm_config_free(wdev);
1289 }
1290
1291
1292
1293
1294
1295
1296 synchronize_rcu();
1297 INIT_LIST_HEAD(&wdev->list);
1298
1299
1300
1301
1302 cfg80211_process_wdev_events(wdev);
1303
1304 if (WARN_ON(wdev->current_bss)) {
1305 cfg80211_unhold_bss(wdev->current_bss);
1306 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
1307 wdev->current_bss = NULL;
1308 }
1309 break;
1310 case NETDEV_PRE_UP:
1311 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
1312 return notifier_from_errno(-EOPNOTSUPP);
1313 if (rfkill_blocked(rdev->rfkill))
1314 return notifier_from_errno(-ERFKILL);
1315 break;
1316 default:
1317 return NOTIFY_DONE;
1318 }
1319
1320 wireless_nlevent_flush();
1321
1322 return NOTIFY_OK;
1323}
1324
1325static struct notifier_block cfg80211_netdev_notifier = {
1326 .notifier_call = cfg80211_netdev_notifier_call,
1327};
1328
1329static void __net_exit cfg80211_pernet_exit(struct net *net)
1330{
1331 struct cfg80211_registered_device *rdev;
1332
1333 rtnl_lock();
1334 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1335 if (net_eq(wiphy_net(&rdev->wiphy), net))
1336 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1337 }
1338 rtnl_unlock();
1339}
1340
1341static struct pernet_operations cfg80211_pernet_ops = {
1342 .exit = cfg80211_pernet_exit,
1343};
1344
1345static int __init cfg80211_init(void)
1346{
1347 int err;
1348
1349 err = register_pernet_device(&cfg80211_pernet_ops);
1350 if (err)
1351 goto out_fail_pernet;
1352
1353 err = wiphy_sysfs_init();
1354 if (err)
1355 goto out_fail_sysfs;
1356
1357 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1358 if (err)
1359 goto out_fail_notifier;
1360
1361 err = nl80211_init();
1362 if (err)
1363 goto out_fail_nl80211;
1364
1365 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1366
1367 err = regulatory_init();
1368 if (err)
1369 goto out_fail_reg;
1370
1371 cfg80211_wq = alloc_ordered_workqueue("cfg80211", WQ_MEM_RECLAIM);
1372 if (!cfg80211_wq) {
1373 err = -ENOMEM;
1374 goto out_fail_wq;
1375 }
1376
1377 return 0;
1378
1379out_fail_wq:
1380 regulatory_exit();
1381out_fail_reg:
1382 debugfs_remove(ieee80211_debugfs_dir);
1383 nl80211_exit();
1384out_fail_nl80211:
1385 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1386out_fail_notifier:
1387 wiphy_sysfs_exit();
1388out_fail_sysfs:
1389 unregister_pernet_device(&cfg80211_pernet_ops);
1390out_fail_pernet:
1391 return err;
1392}
1393fs_initcall(cfg80211_init);
1394
1395static void __exit cfg80211_exit(void)
1396{
1397 debugfs_remove(ieee80211_debugfs_dir);
1398 nl80211_exit();
1399 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1400 wiphy_sysfs_exit();
1401 regulatory_exit();
1402 unregister_pernet_device(&cfg80211_pernet_ops);
1403 destroy_workqueue(cfg80211_wq);
1404}
1405module_exit(cfg80211_exit);
1406
