core.c (cce3b573a52a41dd7face9dbf745f10f9bf4632b) core.c (e8c2af660ba0790afd14d5cbc2fd05c6dc85e207)
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * This is the linux wireless configuration interface.
4 *
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-2022 Intel Corporation

--- 115 unchanged lines hidden (view full) ---

124}
125
126int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
127 char *newname)
128{
129 int result;
130
131 ASSERT_RTNL();
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * This is the linux wireless configuration interface.
4 *
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-2022 Intel Corporation

--- 115 unchanged lines hidden (view full) ---

124}
125
126int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
127 char *newname)
128{
129 int result;
130
131 ASSERT_RTNL();
132 lockdep_assert_wiphy(&rdev->wiphy);
132
133 /* Ignore nop renames */
134 if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
135 return 0;
136
137 result = cfg80211_dev_check_name(rdev, newname);
138 if (result < 0)
139 return result;

--- 50 unchanged lines hidden (view full) ---

190 return err;
191 }
192
193 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
194 if (!wdev->netdev)
195 continue;
196 nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
197 }
133
134 /* Ignore nop renames */
135 if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
136 return 0;
137
138 result = cfg80211_dev_check_name(rdev, newname);
139 if (result < 0)
140 return result;

--- 50 unchanged lines hidden (view full) ---

191 return err;
192 }
193
194 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
195 if (!wdev->netdev)
196 continue;
197 nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
198 }
199
200 wiphy_lock(&rdev->wiphy);
198 nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
199
200 wiphy_net_set(&rdev->wiphy, net);
201
202 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
203 WARN_ON(err);
204
205 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
201 nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
202
203 wiphy_net_set(&rdev->wiphy, net);
204
205 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
206 WARN_ON(err);
207
208 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
209 wiphy_unlock(&rdev->wiphy);
210
206 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
207 if (!wdev->netdev)
208 continue;
209 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
210 }
211
212 return 0;
213}

--- 141 unchanged lines hidden (view full) ---

355 rdev = container_of(work, struct cfg80211_registered_device,
356 destroy_work);
357
358 rtnl_lock();
359 cfg80211_destroy_ifaces(rdev);
360 rtnl_unlock();
361}
362
211 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
212 if (!wdev->netdev)
213 continue;
214 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
215 }
216
217 return 0;
218}

--- 141 unchanged lines hidden (view full) ---

