1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * This file provides /sys/class/ieee80211/<wiphy name>/ 4 * and some default attributes. 5 * 6 * Copyright 2005-2006 Jiri Benc <jbenc@suse.cz> 7 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 8 * Copyright (C) 2020-2021, 2023-2024 Intel Corporation 9 */ 10 11 #include <linux/device.h> 12 #include <linux/module.h> 13 #include <linux/netdevice.h> 14 #include <linux/nl80211.h> 15 #include <linux/rtnetlink.h> 16 #include <net/cfg80211.h> 17 #include "sysfs.h" 18 #include "core.h" 19 #include "rdev-ops.h" 20 21 static inline struct cfg80211_registered_device *dev_to_rdev( 22 struct device *dev) 23 { 24 return container_of(dev, struct cfg80211_registered_device, wiphy.dev); 25 } 26 27 #define SHOW_FMT(name, fmt, member) \ 28 static ssize_t name ## _show(struct device *dev, \ 29 struct device_attribute *attr, \ 30 char *buf) \ 31 { \ 32 return sprintf(buf, fmt "\n", dev_to_rdev(dev)->member); \ 33 } \ 34 static DEVICE_ATTR_RO(name) 35 36 SHOW_FMT(index, "%d", wiphy_idx); 37 SHOW_FMT(macaddress, "%pM", wiphy.perm_addr); 38 SHOW_FMT(address_mask, "%pM", wiphy.addr_mask); 39 40 static ssize_t name_show(struct device *dev, 41 struct device_attribute *attr, 42 char *buf) 43 { 44 struct wiphy *wiphy = &dev_to_rdev(dev)->wiphy; 45 46 return sprintf(buf, "%s\n", wiphy_name(wiphy)); 47 } 48 static DEVICE_ATTR_RO(name); 49 50 static ssize_t addresses_show(struct device *dev, 51 struct device_attribute *attr, 52 char *buf) 53 { 54 struct wiphy *wiphy = &dev_to_rdev(dev)->wiphy; 55 char *start = buf; 56 int i; 57 58 if (!wiphy->addresses) 59 return sprintf(buf, "%pM\n", wiphy->perm_addr); 60 61 for (i = 0; i < wiphy->n_addresses; i++) 62 buf += sprintf(buf, "%pM\n", wiphy->addresses[i].addr); 63 64 return buf - start; 65 } 66 static DEVICE_ATTR_RO(addresses); 67 68 static struct attribute *ieee80211_attrs[] = { 69 &dev_attr_index.attr, 70 &dev_attr_macaddress.attr, 71 &dev_attr_address_mask.attr, 72 &dev_attr_addresses.attr, 73 &dev_attr_name.attr, 74 NULL, 75 }; 76 ATTRIBUTE_GROUPS(ieee80211); 77 78 static void wiphy_dev_release(struct device *dev) 79 { 80 struct cfg80211_registered_device *rdev = dev_to_rdev(dev); 81 82 cfg80211_dev_free(rdev); 83 } 84 85 #ifdef CONFIG_PM_SLEEP 86 static void cfg80211_leave_all(struct cfg80211_registered_device *rdev) 87 { 88 struct wireless_dev *wdev; 89 90 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) 91 cfg80211_leave(rdev, wdev, -1); 92 } 93 94 static int wiphy_suspend(struct device *dev) 95 { 96 struct cfg80211_registered_device *rdev = dev_to_rdev(dev); 97 int ret = 0; 98 99 rdev->suspend_at = ktime_get_boottime_seconds(); 100 101 rtnl_lock(); 102 if (!rdev->wiphy.registered) 103 goto out_unlock_rtnl; 104 105 if (rdev->wiphy.wowlan_config) { 106 scoped_guard(wiphy, &rdev->wiphy) { 107 cfg80211_process_wiphy_works(rdev, NULL); 108 if (rdev->ops->suspend) 109 ret = rdev_suspend(rdev, 110 rdev->wiphy.wowlan_config); 111 if (ret <= 0) 112 goto out_unlock_rtnl; 113 } 114 } 115 116 /* Driver refused to configure wowlan (ret = 1) or no wowlan */ 117 118 cfg80211_leave_all(rdev); 119 scoped_guard(wiphy, &rdev->wiphy) { 120 cfg80211_process_rdev_events(rdev); 121 cfg80211_process_wiphy_works(rdev, NULL); 122 if (rdev->ops->suspend) 123 ret = rdev_suspend(rdev, NULL); 124 } 125 out_unlock_rtnl: 126 if (ret == 0) 127 rdev->suspended = true; 128 rtnl_unlock(); 129 130 return ret; 131 } 132 133 static int wiphy_resume(struct device *dev) 134 { 135 struct cfg80211_registered_device *rdev = dev_to_rdev(dev); 136 int ret = 0; 137 138 /* Age scan results with time spent in suspend */ 139 cfg80211_bss_age(rdev, ktime_get_boottime_seconds() - rdev->suspend_at); 140 141 rtnl_lock(); 142 wiphy_lock(&rdev->wiphy); 143 if (rdev->wiphy.registered && rdev->ops->resume) 144 ret = rdev_resume(rdev); 145 rdev->suspended = false; 146 queue_work(system_dfl_wq, &rdev->wiphy_work); 147 wiphy_unlock(&rdev->wiphy); 148 149 if (ret) 150 cfg80211_shutdown_all_interfaces(&rdev->wiphy); 151 152 rtnl_unlock(); 153 154 return ret; 155 } 156 157 static SIMPLE_DEV_PM_OPS(wiphy_pm_ops, wiphy_suspend, wiphy_resume); 158 #define WIPHY_PM_OPS (&wiphy_pm_ops) 159 #else 160 #define WIPHY_PM_OPS NULL 161 #endif 162 163 static const void *wiphy_namespace(const struct device *d) 164 { 165 struct wiphy *wiphy = container_of(d, struct wiphy, dev); 166 167 return wiphy_net(wiphy); 168 } 169 170 struct class ieee80211_class = { 171 .name = "ieee80211", 172 .dev_release = wiphy_dev_release, 173 .dev_groups = ieee80211_groups, 174 .pm = WIPHY_PM_OPS, 175 .ns_type = &net_ns_type_operations, 176 .namespace = wiphy_namespace, 177 }; 178 179 int wiphy_sysfs_init(void) 180 { 181 return class_register(&ieee80211_class); 182 } 183 184 void wiphy_sysfs_exit(void) 185 { 186 class_unregister(&ieee80211_class); 187 } 188