d06d338812e975081ff20f771ea2c9069abede4c
[linux-2.6.git] / net / rfkill / rfkill.c
1 /*
2  * Copyright (C) 2006 - 2007 Ivo van Doorn
3  * Copyright (C) 2007 Dmitry Torokhov
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the
17  * Free Software Foundation, Inc.,
18  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/workqueue.h>
25 #include <linux/capability.h>
26 #include <linux/list.h>
27 #include <linux/mutex.h>
28 #include <linux/rfkill.h>
29
30 /* Get declaration of rfkill_switch_all() to shut up sparse. */
31 #include "rfkill-input.h"
32
33
34 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
35 MODULE_VERSION("1.0");
36 MODULE_DESCRIPTION("RF switch support");
37 MODULE_LICENSE("GPL");
38
39 static LIST_HEAD(rfkill_list);  /* list of registered rf switches */
40 static DEFINE_MUTEX(rfkill_mutex);
41
42 static enum rfkill_state rfkill_states[RFKILL_TYPE_MAX];
43
44
45 static void rfkill_led_trigger(struct rfkill *rfkill,
46                                enum rfkill_state state)
47 {
48 #ifdef CONFIG_RFKILL_LEDS
49         struct led_trigger *led = &rfkill->led_trigger;
50
51         if (!led->name)
52                 return;
53         if (state == RFKILL_STATE_OFF)
54                 led_trigger_event(led, LED_OFF);
55         else
56                 led_trigger_event(led, LED_FULL);
57 #endif /* CONFIG_RFKILL_LEDS */
58 }
59
60 static int rfkill_toggle_radio(struct rfkill *rfkill,
61                                 enum rfkill_state state)
62 {
63         int retval = 0;
64
65         if (state != rfkill->state) {
66                 retval = rfkill->toggle_radio(rfkill->data, state);
67                 if (!retval) {
68                         rfkill->state = state;
69                         rfkill_led_trigger(rfkill, state);
70                 }
71         }
72
73         return retval;
74 }
75
76 /**
77  * rfkill_switch_all - Toggle state of all switches of given type
78  * @type: type of interfaces to be affeceted
79  * @state: the new state
80  *
81  * This function toggles state of all switches of given type unless
82  * a specific switch is claimed by userspace in which case it is
83  * left alone.
84  */
85
86 void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
87 {
88         struct rfkill *rfkill;
89
90         mutex_lock(&rfkill_mutex);
91
92         rfkill_states[type] = state;
93
94         list_for_each_entry(rfkill, &rfkill_list, node) {
95                 if (!rfkill->user_claim)
96                         rfkill_toggle_radio(rfkill, state);
97         }
98
99         mutex_unlock(&rfkill_mutex);
100 }
101 EXPORT_SYMBOL(rfkill_switch_all);
102
103 static ssize_t rfkill_name_show(struct device *dev,
104                                 struct device_attribute *attr,
105                                 char *buf)
106 {
107         struct rfkill *rfkill = to_rfkill(dev);
108
109         return sprintf(buf, "%s\n", rfkill->name);
110 }
111
112 static ssize_t rfkill_type_show(struct device *dev,
113                                 struct device_attribute *attr,
114                                 char *buf)
115 {
116         struct rfkill *rfkill = to_rfkill(dev);
117         const char *type;
118
119         switch (rfkill->type) {
120         case RFKILL_TYPE_WLAN:
121                 type = "wlan";
122                 break;
123         case RFKILL_TYPE_BLUETOOTH:
124                 type = "bluetooth";
125                 break;
126         case RFKILL_TYPE_UWB:
127                 type = "ultrawideband";
128                 break;
129         default:
130                 BUG();
131         }
132
133         return sprintf(buf, "%s\n", type);
134 }
135
136 static ssize_t rfkill_state_show(struct device *dev,
137                                  struct device_attribute *attr,
138                                  char *buf)
139 {
140         struct rfkill *rfkill = to_rfkill(dev);
141
142         return sprintf(buf, "%d\n", rfkill->state);
143 }
144
145 static ssize_t rfkill_state_store(struct device *dev,
146                                   struct device_attribute *attr,
147                                   const char *buf, size_t count)
148 {
149         struct rfkill *rfkill = to_rfkill(dev);
150         unsigned int state = simple_strtoul(buf, NULL, 0);
151         int error;
152
153         if (!capable(CAP_NET_ADMIN))
154                 return -EPERM;
155
156         if (mutex_lock_interruptible(&rfkill->mutex))
157                 return -ERESTARTSYS;
158         error = rfkill_toggle_radio(rfkill,
159                         state ? RFKILL_STATE_ON : RFKILL_STATE_OFF);
160         mutex_unlock(&rfkill->mutex);
161
162         return error ? error : count;
163 }
164
165 static ssize_t rfkill_claim_show(struct device *dev,
166                                  struct device_attribute *attr,
167                                  char *buf)
168 {
169         struct rfkill *rfkill = to_rfkill(dev);
170
171         return sprintf(buf, "%d", rfkill->user_claim);
172 }
173
174 static ssize_t rfkill_claim_store(struct device *dev,
175                                   struct device_attribute *attr,
176                                   const char *buf, size_t count)
177 {
178         struct rfkill *rfkill = to_rfkill(dev);
179         bool claim = !!simple_strtoul(buf, NULL, 0);
180         int error;
181
182         if (!capable(CAP_NET_ADMIN))
183                 return -EPERM;
184
185         /*
186          * Take the global lock to make sure the kernel is not in
187          * the middle of rfkill_switch_all
188          */
189         error = mutex_lock_interruptible(&rfkill_mutex);
190         if (error)
191                 return error;
192
193         if (rfkill->user_claim_unsupported) {
194                 error = -EOPNOTSUPP;
195                 goto out_unlock;
196         }
197         if (rfkill->user_claim != claim) {
198                 if (!claim)
199                         rfkill_toggle_radio(rfkill,
200                                             rfkill_states[rfkill->type]);
201                 rfkill->user_claim = claim;
202         }
203
204 out_unlock:
205         mutex_unlock(&rfkill_mutex);
206
207         return error ? error : count;
208 }
209
210 static struct device_attribute rfkill_dev_attrs[] = {
211         __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
212         __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
213         __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
214         __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
215         __ATTR_NULL
216 };
217
218 static void rfkill_release(struct device *dev)
219 {
220         struct rfkill *rfkill = to_rfkill(dev);
221
222         kfree(rfkill);
223         module_put(THIS_MODULE);
224 }
225
226 #ifdef CONFIG_PM
227 static int rfkill_suspend(struct device *dev, pm_message_t state)
228 {
229         struct rfkill *rfkill = to_rfkill(dev);
230
231         if (dev->power.power_state.event != state.event) {
232                 if (state.event == PM_EVENT_SUSPEND) {
233                         mutex_lock(&rfkill->mutex);
234
235                         if (rfkill->state == RFKILL_STATE_ON)
236                                 rfkill->toggle_radio(rfkill->data,
237                                                      RFKILL_STATE_OFF);
238
239                         mutex_unlock(&rfkill->mutex);
240                 }
241
242                 dev->power.power_state = state;
243         }
244
245         return 0;
246 }
247
248 static int rfkill_resume(struct device *dev)
249 {
250         struct rfkill *rfkill = to_rfkill(dev);
251
252         if (dev->power.power_state.event != PM_EVENT_ON) {
253                 mutex_lock(&rfkill->mutex);
254
255                 if (rfkill->state == RFKILL_STATE_ON)
256                         rfkill->toggle_radio(rfkill->data, RFKILL_STATE_ON);
257
258                 mutex_unlock(&rfkill->mutex);
259         }
260
261         dev->power.power_state = PMSG_ON;
262         return 0;
263 }
264 #else
265 #define rfkill_suspend NULL
266 #define rfkill_resume NULL
267 #endif
268
269 static struct class rfkill_class = {
270         .name           = "rfkill",
271         .dev_release    = rfkill_release,
272         .dev_attrs      = rfkill_dev_attrs,
273         .suspend        = rfkill_suspend,
274         .resume         = rfkill_resume,
275 };
276
277 static int rfkill_add_switch(struct rfkill *rfkill)
278 {
279         int error;
280
281         mutex_lock(&rfkill_mutex);
282
283         error = rfkill_toggle_radio(rfkill, rfkill_states[rfkill->type]);
284         if (!error)
285                 list_add_tail(&rfkill->node, &rfkill_list);
286
287         mutex_unlock(&rfkill_mutex);
288
289         return error;
290 }
291
292 static void rfkill_remove_switch(struct rfkill *rfkill)
293 {
294         mutex_lock(&rfkill_mutex);
295         list_del_init(&rfkill->node);
296         rfkill_toggle_radio(rfkill, RFKILL_STATE_OFF);
297         mutex_unlock(&rfkill_mutex);
298 }
299
300 /**
301  * rfkill_allocate - allocate memory for rfkill structure.
302  * @parent: device that has rf switch on it
303  * @type: type of the switch (RFKILL_TYPE_*)
304  *
305  * This function should be called by the network driver when it needs
306  * rfkill structure. Once the structure is allocated the driver shoud
307  * finish its initialization by setting name, private data, enable_radio
308  * and disable_radio methods and then register it with rfkill_register().
309  * NOTE: If registration fails the structure shoudl be freed by calling
310  * rfkill_free() otherwise rfkill_unregister() should be used.
311  */
312 struct rfkill *rfkill_allocate(struct device *parent, enum rfkill_type type)
313 {
314         struct rfkill *rfkill;
315         struct device *dev;
316
317         rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
318         if (!rfkill)
319                 return NULL;
320
321         mutex_init(&rfkill->mutex);
322         INIT_LIST_HEAD(&rfkill->node);
323         rfkill->type = type;
324
325         dev = &rfkill->dev;
326         dev->class = &rfkill_class;
327         dev->parent = parent;
328         device_initialize(dev);
329
330         __module_get(THIS_MODULE);
331
332         return rfkill;
333 }
334 EXPORT_SYMBOL(rfkill_allocate);
335
336 /**
337  * rfkill_free - Mark rfkill structure for deletion
338  * @rfkill: rfkill structure to be destroyed
339  *
340  * Decrements reference count of rfkill structure so it is destoryed.
341  * Note that rfkill_free() should _not_ be called after rfkill_unregister().
342  */
343 void rfkill_free(struct rfkill *rfkill)
344 {
345         if (rfkill)
346                 put_device(&rfkill->dev);
347 }
348 EXPORT_SYMBOL(rfkill_free);
349
350 static void rfkill_led_trigger_register(struct rfkill *rfkill)
351 {
352 #ifdef CONFIG_RFKILL_LEDS
353         int error;
354
355         rfkill->led_trigger.name = rfkill->dev.bus_id;
356         error = led_trigger_register(&rfkill->led_trigger);
357         if (error)
358                 rfkill->led_trigger.name = NULL;
359 #endif /* CONFIG_RFKILL_LEDS */
360 }
361
362 static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
363 {
364 #ifdef CONFIG_RFKILL_LEDS
365         if (rfkill->led_trigger.name)
366                 led_trigger_unregister(&rfkill->led_trigger);
367 #endif
368 }
369
370 /**
371  * rfkill_register - Register a rfkill structure.
372  * @rfkill: rfkill structure to be registered
373  *
374  * This function should be called by the network driver when the rfkill
375  * structure needs to be registered. Immediately from registration the
376  * switch driver should be able to service calls to toggle_radio.
377  */
378 int rfkill_register(struct rfkill *rfkill)
379 {
380         static atomic_t rfkill_no = ATOMIC_INIT(0);
381         struct device *dev = &rfkill->dev;
382         int error;
383
384         if (!rfkill->toggle_radio)
385                 return -EINVAL;
386         if (rfkill->type >= RFKILL_TYPE_MAX)
387                 return -EINVAL;
388
389         snprintf(dev->bus_id, sizeof(dev->bus_id),
390                  "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
391
392         rfkill_led_trigger_register(rfkill);
393
394         error = rfkill_add_switch(rfkill);
395         if (error) {
396                 rfkill_led_trigger_unregister(rfkill);
397                 return error;
398         }
399
400         error = device_add(dev);
401         if (error) {
402                 rfkill_led_trigger_unregister(rfkill);
403                 rfkill_remove_switch(rfkill);
404                 return error;
405         }
406
407         return 0;
408 }
409 EXPORT_SYMBOL(rfkill_register);
410
411 /**
412  * rfkill_unregister - Uegister a rfkill structure.
413  * @rfkill: rfkill structure to be unregistered
414  *
415  * This function should be called by the network driver during device
416  * teardown to destroy rfkill structure. Note that rfkill_free() should
417  * _not_ be called after rfkill_unregister().
418  */
419 void rfkill_unregister(struct rfkill *rfkill)
420 {
421         device_del(&rfkill->dev);
422         rfkill_remove_switch(rfkill);
423         rfkill_led_trigger_unregister(rfkill);
424         put_device(&rfkill->dev);
425 }
426 EXPORT_SYMBOL(rfkill_unregister);
427
428 /*
429  * Rfkill module initialization/deinitialization.
430  */
431 static int __init rfkill_init(void)
432 {
433         int error;
434         int i;
435
436         for (i = 0; i < ARRAY_SIZE(rfkill_states); i++)
437                 rfkill_states[i] = RFKILL_STATE_ON;
438
439         error = class_register(&rfkill_class);
440         if (error) {
441                 printk(KERN_ERR "rfkill: unable to register rfkill class\n");
442                 return error;
443         }
444
445         return 0;
446 }
447
448 static void __exit rfkill_exit(void)
449 {
450         class_unregister(&rfkill_class);
451 }
452
453 subsys_initcall(rfkill_init);
454 module_exit(rfkill_exit);