Merge branch 'from-linus' into upstream
[linux-2.6.git] / drivers / net / wireless / bcm43xx / bcm43xx_sysfs.c
1 /*
2
3   Broadcom BCM43xx wireless driver
4
5   SYSFS support routines
6
7   Copyright (c) 2006 Michael Buesch <mbuesch@freenet.de>
8
9   This program is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 2 of the License, or
12   (at your option) any later version.
13
14   This program is distributed in the hope that it will be useful,
15   but WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17   GNU General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; see the file COPYING.  If not, write to
21   the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
22   Boston, MA 02110-1301, USA.
23
24 */
25
26 #include "bcm43xx_sysfs.h"
27 #include "bcm43xx.h"
28 #include "bcm43xx_main.h"
29 #include "bcm43xx_radio.h"
30
31 #include <linux/capability.h>
32
33
34 #define GENERIC_FILESIZE        64
35
36
37 static int get_integer(const char *buf, size_t count)
38 {
39         char tmp[10 + 1] = { 0 };
40         int ret = -EINVAL;
41
42         if (count == 0)
43                 goto out;
44         count = min(count, (size_t)10);
45         memcpy(tmp, buf, count);
46         ret = simple_strtol(tmp, NULL, 10);
47 out:
48         return ret;
49 }
50
51 static int get_boolean(const char *buf, size_t count)
52 {
53         if (count != 0) {
54                 if (buf[0] == '1')
55                         return 1;
56                 if (buf[0] == '0')
57                         return 0;
58                 if (count >= 4 && memcmp(buf, "true", 4) == 0)
59                         return 1;
60                 if (count >= 5 && memcmp(buf, "false", 5) == 0)
61                         return 0;
62                 if (count >= 3 && memcmp(buf, "yes", 3) == 0)
63                         return 1;
64                 if (count >= 2 && memcmp(buf, "no", 2) == 0)
65                         return 0;
66                 if (count >= 2 && memcmp(buf, "on", 2) == 0)
67                         return 1;
68                 if (count >= 3 && memcmp(buf, "off", 3) == 0)
69                         return 0;
70         }
71         return -EINVAL;
72 }
73
74 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len)
75 {
76         int i, pos = 0;
77
78         for (i = 0; i < BCM43xx_SPROM_SIZE; i++) {
79                 pos += snprintf(buf + pos, buf_len - pos - 1,
80                                 "%04X", swab16(sprom[i]) & 0xFFFF);
81         }
82         pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
83
84         return pos + 1;
85 }
86
87 static int hex2sprom(u16 *sprom, const char *dump, size_t len)
88 {
89         char tmp[5] = { 0 };
90         int cnt = 0;
91         unsigned long parsed;
92
93         if (len < BCM43xx_SPROM_SIZE * sizeof(u16) * 2)
94                 return -EINVAL;
95
96         while (cnt < BCM43xx_SPROM_SIZE) {
97                 memcpy(tmp, dump, 4);
98                 dump += 4;
99                 parsed = simple_strtoul(tmp, NULL, 16);
100                 sprom[cnt++] = swab16((u16)parsed);
101         }
102
103         return 0;
104 }
105
106 static ssize_t bcm43xx_attr_sprom_show(struct device *dev,
107                                        struct device_attribute *attr,
108                                        char *buf)
109 {
110         struct bcm43xx_private *bcm = dev_to_bcm(dev);
111         u16 *sprom;
112         unsigned long flags;
113         int err;
114
115         if (!capable(CAP_NET_ADMIN))
116                 return -EPERM;
117
118         assert(BCM43xx_SPROM_SIZE * sizeof(u16) <= PAGE_SIZE);
119         sprom = kmalloc(BCM43xx_SPROM_SIZE * sizeof(*sprom),
120                         GFP_KERNEL);
121         if (!sprom)
122                 return -ENOMEM;
123         mutex_lock(&bcm->mutex);
124         spin_lock_irqsave(&bcm->irq_lock, flags);
125         err = bcm43xx_sprom_read(bcm, sprom);
126         if (!err)
127                 err = sprom2hex(sprom, buf, PAGE_SIZE);
128         mmiowb();
129         spin_unlock_irqrestore(&bcm->irq_lock, flags);
130         mutex_unlock(&bcm->mutex);
131         kfree(sprom);
132
133         return err;
134 }
135
136 static ssize_t bcm43xx_attr_sprom_store(struct device *dev,
137                                         struct device_attribute *attr,
138                                         const char *buf, size_t count)
139 {
140         struct bcm43xx_private *bcm = dev_to_bcm(dev);
141         u16 *sprom;
142         unsigned long flags;
143         int err;
144
145         if (!capable(CAP_NET_ADMIN))
146                 return -EPERM;
147
148         sprom = kmalloc(BCM43xx_SPROM_SIZE * sizeof(*sprom),
149                         GFP_KERNEL);
150         if (!sprom)
151                 return -ENOMEM;
152         err = hex2sprom(sprom, buf, count);
153         if (err)
154                 goto out_kfree;
155         mutex_lock(&bcm->mutex);
156         spin_lock_irqsave(&bcm->irq_lock, flags);
157         spin_lock(&bcm->leds_lock);
158         err = bcm43xx_sprom_write(bcm, sprom);
159         mmiowb();
160         spin_unlock(&bcm->leds_lock);
161         spin_unlock_irqrestore(&bcm->irq_lock, flags);
162         mutex_unlock(&bcm->mutex);
163 out_kfree:
164         kfree(sprom);
165
166         return err ? err : count;
167
168 }
169
170 static DEVICE_ATTR(sprom, 0600,
171                    bcm43xx_attr_sprom_show,
172                    bcm43xx_attr_sprom_store);
173
174 static ssize_t bcm43xx_attr_interfmode_show(struct device *dev,
175                                             struct device_attribute *attr,
176                                             char *buf)
177 {
178         struct bcm43xx_private *bcm = dev_to_bcm(dev);
179         int err;
180         ssize_t count = 0;
181
182         if (!capable(CAP_NET_ADMIN))
183                 return -EPERM;
184
185         mutex_lock(&bcm->mutex);
186
187         switch (bcm43xx_current_radio(bcm)->interfmode) {
188         case BCM43xx_RADIO_INTERFMODE_NONE:
189                 count = snprintf(buf, PAGE_SIZE, "0 (No Interference Mitigation)\n");
190                 break;
191         case BCM43xx_RADIO_INTERFMODE_NONWLAN:
192                 count = snprintf(buf, PAGE_SIZE, "1 (Non-WLAN Interference Mitigation)\n");
193                 break;
194         case BCM43xx_RADIO_INTERFMODE_MANUALWLAN:
195                 count = snprintf(buf, PAGE_SIZE, "2 (WLAN Interference Mitigation)\n");
196                 break;
197         default:
198                 assert(0);
199         }
200         err = 0;
201
202         mutex_unlock(&bcm->mutex);
203
204         return err ? err : count;
205
206 }
207
208 static ssize_t bcm43xx_attr_interfmode_store(struct device *dev,
209                                              struct device_attribute *attr,
210                                              const char *buf, size_t count)
211 {
212         struct bcm43xx_private *bcm = dev_to_bcm(dev);
213         unsigned long flags;
214         int err;
215         int mode;
216
217         if (!capable(CAP_NET_ADMIN))
218                 return -EPERM;
219
220         mode = get_integer(buf, count);
221         switch (mode) {
222         case 0:
223                 mode = BCM43xx_RADIO_INTERFMODE_NONE;
224                 break;
225         case 1:
226                 mode = BCM43xx_RADIO_INTERFMODE_NONWLAN;
227                 break;
228         case 2:
229                 mode = BCM43xx_RADIO_INTERFMODE_MANUALWLAN;
230                 break;
231         case 3:
232                 mode = BCM43xx_RADIO_INTERFMODE_AUTOWLAN;
233                 break;
234         default:
235                 return -EINVAL;
236         }
237
238         mutex_lock(&bcm->mutex);
239         spin_lock_irqsave(&bcm->irq_lock, flags);
240
241         err = bcm43xx_radio_set_interference_mitigation(bcm, mode);
242         if (err) {
243                 printk(KERN_ERR PFX "Interference Mitigation not "
244                                     "supported by device\n");
245         }
246         mmiowb();
247         spin_unlock_irqrestore(&bcm->irq_lock, flags);
248         mutex_unlock(&bcm->mutex);
249
250         return err ? err : count;
251 }
252
253 static DEVICE_ATTR(interference, 0644,
254                    bcm43xx_attr_interfmode_show,
255                    bcm43xx_attr_interfmode_store);
256
257 static ssize_t bcm43xx_attr_preamble_show(struct device *dev,
258                                           struct device_attribute *attr,
259                                           char *buf)
260 {
261         struct bcm43xx_private *bcm = dev_to_bcm(dev);
262         int err;
263         ssize_t count;
264
265         if (!capable(CAP_NET_ADMIN))
266                 return -EPERM;
267
268         mutex_lock(&bcm->mutex);
269
270         if (bcm->short_preamble)
271                 count = snprintf(buf, PAGE_SIZE, "1 (Short Preamble enabled)\n");
272         else
273                 count = snprintf(buf, PAGE_SIZE, "0 (Short Preamble disabled)\n");
274
275         err = 0;
276         mutex_unlock(&bcm->mutex);
277
278         return err ? err : count;
279 }
280
281 static ssize_t bcm43xx_attr_preamble_store(struct device *dev,
282                                            struct device_attribute *attr,
283                                            const char *buf, size_t count)
284 {
285         struct bcm43xx_private *bcm = dev_to_bcm(dev);
286         unsigned long flags;
287         int err;
288         int value;
289
290         if (!capable(CAP_NET_ADMIN))
291                 return -EPERM;
292
293         value = get_boolean(buf, count);
294         if (value < 0)
295                 return value;
296         mutex_lock(&bcm->mutex);
297         spin_lock_irqsave(&bcm->irq_lock, flags);
298
299         bcm->short_preamble = !!value;
300
301         err = 0;
302         spin_unlock_irqrestore(&bcm->irq_lock, flags);
303         mutex_unlock(&bcm->mutex);
304
305         return err ? err : count;
306 }
307
308 static DEVICE_ATTR(shortpreamble, 0644,
309                    bcm43xx_attr_preamble_show,
310                    bcm43xx_attr_preamble_store);
311
312 int bcm43xx_sysfs_register(struct bcm43xx_private *bcm)
313 {
314         struct device *dev = &bcm->pci_dev->dev;
315         int err;
316
317         assert(bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED);
318
319         err = device_create_file(dev, &dev_attr_sprom);
320         if (err)
321                 goto out;
322         err = device_create_file(dev, &dev_attr_interference);
323         if (err)
324                 goto err_remove_sprom;
325         err = device_create_file(dev, &dev_attr_shortpreamble);
326         if (err)
327                 goto err_remove_interfmode;
328
329 out:
330         return err;
331 err_remove_interfmode:
332         device_remove_file(dev, &dev_attr_interference);
333 err_remove_sprom:
334         device_remove_file(dev, &dev_attr_sprom);
335         goto out;
336 }
337
338 void bcm43xx_sysfs_unregister(struct bcm43xx_private *bcm)
339 {
340         struct device *dev = &bcm->pci_dev->dev;
341
342         device_remove_file(dev, &dev_attr_shortpreamble);
343         device_remove_file(dev, &dev_attr_interference);
344         device_remove_file(dev, &dev_attr_sprom);
345 }