blob: 1bacc10799421790e62e9af7a99040cbd2e4afd0 [file] [log] [blame]
Johannes Berg19d337d2009-06-02 13:01:37 +02001/*
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>
Alexey Dobriyana99bbaf2009-10-04 16:11:37 +040030#include <linux/sched.h>
Johannes Berg19d337d2009-06-02 13:01:37 +020031#include <linux/spinlock.h>
Paul Gortmaker51990e82012-01-22 11:23:42 -050032#include <linux/device.h>
Johannes Bergc64fb012009-06-02 13:01:38 +020033#include <linux/miscdevice.h>
34#include <linux/wait.h>
35#include <linux/poll.h>
36#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
Johannes Berg19d337d2009-06-02 13:01:37 +020038
39#include "rfkill.h"
40
41#define POLL_INTERVAL (5 * HZ)
42
43#define RFKILL_BLOCK_HW BIT(0)
44#define RFKILL_BLOCK_SW BIT(1)
45#define RFKILL_BLOCK_SW_PREV BIT(2)
46#define RFKILL_BLOCK_ANY (RFKILL_BLOCK_HW |\
47 RFKILL_BLOCK_SW |\
48 RFKILL_BLOCK_SW_PREV)
49#define RFKILL_BLOCK_SW_SETCALL BIT(31)
50
51struct rfkill {
52 spinlock_t lock;
53
54 const char *name;
55 enum rfkill_type type;
56
57 unsigned long state;
58
Johannes Bergc64fb012009-06-02 13:01:38 +020059 u32 idx;
60
Johannes Berg19d337d2009-06-02 13:01:37 +020061 bool registered;
Alan Jenkinsb3fa1322009-06-08 13:27:27 +010062 bool persistent;
Johannes Berg19d337d2009-06-02 13:01:37 +020063
64 const struct rfkill_ops *ops;
65 void *data;
66
67#ifdef CONFIG_RFKILL_LEDS
68 struct led_trigger led_trigger;
69 const char *ledtrigname;
70#endif
71
72 struct device dev;
73 struct list_head node;
74
75 struct delayed_work poll_work;
76 struct work_struct uevent_work;
77 struct work_struct sync_work;
78};
79#define to_rfkill(d) container_of(d, struct rfkill, dev)
80
Johannes Bergc64fb012009-06-02 13:01:38 +020081struct rfkill_int_event {
82 struct list_head list;
83 struct rfkill_event ev;
84};
85
86struct rfkill_data {
87 struct list_head list;
88 struct list_head events;
89 struct mutex mtx;
90 wait_queue_head_t read_wait;
91 bool input_handler;
92};
Johannes Berg19d337d2009-06-02 13:01:37 +020093
94
95MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
96MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
97MODULE_DESCRIPTION("RF switch support");
98MODULE_LICENSE("GPL");
99
100
101/*
102 * The locking here should be made much smarter, we currently have
103 * a bit of a stupid situation because drivers might want to register
104 * the rfkill struct under their own lock, and take this lock during
105 * rfkill method calls -- which will cause an AB-BA deadlock situation.
106 *
107 * To fix that, we need to rework this code here to be mostly lock-free
108 * and only use the mutex for list manipulations, not to protect the
109 * various other global variables. Then we can avoid holding the mutex
110 * around driver operations, and all is happy.
111 */
112static LIST_HEAD(rfkill_list); /* list of registered rf switches */
113static DEFINE_MUTEX(rfkill_global_mutex);
Johannes Bergc64fb012009-06-02 13:01:38 +0200114static LIST_HEAD(rfkill_fds); /* list of open fds of /dev/rfkill */
Johannes Berg19d337d2009-06-02 13:01:37 +0200115
116static unsigned int rfkill_default_state = 1;
117module_param_named(default_state, rfkill_default_state, uint, 0444);
118MODULE_PARM_DESC(default_state,
119 "Default initial state for all radio types, 0 = radio off");
120
121static struct {
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100122 bool cur, sav;
Johannes Berg19d337d2009-06-02 13:01:37 +0200123} rfkill_global_states[NUM_RFKILL_TYPES];
124
Johannes Berg19d337d2009-06-02 13:01:37 +0200125static bool rfkill_epo_lock_active;
126
127
128#ifdef CONFIG_RFKILL_LEDS
129static void rfkill_led_trigger_event(struct rfkill *rfkill)
130{
131 struct led_trigger *trigger;
132
133 if (!rfkill->registered)
134 return;
135
136 trigger = &rfkill->led_trigger;
137
138 if (rfkill->state & RFKILL_BLOCK_ANY)
139 led_trigger_event(trigger, LED_OFF);
140 else
141 led_trigger_event(trigger, LED_FULL);
142}
143
144static void rfkill_led_trigger_activate(struct led_classdev *led)
145{
146 struct rfkill *rfkill;
147
148 rfkill = container_of(led->trigger, struct rfkill, led_trigger);
149
150 rfkill_led_trigger_event(rfkill);
151}
152
AceLan Kao06d7de82012-07-26 09:51:08 +0800153const char *rfkill_get_led_trigger_name(struct rfkill *rfkill)
154{
155 return rfkill->led_trigger.name;
156}
157EXPORT_SYMBOL(rfkill_get_led_trigger_name);
158
159void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name)
160{
161 BUG_ON(!rfkill);
162
163 rfkill->ledtrigname = name;
164}
165EXPORT_SYMBOL(rfkill_set_led_trigger_name);
166
Johannes Berg19d337d2009-06-02 13:01:37 +0200167static int rfkill_led_trigger_register(struct rfkill *rfkill)
168{
169 rfkill->led_trigger.name = rfkill->ledtrigname
170 ? : dev_name(&rfkill->dev);
171 rfkill->led_trigger.activate = rfkill_led_trigger_activate;
172 return led_trigger_register(&rfkill->led_trigger);
173}
174
175static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
176{
177 led_trigger_unregister(&rfkill->led_trigger);
178}
179#else
180static void rfkill_led_trigger_event(struct rfkill *rfkill)
181{
182}
183
184static inline int rfkill_led_trigger_register(struct rfkill *rfkill)
185{
186 return 0;
187}
188
189static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill)
190{
191}
192#endif /* CONFIG_RFKILL_LEDS */
193
Johannes Bergc64fb012009-06-02 13:01:38 +0200194static void rfkill_fill_event(struct rfkill_event *ev, struct rfkill *rfkill,
195 enum rfkill_operation op)
196{
197 unsigned long flags;
198
199 ev->idx = rfkill->idx;
200 ev->type = rfkill->type;
201 ev->op = op;
202
203 spin_lock_irqsave(&rfkill->lock, flags);
204 ev->hard = !!(rfkill->state & RFKILL_BLOCK_HW);
205 ev->soft = !!(rfkill->state & (RFKILL_BLOCK_SW |
206 RFKILL_BLOCK_SW_PREV));
207 spin_unlock_irqrestore(&rfkill->lock, flags);
208}
209
210static void rfkill_send_events(struct rfkill *rfkill, enum rfkill_operation op)
211{
212 struct rfkill_data *data;
213 struct rfkill_int_event *ev;
214
215 list_for_each_entry(data, &rfkill_fds, list) {
216 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
217 if (!ev)
218 continue;
219 rfkill_fill_event(&ev->ev, rfkill, op);
220 mutex_lock(&data->mtx);
221 list_add_tail(&ev->list, &data->events);
222 mutex_unlock(&data->mtx);
223 wake_up_interruptible(&data->read_wait);
224 }
225}
226
227static void rfkill_event(struct rfkill *rfkill)
Johannes Berg19d337d2009-06-02 13:01:37 +0200228{
Alan Jenkins06d5caf2009-06-16 15:39:51 +0100229 if (!rfkill->registered)
Johannes Berg19d337d2009-06-02 13:01:37 +0200230 return;
231
232 kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
Johannes Bergc64fb012009-06-02 13:01:38 +0200233
234 /* also send event to /dev/rfkill */
235 rfkill_send_events(rfkill, RFKILL_OP_CHANGE);
Johannes Berg19d337d2009-06-02 13:01:37 +0200236}
237
238static bool __rfkill_set_hw_state(struct rfkill *rfkill,
239 bool blocked, bool *change)
240{
241 unsigned long flags;
242 bool prev, any;
243
244 BUG_ON(!rfkill);
245
246 spin_lock_irqsave(&rfkill->lock, flags);
247 prev = !!(rfkill->state & RFKILL_BLOCK_HW);
248 if (blocked)
249 rfkill->state |= RFKILL_BLOCK_HW;
250 else
251 rfkill->state &= ~RFKILL_BLOCK_HW;
252 *change = prev != blocked;
Mohammed Shafi Shajakhan6be19cc2011-09-16 19:03:40 +0530253 any = !!(rfkill->state & RFKILL_BLOCK_ANY);
Johannes Berg19d337d2009-06-02 13:01:37 +0200254 spin_unlock_irqrestore(&rfkill->lock, flags);
255
256 rfkill_led_trigger_event(rfkill);
257
258 return any;
259}
260
261/**
262 * rfkill_set_block - wrapper for set_block method
263 *
264 * @rfkill: the rfkill struct to use
265 * @blocked: the new software state
266 *
267 * Calls the set_block method (when applicable) and handles notifications
268 * etc. as well.
269 */
270static void rfkill_set_block(struct rfkill *rfkill, bool blocked)
271{
272 unsigned long flags;
Vitaly Wooleab48342012-09-06 16:06:52 +0200273 bool prev, curr;
Johannes Berg19d337d2009-06-02 13:01:37 +0200274 int err;
275
Alan Jenkins7fa20a72009-06-16 14:53:24 +0100276 if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
277 return;
278
Johannes Berg19d337d2009-06-02 13:01:37 +0200279 /*
280 * Some platforms (...!) generate input events which affect the
281 * _hard_ kill state -- whenever something tries to change the
282 * current software state query the hardware state too.
283 */
284 if (rfkill->ops->query)
285 rfkill->ops->query(rfkill, rfkill->data);
286
287 spin_lock_irqsave(&rfkill->lock, flags);
Vitaly Wooleab48342012-09-06 16:06:52 +0200288 prev = rfkill->state & RFKILL_BLOCK_SW;
289
Johannes Berg19d337d2009-06-02 13:01:37 +0200290 if (rfkill->state & RFKILL_BLOCK_SW)
291 rfkill->state |= RFKILL_BLOCK_SW_PREV;
292 else
293 rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
294
295 if (blocked)
296 rfkill->state |= RFKILL_BLOCK_SW;
297 else
298 rfkill->state &= ~RFKILL_BLOCK_SW;
299
300 rfkill->state |= RFKILL_BLOCK_SW_SETCALL;
301 spin_unlock_irqrestore(&rfkill->lock, flags);
302
Johannes Berg19d337d2009-06-02 13:01:37 +0200303 err = rfkill->ops->set_block(rfkill->data, blocked);
304
305 spin_lock_irqsave(&rfkill->lock, flags);
306 if (err) {
307 /*
308 * Failed -- reset status to _prev, this may be different
309 * from what set set _PREV to earlier in this function
310 * if rfkill_set_sw_state was invoked.
311 */
312 if (rfkill->state & RFKILL_BLOCK_SW_PREV)
313 rfkill->state |= RFKILL_BLOCK_SW;
314 else
315 rfkill->state &= ~RFKILL_BLOCK_SW;
316 }
317 rfkill->state &= ~RFKILL_BLOCK_SW_SETCALL;
318 rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
Vitaly Wooleab48342012-09-06 16:06:52 +0200319 curr = rfkill->state & RFKILL_BLOCK_SW;
Johannes Berg19d337d2009-06-02 13:01:37 +0200320 spin_unlock_irqrestore(&rfkill->lock, flags);
321
322 rfkill_led_trigger_event(rfkill);
Vitaly Wooleab48342012-09-06 16:06:52 +0200323
324 if (prev != curr)
325 rfkill_event(rfkill);
Johannes Berg19d337d2009-06-02 13:01:37 +0200326}
327
Johannes Bergc64fb012009-06-02 13:01:38 +0200328#ifdef CONFIG_RFKILL_INPUT
329static atomic_t rfkill_input_disabled = ATOMIC_INIT(0);
330
Johannes Berg19d337d2009-06-02 13:01:37 +0200331/**
332 * __rfkill_switch_all - Toggle state of all switches of given type
333 * @type: type of interfaces to be affected
334 * @state: the new state
335 *
336 * This function sets the state of all switches of given type,
337 * unless a specific switch is claimed by userspace (in which case,
338 * that switch is left alone) or suspended.
339 *
340 * Caller must have acquired rfkill_global_mutex.
341 */
342static void __rfkill_switch_all(const enum rfkill_type type, bool blocked)
343{
344 struct rfkill *rfkill;
345
346 rfkill_global_states[type].cur = blocked;
347 list_for_each_entry(rfkill, &rfkill_list, node) {
Alex Hung27e49ca2012-05-23 14:11:52 +0800348 if (rfkill->type != type && type != RFKILL_TYPE_ALL)
Johannes Berg19d337d2009-06-02 13:01:37 +0200349 continue;
350
351 rfkill_set_block(rfkill, blocked);
352 }
353}
354
355/**
356 * rfkill_switch_all - Toggle state of all switches of given type
357 * @type: type of interfaces to be affected
358 * @state: the new state
359 *
360 * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
361 * Please refer to __rfkill_switch_all() for details.
362 *
363 * Does nothing if the EPO lock is active.
364 */
365void rfkill_switch_all(enum rfkill_type type, bool blocked)
366{
Johannes Bergc64fb012009-06-02 13:01:38 +0200367 if (atomic_read(&rfkill_input_disabled))
368 return;
369
Johannes Berg19d337d2009-06-02 13:01:37 +0200370 mutex_lock(&rfkill_global_mutex);
371
372 if (!rfkill_epo_lock_active)
373 __rfkill_switch_all(type, blocked);
374
375 mutex_unlock(&rfkill_global_mutex);
376}
377
378/**
379 * rfkill_epo - emergency power off all transmitters
380 *
381 * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
382 * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
383 *
384 * The global state before the EPO is saved and can be restored later
385 * using rfkill_restore_states().
386 */
387void rfkill_epo(void)
388{
389 struct rfkill *rfkill;
390 int i;
391
Johannes Bergc64fb012009-06-02 13:01:38 +0200392 if (atomic_read(&rfkill_input_disabled))
393 return;
394
Johannes Berg19d337d2009-06-02 13:01:37 +0200395 mutex_lock(&rfkill_global_mutex);
396
397 rfkill_epo_lock_active = true;
398 list_for_each_entry(rfkill, &rfkill_list, node)
399 rfkill_set_block(rfkill, true);
400
401 for (i = 0; i < NUM_RFKILL_TYPES; i++) {
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100402 rfkill_global_states[i].sav = rfkill_global_states[i].cur;
Johannes Berg19d337d2009-06-02 13:01:37 +0200403 rfkill_global_states[i].cur = true;
404 }
Johannes Bergc64fb012009-06-02 13:01:38 +0200405
Johannes Berg19d337d2009-06-02 13:01:37 +0200406 mutex_unlock(&rfkill_global_mutex);
407}
408
409/**
410 * rfkill_restore_states - restore global states
411 *
412 * Restore (and sync switches to) the global state from the
413 * states in rfkill_default_states. This can undo the effects of
414 * a call to rfkill_epo().
415 */
416void rfkill_restore_states(void)
417{
418 int i;
419
Johannes Bergc64fb012009-06-02 13:01:38 +0200420 if (atomic_read(&rfkill_input_disabled))
421 return;
422
Johannes Berg19d337d2009-06-02 13:01:37 +0200423 mutex_lock(&rfkill_global_mutex);
424
425 rfkill_epo_lock_active = false;
426 for (i = 0; i < NUM_RFKILL_TYPES; i++)
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100427 __rfkill_switch_all(i, rfkill_global_states[i].sav);
Johannes Berg19d337d2009-06-02 13:01:37 +0200428 mutex_unlock(&rfkill_global_mutex);
429}
430
431/**
432 * rfkill_remove_epo_lock - unlock state changes
433 *
434 * Used by rfkill-input manually unlock state changes, when
435 * the EPO switch is deactivated.
436 */
437void rfkill_remove_epo_lock(void)
438{
Johannes Bergc64fb012009-06-02 13:01:38 +0200439 if (atomic_read(&rfkill_input_disabled))
440 return;
441
Johannes Berg19d337d2009-06-02 13:01:37 +0200442 mutex_lock(&rfkill_global_mutex);
443 rfkill_epo_lock_active = false;
444 mutex_unlock(&rfkill_global_mutex);
445}
446
447/**
448 * rfkill_is_epo_lock_active - returns true EPO is active
449 *
450 * Returns 0 (false) if there is NOT an active EPO contidion,
451 * and 1 (true) if there is an active EPO contition, which
452 * locks all radios in one of the BLOCKED states.
453 *
454 * Can be called in atomic context.
455 */
456bool rfkill_is_epo_lock_active(void)
457{
458 return rfkill_epo_lock_active;
459}
460
461/**
462 * rfkill_get_global_sw_state - returns global state for a type
463 * @type: the type to get the global state of
464 *
465 * Returns the current global state for a given wireless
466 * device type.
467 */
468bool rfkill_get_global_sw_state(const enum rfkill_type type)
469{
470 return rfkill_global_states[type].cur;
471}
Johannes Bergc64fb012009-06-02 13:01:38 +0200472#endif
Johannes Berg19d337d2009-06-02 13:01:37 +0200473
Johannes Berg19d337d2009-06-02 13:01:37 +0200474
475bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
476{
477 bool ret, change;
478
479 ret = __rfkill_set_hw_state(rfkill, blocked, &change);
480
481 if (!rfkill->registered)
482 return ret;
483
484 if (change)
485 schedule_work(&rfkill->uevent_work);
486
487 return ret;
488}
489EXPORT_SYMBOL(rfkill_set_hw_state);
490
491static void __rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
492{
493 u32 bit = RFKILL_BLOCK_SW;
494
495 /* if in a ops->set_block right now, use other bit */
496 if (rfkill->state & RFKILL_BLOCK_SW_SETCALL)
497 bit = RFKILL_BLOCK_SW_PREV;
498
499 if (blocked)
500 rfkill->state |= bit;
501 else
502 rfkill->state &= ~bit;
503}
504
505bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
506{
507 unsigned long flags;
508 bool prev, hwblock;
509
510 BUG_ON(!rfkill);
511
512 spin_lock_irqsave(&rfkill->lock, flags);
513 prev = !!(rfkill->state & RFKILL_BLOCK_SW);
514 __rfkill_set_sw_state(rfkill, blocked);
515 hwblock = !!(rfkill->state & RFKILL_BLOCK_HW);
516 blocked = blocked || hwblock;
517 spin_unlock_irqrestore(&rfkill->lock, flags);
518
Alan Jenkins06d5caf2009-06-16 15:39:51 +0100519 if (!rfkill->registered)
520 return blocked;
Johannes Berg19d337d2009-06-02 13:01:37 +0200521
Alan Jenkins06d5caf2009-06-16 15:39:51 +0100522 if (prev != blocked && !hwblock)
523 schedule_work(&rfkill->uevent_work);
524
525 rfkill_led_trigger_event(rfkill);
Johannes Berg19d337d2009-06-02 13:01:37 +0200526
527 return blocked;
528}
529EXPORT_SYMBOL(rfkill_set_sw_state);
530
Alan Jenkins06d5caf2009-06-16 15:39:51 +0100531void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked)
532{
533 unsigned long flags;
534
535 BUG_ON(!rfkill);
536 BUG_ON(rfkill->registered);
537
538 spin_lock_irqsave(&rfkill->lock, flags);
539 __rfkill_set_sw_state(rfkill, blocked);
540 rfkill->persistent = true;
541 spin_unlock_irqrestore(&rfkill->lock, flags);
542}
543EXPORT_SYMBOL(rfkill_init_sw_state);
544
Johannes Berg19d337d2009-06-02 13:01:37 +0200545void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
546{
547 unsigned long flags;
548 bool swprev, hwprev;
549
550 BUG_ON(!rfkill);
551
552 spin_lock_irqsave(&rfkill->lock, flags);
553
554 /*
555 * No need to care about prev/setblock ... this is for uevent only
556 * and that will get triggered by rfkill_set_block anyway.
557 */
558 swprev = !!(rfkill->state & RFKILL_BLOCK_SW);
559 hwprev = !!(rfkill->state & RFKILL_BLOCK_HW);
560 __rfkill_set_sw_state(rfkill, sw);
Alan Jenkins48ab3572009-07-12 17:03:13 +0100561 if (hw)
562 rfkill->state |= RFKILL_BLOCK_HW;
563 else
564 rfkill->state &= ~RFKILL_BLOCK_HW;
Johannes Berg19d337d2009-06-02 13:01:37 +0200565
566 spin_unlock_irqrestore(&rfkill->lock, flags);
567
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100568 if (!rfkill->registered) {
569 rfkill->persistent = true;
570 } else {
571 if (swprev != sw || hwprev != hw)
572 schedule_work(&rfkill->uevent_work);
Johannes Berg19d337d2009-06-02 13:01:37 +0200573
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100574 rfkill_led_trigger_event(rfkill);
575 }
Johannes Berg19d337d2009-06-02 13:01:37 +0200576}
577EXPORT_SYMBOL(rfkill_set_states);
578
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700579static ssize_t name_show(struct device *dev, struct device_attribute *attr,
580 char *buf)
Johannes Berg19d337d2009-06-02 13:01:37 +0200581{
582 struct rfkill *rfkill = to_rfkill(dev);
583
584 return sprintf(buf, "%s\n", rfkill->name);
585}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700586static DEVICE_ATTR_RO(name);
Johannes Berg19d337d2009-06-02 13:01:37 +0200587
588static const char *rfkill_get_type_str(enum rfkill_type type)
589{
Samuel Ortiz44b3dec2013-04-11 11:51:36 +0200590 BUILD_BUG_ON(NUM_RFKILL_TYPES != RFKILL_TYPE_NFC + 1);
Andrew Morton02f7f172009-12-03 20:45:07 -0800591
Johannes Berg19d337d2009-06-02 13:01:37 +0200592 switch (type) {
593 case RFKILL_TYPE_WLAN:
594 return "wlan";
595 case RFKILL_TYPE_BLUETOOTH:
596 return "bluetooth";
597 case RFKILL_TYPE_UWB:
598 return "ultrawideband";
599 case RFKILL_TYPE_WIMAX:
600 return "wimax";
601 case RFKILL_TYPE_WWAN:
602 return "wwan";
Tomas Winkler3ad20142009-08-02 02:36:49 +0300603 case RFKILL_TYPE_GPS:
604 return "gps";
Marcel Holtmann875405a2009-11-18 16:48:01 +0100605 case RFKILL_TYPE_FM:
606 return "fm";
Samuel Ortiz44b3dec2013-04-11 11:51:36 +0200607 case RFKILL_TYPE_NFC:
608 return "nfc";
Johannes Berg19d337d2009-06-02 13:01:37 +0200609 default:
610 BUG();
611 }
Johannes Berg19d337d2009-06-02 13:01:37 +0200612}
613
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700614static ssize_t type_show(struct device *dev, struct device_attribute *attr,
615 char *buf)
Johannes Berg19d337d2009-06-02 13:01:37 +0200616{
617 struct rfkill *rfkill = to_rfkill(dev);
618
619 return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
620}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700621static DEVICE_ATTR_RO(type);
Johannes Berg19d337d2009-06-02 13:01:37 +0200622
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700623static ssize_t index_show(struct device *dev, struct device_attribute *attr,
624 char *buf)
Johannes Bergc64fb012009-06-02 13:01:38 +0200625{
626 struct rfkill *rfkill = to_rfkill(dev);
627
628 return sprintf(buf, "%d\n", rfkill->idx);
629}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700630static DEVICE_ATTR_RO(index);
Johannes Bergc64fb012009-06-02 13:01:38 +0200631
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700632static ssize_t persistent_show(struct device *dev,
633 struct device_attribute *attr, char *buf)
Alan Jenkins464902e2009-06-16 14:54:04 +0100634{
635 struct rfkill *rfkill = to_rfkill(dev);
636
637 return sprintf(buf, "%d\n", rfkill->persistent);
638}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700639static DEVICE_ATTR_RO(persistent);
Alan Jenkins464902e2009-06-16 14:54:04 +0100640
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700641static ssize_t hard_show(struct device *dev, struct device_attribute *attr,
642 char *buf)
florian@mickler.org6c263612010-02-26 12:01:34 +0100643{
644 struct rfkill *rfkill = to_rfkill(dev);
florian@mickler.org6c263612010-02-26 12:01:34 +0100645
florian@mickler.org819bfec2010-03-13 13:31:05 +0100646 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0 );
florian@mickler.org6c263612010-02-26 12:01:34 +0100647}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700648static DEVICE_ATTR_RO(hard);
florian@mickler.org6c263612010-02-26 12:01:34 +0100649
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700650static ssize_t soft_show(struct device *dev, struct device_attribute *attr,
651 char *buf)
florian@mickler.org6c263612010-02-26 12:01:34 +0100652{
653 struct rfkill *rfkill = to_rfkill(dev);
florian@mickler.org6c263612010-02-26 12:01:34 +0100654
florian@mickler.org819bfec2010-03-13 13:31:05 +0100655 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0 );
florian@mickler.org6c263612010-02-26 12:01:34 +0100656}
657
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700658static ssize_t soft_store(struct device *dev, struct device_attribute *attr,
659 const char *buf, size_t count)
florian@mickler.org6c263612010-02-26 12:01:34 +0100660{
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
Julia Lawall1bac92c2011-11-06 14:26:49 +0100668 err = kstrtoul(buf, 0, &state);
florian@mickler.org6c263612010-02-26 12:01:34 +0100669 if (err)
670 return err;
671
672 if (state > 1 )
673 return -EINVAL;
674
675 mutex_lock(&rfkill_global_mutex);
676 rfkill_set_block(rfkill, state);
677 mutex_unlock(&rfkill_global_mutex);
678
Alan Cox6f7c9622012-10-25 15:18:34 +0100679 return count;
florian@mickler.org6c263612010-02-26 12:01:34 +0100680}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700681static DEVICE_ATTR_RW(soft);
florian@mickler.org6c263612010-02-26 12:01:34 +0100682
Johannes Berg19d337d2009-06-02 13:01:37 +0200683static u8 user_state_from_blocked(unsigned long state)
684{
685 if (state & RFKILL_BLOCK_HW)
686 return RFKILL_USER_STATE_HARD_BLOCKED;
687 if (state & RFKILL_BLOCK_SW)
688 return RFKILL_USER_STATE_SOFT_BLOCKED;
689
690 return RFKILL_USER_STATE_UNBLOCKED;
691}
692
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700693static ssize_t state_show(struct device *dev, struct device_attribute *attr,
694 char *buf)
Johannes Berg19d337d2009-06-02 13:01:37 +0200695{
696 struct rfkill *rfkill = to_rfkill(dev);
Johannes Berg19d337d2009-06-02 13:01:37 +0200697
florian@mickler.org819bfec2010-03-13 13:31:05 +0100698 return sprintf(buf, "%d\n", user_state_from_blocked(rfkill->state));
Johannes Berg19d337d2009-06-02 13:01:37 +0200699}
700
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700701static ssize_t state_store(struct device *dev, struct device_attribute *attr,
702 const char *buf, size_t count)
Johannes Berg19d337d2009-06-02 13:01:37 +0200703{
Johannes Bergf54c1422009-07-10 21:41:39 +0200704 struct rfkill *rfkill = to_rfkill(dev);
705 unsigned long state;
706 int err;
Johannes Berg19d337d2009-06-02 13:01:37 +0200707
Johannes Bergf54c1422009-07-10 21:41:39 +0200708 if (!capable(CAP_NET_ADMIN))
709 return -EPERM;
710
Julia Lawall1bac92c2011-11-06 14:26:49 +0100711 err = kstrtoul(buf, 0, &state);
Johannes Bergf54c1422009-07-10 21:41:39 +0200712 if (err)
713 return err;
714
715 if (state != RFKILL_USER_STATE_SOFT_BLOCKED &&
716 state != RFKILL_USER_STATE_UNBLOCKED)
717 return -EINVAL;
718
719 mutex_lock(&rfkill_global_mutex);
720 rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED);
721 mutex_unlock(&rfkill_global_mutex);
722
Alan Cox6f7c9622012-10-25 15:18:34 +0100723 return count;
Johannes Berg19d337d2009-06-02 13:01:37 +0200724}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700725static DEVICE_ATTR_RW(state);
Johannes Berg19d337d2009-06-02 13:01:37 +0200726
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700727static ssize_t claim_show(struct device *dev, struct device_attribute *attr,
728 char *buf)
Johannes Berg19d337d2009-06-02 13:01:37 +0200729{
730 return sprintf(buf, "%d\n", 0);
731}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700732static DEVICE_ATTR_RO(claim);
Johannes Berg19d337d2009-06-02 13:01:37 +0200733
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700734static struct attribute *rfkill_dev_attrs[] = {
735 &dev_attr_name.attr,
736 &dev_attr_type.attr,
737 &dev_attr_index.attr,
738 &dev_attr_persistent.attr,
739 &dev_attr_state.attr,
740 &dev_attr_claim.attr,
741 &dev_attr_soft.attr,
742 &dev_attr_hard.attr,
743 NULL,
Johannes Berg19d337d2009-06-02 13:01:37 +0200744};
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700745ATTRIBUTE_GROUPS(rfkill_dev);
Johannes Berg19d337d2009-06-02 13:01:37 +0200746
747static void rfkill_release(struct device *dev)
748{
749 struct rfkill *rfkill = to_rfkill(dev);
750
751 kfree(rfkill);
752}
753
754static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
755{
756 struct rfkill *rfkill = to_rfkill(dev);
757 unsigned long flags;
758 u32 state;
759 int error;
760
761 error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
762 if (error)
763 return error;
764 error = add_uevent_var(env, "RFKILL_TYPE=%s",
765 rfkill_get_type_str(rfkill->type));
766 if (error)
767 return error;
768 spin_lock_irqsave(&rfkill->lock, flags);
769 state = rfkill->state;
770 spin_unlock_irqrestore(&rfkill->lock, flags);
771 error = add_uevent_var(env, "RFKILL_STATE=%d",
772 user_state_from_blocked(state));
773 return error;
774}
775
776void rfkill_pause_polling(struct rfkill *rfkill)
777{
778 BUG_ON(!rfkill);
779
780 if (!rfkill->ops->poll)
781 return;
782
783 cancel_delayed_work_sync(&rfkill->poll_work);
784}
785EXPORT_SYMBOL(rfkill_pause_polling);
786
787void rfkill_resume_polling(struct rfkill *rfkill)
788{
789 BUG_ON(!rfkill);
790
791 if (!rfkill->ops->poll)
792 return;
793
794 schedule_work(&rfkill->poll_work.work);
795}
796EXPORT_SYMBOL(rfkill_resume_polling);
797
798static int rfkill_suspend(struct device *dev, pm_message_t state)
799{
800 struct rfkill *rfkill = to_rfkill(dev);
801
802 rfkill_pause_polling(rfkill);
803
Johannes Berg19d337d2009-06-02 13:01:37 +0200804 return 0;
805}
806
807static int rfkill_resume(struct device *dev)
808{
809 struct rfkill *rfkill = to_rfkill(dev);
810 bool cur;
811
Alan Jenkins06d5caf2009-06-16 15:39:51 +0100812 if (!rfkill->persistent) {
813 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
814 rfkill_set_block(rfkill, cur);
815 }
Johannes Berg19d337d2009-06-02 13:01:37 +0200816
Johannes Berg19d337d2009-06-02 13:01:37 +0200817 rfkill_resume_polling(rfkill);
818
819 return 0;
820}
821
822static struct class rfkill_class = {
823 .name = "rfkill",
824 .dev_release = rfkill_release,
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700825 .dev_groups = rfkill_dev_groups,
Johannes Berg19d337d2009-06-02 13:01:37 +0200826 .dev_uevent = rfkill_dev_uevent,
827 .suspend = rfkill_suspend,
828 .resume = rfkill_resume,
829};
830
Johannes Berg60811622009-06-02 13:01:40 +0200831bool rfkill_blocked(struct rfkill *rfkill)
832{
833 unsigned long flags;
834 u32 state;
835
836 spin_lock_irqsave(&rfkill->lock, flags);
837 state = rfkill->state;
838 spin_unlock_irqrestore(&rfkill->lock, flags);
839
840 return !!(state & RFKILL_BLOCK_ANY);
841}
842EXPORT_SYMBOL(rfkill_blocked);
843
Johannes Berg19d337d2009-06-02 13:01:37 +0200844
845struct rfkill * __must_check rfkill_alloc(const char *name,
846 struct device *parent,
847 const enum rfkill_type type,
848 const struct rfkill_ops *ops,
849 void *ops_data)
850{
851 struct rfkill *rfkill;
852 struct device *dev;
853
854 if (WARN_ON(!ops))
855 return NULL;
856
857 if (WARN_ON(!ops->set_block))
858 return NULL;
859
860 if (WARN_ON(!name))
861 return NULL;
862
Johannes Bergc64fb012009-06-02 13:01:38 +0200863 if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES))
Johannes Berg19d337d2009-06-02 13:01:37 +0200864 return NULL;
865
866 rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
867 if (!rfkill)
868 return NULL;
869
870 spin_lock_init(&rfkill->lock);
871 INIT_LIST_HEAD(&rfkill->node);
872 rfkill->type = type;
873 rfkill->name = name;
874 rfkill->ops = ops;
875 rfkill->data = ops_data;
876
877 dev = &rfkill->dev;
878 dev->class = &rfkill_class;
879 dev->parent = parent;
880 device_initialize(dev);
881
882 return rfkill;
883}
884EXPORT_SYMBOL(rfkill_alloc);
885
886static void rfkill_poll(struct work_struct *work)
887{
888 struct rfkill *rfkill;
889
890 rfkill = container_of(work, struct rfkill, poll_work.work);
891
892 /*
893 * Poll hardware state -- driver will use one of the
894 * rfkill_set{,_hw,_sw}_state functions and use its
895 * return value to update the current status.
896 */
897 rfkill->ops->poll(rfkill, rfkill->data);
898
899 schedule_delayed_work(&rfkill->poll_work,
900 round_jiffies_relative(POLL_INTERVAL));
901}
902
903static void rfkill_uevent_work(struct work_struct *work)
904{
905 struct rfkill *rfkill;
906
907 rfkill = container_of(work, struct rfkill, uevent_work);
908
Johannes Bergc64fb012009-06-02 13:01:38 +0200909 mutex_lock(&rfkill_global_mutex);
910 rfkill_event(rfkill);
911 mutex_unlock(&rfkill_global_mutex);
Johannes Berg19d337d2009-06-02 13:01:37 +0200912}
913
914static void rfkill_sync_work(struct work_struct *work)
915{
916 struct rfkill *rfkill;
917 bool cur;
918
919 rfkill = container_of(work, struct rfkill, sync_work);
920
921 mutex_lock(&rfkill_global_mutex);
922 cur = rfkill_global_states[rfkill->type].cur;
923 rfkill_set_block(rfkill, cur);
924 mutex_unlock(&rfkill_global_mutex);
925}
926
927int __must_check rfkill_register(struct rfkill *rfkill)
928{
929 static unsigned long rfkill_no;
930 struct device *dev = &rfkill->dev;
931 int error;
932
933 BUG_ON(!rfkill);
934
935 mutex_lock(&rfkill_global_mutex);
936
937 if (rfkill->registered) {
938 error = -EALREADY;
939 goto unlock;
940 }
941
Johannes Bergc64fb012009-06-02 13:01:38 +0200942 rfkill->idx = rfkill_no;
Johannes Berg19d337d2009-06-02 13:01:37 +0200943 dev_set_name(dev, "rfkill%lu", rfkill_no);
944 rfkill_no++;
945
Johannes Berg19d337d2009-06-02 13:01:37 +0200946 list_add_tail(&rfkill->node, &rfkill_list);
947
948 error = device_add(dev);
949 if (error)
950 goto remove;
951
952 error = rfkill_led_trigger_register(rfkill);
953 if (error)
954 goto devdel;
955
956 rfkill->registered = true;
957
Johannes Berg2ec2c682009-06-03 09:55:29 +0200958 INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll);
959 INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work);
960 INIT_WORK(&rfkill->sync_work, rfkill_sync_work);
961
962 if (rfkill->ops->poll)
Johannes Berg19d337d2009-06-02 13:01:37 +0200963 schedule_delayed_work(&rfkill->poll_work,
964 round_jiffies_relative(POLL_INTERVAL));
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100965
966 if (!rfkill->persistent || rfkill_epo_lock_active) {
967 schedule_work(&rfkill->sync_work);
968 } else {
969#ifdef CONFIG_RFKILL_INPUT
970 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
971
972 if (!atomic_read(&rfkill_input_disabled))
973 __rfkill_switch_all(rfkill->type, soft_blocked);
974#endif
975 }
Johannes Berg2ec2c682009-06-03 09:55:29 +0200976
Johannes Bergc64fb012009-06-02 13:01:38 +0200977 rfkill_send_events(rfkill, RFKILL_OP_ADD);
Johannes Berg19d337d2009-06-02 13:01:37 +0200978
979 mutex_unlock(&rfkill_global_mutex);
980 return 0;
981
982 devdel:
983 device_del(&rfkill->dev);
984 remove:
985 list_del_init(&rfkill->node);
986 unlock:
987 mutex_unlock(&rfkill_global_mutex);
988 return error;
989}
990EXPORT_SYMBOL(rfkill_register);
991
992void rfkill_unregister(struct rfkill *rfkill)
993{
994 BUG_ON(!rfkill);
995
996 if (rfkill->ops->poll)
997 cancel_delayed_work_sync(&rfkill->poll_work);
998
999 cancel_work_sync(&rfkill->uevent_work);
1000 cancel_work_sync(&rfkill->sync_work);
1001
1002 rfkill->registered = false;
1003
1004 device_del(&rfkill->dev);
1005
1006 mutex_lock(&rfkill_global_mutex);
Johannes Bergc64fb012009-06-02 13:01:38 +02001007 rfkill_send_events(rfkill, RFKILL_OP_DEL);
Johannes Berg19d337d2009-06-02 13:01:37 +02001008 list_del_init(&rfkill->node);
1009 mutex_unlock(&rfkill_global_mutex);
1010
1011 rfkill_led_trigger_unregister(rfkill);
1012}
1013EXPORT_SYMBOL(rfkill_unregister);
1014
1015void rfkill_destroy(struct rfkill *rfkill)
1016{
1017 if (rfkill)
1018 put_device(&rfkill->dev);
1019}
1020EXPORT_SYMBOL(rfkill_destroy);
1021
Johannes Bergc64fb012009-06-02 13:01:38 +02001022static int rfkill_fop_open(struct inode *inode, struct file *file)
1023{
1024 struct rfkill_data *data;
1025 struct rfkill *rfkill;
1026 struct rfkill_int_event *ev, *tmp;
1027
1028 data = kzalloc(sizeof(*data), GFP_KERNEL);
1029 if (!data)
1030 return -ENOMEM;
1031
1032 INIT_LIST_HEAD(&data->events);
1033 mutex_init(&data->mtx);
1034 init_waitqueue_head(&data->read_wait);
1035
1036 mutex_lock(&rfkill_global_mutex);
1037 mutex_lock(&data->mtx);
1038 /*
1039 * start getting events from elsewhere but hold mtx to get
1040 * startup events added first
1041 */
Johannes Bergc64fb012009-06-02 13:01:38 +02001042
1043 list_for_each_entry(rfkill, &rfkill_list, node) {
1044 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1045 if (!ev)
1046 goto free;
1047 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD);
1048 list_add_tail(&ev->list, &data->events);
1049 }
Julia Lawallbd2281b2011-05-13 15:52:10 +02001050 list_add(&data->list, &rfkill_fds);
Johannes Bergc64fb012009-06-02 13:01:38 +02001051 mutex_unlock(&data->mtx);
1052 mutex_unlock(&rfkill_global_mutex);
1053
1054 file->private_data = data;
1055
1056 return nonseekable_open(inode, file);
1057
1058 free:
1059 mutex_unlock(&data->mtx);
1060 mutex_unlock(&rfkill_global_mutex);
1061 mutex_destroy(&data->mtx);
1062 list_for_each_entry_safe(ev, tmp, &data->events, list)
1063 kfree(ev);
1064 kfree(data);
1065 return -ENOMEM;
1066}
1067
1068static unsigned int rfkill_fop_poll(struct file *file, poll_table *wait)
1069{
1070 struct rfkill_data *data = file->private_data;
1071 unsigned int res = POLLOUT | POLLWRNORM;
1072
1073 poll_wait(file, &data->read_wait, wait);
1074
1075 mutex_lock(&data->mtx);
1076 if (!list_empty(&data->events))
1077 res = POLLIN | POLLRDNORM;
1078 mutex_unlock(&data->mtx);
1079
1080 return res;
1081}
1082
1083static bool rfkill_readable(struct rfkill_data *data)
1084{
1085 bool r;
1086
1087 mutex_lock(&data->mtx);
1088 r = !list_empty(&data->events);
1089 mutex_unlock(&data->mtx);
1090
1091 return r;
1092}
1093
1094static ssize_t rfkill_fop_read(struct file *file, char __user *buf,
1095 size_t count, loff_t *pos)
1096{
1097 struct rfkill_data *data = file->private_data;
1098 struct rfkill_int_event *ev;
1099 unsigned long sz;
1100 int ret;
1101
1102 mutex_lock(&data->mtx);
1103
1104 while (list_empty(&data->events)) {
1105 if (file->f_flags & O_NONBLOCK) {
1106 ret = -EAGAIN;
1107 goto out;
1108 }
1109 mutex_unlock(&data->mtx);
1110 ret = wait_event_interruptible(data->read_wait,
1111 rfkill_readable(data));
1112 mutex_lock(&data->mtx);
1113
1114 if (ret)
1115 goto out;
1116 }
1117
1118 ev = list_first_entry(&data->events, struct rfkill_int_event,
1119 list);
1120
1121 sz = min_t(unsigned long, sizeof(ev->ev), count);
1122 ret = sz;
1123 if (copy_to_user(buf, &ev->ev, sz))
1124 ret = -EFAULT;
1125
1126 list_del(&ev->list);
1127 kfree(ev);
1128 out:
1129 mutex_unlock(&data->mtx);
1130 return ret;
1131}
1132
1133static ssize_t rfkill_fop_write(struct file *file, const char __user *buf,
1134 size_t count, loff_t *pos)
1135{
1136 struct rfkill *rfkill;
1137 struct rfkill_event ev;
1138
1139 /* we don't need the 'hard' variable but accept it */
Johannes Berg1be491f2009-07-05 14:51:06 +02001140 if (count < RFKILL_EVENT_SIZE_V1 - 1)
Johannes Bergc64fb012009-06-02 13:01:38 +02001141 return -EINVAL;
1142
Johannes Berg1be491f2009-07-05 14:51:06 +02001143 /*
1144 * Copy as much data as we can accept into our 'ev' buffer,
1145 * but tell userspace how much we've copied so it can determine
1146 * our API version even in a write() call, if it cares.
1147 */
1148 count = min(count, sizeof(ev));
1149 if (copy_from_user(&ev, buf, count))
Johannes Bergc64fb012009-06-02 13:01:38 +02001150 return -EFAULT;
1151
1152 if (ev.op != RFKILL_OP_CHANGE && ev.op != RFKILL_OP_CHANGE_ALL)
1153 return -EINVAL;
1154
1155 if (ev.type >= NUM_RFKILL_TYPES)
1156 return -EINVAL;
1157
1158 mutex_lock(&rfkill_global_mutex);
1159
1160 if (ev.op == RFKILL_OP_CHANGE_ALL) {
1161 if (ev.type == RFKILL_TYPE_ALL) {
1162 enum rfkill_type i;
1163 for (i = 0; i < NUM_RFKILL_TYPES; i++)
1164 rfkill_global_states[i].cur = ev.soft;
1165 } else {
1166 rfkill_global_states[ev.type].cur = ev.soft;
1167 }
1168 }
1169
1170 list_for_each_entry(rfkill, &rfkill_list, node) {
1171 if (rfkill->idx != ev.idx && ev.op != RFKILL_OP_CHANGE_ALL)
1172 continue;
1173
1174 if (rfkill->type != ev.type && ev.type != RFKILL_TYPE_ALL)
1175 continue;
1176
1177 rfkill_set_block(rfkill, ev.soft);
1178 }
1179 mutex_unlock(&rfkill_global_mutex);
1180
1181 return count;
1182}
1183
1184static int rfkill_fop_release(struct inode *inode, struct file *file)
1185{
1186 struct rfkill_data *data = file->private_data;
1187 struct rfkill_int_event *ev, *tmp;
1188
1189 mutex_lock(&rfkill_global_mutex);
1190 list_del(&data->list);
1191 mutex_unlock(&rfkill_global_mutex);
1192
1193 mutex_destroy(&data->mtx);
1194 list_for_each_entry_safe(ev, tmp, &data->events, list)
1195 kfree(ev);
1196
1197#ifdef CONFIG_RFKILL_INPUT
1198 if (data->input_handler)
Johannes Berg207ee162009-06-07 12:26:52 +02001199 if (atomic_dec_return(&rfkill_input_disabled) == 0)
1200 printk(KERN_DEBUG "rfkill: input handler enabled\n");
Johannes Bergc64fb012009-06-02 13:01:38 +02001201#endif
1202
1203 kfree(data);
1204
1205 return 0;
1206}
1207
1208#ifdef CONFIG_RFKILL_INPUT
1209static long rfkill_fop_ioctl(struct file *file, unsigned int cmd,
1210 unsigned long arg)
1211{
1212 struct rfkill_data *data = file->private_data;
1213
1214 if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC)
1215 return -ENOSYS;
1216
1217 if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT)
1218 return -ENOSYS;
1219
1220 mutex_lock(&data->mtx);
1221
1222 if (!data->input_handler) {
Johannes Berg207ee162009-06-07 12:26:52 +02001223 if (atomic_inc_return(&rfkill_input_disabled) == 1)
1224 printk(KERN_DEBUG "rfkill: input handler disabled\n");
Johannes Bergc64fb012009-06-02 13:01:38 +02001225 data->input_handler = true;
1226 }
1227
1228 mutex_unlock(&data->mtx);
1229
1230 return 0;
1231}
1232#endif
1233
1234static const struct file_operations rfkill_fops = {
Johannes Berg45ba5642009-11-23 11:27:30 +01001235 .owner = THIS_MODULE,
Johannes Bergc64fb012009-06-02 13:01:38 +02001236 .open = rfkill_fop_open,
1237 .read = rfkill_fop_read,
1238 .write = rfkill_fop_write,
1239 .poll = rfkill_fop_poll,
1240 .release = rfkill_fop_release,
1241#ifdef CONFIG_RFKILL_INPUT
1242 .unlocked_ioctl = rfkill_fop_ioctl,
1243 .compat_ioctl = rfkill_fop_ioctl,
1244#endif
Arnd Bergmann6038f372010-08-15 18:52:59 +02001245 .llseek = no_llseek,
Johannes Bergc64fb012009-06-02 13:01:38 +02001246};
1247
1248static struct miscdevice rfkill_miscdev = {
1249 .name = "rfkill",
1250 .fops = &rfkill_fops,
1251 .minor = MISC_DYNAMIC_MINOR,
1252};
Johannes Berg19d337d2009-06-02 13:01:37 +02001253
1254static int __init rfkill_init(void)
1255{
1256 int error;
1257 int i;
1258
1259 for (i = 0; i < NUM_RFKILL_TYPES; i++)
Alan Jenkinsb3fa1322009-06-08 13:27:27 +01001260 rfkill_global_states[i].cur = !rfkill_default_state;
Johannes Berg19d337d2009-06-02 13:01:37 +02001261
1262 error = class_register(&rfkill_class);
1263 if (error)
1264 goto out;
1265
Johannes Bergc64fb012009-06-02 13:01:38 +02001266 error = misc_register(&rfkill_miscdev);
1267 if (error) {
1268 class_unregister(&rfkill_class);
1269 goto out;
1270 }
1271
Johannes Berg19d337d2009-06-02 13:01:37 +02001272#ifdef CONFIG_RFKILL_INPUT
1273 error = rfkill_handler_init();
Johannes Bergc64fb012009-06-02 13:01:38 +02001274 if (error) {
1275 misc_deregister(&rfkill_miscdev);
Johannes Berg19d337d2009-06-02 13:01:37 +02001276 class_unregister(&rfkill_class);
Johannes Bergc64fb012009-06-02 13:01:38 +02001277 goto out;
1278 }
Johannes Berg19d337d2009-06-02 13:01:37 +02001279#endif
1280
1281 out:
1282 return error;
1283}
1284subsys_initcall(rfkill_init);
1285
1286static void __exit rfkill_exit(void)
1287{
1288#ifdef CONFIG_RFKILL_INPUT
1289 rfkill_handler_exit();
1290#endif
Johannes Bergc64fb012009-06-02 13:01:38 +02001291 misc_deregister(&rfkill_miscdev);
Johannes Berg19d337d2009-06-02 13:01:37 +02001292 class_unregister(&rfkill_class);
1293}
1294module_exit(rfkill_exit);