← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to net/wireless/sysfs.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/wireless/sysfs.c
 
1
/*
 
2
 * This file provides /sys/class/ieee80211/<wiphy name>/
 
3
 * and some default attributes.
 
4
 *
 
5
 * Copyright 2005-2006  Jiri Benc <jbenc@suse.cz>
 
6
 * Copyright 2006       Johannes Berg <johannes@sipsolutions.net>
 
7
 *
 
8
 * This file is GPLv2 as found in COPYING.
 
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
 
 
20
static inline struct cfg80211_registered_device *dev_to_rdev(
 
21
        struct device *dev)
 
22
{
 
23
        return container_of(dev, struct cfg80211_registered_device, wiphy.dev);
 
24
}
 
25
 
 
26
#define SHOW_FMT(name, fmt, member)                                     \
 
27
static ssize_t name ## _show(struct device *dev,                        \
 
28
                              struct device_attribute *attr,            \
 
29
                              char *buf)                                \
 
30
{                                                                       \
 
31
        return sprintf(buf, fmt "\n", dev_to_rdev(dev)->member);        \
 
32
}
 
33
 
 
34
SHOW_FMT(index, "%d", wiphy_idx);
 
35
SHOW_FMT(macaddress, "%pM", wiphy.perm_addr);
 
36
SHOW_FMT(address_mask, "%pM", wiphy.addr_mask);
 
37
 
 
38
static ssize_t name_show(struct device *dev,
 
39
                         struct device_attribute *attr,
 
40
                         char *buf) {
 
41
        struct wiphy *wiphy = &dev_to_rdev(dev)->wiphy;
 
42
        return sprintf(buf, "%s\n", dev_name(&wiphy->dev));
 
43
}
 
44
 
 
45
 
 
46
static ssize_t addresses_show(struct device *dev,
 
47
                              struct device_attribute *attr,
 
48
                              char *buf)
 
49
{
 
50
        struct wiphy *wiphy = &dev_to_rdev(dev)->wiphy;
 
51
        char *start = buf;
 
52
        int i;
 
53
 
 
54
        if (!wiphy->addresses)
 
55
                return sprintf(buf, "%pM\n", wiphy->perm_addr);
 
56
 
 
57
        for (i = 0; i < wiphy->n_addresses; i++)
 
58
                buf += sprintf(buf, "%pM\n", &wiphy->addresses[i].addr);
 
59
 
 
60
        return buf - start;
 
61
}
 
62
 
 
63
static struct device_attribute ieee80211_dev_attrs[] = {
 
64
        __ATTR_RO(index),
 
65
        __ATTR_RO(macaddress),
 
66
        __ATTR_RO(address_mask),
 
67
        __ATTR_RO(addresses),
 
68
        __ATTR_RO(name),
 
69
        {}
 
70
};
 
71
 
 
72
static void wiphy_dev_release(struct device *dev)
 
73
{
 
74
        struct cfg80211_registered_device *rdev = dev_to_rdev(dev);
 
75
 
 
76
        cfg80211_dev_free(rdev);
 
77
}
 
78
 
 
79
#ifdef CONFIG_HOTPLUG
 
80
static int wiphy_uevent(struct device *dev, struct kobj_uevent_env *env)
 
81
{
 
82
        /* TODO, we probably need stuff here */
 
83
        return 0;
 
84
}
 
85
#endif
 
86
 
 
87
static int wiphy_suspend(struct device *dev, pm_message_t state)
 
88
{
 
89
        struct cfg80211_registered_device *rdev = dev_to_rdev(dev);
 
90
        int ret = 0;
 
91
 
 
92
        rdev->suspend_at = get_seconds();
 
93
 
 
94
        if (rdev->ops->suspend) {
 
95
                rtnl_lock();
 
96
                if (rdev->wiphy.registered)
 
97
                        ret = rdev->ops->suspend(&rdev->wiphy, rdev->wowlan);
 
98
                rtnl_unlock();
 
99
        }
 
100
 
 
101
        return ret;
 
102
}
 
103
 
 
104
static int wiphy_resume(struct device *dev)
 
105
{
 
106
        struct cfg80211_registered_device *rdev = dev_to_rdev(dev);
 
107
        int ret = 0;
 
108
 
 
109
        /* Age scan results with time spent in suspend */
 
110
        spin_lock_bh(&rdev->bss_lock);
 
111
        cfg80211_bss_age(rdev, get_seconds() - rdev->suspend_at);
 
112
        spin_unlock_bh(&rdev->bss_lock);
 
113
 
 
114
        if (rdev->ops->resume) {
 
115
                rtnl_lock();
 
116
                if (rdev->wiphy.registered)
 
117
                        ret = rdev->ops->resume(&rdev->wiphy);
 
118
                rtnl_unlock();
 
119
        }
 
120
 
 
121
        return ret;
 
122
}
 
123
 
 
124
static const void *wiphy_namespace(struct device *d)
 
125
{
 
126
        struct wiphy *wiphy = container_of(d, struct wiphy, dev);
 
127
 
 
128
        return wiphy_net(wiphy);
 
129
}
 
130
 
 
131
struct class ieee80211_class = {
 
132
        .name = "ieee80211",
 
133
        .owner = THIS_MODULE,
 
134
        .dev_release = wiphy_dev_release,
 
135
        .dev_attrs = ieee80211_dev_attrs,
 
136
#ifdef CONFIG_HOTPLUG
 
137
        .dev_uevent = wiphy_uevent,
 
138
#endif
 
139
        .suspend = wiphy_suspend,
 
140
        .resume = wiphy_resume,
 
141
        .ns_type = &net_ns_type_operations,
 
142
        .namespace = wiphy_namespace,
 
143
};
 
144
 
 
145
int wiphy_sysfs_init(void)
 
146
{
 
147
        return class_register(&ieee80211_class);
 
148
}
 
149
 
 
150
void wiphy_sysfs_exit(void)
 
151
{
 
152
        class_unregister(&ieee80211_class);
 
153
}