360 rdev = container_of(work, struct cfg80211_registered_device,
361 destroy_work);
362
363 rtnl_lock();
364 cfg80211_destroy_ifaces(rdev);
365 rtnl_unlock();
366}
367
363static void cfg80211_sched_scan_stop_wk(struct work_struct *work)
368static void cfg80211_sched_scan_stop_wk(struct wiphy *wiphy,
369 struct wiphy_work *work)
364{
365 struct cfg80211_registered_device *rdev;
366 struct cfg80211_sched_scan_request *req, *tmp;
367
368 rdev = container_of(work, struct cfg80211_registered_device,
369 sched_scan_stop_wk);
370
370{
371 struct cfg80211_registered_device *rdev;
372 struct cfg80211_sched_scan_request *req, *tmp;
373
374 rdev = container_of(work, struct cfg80211_registered_device,
375 sched_scan_stop_wk);
376
371 wiphy_lock(&rdev->wiphy);
372 list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
373 if (req->nl_owner_dead)
374 cfg80211_stop_sched_scan_req(rdev, req, false);
375 }
377 list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
378 if (req->nl_owner_dead)
379 cfg80211_stop_sched_scan_req(rdev, req, false);
380 }
376 wiphy_unlock(&rdev->wiphy);
377}
378
379static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
380{
381 struct cfg80211_registered_device *rdev;
382
383 rdev = container_of(work, struct cfg80211_registered_device,
384 propagate_radar_detect_wk);

--- 18 unchanged lines hidden (view full) ---

403
404 regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
405 NL80211_DFS_AVAILABLE,
406 NL80211_RADAR_CAC_FINISHED);
407
408 rtnl_unlock();
409}
410
381}
382
383static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
384{
385 struct cfg80211_registered_device *rdev;
386
387 rdev = container_of(work, struct cfg80211_registered_device,
388 propagate_radar_detect_wk);

--- 18 unchanged lines hidden (view full) ---

407
408 regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
409 NL80211_DFS_AVAILABLE,
410 NL80211_RADAR_CAC_FINISHED);
411
412 rtnl_unlock();
413}
414
415static void cfg80211_wiphy_work(struct work_struct *work)
416{
417 struct cfg80211_registered_device *rdev;
418 struct wiphy_work *wk;
419
420 rdev = container_of(work, struct cfg80211_registered_device, wiphy_work);
421
422 wiphy_lock(&rdev->wiphy);
423 if (rdev->suspended)
424 goto out;
425
426 spin_lock_irq(&rdev->wiphy_work_lock);
427 wk = list_first_entry_or_null(&rdev->wiphy_work_list,
428 struct wiphy_work, entry);
429 if (wk) {
430 list_del_init(&wk->entry);
431 if (!list_empty(&rdev->wiphy_work_list))
432 schedule_work(work);
433 spin_unlock_irq(&rdev->wiphy_work_lock);
434
435 wk->func(&rdev->wiphy, wk);
436 } else {
437 spin_unlock_irq(&rdev->wiphy_work_lock);
438 }
439out:
440 wiphy_unlock(&rdev->wiphy);
441}
442
411/* exported functions */
412
413struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
414 const char *requested_name)
415{
416 static atomic_t wiphy_counter = ATOMIC_INIT(0);
417
418 struct cfg80211_registered_device *rdev;

--- 71 unchanged lines hidden (view full) ---

490
491 mutex_init(&rdev->wiphy.mtx);
492 INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
493 INIT_LIST_HEAD(&rdev->beacon_registrations);
494 spin_lock_init(&rdev->beacon_registrations_lock);
495 spin_lock_init(&rdev->bss_lock);
496 INIT_LIST_HEAD(&rdev->bss_list);
497 INIT_LIST_HEAD(&rdev->sched_scan_req_list);
443/* exported functions */
444
445struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
446 const char *requested_name)
447{
448 static atomic_t wiphy_counter = ATOMIC_INIT(0);
449
450 struct cfg80211_registered_device *rdev;

--- 71 unchanged lines hidden (view full) ---

522
523 mutex_init(&rdev->wiphy.mtx);
524 INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
525 INIT_LIST_HEAD(&rdev->beacon_registrations);
526 spin_lock_init(&rdev->beacon_registrations_lock);
527 spin_lock_init(&rdev->bss_lock);
528 INIT_LIST_HEAD(&rdev->bss_list);
529 INIT_LIST_HEAD(&rdev->sched_scan_req_list);
498 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
530 wiphy_work_init(&rdev->scan_done_wk, __cfg80211_scan_done);
499 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
500 cfg80211_dfs_channels_update_work);
501#ifdef CONFIG_CFG80211_WEXT
502 rdev->wiphy.wext = &cfg80211_wext_handler;
503#endif
504
505 device_initialize(&rdev->wiphy.dev);
506 rdev->wiphy.dev.class = &ieee80211_class;
507 rdev->wiphy.dev.platform_data = rdev;
508 device_enable_async_suspend(&rdev->wiphy.dev);
509
510 INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
531 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
532 cfg80211_dfs_channels_update_work);
533#ifdef CONFIG_CFG80211_WEXT
534 rdev->wiphy.wext = &cfg80211_wext_handler;
535#endif
536
537 device_initialize(&rdev->wiphy.dev);
538 rdev->wiphy.dev.class = &ieee80211_class;
539 rdev->wiphy.dev.platform_data = rdev;
540 device_enable_async_suspend(&rdev->wiphy.dev);
541
542 INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
511 INIT_WORK(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
543 wiphy_work_init(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
512 INIT_WORK(&rdev->sched_scan_res_wk, cfg80211_sched_scan_results_wk);
513 INIT_WORK(&rdev->propagate_radar_detect_wk,
514 cfg80211_propagate_radar_detect_wk);
515 INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
516 INIT_WORK(&rdev->mgmt_registrations_update_wk,
517 cfg80211_mgmt_registrations_update_wk);
518 spin_lock_init(&rdev->mgmt_registrations_lock);
519

--- 8 unchanged lines hidden (view full) ---

528 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
529 &rdev->rfkill_ops, rdev);
530
531 if (!rdev->wiphy.rfkill) {
532 wiphy_free(&rdev->wiphy);
533 return NULL;
534 }
535
544 INIT_WORK(&rdev->sched_scan_res_wk, cfg80211_sched_scan_results_wk);
545 INIT_WORK(&rdev->propagate_radar_detect_wk,
546 cfg80211_propagate_radar_detect_wk);
547 INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
548 INIT_WORK(&rdev->mgmt_registrations_update_wk,
549 cfg80211_mgmt_registrations_update_wk);
550 spin_lock_init(&rdev->mgmt_registrations_lock);
551

--- 8 unchanged lines hidden (view full) ---

560 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
561 &rdev->rfkill_ops, rdev);
562
563 if (!rdev->wiphy.rfkill) {
564 wiphy_free(&rdev->wiphy);
565 return NULL;
566 }
567
568 INIT_WORK(&rdev->wiphy_work, cfg80211_wiphy_work);
569 INIT_LIST_HEAD(&rdev->wiphy_work_list);
570 spin_lock_init(&rdev->wiphy_work_lock);
536 INIT_WORK(&rdev->rfkill_block, cfg80211_rfkill_block_work);
537 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
538 INIT_WORK(&rdev->event_work, cfg80211_event_work);
539 INIT_WORK(&rdev->background_cac_abort_wk,
540 cfg80211_background_cac_abort_wk);
541 INIT_DELAYED_WORK(&rdev->background_cac_done_wk,
542 cfg80211_background_cac_done_wk);
543

