ARM: tegra: dvfs: Removed rail dfll mode thermal trips
[linux-3.10.git] / net / wireless / wext-spy.c
1 /*
2  * This file implement the Wireless Extensions spy API.
3  *
4  * Authors :    Jean Tourrilhes - HPL - <jt@hpl.hp.com>
5  * Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved.
6  *
7  * (As all part of the Linux kernel, this file is GPL)
8  */
9
10 #include <linux/wireless.h>
11 #include <linux/netdevice.h>
12 #include <linux/etherdevice.h>
13 #include <linux/export.h>
14 #include <net/iw_handler.h>
15 #include <net/arp.h>
16 #include <net/wext.h>
17
18 static inline struct iw_spy_data *get_spydata(struct net_device *dev)
19 {
20         /* This is the new way */
21         if (dev->wireless_data)
22                 return dev->wireless_data->spy_data;
23         return NULL;
24 }
25
26 int iw_handler_set_spy(struct net_device *      dev,
27                        struct iw_request_info * info,
28                        union iwreq_data *       wrqu,
29                        char *                   extra)
30 {
31         struct iw_spy_data *    spydata = get_spydata(dev);
32         struct sockaddr *       address = (struct sockaddr *) extra;
33
34         /* Make sure driver is not buggy or using the old API */
35         if (!spydata)
36                 return -EOPNOTSUPP;
37
38         /* Disable spy collection while we copy the addresses.
39          * While we copy addresses, any call to wireless_spy_update()
40          * will NOP. This is OK, as anyway the addresses are changing. */
41         spydata->spy_number = 0;
42
43         /* We want to operate without locking, because wireless_spy_update()
44          * most likely will happen in the interrupt handler, and therefore
45          * have its own locking constraints and needs performance.
46          * The rtnl_lock() make sure we don't race with the other iw_handlers.
47          * This make sure wireless_spy_update() "see" that the spy list
48          * is temporarily disabled. */
49         smp_wmb();
50
51         /* Are there are addresses to copy? */
52         if (wrqu->data.length > 0) {
53                 int i;
54
55                 /* Copy addresses */
56                 for (i = 0; i < wrqu->data.length; i++)
57                         memcpy(spydata->spy_address[i], address[i].sa_data,
58                                ETH_ALEN);
59                 /* Reset stats */
60                 memset(spydata->spy_stat, 0,
61                        sizeof(struct iw_quality) * IW_MAX_SPY);
62         }
63
64         /* Make sure above is updated before re-enabling */
65         smp_wmb();
66
67         /* Enable addresses */
68         spydata->spy_number = wrqu->data.length;
69
70         return 0;
71 }
72 EXPORT_SYMBOL(iw_handler_set_spy);
73
74 int iw_handler_get_spy(struct net_device *      dev,
75                        struct iw_request_info * info,
76                        union iwreq_data *       wrqu,
77                        char *                   extra)
78 {
79         struct iw_spy_data *    spydata = get_spydata(dev);
80         struct sockaddr *       address = (struct sockaddr *) extra;
81         int                     i;
82
83         /* Make sure driver is not buggy or using the old API */
84         if (!spydata)
85                 return -EOPNOTSUPP;
86
87         wrqu->data.length = spydata->spy_number;
88
89         /* Copy addresses. */
90         for (i = 0; i < spydata->spy_number; i++)       {
91                 memcpy(address[i].sa_data, spydata->spy_address[i], ETH_ALEN);
92                 address[i].sa_family = AF_UNIX;
93         }
94         /* Copy stats to the user buffer (just after). */
95         if (spydata->spy_number > 0)
96                 memcpy(extra  + (sizeof(struct sockaddr) *spydata->spy_number),
97                        spydata->spy_stat,
98                        sizeof(struct iw_quality) * spydata->spy_number);
99         /* Reset updated flags. */
100         for (i = 0; i < spydata->spy_number; i++)
101                 spydata->spy_stat[i].updated &= ~IW_QUAL_ALL_UPDATED;
102         return 0;
103 }
104 EXPORT_SYMBOL(iw_handler_get_spy);
105
106 /*------------------------------------------------------------------*/
107 /*
108  * Standard Wireless Handler : set spy threshold
109  */
110 int iw_handler_set_thrspy(struct net_device *   dev,
111                           struct iw_request_info *info,
112                           union iwreq_data *    wrqu,
113                           char *                extra)
114 {
115         struct iw_spy_data *    spydata = get_spydata(dev);
116         struct iw_thrspy *      threshold = (struct iw_thrspy *) extra;
117
118         /* Make sure driver is not buggy or using the old API */
119         if (!spydata)
120                 return -EOPNOTSUPP;
121
122         /* Just do it */
123         memcpy(&(spydata->spy_thr_low), &(threshold->low),
124                2 * sizeof(struct iw_quality));
125
126         /* Clear flag */
127         memset(spydata->spy_thr_under, '\0', sizeof(spydata->spy_thr_under));
128
129         return 0;
130 }
131 EXPORT_SYMBOL(iw_handler_set_thrspy);
132
133 /*------------------------------------------------------------------*/
134 /*
135  * Standard Wireless Handler : get spy threshold
136  */
137 int iw_handler_get_thrspy(struct net_device *   dev,
138                           struct iw_request_info *info,
139                           union iwreq_data *    wrqu,
140                           char *                extra)
141 {
142         struct iw_spy_data *    spydata = get_spydata(dev);
143         struct iw_thrspy *      threshold = (struct iw_thrspy *) extra;
144
145         /* Make sure driver is not buggy or using the old API */
146         if (!spydata)
147                 return -EOPNOTSUPP;
148
149         /* Just do it */
150         memcpy(&(threshold->low), &(spydata->spy_thr_low),
151                2 * sizeof(struct iw_quality));
152
153         return 0;
154 }
155 EXPORT_SYMBOL(iw_handler_get_thrspy);
156
157 /*------------------------------------------------------------------*/
158 /*
159  * Prepare and send a Spy Threshold event
160  */
161 static void iw_send_thrspy_event(struct net_device *    dev,
162                                  struct iw_spy_data *   spydata,
163                                  unsigned char *        address,
164                                  struct iw_quality *    wstats)
165 {
166         union iwreq_data        wrqu;
167         struct iw_thrspy        threshold;
168
169         /* Init */
170         wrqu.data.length = 1;
171         wrqu.data.flags = 0;
172         /* Copy address */
173         memcpy(threshold.addr.sa_data, address, ETH_ALEN);
174         threshold.addr.sa_family = ARPHRD_ETHER;
175         /* Copy stats */
176         memcpy(&(threshold.qual), wstats, sizeof(struct iw_quality));
177         /* Copy also thresholds */
178         memcpy(&(threshold.low), &(spydata->spy_thr_low),
179                2 * sizeof(struct iw_quality));
180
181         /* Send event to user space */
182         wireless_send_event(dev, SIOCGIWTHRSPY, &wrqu, (char *) &threshold);
183 }
184
185 /* ---------------------------------------------------------------- */
186 /*
187  * Call for the driver to update the spy data.
188  * For now, the spy data is a simple array. As the size of the array is
189  * small, this is good enough. If we wanted to support larger number of
190  * spy addresses, we should use something more efficient...
191  */
192 void wireless_spy_update(struct net_device *    dev,
193                          unsigned char *        address,
194                          struct iw_quality *    wstats)
195 {
196         struct iw_spy_data *    spydata = get_spydata(dev);
197         int                     i;
198         int                     match = -1;
199
200         /* Make sure driver is not buggy or using the old API */
201         if (!spydata)
202                 return;
203
204         /* Update all records that match */
205         for (i = 0; i < spydata->spy_number; i++)
206                 if (ether_addr_equal(address, spydata->spy_address[i])) {
207                         memcpy(&(spydata->spy_stat[i]), wstats,
208                                sizeof(struct iw_quality));
209                         match = i;
210                 }
211
212         /* Generate an event if we cross the spy threshold.
213          * To avoid event storms, we have a simple hysteresis : we generate
214          * event only when we go under the low threshold or above the
215          * high threshold. */
216         if (match >= 0) {
217                 if (spydata->spy_thr_under[match]) {
218                         if (wstats->level > spydata->spy_thr_high.level) {
219                                 spydata->spy_thr_under[match] = 0;
220                                 iw_send_thrspy_event(dev, spydata,
221                                                      address, wstats);
222                         }
223                 } else {
224                         if (wstats->level < spydata->spy_thr_low.level) {
225                                 spydata->spy_thr_under[match] = 1;
226                                 iw_send_thrspy_event(dev, spydata,
227                                                      address, wstats);
228                         }
229                 }
230         }
231 }
232 EXPORT_SYMBOL(wireless_spy_update);