mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-04 18:09:57 +00:00
![Johannes Berg](/assets/img/avatar_default.png)
Add a work abstraction at the cfg80211 level that will always hold the wiphy_lock() for any work executed and therefore also can be canceled safely (without waiting) while holding that. This improves on what we do now as with the new wiphy works we don't have to worry about locking while cancelling them safely. Also, don't let such works run while the device is suspended, since they'll likely need to interact with the device. Flush them before suspend though. Signed-off-by: Johannes Berg <johannes.berg@intel.com>
181 lines
4.2 KiB
C
181 lines
4.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* This file provides /sys/class/ieee80211/<wiphy name>/
|
|
* and some default attributes.
|
|
*
|
|
* Copyright 2005-2006 Jiri Benc <jbenc@suse.cz>
|
|
* Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
|
|
* Copyright (C) 2020-2021, 2023 Intel Corporation
|
|
*/
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/module.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/nl80211.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <net/cfg80211.h>
|
|
#include "sysfs.h"
|
|
#include "core.h"
|
|
#include "rdev-ops.h"
|
|
|
|
static inline struct cfg80211_registered_device *dev_to_rdev(
|
|
struct device *dev)
|
|
{
|
|
return container_of(dev, struct cfg80211_registered_device, wiphy.dev);
|
|
}
|
|
|
|
#define SHOW_FMT(name, fmt, member) \
|
|
static ssize_t name ## _show(struct device *dev, \
|
|
struct device_attribute *attr, \
|
|
char *buf) \
|
|
{ \
|
|
return sprintf(buf, fmt "\n", dev_to_rdev(dev)->member); \
|
|
} \
|
|
static DEVICE_ATTR_RO(name)
|
|
|
|
SHOW_FMT(index, "%d", wiphy_idx);
|
|
SHOW_FMT(macaddress, "%pM", wiphy.perm_addr);
|
|
SHOW_FMT(address_mask, "%pM", wiphy.addr_mask);
|
|
|
|
static ssize_t name_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct wiphy *wiphy = &dev_to_rdev(dev)->wiphy;
|
|
|
|
return sprintf(buf, "%s\n", wiphy_name(wiphy));
|
|
}
|
|
static DEVICE_ATTR_RO(name);
|
|
|
|
static ssize_t addresses_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct wiphy *wiphy = &dev_to_rdev(dev)->wiphy;
|
|
char *start = buf;
|
|
int i;
|
|
|
|
if (!wiphy->addresses)
|
|
return sprintf(buf, "%pM\n", wiphy->perm_addr);
|
|
|
|
for (i = 0; i < wiphy->n_addresses; i++)
|
|
buf += sprintf(buf, "%pM\n", wiphy->addresses[i].addr);
|
|
|
|
return buf - start;
|
|
}
|
|
static DEVICE_ATTR_RO(addresses);
|
|
|
|
static struct attribute *ieee80211_attrs[] = {
|
|
&dev_attr_index.attr,
|
|
&dev_attr_macaddress.attr,
|
|
&dev_attr_address_mask.attr,
|
|
&dev_attr_addresses.attr,
|
|
&dev_attr_name.attr,
|
|
NULL,
|
|
};
|
|
ATTRIBUTE_GROUPS(ieee80211);
|
|
|
|
static void wiphy_dev_release(struct device *dev)
|
|
{
|
|
struct cfg80211_registered_device *rdev = dev_to_rdev(dev);
|
|
|
|
cfg80211_dev_free(rdev);
|
|
}
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static void cfg80211_leave_all(struct cfg80211_registered_device *rdev)
|
|
{
|
|
struct wireless_dev *wdev;
|
|
|
|
list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list)
|
|
cfg80211_leave(rdev, wdev);
|
|
}
|
|
|
|
static int wiphy_suspend(struct device *dev)
|
|
{
|
|
struct cfg80211_registered_device *rdev = dev_to_rdev(dev);
|
|
int ret = 0;
|
|
|
|
rdev->suspend_at = ktime_get_boottime_seconds();
|
|
|
|
rtnl_lock();
|
|
wiphy_lock(&rdev->wiphy);
|
|
if (rdev->wiphy.registered) {
|
|
if (!rdev->wiphy.wowlan_config) {
|
|
cfg80211_leave_all(rdev);
|
|
cfg80211_process_rdev_events(rdev);
|
|
}
|
|
cfg80211_process_wiphy_works(rdev);
|
|
if (rdev->ops->suspend)
|
|
ret = rdev_suspend(rdev, rdev->wiphy.wowlan_config);
|
|
if (ret == 1) {
|
|
/* Driver refuse to configure wowlan */
|
|
cfg80211_leave_all(rdev);
|
|
cfg80211_process_rdev_events(rdev);
|
|
cfg80211_process_wiphy_works(rdev);
|
|
ret = rdev_suspend(rdev, NULL);
|
|
}
|
|
if (ret == 0)
|
|
rdev->suspended = true;
|
|
}
|
|
wiphy_unlock(&rdev->wiphy);
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wiphy_resume(struct device *dev)
|
|
{
|
|
struct cfg80211_registered_device *rdev = dev_to_rdev(dev);
|
|
int ret = 0;
|
|
|
|
/* Age scan results with time spent in suspend */
|
|
cfg80211_bss_age(rdev, ktime_get_boottime_seconds() - rdev->suspend_at);
|
|
|
|
rtnl_lock();
|
|
wiphy_lock(&rdev->wiphy);
|
|
if (rdev->wiphy.registered && rdev->ops->resume)
|
|
ret = rdev_resume(rdev);
|
|
rdev->suspended = false;
|
|
schedule_work(&rdev->wiphy_work);
|
|
wiphy_unlock(&rdev->wiphy);
|
|
|
|
if (ret)
|
|
cfg80211_shutdown_all_interfaces(&rdev->wiphy);
|
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static SIMPLE_DEV_PM_OPS(wiphy_pm_ops, wiphy_suspend, wiphy_resume);
|
|
#define WIPHY_PM_OPS (&wiphy_pm_ops)
|
|
#else
|
|
#define WIPHY_PM_OPS NULL
|
|
#endif
|
|
|
|
static const void *wiphy_namespace(const struct device *d)
|
|
{
|
|
struct wiphy *wiphy = container_of(d, struct wiphy, dev);
|
|
|
|
return wiphy_net(wiphy);
|
|
}
|
|
|
|
struct class ieee80211_class = {
|
|
.name = "ieee80211",
|
|
.dev_release = wiphy_dev_release,
|
|
.dev_groups = ieee80211_groups,
|
|
.pm = WIPHY_PM_OPS,
|
|
.ns_type = &net_ns_type_operations,
|
|
.namespace = wiphy_namespace,
|
|
};
|
|
|
|
int wiphy_sysfs_init(void)
|
|
{
|
|
return class_register(&ieee80211_class);
|
|
}
|
|
|
|
void wiphy_sysfs_exit(void)
|
|
{
|
|
class_unregister(&ieee80211_class);
|
|
}
|