--- 172 unchanged lines hidden (view full) ---

716 BIT(NL80211_CHAN_WIDTH_80) |
717 BIT(NL80211_CHAN_WIDTH_80P80) |
718 BIT(NL80211_CHAN_WIDTH_160) |
719 BIT(NL80211_CHAN_WIDTH_5) |
720 BIT(NL80211_CHAN_WIDTH_10))))
721 return -EINVAL;
722 }
723
571 INIT_WORK(&rdev->rfkill_block, cfg80211_rfkill_block_work);
572 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
573 INIT_WORK(&rdev->event_work, cfg80211_event_work);
574 INIT_WORK(&rdev->background_cac_abort_wk,
575 cfg80211_background_cac_abort_wk);
576 INIT_DELAYED_WORK(&rdev->background_cac_done_wk,
577 cfg80211_background_cac_done_wk);
578

--- 172 unchanged lines hidden (view full) ---

751 BIT(NL80211_CHAN_WIDTH_80) |
752 BIT(NL80211_CHAN_WIDTH_80P80) |
753 BIT(NL80211_CHAN_WIDTH_160) |
754 BIT(NL80211_CHAN_WIDTH_5) |
755 BIT(NL80211_CHAN_WIDTH_10))))
756 return -EINVAL;
757 }
758
724 /*
725 * if a wiphy has unsupported modes for regulatory channel enforcement,
726 * opt-out of enforcement checking
727 */
728 if (wiphy->interface_modes & ~(BIT(NL80211_IFTYPE_STATION) |
729 BIT(NL80211_IFTYPE_P2P_CLIENT) |
730 BIT(NL80211_IFTYPE_AP) |
731 BIT(NL80211_IFTYPE_MESH_POINT) |
732 BIT(NL80211_IFTYPE_P2P_GO) |
733 BIT(NL80211_IFTYPE_ADHOC) |
734 BIT(NL80211_IFTYPE_P2P_DEVICE) |
735 BIT(NL80211_IFTYPE_NAN) |
736 BIT(NL80211_IFTYPE_AP_VLAN) |
737 BIT(NL80211_IFTYPE_MONITOR)))
738 wiphy->regulatory_flags |= REGULATORY_IGNORE_STALE_KICKOFF;
739
740 if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
741 (wiphy->regulatory_flags &
742 (REGULATORY_CUSTOM_REG |
743 REGULATORY_STRICT_REG |
744 REGULATORY_COUNTRY_IE_FOLLOW_POWER |
745 REGULATORY_COUNTRY_IE_IGNORE))))
746 return -EINVAL;
747

--- 188 unchanged lines hidden (view full) ---

936 return -EINVAL;
937
938 /* check and set up bitrates */
939 ieee80211_set_bitrate_flags(wiphy);
940
941 rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
942
943 rtnl_lock();
759 if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
760 (wiphy->regulatory_flags &
761 (REGULATORY_CUSTOM_REG |
762 REGULATORY_STRICT_REG |
763 REGULATORY_COUNTRY_IE_FOLLOW_POWER |
764 REGULATORY_COUNTRY_IE_IGNORE))))
765 return -EINVAL;
766

--- 188 unchanged lines hidden (view full) ---

