fdf87d2ab25e358ddf8e5d9aec29e5392a2cf432
[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_global_mutex);
41
42 static unsigned int rfkill_default_state = RFKILL_STATE_UNBLOCKED;
43 module_param_named(default_state, rfkill_default_state, uint, 0444);
44 MODULE_PARM_DESC(default_state,
45                  "Default initial state for all radio types, 0 = radio off");
46
47 struct rfkill_gsw_state {
48         enum rfkill_state current_state;
49         enum rfkill_state default_state;
50 };
51
52 static struct rfkill_gsw_state rfkill_global_states[RFKILL_TYPE_MAX];
53 static unsigned long rfkill_states_lockdflt[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
54
55 static BLOCKING_NOTIFIER_HEAD(rfkill_notifier_list);
56
57
58 /**
59  * register_rfkill_notifier - Add notifier to rfkill notifier chain
60  * @nb: pointer to the new entry to add to the chain
61  *
62  * See blocking_notifier_chain_register() for return value and further
63  * observations.
64  *
65  * Adds a notifier to the rfkill notifier chain.  The chain will be
66  * called with a pointer to the relevant rfkill structure as a parameter,
67  * refer to include/linux/rfkill.h for the possible events.
68  *
69  * Notifiers added to this chain are to always return NOTIFY_DONE.  This
70  * chain is a blocking notifier chain: notifiers can sleep.
71  *
72  * Calls to this chain may have been done through a workqueue.  One must
73  * assume unordered asynchronous behaviour, there is no way to know if
74  * actions related to the event that generated the notification have been
75  * carried out already.
76  */
77 int register_rfkill_notifier(struct notifier_block *nb)
78 {
79         BUG_ON(!nb);
80         return blocking_notifier_chain_register(&rfkill_notifier_list, nb);
81 }
82 EXPORT_SYMBOL_GPL(register_rfkill_notifier);
83
84 /**
85  * unregister_rfkill_notifier - remove notifier from rfkill notifier chain
86  * @nb: pointer to the entry to remove from the chain
87  *
88  * See blocking_notifier_chain_unregister() for return value and further
89  * observations.
90  *
91  * Removes a notifier from the rfkill notifier chain.
92  */
93 int unregister_rfkill_notifier(struct notifier_block *nb)
94 {
95         BUG_ON(!nb);
96         return blocking_notifier_chain_unregister(&rfkill_notifier_list, nb);
97 }
98 EXPORT_SYMBOL_GPL(unregister_rfkill_notifier);
99
100
101 static void rfkill_led_trigger(struct rfkill *rfkill,
102                                enum rfkill_state state)
103 {
104 #ifdef CONFIG_RFKILL_LEDS
105         struct led_trigger *led = &rfkill->led_trigger;
106
107         if (!led->name)
108                 return;
109         if (state != RFKILL_STATE_UNBLOCKED)
110                 led_trigger_event(led, LED_OFF);
111         else
112                 led_trigger_event(led, LED_FULL);
113 #endif /* CONFIG_RFKILL_LEDS */
114 }
115
116 #ifdef CONFIG_RFKILL_LEDS
117 static void rfkill_led_trigger_activate(struct led_classdev *led)
118 {
119         struct rfkill *rfkill = container_of(led->trigger,
120                         struct rfkill, led_trigger);
121
122         rfkill_led_trigger(rfkill, rfkill->state);
123 }
124 #endif /* CONFIG_RFKILL_LEDS */
125
126 static void notify_rfkill_state_change(struct rfkill *rfkill)
127 {
128         rfkill_led_trigger(rfkill, rfkill->state);
129         blocking_notifier_call_chain(&rfkill_notifier_list,
130                         RFKILL_STATE_CHANGED,
131                         rfkill);
132 }
133
134 static void update_rfkill_state(struct rfkill *rfkill)
135 {
136         enum rfkill_state newstate, oldstate;
137
138         if (rfkill->get_state) {
139                 mutex_lock(&rfkill->mutex);
140                 if (!rfkill->get_state(rfkill->data, &newstate)) {
141                         oldstate = rfkill->state;
142                         rfkill->state = newstate;
143                         if (oldstate != newstate)
144                                 notify_rfkill_state_change(rfkill);
145                 }
146                 mutex_unlock(&rfkill->mutex);
147         }
148 }
149
150 /**
151  * rfkill_toggle_radio - wrapper for toggle_radio hook
152  * @rfkill: the rfkill struct to use
153  * @force: calls toggle_radio even if cache says it is not needed,
154  *      and also makes sure notifications of the state will be
155  *      sent even if it didn't change
156  * @state: the new state to call toggle_radio() with
157  *
158  * Calls rfkill->toggle_radio, enforcing the API for toggle_radio
159  * calls and handling all the red tape such as issuing notifications
160  * if the call is successful.
161  *
162  * Suspended devices are not touched at all, and -EAGAIN is returned.
163  *
164  * Note that the @force parameter cannot override a (possibly cached)
165  * state of RFKILL_STATE_HARD_BLOCKED.  Any device making use of
166  * RFKILL_STATE_HARD_BLOCKED implements either get_state() or
167  * rfkill_force_state(), so the cache either is bypassed or valid.
168  *
169  * Note that we do call toggle_radio for RFKILL_STATE_SOFT_BLOCKED
170  * even if the radio is in RFKILL_STATE_HARD_BLOCKED state, so as to
171  * give the driver a hint that it should double-BLOCK the transmitter.
172  *
173  * Caller must have acquired rfkill->mutex.
174  */
175 static int rfkill_toggle_radio(struct rfkill *rfkill,
176                                 enum rfkill_state state,
177                                 int force)
178 {
179         int retval = 0;
180         enum rfkill_state oldstate, newstate;
181
182         if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
183                 return -EBUSY;
184
185         oldstate = rfkill->state;
186
187         if (rfkill->get_state && !force &&
188             !rfkill->get_state(rfkill->data, &newstate))
189                 rfkill->state = newstate;
190
191         switch (state) {
192         case RFKILL_STATE_HARD_BLOCKED:
193                 /* typically happens when refreshing hardware state,
194                  * such as on resume */
195                 state = RFKILL_STATE_SOFT_BLOCKED;
196                 break;
197         case RFKILL_STATE_UNBLOCKED:
198                 /* force can't override this, only rfkill_force_state() can */
199                 if (rfkill->state == RFKILL_STATE_HARD_BLOCKED)
200                         return -EPERM;
201                 break;
202         case RFKILL_STATE_SOFT_BLOCKED:
203                 /* nothing to do, we want to give drivers the hint to double
204                  * BLOCK even a transmitter that is already in state
205                  * RFKILL_STATE_HARD_BLOCKED */
206                 break;
207         default:
208                 WARN(1, KERN_WARNING
209                         "rfkill: illegal state %d passed as parameter "
210                         "to rfkill_toggle_radio\n", state);
211                 return -EINVAL;
212         }
213
214         if (force || state != rfkill->state) {
215                 retval = rfkill->toggle_radio(rfkill->data, state);
216                 /* never allow a HARD->SOFT downgrade! */
217                 if (!retval && rfkill->state != RFKILL_STATE_HARD_BLOCKED)
218                         rfkill->state = state;
219         }
220
221         if (force || rfkill->state != oldstate)
222                 notify_rfkill_state_change(rfkill);
223
224         return retval;
225 }
226
227 /**
228  * __rfkill_switch_all - Toggle state of all switches of given type
229  * @type: type of interfaces to be affected
230  * @state: the new state
231  *
232  * This function toggles the state of all switches of given type,
233  * unless a specific switch is claimed by userspace (in which case,
234  * that switch is left alone) or suspended.
235  *
236  * Caller must have acquired rfkill_global_mutex.
237  */
238 static void __rfkill_switch_all(const enum rfkill_type type,
239                                 const enum rfkill_state state)
240 {
241         struct rfkill *rfkill;
242
243         if (WARN((state >= RFKILL_STATE_MAX || type >= RFKILL_TYPE_MAX),
244                         KERN_WARNING
245                         "rfkill: illegal state %d or type %d "
246                         "passed as parameter to __rfkill_switch_all\n",
247                         state, type))
248                 return;
249
250         rfkill_global_states[type].current_state = state;
251         list_for_each_entry(rfkill, &rfkill_list, node) {
252                 if ((!rfkill->user_claim) && (rfkill->type == type)) {
253                         mutex_lock(&rfkill->mutex);
254                         rfkill_toggle_radio(rfkill, state, 0);
255                         mutex_unlock(&rfkill->mutex);
256                 }
257         }
258 }
259
260 /**
261  * rfkill_switch_all - Toggle state of all switches of given type
262  * @type: type of interfaces to be affected
263  * @state: the new state
264  *
265  * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
266  * Please refer to __rfkill_switch_all() for details.
267  */
268 void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
269 {
270         mutex_lock(&rfkill_global_mutex);
271         __rfkill_switch_all(type, state);
272         mutex_unlock(&rfkill_global_mutex);
273 }
274 EXPORT_SYMBOL(rfkill_switch_all);
275
276 /**
277  * rfkill_epo - emergency power off all transmitters
278  *
279  * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
280  * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
281  *
282  * The global state before the EPO is saved and can be restored later
283  * using rfkill_restore_states().
284  */
285 void rfkill_epo(void)
286 {
287         struct rfkill *rfkill;
288         int i;
289
290         mutex_lock(&rfkill_global_mutex);
291
292         list_for_each_entry(rfkill, &rfkill_list, node) {
293                 mutex_lock(&rfkill->mutex);
294                 rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
295                 mutex_unlock(&rfkill->mutex);
296         }
297         for (i = 0; i < RFKILL_TYPE_MAX; i++) {
298                 rfkill_global_states[i].default_state =
299                                 rfkill_global_states[i].current_state;
300                 rfkill_global_states[i].current_state =
301                                 RFKILL_STATE_SOFT_BLOCKED;
302         }
303         mutex_unlock(&rfkill_global_mutex);
304 }
305 EXPORT_SYMBOL_GPL(rfkill_epo);
306
307 /**
308  * rfkill_restore_states - restore global states
309  *
310  * Restore (and sync switches to) the global state from the
311  * states in rfkill_default_states.  This can undo the effects of
312  * a call to rfkill_epo().
313  */
314 void rfkill_restore_states(void)
315 {
316         int i;
317
318         mutex_lock(&rfkill_global_mutex);
319
320         for (i = 0; i < RFKILL_TYPE_MAX; i++)
321                 __rfkill_switch_all(i, rfkill_global_states[i].default_state);
322         mutex_unlock(&rfkill_global_mutex);
323 }
324 EXPORT_SYMBOL_GPL(rfkill_restore_states);
325
326 /**
327  * rfkill_get_global_state - returns global state for a type
328  * @type: the type to get the global state of
329  *
330  * Returns the current global state for a given wireless
331  * device type.
332  */
333 enum rfkill_state rfkill_get_global_state(const enum rfkill_type type)
334 {
335         return rfkill_global_states[type].current_state;
336 }
337 EXPORT_SYMBOL_GPL(rfkill_get_global_state);
338
339 /**
340  * rfkill_force_state - Force the internal rfkill radio state
341  * @rfkill: pointer to the rfkill class to modify.
342  * @state: the current radio state the class should be forced to.
343  *
344  * This function updates the internal state of the radio cached
345  * by the rfkill class.  It should be used when the driver gets
346  * a notification by the firmware/hardware of the current *real*
347  * state of the radio rfkill switch.
348  *
349  * Devices which are subject to external changes on their rfkill
350  * state (such as those caused by a hardware rfkill line) MUST
351  * have their driver arrange to call rfkill_force_state() as soon
352  * as possible after such a change.
353  *
354  * This function may not be called from an atomic context.
355  */
356 int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state)
357 {
358         enum rfkill_state oldstate;
359
360         BUG_ON(!rfkill);
361         if (WARN((state >= RFKILL_STATE_MAX),
362                         KERN_WARNING
363                         "rfkill: illegal state %d passed as parameter "
364                         "to rfkill_force_state\n", state))
365                 return -EINVAL;
366
367         mutex_lock(&rfkill->mutex);
368
369         oldstate = rfkill->state;
370         rfkill->state = state;
371
372         if (state != oldstate)
373                 notify_rfkill_state_change(rfkill);
374
375         mutex_unlock(&rfkill->mutex);
376
377         return 0;
378 }
379 EXPORT_SYMBOL(rfkill_force_state);
380
381 static ssize_t rfkill_name_show(struct device *dev,
382                                 struct device_attribute *attr,
383                                 char *buf)
384 {
385         struct rfkill *rfkill = to_rfkill(dev);
386
387         return sprintf(buf, "%s\n", rfkill->name);
388 }
389
390 static const char *rfkill_get_type_str(enum rfkill_type type)
391 {
392         switch (type) {
393         case RFKILL_TYPE_WLAN:
394                 return "wlan";
395         case RFKILL_TYPE_BLUETOOTH:
396                 return "bluetooth";
397         case RFKILL_TYPE_UWB:
398                 return "ultrawideband";
399         case RFKILL_TYPE_WIMAX:
400                 return "wimax";
401         case RFKILL_TYPE_WWAN:
402                 return "wwan";
403         default:
404                 BUG();
405         }
406 }
407
408 static ssize_t rfkill_type_show(struct device *dev,
409                                 struct device_attribute *attr,
410                                 char *buf)
411 {
412         struct rfkill *rfkill = to_rfkill(dev);
413
414         return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
415 }
416
417 static ssize_t rfkill_state_show(struct device *dev,
418                                  struct device_attribute *attr,
419                                  char *buf)
420 {
421         struct rfkill *rfkill = to_rfkill(dev);
422
423         update_rfkill_state(rfkill);
424         return sprintf(buf, "%d\n", rfkill->state);
425 }
426
427 static ssize_t rfkill_state_store(struct device *dev,
428                                   struct device_attribute *attr,
429                                   const char *buf, size_t count)
430 {
431         struct rfkill *rfkill = to_rfkill(dev);
432         unsigned long state;
433         int error;
434
435         if (!capable(CAP_NET_ADMIN))
436                 return -EPERM;
437
438         error = strict_strtoul(buf, 0, &state);
439         if (error)
440                 return error;
441
442         /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
443         if (state != RFKILL_STATE_UNBLOCKED &&
444             state != RFKILL_STATE_SOFT_BLOCKED)
445                 return -EINVAL;
446
447         error = mutex_lock_killable(&rfkill->mutex);
448         if (error)
449                 return error;
450         error = rfkill_toggle_radio(rfkill, state, 0);
451         mutex_unlock(&rfkill->mutex);
452
453         return error ? error : count;
454 }
455
456 static ssize_t rfkill_claim_show(struct device *dev,
457                                  struct device_attribute *attr,
458                                  char *buf)
459 {
460         struct rfkill *rfkill = to_rfkill(dev);
461
462         return sprintf(buf, "%d\n", rfkill->user_claim);
463 }
464
465 static ssize_t rfkill_claim_store(struct device *dev,
466                                   struct device_attribute *attr,
467                                   const char *buf, size_t count)
468 {
469         struct rfkill *rfkill = to_rfkill(dev);
470         unsigned long claim_tmp;
471         bool claim;
472         int error;
473
474         if (!capable(CAP_NET_ADMIN))
475                 return -EPERM;
476
477         if (rfkill->user_claim_unsupported)
478                 return -EOPNOTSUPP;
479
480         error = strict_strtoul(buf, 0, &claim_tmp);
481         if (error)
482                 return error;
483         claim = !!claim_tmp;
484
485         /*
486          * Take the global lock to make sure the kernel is not in
487          * the middle of rfkill_switch_all
488          */
489         error = mutex_lock_killable(&rfkill_global_mutex);
490         if (error)
491                 return error;
492
493         if (rfkill->user_claim != claim) {
494                 if (!claim) {
495                         mutex_lock(&rfkill->mutex);
496                         rfkill_toggle_radio(rfkill,
497                                         rfkill_global_states[rfkill->type].current_state,
498                                         0);
499                         mutex_unlock(&rfkill->mutex);
500                 }
501                 rfkill->user_claim = claim;
502         }
503
504         mutex_unlock(&rfkill_global_mutex);
505
506         return error ? error : count;
507 }
508
509 static struct device_attribute rfkill_dev_attrs[] = {
510         __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
511         __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
512         __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
513         __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
514         __ATTR_NULL
515 };
516
517 static void rfkill_release(struct device *dev)
518 {
519         struct rfkill *rfkill = to_rfkill(dev);
520
521         kfree(rfkill);
522         module_put(THIS_MODULE);
523 }
524
525 #ifdef CONFIG_PM
526 static int rfkill_suspend(struct device *dev, pm_message_t state)
527 {
528         /* mark class device as suspended */
529         if (dev->power.power_state.event != state.event)
530                 dev->power.power_state = state;
531
532         return 0;
533 }
534
535 static int rfkill_resume(struct device *dev)
536 {
537         struct rfkill *rfkill = to_rfkill(dev);
538
539         if (dev->power.power_state.event != PM_EVENT_ON) {
540                 mutex_lock(&rfkill->mutex);
541
542                 dev->power.power_state.event = PM_EVENT_ON;
543
544                 /* restore radio state AND notify everybody */
545                 rfkill_toggle_radio(rfkill, rfkill->state, 1);
546
547                 mutex_unlock(&rfkill->mutex);
548         }
549
550         return 0;
551 }
552 #else
553 #define rfkill_suspend NULL
554 #define rfkill_resume NULL
555 #endif
556
557 static int rfkill_blocking_uevent_notifier(struct notifier_block *nb,
558                                         unsigned long eventid,
559                                         void *data)
560 {
561         struct rfkill *rfkill = (struct rfkill *)data;
562
563         switch (eventid) {
564         case RFKILL_STATE_CHANGED:
565                 kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
566                 break;
567         default:
568                 break;
569         }
570
571         return NOTIFY_DONE;
572 }
573
574 static struct notifier_block rfkill_blocking_uevent_nb = {
575         .notifier_call  = rfkill_blocking_uevent_notifier,
576         .priority       = 0,
577 };
578
579 static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
580 {
581         struct rfkill *rfkill = to_rfkill(dev);
582         int error;
583
584         error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
585         if (error)
586                 return error;
587         error = add_uevent_var(env, "RFKILL_TYPE=%s",
588                                 rfkill_get_type_str(rfkill->type));
589         if (error)
590                 return error;
591         error = add_uevent_var(env, "RFKILL_STATE=%d", rfkill->state);
592         return error;
593 }
594
595 static struct class rfkill_class = {
596         .name           = "rfkill",
597         .dev_release    = rfkill_release,
598         .dev_attrs      = rfkill_dev_attrs,
599         .suspend        = rfkill_suspend,
600         .resume         = rfkill_resume,
601         .dev_uevent     = rfkill_dev_uevent,
602 };
603
604 static int rfkill_check_duplicity(const struct rfkill *rfkill)
605 {
606         struct rfkill *p;
607         unsigned long seen[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
608
609         memset(seen, 0, sizeof(seen));
610
611         list_for_each_entry(p, &rfkill_list, node) {
612                 if (WARN((p == rfkill), KERN_WARNING
613                                 "rfkill: illegal attempt to register "
614                                 "an already registered rfkill struct\n"))
615                         return -EEXIST;
616                 set_bit(p->type, seen);
617         }
618
619         /* 0: first switch of its kind */
620         return test_bit(rfkill->type, seen);
621 }
622
623 static int rfkill_add_switch(struct rfkill *rfkill)
624 {
625         int error;
626
627         mutex_lock(&rfkill_global_mutex);
628
629         error = rfkill_check_duplicity(rfkill);
630         if (error < 0)
631                 goto unlock_out;
632
633         if (!error) {
634                 /* lock default after first use */
635                 set_bit(rfkill->type, rfkill_states_lockdflt);
636                 rfkill_global_states[rfkill->type].current_state =
637                         rfkill_global_states[rfkill->type].default_state;
638         }
639
640         rfkill_toggle_radio(rfkill,
641                             rfkill_global_states[rfkill->type].current_state,
642                             0);
643
644         list_add_tail(&rfkill->node, &rfkill_list);
645
646         error = 0;
647 unlock_out:
648         mutex_unlock(&rfkill_global_mutex);
649
650         return error;
651 }
652
653 static void rfkill_remove_switch(struct rfkill *rfkill)
654 {
655         mutex_lock(&rfkill_global_mutex);
656         list_del_init(&rfkill->node);
657         mutex_unlock(&rfkill_global_mutex);
658
659         mutex_lock(&rfkill->mutex);
660         rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
661         mutex_unlock(&rfkill->mutex);
662 }
663
664 /**
665  * rfkill_allocate - allocate memory for rfkill structure.
666  * @parent: device that has rf switch on it
667  * @type: type of the switch (RFKILL_TYPE_*)
668  *
669  * This function should be called by the network driver when it needs
670  * rfkill structure.  Once the structure is allocated the driver should
671  * finish its initialization by setting the name, private data, enable_radio
672  * and disable_radio methods and then register it with rfkill_register().
673  *
674  * NOTE: If registration fails the structure shoudl be freed by calling
675  * rfkill_free() otherwise rfkill_unregister() should be used.
676  */
677 struct rfkill * __must_check rfkill_allocate(struct device *parent,
678                                              enum rfkill_type type)
679 {
680         struct rfkill *rfkill;
681         struct device *dev;
682
683         if (WARN((type >= RFKILL_TYPE_MAX),
684                         KERN_WARNING
685                         "rfkill: illegal type %d passed as parameter "
686                         "to rfkill_allocate\n", type))
687                 return NULL;
688
689         rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
690         if (!rfkill)
691                 return NULL;
692
693         mutex_init(&rfkill->mutex);
694         INIT_LIST_HEAD(&rfkill->node);
695         rfkill->type = type;
696
697         dev = &rfkill->dev;
698         dev->class = &rfkill_class;
699         dev->parent = parent;
700         device_initialize(dev);
701
702         __module_get(THIS_MODULE);
703
704         return rfkill;
705 }
706 EXPORT_SYMBOL(rfkill_allocate);
707
708 /**
709  * rfkill_free - Mark rfkill structure for deletion
710  * @rfkill: rfkill structure to be destroyed
711  *
712  * Decrements reference count of the rfkill structure so it is destroyed.
713  * Note that rfkill_free() should _not_ be called after rfkill_unregister().
714  */
715 void rfkill_free(struct rfkill *rfkill)
716 {
717         if (rfkill)
718                 put_device(&rfkill->dev);
719 }
720 EXPORT_SYMBOL(rfkill_free);
721
722 static void rfkill_led_trigger_register(struct rfkill *rfkill)
723 {
724 #ifdef CONFIG_RFKILL_LEDS
725         int error;
726
727         if (!rfkill->led_trigger.name)
728                 rfkill->led_trigger.name = rfkill->dev.bus_id;
729         if (!rfkill->led_trigger.activate)
730                 rfkill->led_trigger.activate = rfkill_led_trigger_activate;
731         error = led_trigger_register(&rfkill->led_trigger);
732         if (error)
733                 rfkill->led_trigger.name = NULL;
734 #endif /* CONFIG_RFKILL_LEDS */
735 }
736
737 static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
738 {
739 #ifdef CONFIG_RFKILL_LEDS
740         if (rfkill->led_trigger.name) {
741                 led_trigger_unregister(&rfkill->led_trigger);
742                 rfkill->led_trigger.name = NULL;
743         }
744 #endif
745 }
746
747 /**
748  * rfkill_register - Register a rfkill structure.
749  * @rfkill: rfkill structure to be registered
750  *
751  * This function should be called by the network driver when the rfkill
752  * structure needs to be registered. Immediately from registration the
753  * switch driver should be able to service calls to toggle_radio.
754  */
755 int __must_check rfkill_register(struct rfkill *rfkill)
756 {
757         static atomic_t rfkill_no = ATOMIC_INIT(0);
758         struct device *dev = &rfkill->dev;
759         int error;
760
761         if (WARN((!rfkill || !rfkill->toggle_radio ||
762                         rfkill->type >= RFKILL_TYPE_MAX ||
763                         rfkill->state >= RFKILL_STATE_MAX),
764                         KERN_WARNING
765                         "rfkill: attempt to register a "
766                         "badly initialized rfkill struct\n"))
767                 return -EINVAL;
768
769         snprintf(dev->bus_id, sizeof(dev->bus_id),
770                  "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
771
772         rfkill_led_trigger_register(rfkill);
773
774         error = rfkill_add_switch(rfkill);
775         if (error) {
776                 rfkill_led_trigger_unregister(rfkill);
777                 return error;
778         }
779
780         error = device_add(dev);
781         if (error) {
782                 rfkill_remove_switch(rfkill);
783                 rfkill_led_trigger_unregister(rfkill);
784                 return error;
785         }
786
787         return 0;
788 }
789 EXPORT_SYMBOL(rfkill_register);
790
791 /**
792  * rfkill_unregister - Unregister a rfkill structure.
793  * @rfkill: rfkill structure to be unregistered
794  *
795  * This function should be called by the network driver during device
796  * teardown to destroy rfkill structure. Note that rfkill_free() should
797  * _not_ be called after rfkill_unregister().
798  */
799 void rfkill_unregister(struct rfkill *rfkill)
800 {
801         BUG_ON(!rfkill);
802         device_del(&rfkill->dev);
803         rfkill_remove_switch(rfkill);
804         rfkill_led_trigger_unregister(rfkill);
805         put_device(&rfkill->dev);
806 }
807 EXPORT_SYMBOL(rfkill_unregister);
808
809 /**
810  * rfkill_set_default - set initial value for a switch type
811  * @type - the type of switch to set the default state of
812  * @state - the new default state for that group of switches
813  *
814  * Sets the initial state rfkill should use for a given type.
815  * The following initial states are allowed: RFKILL_STATE_SOFT_BLOCKED
816  * and RFKILL_STATE_UNBLOCKED.
817  *
818  * This function is meant to be used by platform drivers for platforms
819  * that can save switch state across power down/reboot.
820  *
821  * The default state for each switch type can be changed exactly once.
822  * After a switch of that type is registered, the default state cannot
823  * be changed anymore.  This guards against multiple drivers it the
824  * same platform trying to set the initial switch default state, which
825  * is not allowed.
826  *
827  * Returns -EPERM if the state has already been set once or is in use,
828  * so drivers likely want to either ignore or at most printk(KERN_NOTICE)
829  * if this function returns -EPERM.
830  *
831  * Returns 0 if the new default state was set, or an error if it
832  * could not be set.
833  */
834 int rfkill_set_default(enum rfkill_type type, enum rfkill_state state)
835 {
836         int error;
837
838         if (WARN((type >= RFKILL_TYPE_MAX ||
839                         (state != RFKILL_STATE_SOFT_BLOCKED &&
840                          state != RFKILL_STATE_UNBLOCKED)),
841                         KERN_WARNING
842                         "rfkill: illegal state %d or type %d passed as "
843                         "parameter to rfkill_set_default\n", state, type))
844                 return -EINVAL;
845
846         mutex_lock(&rfkill_global_mutex);
847
848         if (!test_and_set_bit(type, rfkill_states_lockdflt)) {
849                 rfkill_global_states[type].default_state = state;
850                 rfkill_global_states[type].current_state = state;
851                 error = 0;
852         } else
853                 error = -EPERM;
854
855         mutex_unlock(&rfkill_global_mutex);
856         return error;
857 }
858 EXPORT_SYMBOL_GPL(rfkill_set_default);
859
860 /*
861  * Rfkill module initialization/deinitialization.
862  */
863 static int __init rfkill_init(void)
864 {
865         int error;
866         int i;
867
868         /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
869         if (rfkill_default_state != RFKILL_STATE_SOFT_BLOCKED &&
870             rfkill_default_state != RFKILL_STATE_UNBLOCKED)
871                 return -EINVAL;
872
873         for (i = 0; i < RFKILL_TYPE_MAX; i++)
874                 rfkill_global_states[i].default_state = rfkill_default_state;
875
876         error = class_register(&rfkill_class);
877         if (error) {
878                 printk(KERN_ERR "rfkill: unable to register rfkill class\n");
879                 return error;
880         }
881
882         register_rfkill_notifier(&rfkill_blocking_uevent_nb);
883
884         return 0;
885 }
886
887 static void __exit rfkill_exit(void)
888 {
889         unregister_rfkill_notifier(&rfkill_blocking_uevent_nb);
890         class_unregister(&rfkill_class);
891 }
892
893 subsys_initcall(rfkill_init);
894 module_exit(rfkill_exit);