iwlwifi: rename restricted_mem to targ_mem
[linux-2.6] / 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         ssize_t count = 0;
180
181         if (!capable(CAP_NET_ADMIN))
182                 return -EPERM;
183
184         mutex_lock(&bcm->mutex);
185
186         switch (bcm43xx_current_radio(bcm)->interfmode) {
187         case BCM43xx_RADIO_INTERFMODE_NONE:
188                 count = snprintf(buf, PAGE_SIZE, "0 (No Interference Mitigation)\n");
189                 break;
190         case BCM43xx_RADIO_INTERFMODE_NONWLAN:
191                 count = snprintf(buf, PAGE_SIZE, "1 (Non-WLAN Interference Mitigation)\n");
192                 break;
193         case BCM43xx_RADIO_INTERFMODE_MANUALWLAN:
194                 count = snprintf(buf, PAGE_SIZE, "2 (WLAN Interference Mitigation)\n");
195                 break;
196         default:
197                 assert(0);
198         }
199
200         mutex_unlock(&bcm->mutex);
201
202         return count;
203
204 }
205
206 static ssize_t bcm43xx_attr_interfmode_store(struct device *dev,
207                                              struct device_attribute *attr,
208                                              const char *buf, size_t count)
209 {
210         struct bcm43xx_private *bcm = dev_to_bcm(dev);
211         unsigned long flags;
212         int err;
213         int mode;
214
215         if (!capable(CAP_NET_ADMIN))
216                 return -EPERM;
217
218         mode = get_integer(buf, count);
219         switch (mode) {
220         case 0:
221                 mode = BCM43xx_RADIO_INTERFMODE_NONE;
222                 break;
223         case 1:
224                 mode = BCM43xx_RADIO_INTERFMODE_NONWLAN;
225                 break;
226         case 2:
227                 mode = BCM43xx_RADIO_INTERFMODE_MANUALWLAN;
228                 break;
229         case 3:
230                 mode = BCM43xx_RADIO_INTERFMODE_AUTOWLAN;
231                 break;
232         default:
233                 return -EINVAL;
234         }
235
236         mutex_lock(&bcm->mutex);
237         spin_lock_irqsave(&bcm->irq_lock, flags);
238
239         err = bcm43xx_radio_set_interference_mitigation(bcm, mode);
240         if (err) {
241                 printk(KERN_ERR PFX "Interference Mitigation not "
242                                     "supported by device\n");
243         }
244         mmiowb();
245         spin_unlock_irqrestore(&bcm->irq_lock, flags);
246         mutex_unlock(&bcm->mutex);
247
248         return err ? err : count;
249 }
250
251 static DEVICE_ATTR(interference, 0644,
252                    bcm43xx_attr_interfmode_show,
253                    bcm43xx_attr_interfmode_store);
254
255 static ssize_t bcm43xx_attr_preamble_show(struct device *dev,
256                                           struct device_attribute *attr,
257                                           char *buf)
258 {
259         struct bcm43xx_private *bcm = dev_to_bcm(dev);
260         ssize_t count;
261
262         if (!capable(CAP_NET_ADMIN))
263                 return -EPERM;
264
265         mutex_lock(&bcm->mutex);
266
267         if (bcm->short_preamble)
268                 count = snprintf(buf, PAGE_SIZE, "1 (Short Preamble enabled)\n");
269         else
270                 count = snprintf(buf, PAGE_SIZE, "0 (Short Preamble disabled)\n");
271
272         mutex_unlock(&bcm->mutex);
273
274         return count;
275 }
276
277 static ssize_t bcm43xx_attr_preamble_store(struct device *dev,
278                                            struct device_attribute *attr,
279                                            const char *buf, size_t count)
280 {
281         struct bcm43xx_private *bcm = dev_to_bcm(dev);
282         unsigned long flags;
283         int value;
284
285         if (!capable(CAP_NET_ADMIN))
286                 return -EPERM;
287
288         value = get_boolean(buf, count);
289         if (value < 0)
290                 return value;
291         mutex_lock(&bcm->mutex);
292         spin_lock_irqsave(&bcm->irq_lock, flags);
293
294         bcm->short_preamble = !!value;
295
296         spin_unlock_irqrestore(&bcm->irq_lock, flags);
297         mutex_unlock(&bcm->mutex);
298
299         return count;
300 }
301
302 static DEVICE_ATTR(shortpreamble, 0644,
303                    bcm43xx_attr_preamble_show,
304                    bcm43xx_attr_preamble_store);
305
306 static ssize_t bcm43xx_attr_phymode_store(struct device *dev,
307                                           struct device_attribute *attr,
308                                           const char *buf, size_t count)
309 {
310         struct bcm43xx_private *bcm = dev_to_bcm(dev);
311         int phytype;
312         int err = -EINVAL;
313
314         if (count < 1)
315                 goto out;
316         switch (buf[0]) {
317         case 'a':  case 'A':
318                 phytype = BCM43xx_PHYTYPE_A;
319                 break;
320         case 'b':  case 'B':
321                 phytype = BCM43xx_PHYTYPE_B;
322                 break;
323         case 'g':  case 'G':
324                 phytype = BCM43xx_PHYTYPE_G;
325                 break;
326         default:
327                 goto out;
328         }
329
330         bcm43xx_cancel_work(bcm);
331         mutex_lock(&(bcm)->mutex);
332         err = bcm43xx_select_wireless_core(bcm, phytype);
333         if (!err)
334                 bcm43xx_periodic_tasks_setup(bcm);
335         mutex_unlock(&(bcm)->mutex);
336         if (err == -ESRCH)
337                 err = -ENODEV;
338
339 out:
340         return err ? err : count;
341 }
342
343 static ssize_t bcm43xx_attr_phymode_show(struct device *dev,
344                                          struct device_attribute *attr,
345                                          char *buf)
346 {
347         struct bcm43xx_private *bcm = dev_to_bcm(dev);
348         ssize_t count = 0;
349
350         mutex_lock(&(bcm)->mutex);
351         switch (bcm43xx_current_phy(bcm)->type) {
352         case BCM43xx_PHYTYPE_A:
353                 snprintf(buf, PAGE_SIZE, "A");
354                 break;
355         case BCM43xx_PHYTYPE_B:
356                 snprintf(buf, PAGE_SIZE, "B");
357                 break;
358         case BCM43xx_PHYTYPE_G:
359                 snprintf(buf, PAGE_SIZE, "G");
360                 break;
361         default:
362                 assert(0);
363         }
364         mutex_unlock(&(bcm)->mutex);
365
366         return count;
367 }
368
369 static DEVICE_ATTR(phymode, 0644,
370                    bcm43xx_attr_phymode_show,
371                    bcm43xx_attr_phymode_store);
372
373 static ssize_t bcm43xx_attr_microcode_show(struct device *dev,
374                                            struct device_attribute *attr,
375                                            char *buf)
376 {
377         unsigned long flags;
378         struct bcm43xx_private *bcm = dev_to_bcm(dev);
379         ssize_t count = 0;
380         u16 status;
381
382         if (!capable(CAP_NET_ADMIN))
383                 return -EPERM;
384
385         mutex_lock(&(bcm)->mutex);
386         spin_lock_irqsave(&bcm->irq_lock, flags);
387         status = bcm43xx_shm_read16(bcm, BCM43xx_SHM_SHARED,
388                                     BCM43xx_UCODE_STATUS);
389
390         spin_unlock_irqrestore(&bcm->irq_lock, flags);
391         mutex_unlock(&(bcm)->mutex);
392         switch (status) {
393         case 0x0000:
394                 count = snprintf(buf, PAGE_SIZE, "0x%.4x (invalid)\n",
395                                  status);
396                 break;
397         case 0x0001:
398                 count = snprintf(buf, PAGE_SIZE, "0x%.4x (init)\n",
399                                  status);
400                 break;
401         case 0x0002:
402                 count = snprintf(buf, PAGE_SIZE, "0x%.4x (active)\n",
403                                  status);
404                 break;
405         case 0x0003:
406                 count = snprintf(buf, PAGE_SIZE, "0x%.4x (suspended)\n",
407                                  status);
408                 break;
409         case 0x0004:
410                 count = snprintf(buf, PAGE_SIZE, "0x%.4x (asleep)\n",
411                                  status);
412                 break;
413         default:
414                 count = snprintf(buf, PAGE_SIZE, "0x%.4x (unknown)\n",
415                                  status);
416                 break;
417         }
418
419         return count;
420 }
421
422 static DEVICE_ATTR(microcodestatus, 0444,
423                    bcm43xx_attr_microcode_show,
424                    NULL);
425
426 int bcm43xx_sysfs_register(struct bcm43xx_private *bcm)
427 {
428         struct device *dev = &bcm->pci_dev->dev;
429         int err;
430
431         assert(bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED);
432
433         err = device_create_file(dev, &dev_attr_sprom);
434         if (err)
435                 goto out;
436         err = device_create_file(dev, &dev_attr_interference);
437         if (err)
438                 goto err_remove_sprom;
439         err = device_create_file(dev, &dev_attr_shortpreamble);
440         if (err)
441                 goto err_remove_interfmode;
442         err = device_create_file(dev, &dev_attr_phymode);
443         if (err)
444                 goto err_remove_shortpreamble;
445         err = device_create_file(dev, &dev_attr_microcodestatus);
446         if (err)
447                 goto err_remove_phymode;
448
449 out:
450         return err;
451 err_remove_phymode:
452         device_remove_file(dev, &dev_attr_phymode);
453 err_remove_shortpreamble:
454         device_remove_file(dev, &dev_attr_shortpreamble);
455 err_remove_interfmode:
456         device_remove_file(dev, &dev_attr_interference);
457 err_remove_sprom:
458         device_remove_file(dev, &dev_attr_sprom);
459         goto out;
460 }
461
462 void bcm43xx_sysfs_unregister(struct bcm43xx_private *bcm)
463 {
464         struct device *dev = &bcm->pci_dev->dev;
465
466         device_remove_file(dev, &dev_attr_microcodestatus);
467         device_remove_file(dev, &dev_attr_phymode);
468         device_remove_file(dev, &dev_attr_shortpreamble);
469         device_remove_file(dev, &dev_attr_interference);
470         device_remove_file(dev, &dev_attr_sprom);
471 }