955 return -EINVAL;
956
957 /* check and set up bitrates */
958 ieee80211_set_bitrate_flags(wiphy);
959
960 rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
961
962 rtnl_lock();
963 wiphy_lock(&rdev->wiphy);
944 res = device_add(&rdev->wiphy.dev);
945 if (res) {
964 res = device_add(&rdev->wiphy.dev);
965 if (res) {
966 wiphy_unlock(&rdev->wiphy);
946 rtnl_unlock();
947 return res;
948 }
949
950 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
951 cfg80211_rdev_list_generation++;
952
953 /* add to debugfs */
954 rdev->wiphy.debugfsdir = debugfs_create_dir(wiphy_name(&rdev->wiphy),
955 ieee80211_debugfs_dir);
956
957 cfg80211_debugfs_rdev_add(rdev);
958 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
967 rtnl_unlock();
968 return res;
969 }
970
971 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
972 cfg80211_rdev_list_generation++;
973
974 /* add to debugfs */
975 rdev->wiphy.debugfsdir = debugfs_create_dir(wiphy_name(&rdev->wiphy),
976 ieee80211_debugfs_dir);
977
978 cfg80211_debugfs_rdev_add(rdev);
979 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
980 wiphy_unlock(&rdev->wiphy);
959
960 /* set up regulatory info */
961 wiphy_regulatory_register(wiphy);
962
963 if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
964 struct regulatory_request request;
965
966 request.wiphy_idx = get_wiphy_idx(wiphy);

--- 55 unchanged lines hidden (view full) ---

1022
1023 if (!rdev->ops->rfkill_poll)
1024 return;
1025 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
1026 rfkill_resume_polling(wiphy->rfkill);
1027}
1028EXPORT_SYMBOL(wiphy_rfkill_start_polling);
1029
981
982 /* set up regulatory info */
983 wiphy_regulatory_register(wiphy);
984
985 if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
986 struct regulatory_request request;
987
988 request.wiphy_idx = get_wiphy_idx(wiphy);

--- 55 unchanged lines hidden (view full) ---

