net: Annotates neigh_invalidate()
[linux-2.6.git] / net / rfkill / core.c
1 /*
2  * Copyright (C) 2006 - 2007 Ivo van Doorn
3  * Copyright (C) 2007 Dmitry Torokhov
4  * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the
18  * Free Software Foundation, Inc.,
19  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/workqueue.h>
26 #include <linux/capability.h>
27 #include <linux/list.h>
28 #include <linux/mutex.h>
29 #include <linux/rfkill.h>
30 #include <linux/sched.h>
31 #include <linux/spinlock.h>
32 #include <linux/miscdevice.h>
33 #include <linux/wait.h>
34 #include <linux/poll.h>
35 #include <linux/fs.h>
36
37 #include "rfkill.h"
38
39 #define POLL_INTERVAL           (5 * HZ)
40
41 #define RFKILL_BLOCK_HW         BIT(0)
42 #define RFKILL_BLOCK_SW         BIT(1)
43 #define RFKILL_BLOCK_SW_PREV    BIT(2)
44 #define RFKILL_BLOCK_ANY        (RFKILL_BLOCK_HW |\
45                                  RFKILL_BLOCK_SW |\
46                                  RFKILL_BLOCK_SW_PREV)
47 #define RFKILL_BLOCK_SW_SETCALL BIT(31)
48
49 struct rfkill {
50         spinlock_t              lock;
51
52         const char              *name;
53         enum rfkill_type        type;
54
55         unsigned long           state;
56
57         u32                     idx;
58
59         bool                    registered;
60         bool                    persistent;
61
62         const struct rfkill_ops *ops;
63         void                    *data;
64
65 #ifdef CONFIG_RFKILL_LEDS
66         struct led_trigger      led_trigger;
67         const char              *ledtrigname;
68 #endif
69
70         struct device           dev;
71         struct list_head        node;
72
73         struct delayed_work     poll_work;
74         struct work_struct      uevent_work;
75         struct work_struct      sync_work;
76 };
77 #define to_rfkill(d)    container_of(d, struct rfkill, dev)
78
79 struct rfkill_int_event {
80         struct list_head        list;
81         struct rfkill_event     ev;
82 };
83
84 struct rfkill_data {
85         struct list_head        list;
86         struct list_head        events;
87         struct mutex            mtx;
88         wait_queue_head_t       read_wait;
89         bool                    input_handler;
90 };
91
92
93 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
94 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
95 MODULE_DESCRIPTION("RF switch support");
96 MODULE_LICENSE("GPL");
97
98
99 /*
100  * The locking here should be made much smarter, we currently have
101  * a bit of a stupid situation because drivers might want to register
102  * the rfkill struct under their own lock, and take this lock during
103  * rfkill method calls -- which will cause an AB-BA deadlock situation.
104  *
105  * To fix that, we need to rework this code here to be mostly lock-free
106  * and only use the mutex for list manipulations, not to protect the
107  * various other global variables. Then we can avoid holding the mutex
108  * around driver operations, and all is happy.
109  */
110 static LIST_HEAD(rfkill_list);  /* list of registered rf switches */
111 static DEFINE_MUTEX(rfkill_global_mutex);
112 static LIST_HEAD(rfkill_fds);   /* list of open fds of /dev/rfkill */
113
114 static unsigned int rfkill_default_state = 1;
115 module_param_named(default_state, rfkill_default_state, uint, 0444);
116 MODULE_PARM_DESC(default_state,
117                  "Default initial state for all radio types, 0 = radio off");
118
119 static struct {
120         bool cur, sav;
121 } rfkill_global_states[NUM_RFKILL_TYPES];
122
123 static bool rfkill_epo_lock_active;
124
125
126 #ifdef CONFIG_RFKILL_LEDS
127 static void rfkill_led_trigger_event(struct rfkill *rfkill)
128 {
129         struct led_trigger *trigger;
130
131         if (!rfkill->registered)
132                 return;
133
134         trigger = &rfkill->led_trigger;
135
136         if (rfkill->state & RFKILL_BLOCK_ANY)
137                 led_trigger_event(trigger, LED_OFF);
138         else
139                 led_trigger_event(trigger, LED_FULL);
140 }
141
142 static void rfkill_led_trigger_activate(struct led_classdev *led)
143 {
144         struct rfkill *rfkill;
145
146         rfkill = container_of(led->trigger, struct rfkill, led_trigger);
147
148         rfkill_led_trigger_event(rfkill);
149 }
150
151 const char *rfkill_get_led_trigger_name(struct rfkill *rfkill)
152 {
153         return rfkill->led_trigger.name;
154 }
155 EXPORT_SYMBOL(rfkill_get_led_trigger_name);
156
157 void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name)
158 {
159         BUG_ON(!rfkill);
160
161         rfkill->ledtrigname = name;
162 }
163 EXPORT_SYMBOL(rfkill_set_led_trigger_name);
164
165 static int rfkill_led_trigger_register(struct rfkill *rfkill)
166 {
167         rfkill->led_trigger.name = rfkill->ledtrigname
168                                         ? : dev_name(&rfkill->dev);
169         rfkill->led_trigger.activate = rfkill_led_trigger_activate;
170         return led_trigger_register(&rfkill->led_trigger);
171 }
172
173 static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
174 {
175         led_trigger_unregister(&rfkill->led_trigger);
176 }
177 #else
178 static void rfkill_led_trigger_event(struct rfkill *rfkill)
179 {
180 }
181
182 static inline int rfkill_led_trigger_register(struct rfkill *rfkill)
183 {
184         return 0;
185 }
186
187 static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill)
188 {
189 }
190 #endif /* CONFIG_RFKILL_LEDS */
191
192 static void rfkill_fill_event(struct rfkill_event *ev, struct rfkill *rfkill,
193                               enum rfkill_operation op)
194 {
195         unsigned long flags;
196
197         ev->idx = rfkill->idx;
198         ev->type = rfkill->type;
199         ev->op = op;
200
201         spin_lock_irqsave(&rfkill->lock, flags);
202         ev->hard = !!(rfkill->state & RFKILL_BLOCK_HW);
203         ev->soft = !!(rfkill->state & (RFKILL_BLOCK_SW |
204                                         RFKILL_BLOCK_SW_PREV));
205         spin_unlock_irqrestore(&rfkill->lock, flags);
206 }
207
208 static void rfkill_send_events(struct rfkill *rfkill, enum rfkill_operation op)
209 {
210         struct rfkill_data *data;
211         struct rfkill_int_event *ev;
212
213         list_for_each_entry(data, &rfkill_fds, list) {
214                 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
215                 if (!ev)
216                         continue;
217                 rfkill_fill_event(&ev->ev, rfkill, op);
218                 mutex_lock(&data->mtx);
219                 list_add_tail(&ev->list, &data->events);
220                 mutex_unlock(&data->mtx);
221                 wake_up_interruptible(&data->read_wait);
222         }
223 }
224
225 static void rfkill_event(struct rfkill *rfkill)
226 {
227         if (!rfkill->registered)
228                 return;
229
230         kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
231
232         /* also send event to /dev/rfkill */
233         rfkill_send_events(rfkill, RFKILL_OP_CHANGE);
234 }
235
236 static bool __rfkill_set_hw_state(struct rfkill *rfkill,
237                                   bool blocked, bool *change)
238 {
239         unsigned long flags;
240         bool prev, any;
241
242         BUG_ON(!rfkill);
243
244         spin_lock_irqsave(&rfkill->lock, flags);
245         prev = !!(rfkill->state & RFKILL_BLOCK_HW);
246         if (blocked)
247                 rfkill->state |= RFKILL_BLOCK_HW;
248         else
249                 rfkill->state &= ~RFKILL_BLOCK_HW;
250         *change = prev != blocked;
251         any = rfkill->state & RFKILL_BLOCK_ANY;
252         spin_unlock_irqrestore(&rfkill->lock, flags);
253
254         rfkill_led_trigger_event(rfkill);
255
256         return any;
257 }
258
259 /**
260  * rfkill_set_block - wrapper for set_block method
261  *
262  * @rfkill: the rfkill struct to use
263  * @blocked: the new software state
264  *
265  * Calls the set_block method (when applicable) and handles notifications
266  * etc. as well.
267  */
268 static void rfkill_set_block(struct rfkill *rfkill, bool blocked)
269 {
270         unsigned long flags;
271         int err;
272
273         if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
274                 return;
275
276         /*
277          * Some platforms (...!) generate input events which affect the
278          * _hard_ kill state -- whenever something tries to change the
279          * current software state query the hardware state too.
280          */
281         if (rfkill->ops->query)
282                 rfkill->ops->query(rfkill, rfkill->data);
283
284         spin_lock_irqsave(&rfkill->lock, flags);
285         if (rfkill->state & RFKILL_BLOCK_SW)
286                 rfkill->state |= RFKILL_BLOCK_SW_PREV;
287         else
288                 rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
289
290         if (blocked)
291                 rfkill->state |= RFKILL_BLOCK_SW;
292         else
293                 rfkill->state &= ~RFKILL_BLOCK_SW;
294
295         rfkill->state |= RFKILL_BLOCK_SW_SETCALL;
296         spin_unlock_irqrestore(&rfkill->lock, flags);
297
298         err = rfkill->ops->set_block(rfkill->data, blocked);
299
300         spin_lock_irqsave(&rfkill->lock, flags);
301         if (err) {
302                 /*
303                  * Failed -- reset status to _prev, this may be different
304                  * from what set set _PREV to earlier in this function
305                  * if rfkill_set_sw_state was invoked.
306                  */
307                 if (rfkill->state & RFKILL_BLOCK_SW_PREV)
308                         rfkill->state |= RFKILL_BLOCK_SW;
309                 else
310                         rfkill->state &= ~RFKILL_BLOCK_SW;
311         }
312         rfkill->state &= ~RFKILL_BLOCK_SW_SETCALL;
313         rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
314         spin_unlock_irqrestore(&rfkill->lock, flags);
315
316         rfkill_led_trigger_event(rfkill);
317         rfkill_event(rfkill);
318 }
319
320 #ifdef CONFIG_RFKILL_INPUT
321 static atomic_t rfkill_input_disabled = ATOMIC_INIT(0);
322
323 /**
324  * __rfkill_switch_all - Toggle state of all switches of given type
325  * @type: type of interfaces to be affected
326  * @state: the new state
327  *
328  * This function sets the state of all switches of given type,
329  * unless a specific switch is claimed by userspace (in which case,
330  * that switch is left alone) or suspended.
331  *
332  * Caller must have acquired rfkill_global_mutex.
333  */
334 static void __rfkill_switch_all(const enum rfkill_type type, bool blocked)
335 {
336         struct rfkill *rfkill;
337
338         rfkill_global_states[type].cur = blocked;
339         list_for_each_entry(rfkill, &rfkill_list, node) {
340                 if (rfkill->type != type)
341                         continue;
342
343                 rfkill_set_block(rfkill, blocked);
344         }
345 }
346
347 /**
348  * rfkill_switch_all - Toggle state of all switches of given type
349  * @type: type of interfaces to be affected
350  * @state: the new state
351  *
352  * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
353  * Please refer to __rfkill_switch_all() for details.
354  *
355  * Does nothing if the EPO lock is active.
356  */
357 void rfkill_switch_all(enum rfkill_type type, bool blocked)
358 {
359         if (atomic_read(&rfkill_input_disabled))
360                 return;
361
362         mutex_lock(&rfkill_global_mutex);
363
364         if (!rfkill_epo_lock_active)
365                 __rfkill_switch_all(type, blocked);
366
367         mutex_unlock(&rfkill_global_mutex);
368 }
369
370 /**
371  * rfkill_epo - emergency power off all transmitters
372  *
373  * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
374  * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
375  *
376  * The global state before the EPO is saved and can be restored later
377  * using rfkill_restore_states().
378  */
379 void rfkill_epo(void)
380 {
381         struct rfkill *rfkill;
382         int i;
383
384         if (atomic_read(&rfkill_input_disabled))
385                 return;
386
387         mutex_lock(&rfkill_global_mutex);
388
389         rfkill_epo_lock_active = true;
390         list_for_each_entry(rfkill, &rfkill_list, node)
391                 rfkill_set_block(rfkill, true);
392
393         for (i = 0; i < NUM_RFKILL_TYPES; i++) {
394                 rfkill_global_states[i].sav = rfkill_global_states[i].cur;
395                 rfkill_global_states[i].cur = true;
396         }
397
398         mutex_unlock(&rfkill_global_mutex);
399 }
400
401 /**
402  * rfkill_restore_states - restore global states
403  *
404  * Restore (and sync switches to) the global state from the
405  * states in rfkill_default_states.  This can undo the effects of
406  * a call to rfkill_epo().
407  */
408 void rfkill_restore_states(void)
409 {
410         int i;
411
412         if (atomic_read(&rfkill_input_disabled))
413                 return;
414
415         mutex_lock(&rfkill_global_mutex);
416
417         rfkill_epo_lock_active = false;
418         for (i = 0; i < NUM_RFKILL_TYPES; i++)
419                 __rfkill_switch_all(i, rfkill_global_states[i].sav);
420         mutex_unlock(&rfkill_global_mutex);
421 }
422
423 /**
424  * rfkill_remove_epo_lock - unlock state changes
425  *
426  * Used by rfkill-input manually unlock state changes, when
427  * the EPO switch is deactivated.
428  */
429 void rfkill_remove_epo_lock(void)
430 {
431         if (atomic_read(&rfkill_input_disabled))
432                 return;
433
434         mutex_lock(&rfkill_global_mutex);
435         rfkill_epo_lock_active = false;
436         mutex_unlock(&rfkill_global_mutex);
437 }
438
439 /**
440  * rfkill_is_epo_lock_active - returns true EPO is active
441  *
442  * Returns 0 (false) if there is NOT an active EPO contidion,
443  * and 1 (true) if there is an active EPO contition, which
444  * locks all radios in one of the BLOCKED states.
445  *
446  * Can be called in atomic context.
447  */
448 bool rfkill_is_epo_lock_active(void)
449 {
450         return rfkill_epo_lock_active;
451 }
452
453 /**
454  * rfkill_get_global_sw_state - returns global state for a type
455  * @type: the type to get the global state of
456  *
457  * Returns the current global state for a given wireless
458  * device type.
459  */
460 bool rfkill_get_global_sw_state(const enum rfkill_type type)
461 {
462         return rfkill_global_states[type].cur;
463 }
464 #endif
465
466
467 bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
468 {
469         bool ret, change;
470
471         ret = __rfkill_set_hw_state(rfkill, blocked, &change);
472
473         if (!rfkill->registered)
474                 return ret;
475
476         if (change)
477                 schedule_work(&rfkill->uevent_work);
478
479         return ret;
480 }
481 EXPORT_SYMBOL(rfkill_set_hw_state);
482
483 static void __rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
484 {
485         u32 bit = RFKILL_BLOCK_SW;
486
487         /* if in a ops->set_block right now, use other bit */
488         if (rfkill->state & RFKILL_BLOCK_SW_SETCALL)
489                 bit = RFKILL_BLOCK_SW_PREV;
490
491         if (blocked)
492                 rfkill->state |= bit;
493         else
494                 rfkill->state &= ~bit;
495 }
496
497 bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
498 {
499         unsigned long flags;
500         bool prev, hwblock;
501
502         BUG_ON(!rfkill);
503
504         spin_lock_irqsave(&rfkill->lock, flags);
505         prev = !!(rfkill->state & RFKILL_BLOCK_SW);
506         __rfkill_set_sw_state(rfkill, blocked);
507         hwblock = !!(rfkill->state & RFKILL_BLOCK_HW);
508         blocked = blocked || hwblock;
509         spin_unlock_irqrestore(&rfkill->lock, flags);
510
511         if (!rfkill->registered)
512                 return blocked;
513
514         if (prev != blocked && !hwblock)
515                 schedule_work(&rfkill->uevent_work);
516
517         rfkill_led_trigger_event(rfkill);
518
519         return blocked;
520 }
521 EXPORT_SYMBOL(rfkill_set_sw_state);
522
523 void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked)
524 {
525         unsigned long flags;
526
527         BUG_ON(!rfkill);
528         BUG_ON(rfkill->registered);
529
530         spin_lock_irqsave(&rfkill->lock, flags);
531         __rfkill_set_sw_state(rfkill, blocked);
532         rfkill->persistent = true;
533         spin_unlock_irqrestore(&rfkill->lock, flags);
534 }
535 EXPORT_SYMBOL(rfkill_init_sw_state);
536
537 void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
538 {
539         unsigned long flags;
540         bool swprev, hwprev;
541
542         BUG_ON(!rfkill);
543
544         spin_lock_irqsave(&rfkill->lock, flags);
545
546         /*
547          * No need to care about prev/setblock ... this is for uevent only
548          * and that will get triggered by rfkill_set_block anyway.
549          */
550         swprev = !!(rfkill->state & RFKILL_BLOCK_SW);
551         hwprev = !!(rfkill->state & RFKILL_BLOCK_HW);
552         __rfkill_set_sw_state(rfkill, sw);
553         if (hw)
554                 rfkill->state |= RFKILL_BLOCK_HW;
555         else
556                 rfkill->state &= ~RFKILL_BLOCK_HW;
557
558         spin_unlock_irqrestore(&rfkill->lock, flags);
559
560         if (!rfkill->registered) {
561                 rfkill->persistent = true;
562         } else {
563                 if (swprev != sw || hwprev != hw)
564                         schedule_work(&rfkill->uevent_work);
565
566                 rfkill_led_trigger_event(rfkill);
567         }
568 }
569 EXPORT_SYMBOL(rfkill_set_states);
570
571 static ssize_t rfkill_name_show(struct device *dev,
572                                 struct device_attribute *attr,
573                                 char *buf)
574 {
575         struct rfkill *rfkill = to_rfkill(dev);
576
577         return sprintf(buf, "%s\n", rfkill->name);
578 }
579
580 static const char *rfkill_get_type_str(enum rfkill_type type)
581 {
582         BUILD_BUG_ON(NUM_RFKILL_TYPES != RFKILL_TYPE_FM + 1);
583
584         switch (type) {
585         case RFKILL_TYPE_WLAN:
586                 return "wlan";
587         case RFKILL_TYPE_BLUETOOTH:
588                 return "bluetooth";
589         case RFKILL_TYPE_UWB:
590                 return "ultrawideband";
591         case RFKILL_TYPE_WIMAX:
592                 return "wimax";
593         case RFKILL_TYPE_WWAN:
594                 return "wwan";
595         case RFKILL_TYPE_GPS:
596                 return "gps";
597         case RFKILL_TYPE_FM:
598                 return "fm";
599         default:
600                 BUG();
601         }
602 }
603
604 static ssize_t rfkill_type_show(struct device *dev,
605                                 struct device_attribute *attr,
606                                 char *buf)
607 {
608         struct rfkill *rfkill = to_rfkill(dev);
609
610         return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
611 }
612
613 static ssize_t rfkill_idx_show(struct device *dev,
614                                struct device_attribute *attr,
615                                char *buf)
616 {
617         struct rfkill *rfkill = to_rfkill(dev);
618
619         return sprintf(buf, "%d\n", rfkill->idx);
620 }
621
622 static ssize_t rfkill_persistent_show(struct device *dev,
623                                struct device_attribute *attr,
624                                char *buf)
625 {
626         struct rfkill *rfkill = to_rfkill(dev);
627
628         return sprintf(buf, "%d\n", rfkill->persistent);
629 }
630
631 static u8 user_state_from_blocked(unsigned long state)
632 {
633         if (state & RFKILL_BLOCK_HW)
634                 return RFKILL_USER_STATE_HARD_BLOCKED;
635         if (state & RFKILL_BLOCK_SW)
636                 return RFKILL_USER_STATE_SOFT_BLOCKED;
637
638         return RFKILL_USER_STATE_UNBLOCKED;
639 }
640
641 static ssize_t rfkill_state_show(struct device *dev,
642                                  struct device_attribute *attr,
643                                  char *buf)
644 {
645         struct rfkill *rfkill = to_rfkill(dev);
646         unsigned long flags;
647         u32 state;
648
649         spin_lock_irqsave(&rfkill->lock, flags);
650         state = rfkill->state;
651         spin_unlock_irqrestore(&rfkill->lock, flags);
652
653         return sprintf(buf, "%d\n", user_state_from_blocked(state));
654 }
655
656 static ssize_t rfkill_state_store(struct device *dev,
657                                   struct device_attribute *attr,
658                                   const char *buf, size_t count)
659 {
660         struct rfkill *rfkill = to_rfkill(dev);
661         unsigned long state;
662         int err;
663
664         if (!capable(CAP_NET_ADMIN))
665                 return -EPERM;
666
667         err = strict_strtoul(buf, 0, &state);
668         if (err)
669                 return err;
670
671         if (state != RFKILL_USER_STATE_SOFT_BLOCKED &&
672             state != RFKILL_USER_STATE_UNBLOCKED)
673                 return -EINVAL;
674
675         mutex_lock(&rfkill_global_mutex);
676         rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED);
677         mutex_unlock(&rfkill_global_mutex);
678
679         return err ?: count;
680 }
681
682 static ssize_t rfkill_claim_show(struct device *dev,
683                                  struct device_attribute *attr,
684                                  char *buf)
685 {
686         return sprintf(buf, "%d\n", 0);
687 }
688
689 static ssize_t rfkill_claim_store(struct device *dev,
690                                   struct device_attribute *attr,
691                                   const char *buf, size_t count)
692 {
693         return -EOPNOTSUPP;
694 }
695
696 static struct device_attribute rfkill_dev_attrs[] = {
697         __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
698         __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
699         __ATTR(index, S_IRUGO, rfkill_idx_show, NULL),
700         __ATTR(persistent, S_IRUGO, rfkill_persistent_show, NULL),
701         __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
702         __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
703         __ATTR_NULL
704 };
705
706 static void rfkill_release(struct device *dev)
707 {
708         struct rfkill *rfkill = to_rfkill(dev);
709
710         kfree(rfkill);
711 }
712
713 static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
714 {
715         struct rfkill *rfkill = to_rfkill(dev);
716         unsigned long flags;
717         u32 state;
718         int error;
719
720         error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
721         if (error)
722                 return error;
723         error = add_uevent_var(env, "RFKILL_TYPE=%s",
724                                rfkill_get_type_str(rfkill->type));
725         if (error)
726                 return error;
727         spin_lock_irqsave(&rfkill->lock, flags);
728         state = rfkill->state;
729         spin_unlock_irqrestore(&rfkill->lock, flags);
730         error = add_uevent_var(env, "RFKILL_STATE=%d",
731                                user_state_from_blocked(state));
732         return error;
733 }
734
735 void rfkill_pause_polling(struct rfkill *rfkill)
736 {
737         BUG_ON(!rfkill);
738
739         if (!rfkill->ops->poll)
740                 return;
741
742         cancel_delayed_work_sync(&rfkill->poll_work);
743 }
744 EXPORT_SYMBOL(rfkill_pause_polling);
745
746 void rfkill_resume_polling(struct rfkill *rfkill)
747 {
748         BUG_ON(!rfkill);
749
750         if (!rfkill->ops->poll)
751                 return;
752
753         schedule_work(&rfkill->poll_work.work);
754 }
755 EXPORT_SYMBOL(rfkill_resume_polling);
756
757 static int rfkill_suspend(struct device *dev, pm_message_t state)
758 {
759         struct rfkill *rfkill = to_rfkill(dev);
760
761         rfkill_pause_polling(rfkill);
762
763         return 0;
764 }
765
766 static int rfkill_resume(struct device *dev)
767 {
768         struct rfkill *rfkill = to_rfkill(dev);
769         bool cur;
770
771         if (!rfkill->persistent) {
772                 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
773                 rfkill_set_block(rfkill, cur);
774         }
775
776         rfkill_resume_polling(rfkill);
777
778         return 0;
779 }
780
781 static struct class rfkill_class = {
782         .name           = "rfkill",
783         .dev_release    = rfkill_release,
784         .dev_attrs      = rfkill_dev_attrs,
785         .dev_uevent     = rfkill_dev_uevent,
786         .suspend        = rfkill_suspend,
787         .resume         = rfkill_resume,
788 };
789
790 bool rfkill_blocked(struct rfkill *rfkill)
791 {
792         unsigned long flags;
793         u32 state;
794
795         spin_lock_irqsave(&rfkill->lock, flags);
796         state = rfkill->state;
797         spin_unlock_irqrestore(&rfkill->lock, flags);
798
799         return !!(state & RFKILL_BLOCK_ANY);
800 }
801 EXPORT_SYMBOL(rfkill_blocked);
802
803
804 struct rfkill * __must_check rfkill_alloc(const char *name,
805                                           struct device *parent,
806                                           const enum rfkill_type type,
807                                           const struct rfkill_ops *ops,
808                                           void *ops_data)
809 {
810         struct rfkill *rfkill;
811         struct device *dev;
812
813         if (WARN_ON(!ops))
814                 return NULL;
815
816         if (WARN_ON(!ops->set_block))
817                 return NULL;
818
819         if (WARN_ON(!name))
820                 return NULL;
821
822         if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES))
823                 return NULL;
824
825         rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
826         if (!rfkill)
827                 return NULL;
828
829         spin_lock_init(&rfkill->lock);
830         INIT_LIST_HEAD(&rfkill->node);
831         rfkill->type = type;
832         rfkill->name = name;
833         rfkill->ops = ops;
834         rfkill->data = ops_data;
835
836         dev = &rfkill->dev;
837         dev->class = &rfkill_class;
838         dev->parent = parent;
839         device_initialize(dev);
840
841         return rfkill;
842 }
843 EXPORT_SYMBOL(rfkill_alloc);
844
845 static void rfkill_poll(struct work_struct *work)
846 {
847         struct rfkill *rfkill;
848
849         rfkill = container_of(work, struct rfkill, poll_work.work);
850
851         /*
852          * Poll hardware state -- driver will use one of the
853          * rfkill_set{,_hw,_sw}_state functions and use its
854          * return value to update the current status.
855          */
856         rfkill->ops->poll(rfkill, rfkill->data);
857
858         schedule_delayed_work(&rfkill->poll_work,
859                 round_jiffies_relative(POLL_INTERVAL));
860 }
861
862 static void rfkill_uevent_work(struct work_struct *work)
863 {
864         struct rfkill *rfkill;
865
866         rfkill = container_of(work, struct rfkill, uevent_work);
867
868         mutex_lock(&rfkill_global_mutex);
869         rfkill_event(rfkill);
870         mutex_unlock(&rfkill_global_mutex);
871 }
872
873 static void rfkill_sync_work(struct work_struct *work)
874 {
875         struct rfkill *rfkill;
876         bool cur;
877
878         rfkill = container_of(work, struct rfkill, sync_work);
879
880         mutex_lock(&rfkill_global_mutex);
881         cur = rfkill_global_states[rfkill->type].cur;
882         rfkill_set_block(rfkill, cur);
883         mutex_unlock(&rfkill_global_mutex);
884 }
885
886 int __must_check rfkill_register(struct rfkill *rfkill)
887 {
888         static unsigned long rfkill_no;
889         struct device *dev = &rfkill->dev;
890         int error;
891
892         BUG_ON(!rfkill);
893
894         mutex_lock(&rfkill_global_mutex);
895
896         if (rfkill->registered) {
897                 error = -EALREADY;
898                 goto unlock;
899         }
900
901         rfkill->idx = rfkill_no;
902         dev_set_name(dev, "rfkill%lu", rfkill_no);
903         rfkill_no++;
904
905         list_add_tail(&rfkill->node, &rfkill_list);
906
907         error = device_add(dev);
908         if (error)
909                 goto remove;
910
911         error = rfkill_led_trigger_register(rfkill);
912         if (error)
913                 goto devdel;
914
915         rfkill->registered = true;
916
917         INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll);
918         INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work);
919         INIT_WORK(&rfkill->sync_work, rfkill_sync_work);
920
921         if (rfkill->ops->poll)
922                 schedule_delayed_work(&rfkill->poll_work,
923                         round_jiffies_relative(POLL_INTERVAL));
924
925         if (!rfkill->persistent || rfkill_epo_lock_active) {
926                 schedule_work(&rfkill->sync_work);
927         } else {
928 #ifdef CONFIG_RFKILL_INPUT
929                 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
930
931                 if (!atomic_read(&rfkill_input_disabled))
932                         __rfkill_switch_all(rfkill->type, soft_blocked);
933 #endif
934         }
935
936         rfkill_send_events(rfkill, RFKILL_OP_ADD);
937
938         mutex_unlock(&rfkill_global_mutex);
939         return 0;
940
941  devdel:
942         device_del(&rfkill->dev);
943  remove:
944         list_del_init(&rfkill->node);
945  unlock:
946         mutex_unlock(&rfkill_global_mutex);
947         return error;
948 }
949 EXPORT_SYMBOL(rfkill_register);
950
951 void rfkill_unregister(struct rfkill *rfkill)
952 {
953         BUG_ON(!rfkill);
954
955         if (rfkill->ops->poll)
956                 cancel_delayed_work_sync(&rfkill->poll_work);
957
958         cancel_work_sync(&rfkill->uevent_work);
959         cancel_work_sync(&rfkill->sync_work);
960
961         rfkill->registered = false;
962
963         device_del(&rfkill->dev);
964
965         mutex_lock(&rfkill_global_mutex);
966         rfkill_send_events(rfkill, RFKILL_OP_DEL);
967         list_del_init(&rfkill->node);
968         mutex_unlock(&rfkill_global_mutex);
969
970         rfkill_led_trigger_unregister(rfkill);
971 }
972 EXPORT_SYMBOL(rfkill_unregister);
973
974 void rfkill_destroy(struct rfkill *rfkill)
975 {
976         if (rfkill)
977                 put_device(&rfkill->dev);
978 }
979 EXPORT_SYMBOL(rfkill_destroy);
980
981 static int rfkill_fop_open(struct inode *inode, struct file *file)
982 {
983         struct rfkill_data *data;
984         struct rfkill *rfkill;
985         struct rfkill_int_event *ev, *tmp;
986
987         data = kzalloc(sizeof(*data), GFP_KERNEL);
988         if (!data)
989                 return -ENOMEM;
990
991         INIT_LIST_HEAD(&data->events);
992         mutex_init(&data->mtx);
993         init_waitqueue_head(&data->read_wait);
994
995         mutex_lock(&rfkill_global_mutex);
996         mutex_lock(&data->mtx);
997         /*
998          * start getting events from elsewhere but hold mtx to get
999          * startup events added first
1000          */
1001         list_add(&data->list, &rfkill_fds);
1002
1003         list_for_each_entry(rfkill, &rfkill_list, node) {
1004                 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1005                 if (!ev)
1006                         goto free;
1007                 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD);
1008                 list_add_tail(&ev->list, &data->events);
1009         }
1010         mutex_unlock(&data->mtx);
1011         mutex_unlock(&rfkill_global_mutex);
1012
1013         file->private_data = data;
1014
1015         return nonseekable_open(inode, file);
1016
1017  free:
1018         mutex_unlock(&data->mtx);
1019         mutex_unlock(&rfkill_global_mutex);
1020         mutex_destroy(&data->mtx);
1021         list_for_each_entry_safe(ev, tmp, &data->events, list)
1022                 kfree(ev);
1023         kfree(data);
1024         return -ENOMEM;
1025 }
1026
1027 static unsigned int rfkill_fop_poll(struct file *file, poll_table *wait)
1028 {
1029         struct rfkill_data *data = file->private_data;
1030         unsigned int res = POLLOUT | POLLWRNORM;
1031
1032         poll_wait(file, &data->read_wait, wait);
1033
1034         mutex_lock(&data->mtx);
1035         if (!list_empty(&data->events))
1036                 res = POLLIN | POLLRDNORM;
1037         mutex_unlock(&data->mtx);
1038
1039         return res;
1040 }
1041
1042 static bool rfkill_readable(struct rfkill_data *data)
1043 {
1044         bool r;
1045
1046         mutex_lock(&data->mtx);
1047         r = !list_empty(&data->events);
1048         mutex_unlock(&data->mtx);
1049
1050         return r;
1051 }
1052
1053 static ssize_t rfkill_fop_read(struct file *file, char __user *buf,
1054                                size_t count, loff_t *pos)
1055 {
1056         struct rfkill_data *data = file->private_data;
1057         struct rfkill_int_event *ev;
1058         unsigned long sz;
1059         int ret;
1060
1061         mutex_lock(&data->mtx);
1062
1063         while (list_empty(&data->events)) {
1064                 if (file->f_flags & O_NONBLOCK) {
1065                         ret = -EAGAIN;
1066                         goto out;
1067                 }
1068                 mutex_unlock(&data->mtx);
1069                 ret = wait_event_interruptible(data->read_wait,
1070                                                rfkill_readable(data));
1071                 mutex_lock(&data->mtx);
1072
1073                 if (ret)
1074                         goto out;
1075         }
1076
1077         ev = list_first_entry(&data->events, struct rfkill_int_event,
1078                                 list);
1079
1080         sz = min_t(unsigned long, sizeof(ev->ev), count);
1081         ret = sz;
1082         if (copy_to_user(buf, &ev->ev, sz))
1083                 ret = -EFAULT;
1084
1085         list_del(&ev->list);
1086         kfree(ev);
1087  out:
1088         mutex_unlock(&data->mtx);
1089         return ret;
1090 }
1091
1092 static ssize_t rfkill_fop_write(struct file *file, const char __user *buf,
1093                                 size_t count, loff_t *pos)
1094 {
1095         struct rfkill *rfkill;
1096         struct rfkill_event ev;
1097
1098         /* we don't need the 'hard' variable but accept it */
1099         if (count < RFKILL_EVENT_SIZE_V1 - 1)
1100                 return -EINVAL;
1101
1102         /*
1103          * Copy as much data as we can accept into our 'ev' buffer,
1104          * but tell userspace how much we've copied so it can determine
1105          * our API version even in a write() call, if it cares.
1106          */
1107         count = min(count, sizeof(ev));
1108         if (copy_from_user(&ev, buf, count))
1109                 return -EFAULT;
1110
1111         if (ev.op != RFKILL_OP_CHANGE && ev.op != RFKILL_OP_CHANGE_ALL)
1112                 return -EINVAL;
1113
1114         if (ev.type >= NUM_RFKILL_TYPES)
1115                 return -EINVAL;
1116
1117         mutex_lock(&rfkill_global_mutex);
1118
1119         if (ev.op == RFKILL_OP_CHANGE_ALL) {
1120                 if (ev.type == RFKILL_TYPE_ALL) {
1121                         enum rfkill_type i;
1122                         for (i = 0; i < NUM_RFKILL_TYPES; i++)
1123                                 rfkill_global_states[i].cur = ev.soft;
1124                 } else {
1125                         rfkill_global_states[ev.type].cur = ev.soft;
1126                 }
1127         }
1128
1129         list_for_each_entry(rfkill, &rfkill_list, node) {
1130                 if (rfkill->idx != ev.idx && ev.op != RFKILL_OP_CHANGE_ALL)
1131                         continue;
1132
1133                 if (rfkill->type != ev.type && ev.type != RFKILL_TYPE_ALL)
1134                         continue;
1135
1136                 rfkill_set_block(rfkill, ev.soft);
1137         }
1138         mutex_unlock(&rfkill_global_mutex);
1139
1140         return count;
1141 }
1142
1143 static int rfkill_fop_release(struct inode *inode, struct file *file)
1144 {
1145         struct rfkill_data *data = file->private_data;
1146         struct rfkill_int_event *ev, *tmp;
1147
1148         mutex_lock(&rfkill_global_mutex);
1149         list_del(&data->list);
1150         mutex_unlock(&rfkill_global_mutex);
1151
1152         mutex_destroy(&data->mtx);
1153         list_for_each_entry_safe(ev, tmp, &data->events, list)
1154                 kfree(ev);
1155
1156 #ifdef CONFIG_RFKILL_INPUT
1157         if (data->input_handler)
1158                 if (atomic_dec_return(&rfkill_input_disabled) == 0)
1159                         printk(KERN_DEBUG "rfkill: input handler enabled\n");
1160 #endif
1161
1162         kfree(data);
1163
1164         return 0;
1165 }
1166
1167 #ifdef CONFIG_RFKILL_INPUT
1168 static long rfkill_fop_ioctl(struct file *file, unsigned int cmd,
1169                              unsigned long arg)
1170 {
1171         struct rfkill_data *data = file->private_data;
1172
1173         if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC)
1174                 return -ENOSYS;
1175
1176         if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT)
1177                 return -ENOSYS;
1178
1179         mutex_lock(&data->mtx);
1180
1181         if (!data->input_handler) {
1182                 if (atomic_inc_return(&rfkill_input_disabled) == 1)
1183                         printk(KERN_DEBUG "rfkill: input handler disabled\n");
1184                 data->input_handler = true;
1185         }
1186
1187         mutex_unlock(&data->mtx);
1188
1189         return 0;
1190 }
1191 #endif
1192
1193 static const struct file_operations rfkill_fops = {
1194         .owner          = THIS_MODULE,
1195         .open           = rfkill_fop_open,
1196         .read           = rfkill_fop_read,
1197         .write          = rfkill_fop_write,
1198         .poll           = rfkill_fop_poll,
1199         .release        = rfkill_fop_release,
1200 #ifdef CONFIG_RFKILL_INPUT
1201         .unlocked_ioctl = rfkill_fop_ioctl,
1202         .compat_ioctl   = rfkill_fop_ioctl,
1203 #endif
1204 };
1205
1206 static struct miscdevice rfkill_miscdev = {
1207         .name   = "rfkill",
1208         .fops   = &rfkill_fops,
1209         .minor  = MISC_DYNAMIC_MINOR,
1210 };
1211
1212 static int __init rfkill_init(void)
1213 {
1214         int error;
1215         int i;
1216
1217         for (i = 0; i < NUM_RFKILL_TYPES; i++)
1218                 rfkill_global_states[i].cur = !rfkill_default_state;
1219
1220         error = class_register(&rfkill_class);
1221         if (error)
1222                 goto out;
1223
1224         error = misc_register(&rfkill_miscdev);
1225         if (error) {
1226                 class_unregister(&rfkill_class);
1227                 goto out;
1228         }
1229
1230 #ifdef CONFIG_RFKILL_INPUT
1231         error = rfkill_handler_init();
1232         if (error) {
1233                 misc_deregister(&rfkill_miscdev);
1234                 class_unregister(&rfkill_class);
1235                 goto out;
1236         }
1237 #endif
1238
1239  out:
1240         return error;
1241 }
1242 subsys_initcall(rfkill_init);
1243
1244 static void __exit rfkill_exit(void)
1245 {
1246 #ifdef CONFIG_RFKILL_INPUT
1247         rfkill_handler_exit();
1248 #endif
1249         misc_deregister(&rfkill_miscdev);
1250         class_unregister(&rfkill_class);
1251 }
1252 module_exit(rfkill_exit);