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