1044
1045 if (!rdev->ops->rfkill_poll)
1046 return;
1047 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
1048 rfkill_resume_polling(wiphy->rfkill);
1049}
1050EXPORT_SYMBOL(wiphy_rfkill_start_polling);
1051
1052void cfg80211_process_wiphy_works(struct cfg80211_registered_device *rdev)
1053{
1054 unsigned int runaway_limit = 100;
1055 unsigned long flags;
1056
1057 lockdep_assert_held(&rdev->wiphy.mtx);
1058
1059 spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1060 while (!list_empty(&rdev->wiphy_work_list)) {
1061 struct wiphy_work *wk;
1062
1063 wk = list_first_entry(&rdev->wiphy_work_list,
1064 struct wiphy_work, entry);
1065 list_del_init(&wk->entry);
1066 spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1067
1068 wk->func(&rdev->wiphy, wk);
1069
1070 spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1071 if (WARN_ON(--runaway_limit == 0))
1072 INIT_LIST_HEAD(&rdev->wiphy_work_list);
1073 }
1074 spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1075}
1076
1030void wiphy_unregister(struct wiphy *wiphy)
1031{
1032 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1033
1034 wait_event(rdev->dev_wait, ({
1035 int __count;
1036 wiphy_lock(&rdev->wiphy);
1037 __count = rdev->opencount;

--- 22 unchanged lines hidden (view full) ---

1060 * If this device got a regulatory hint tell core its
1061 * free to listen now to a new shiny device regulatory hint
1062 */
1063 wiphy_regulatory_deregister(wiphy);
1064
1065 cfg80211_rdev_list_generation++;
1066 device_del(&rdev->wiphy.dev);
1067
1077void wiphy_unregister(struct wiphy *wiphy)
1078{
1079 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1080
1081 wait_event(rdev->dev_wait, ({
1082 int __count;
1083 wiphy_lock(&rdev->wiphy);
1084 __count = rdev->opencount;

--- 22 unchanged lines hidden (view full) ---

1107 * If this device got a regulatory hint tell core its
1108 * free to listen now to a new shiny device regulatory hint
1109 */
1110 wiphy_regulatory_deregister(wiphy);
1111
1112 cfg80211_rdev_list_generation++;
1113 device_del(&rdev->wiphy.dev);
1114
1115#ifdef CONFIG_PM
1116 if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
1117 rdev_set_wakeup(rdev, false);
1118#endif
1119
1120 /* surely nothing is reachable now, clean up work */
1121 cfg80211_process_wiphy_works(rdev);
1068 wiphy_unlock(&rdev->wiphy);
1069 rtnl_unlock();
1070
1122 wiphy_unlock(&rdev->wiphy);
1123 rtnl_unlock();
1124
1071 flush_work(&rdev->scan_done_wk);
1125 /* this has nothing to do now but make sure it's gone */
1126 cancel_work_sync(&rdev->wiphy_work);
1127
1072 cancel_work_sync(&rdev->conn_work);
1073 flush_work(&rdev->event_work);
1074 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
1075 cancel_delayed_work_sync(&rdev->background_cac_done_wk);
1076 flush_work(&rdev->destroy_work);
1128 cancel_work_sync(&rdev->conn_work);
1129 flush_work(&rdev->event_work);
1130 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
1131 cancel_delayed_work_sync(&rdev->background_cac_done_wk);
1132 flush_work(&rdev->destroy_work);
1077 flush_work(&rdev->sched_scan_stop_wk);
1078 flush_work(&rdev->propagate_radar_detect_wk);
1079 flush_work(&rdev->propagate_cac_done_wk);
1080 flush_work(&rdev->mgmt_registrations_update_wk);
1081 flush_work(&rdev->background_cac_abort_wk);
1082
1133 flush_work(&rdev->propagate_radar_detect_wk);
1134 flush_work(&rdev->propagate_cac_done_wk);
1135 flush_work(&rdev->mgmt_registrations_update_wk);
1136 flush_work(&rdev->background_cac_abort_wk);
1137
1083#ifdef CONFIG_PM
1084 if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
1085 rdev_set_wakeup(rdev, false);
1086#endif
1087 cfg80211_rdev_free_wowlan(rdev);
1088 cfg80211_rdev_free_coalesce(rdev);
1089}
1090EXPORT_SYMBOL(wiphy_unregister);
1091
1092void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
1093{
1094 struct cfg80211_internal_bss *scan, *tmp;

--- 45 unchanged lines hidden (view full) ---

1140 bool unregister_netdev)
1141{
1142 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1143 unsigned int link_id;
1144
1145 ASSERT_RTNL();
1146 lockdep_assert_held(&rdev->wiphy.mtx);
1147
1138 cfg80211_rdev_free_wowlan(rdev);
1139 cfg80211_rdev_free_coalesce(rdev);
1140}
1141EXPORT_SYMBOL(wiphy_unregister);
1142
1143void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
1144{
1145 struct cfg80211_internal_bss *scan, *tmp;

--- 45 unchanged lines hidden (view full) ---

1191 bool unregister_netdev)
1192{
1193 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1194 unsigned int link_id;
1195
1196 ASSERT_RTNL();
1197 lockdep_assert_held(&rdev->wiphy.mtx);
1198
1148 flush_work(&wdev->pmsr_free_wk);
1149
1150 nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
1151
1152 wdev->registered = false;
1153
1154 if (wdev->netdev) {
1155 sysfs_remove_link(&wdev->netdev->dev.kobj, "phy80211");
1156 if (unregister_netdev)
1157 unregister_netdevice(wdev->netdev);

--- 15 unchanged lines hidden (view full) ---

1173 default:
1174 break;
1175 }
1176
1177#ifdef CONFIG_CFG80211_WEXT
1178 kfree_sensitive(wdev->wext.keys);
1179 wdev->wext.keys = NULL;
1180#endif
1199 nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
1200
1201 wdev->registered = false;
1202
1203 if (wdev->netdev) {
1204 sysfs_remove_link(&wdev->netdev->dev.kobj, "phy80211");
1205 if (unregister_netdev)
1206 unregister_netdevice(wdev->netdev);

--- 15 unchanged lines hidden (view full) ---

1222 default:
1223 break;
1224 }
1225
1226#ifdef CONFIG_CFG80211_WEXT
1227 kfree_sensitive(wdev->wext.keys);
1228 wdev->wext.keys = NULL;
1229#endif
1181 /* only initialized if we have a netdev */
1182 if (wdev->netdev)
1183 flush_work(&wdev->disconnect_wk);
1184
1185 cfg80211_cqm_config_free(wdev);
1186
1187 /*
1188 * Ensure that all events have been processed and
1189 * freed.
1190 */
1191 cfg80211_process_wdev_events(wdev);
1192

--- 257 unchanged lines hidden (view full) ---

1450 wiphy_unlock(&rdev->wiphy);
1451 }
1452 break;
1453 case NETDEV_GOING_DOWN:
1454 wiphy_lock(&rdev->wiphy);
1455 cfg80211_leave(rdev, wdev);
1456 cfg80211_remove_links(wdev);
1457 wiphy_unlock(&rdev->wiphy);
1230 cfg80211_cqm_config_free(wdev);
1231
1232 /*
1233 * Ensure that all events have been processed and
1234 * freed.
1235 */
1236 cfg80211_process_wdev_events(wdev);
1237

--- 257 unchanged lines hidden (view full) ---

1495 wiphy_unlock(&rdev->wiphy);
1496 }
1497 break;
1498 case NETDEV_GOING_DOWN:
1499 wiphy_lock(&rdev->wiphy);
1500 cfg80211_leave(rdev, wdev);
1501 cfg80211_remove_links(wdev);
1502 wiphy_unlock(&rdev->wiphy);
1503 /* since we just did cfg80211_leave() nothing to do there */
1504 cancel_work_sync(&wdev->disconnect_wk);
1505 cancel_work_sync(&wdev->pmsr_free_wk);
1458 break;
1459 case NETDEV_DOWN:
1460 wiphy_lock(&rdev->wiphy);
1461 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1462 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1463 if (WARN_ON(!rdev->scan_req->notified &&
1464 (!rdev->int_scan_req ||
1465 !rdev->int_scan_req->notified)))

--- 93 unchanged lines hidden (view full) ---

1559 }
1560 rtnl_unlock();
1561}
1562
1563static struct pernet_operations cfg80211_pernet_ops = {
1564 .exit = cfg80211_pernet_exit,
1565};
1566
1506 break;
1507 case NETDEV_DOWN:
1508 wiphy_lock(&rdev->wiphy);
1509 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1510 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1511 if (WARN_ON(!rdev->scan_req->notified &&
1512 (!rdev->int_scan_req ||
1513 !rdev->int_scan_req->notified)))

--- 93 unchanged lines hidden (view full) ---

1607 }
1608 rtnl_unlock();
1609}
1610
1611static struct pernet_operations cfg80211_pernet_ops = {
1612 .exit = cfg80211_pernet_exit,
1613};
1614
1615void wiphy_work_queue(struct wiphy *wiphy, struct wiphy_work *work)
1616{
1617 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1618 unsigned long flags;
1619
1620 spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1621 if (list_empty(&work->entry))
1622 list_add_tail(&work->entry, &rdev->wiphy_work_list);
1623 spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1624
1625 schedule_work(&rdev->wiphy_work);
1626}
1627EXPORT_SYMBOL_GPL(wiphy_work_queue);
1628
1629void wiphy_work_cancel(struct wiphy *wiphy, struct wiphy_work *work)
1630{
1631 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1632 unsigned long flags;
1633
1634 lockdep_assert_held(&wiphy->mtx);
1635
1636 spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1637 if (!list_empty(&work->entry))
1638 list_del_init(&work->entry);
1639 spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1640}
1641EXPORT_SYMBOL_GPL(wiphy_work_cancel);
1642
1643void wiphy_delayed_work_timer(struct timer_list *t)
1644{
1645 struct wiphy_delayed_work *dwork = from_timer(dwork, t, timer);
1646
1647 wiphy_work_queue(dwork->wiphy, &dwork->work);
1648}
1649EXPORT_SYMBOL(wiphy_delayed_work_timer);
1650
1651void wiphy_delayed_work_queue(struct wiphy *wiphy,
1652 struct wiphy_delayed_work *dwork,
1653 unsigned long delay)
1654{
1655 if (!delay) {
1656 wiphy_work_queue(wiphy, &dwork->work);
1657 return;
1658 }
1659
1660 dwork->wiphy = wiphy;
1661 mod_timer(&dwork->timer, jiffies + delay);
1662}
1663EXPORT_SYMBOL_GPL(wiphy_delayed_work_queue);
1664
1665void wiphy_delayed_work_cancel(struct wiphy *wiphy,
1666 struct wiphy_delayed_work *dwork)
1667{
1668 lockdep_assert_held(&wiphy->mtx);
1669
1670 del_timer_sync(&dwork->timer);
1671 wiphy_work_cancel(wiphy, &dwork->work);
1672}
1673EXPORT_SYMBOL_GPL(wiphy_delayed_work_cancel);
1674
1567static int __init cfg80211_init(void)
1568{
1569 int err;
1570
1571 err = register_pernet_device(&cfg80211_pernet_ops);
1572 if (err)
1573 goto out_fail_pernet;
1574

--- 53 unchanged lines hidden --- 		1675static int __init cfg80211_init(void)
1676{
1677 int err;
1678
1679 err = register_pernet_device(&cfg80211_pernet_ops);
1680 if (err)
1681 goto out_fail_pernet;
1682

--- 53 unchanged lines hidden ---