blob: 9b9be5279f5dac83f53b1027f10144fe91d6bf98 [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
579static ssize_t rfkill_name_show(struct device *dev,
580 struct device_attribute *attr,
581 char *buf)
582{
583 struct rfkill *rfkill = to_rfkill(dev);
584
585 return sprintf(buf, "%s\n", rfkill->name);
586}
587
588static const char *rfkill_get_type_str(enum rfkill_type type)
589{
Andrew Morton02f7f172009-12-03 20:45:07 -0800590 BUILD_BUG_ON(NUM_RFKILL_TYPES != RFKILL_TYPE_FM + 1);
591
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";
Johannes Berg19d337d2009-06-02 13:01:37 +0200607 default:
608 BUG();
609 }
Johannes Berg19d337d2009-06-02 13:01:37 +0200610}
611
612static ssize_t rfkill_type_show(struct device *dev,
613 struct device_attribute *attr,
614 char *buf)
615{
616 struct rfkill *rfkill = to_rfkill(dev);
617
618 return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
619}
620
Johannes Bergc64fb012009-06-02 13:01:38 +0200621static ssize_t rfkill_idx_show(struct device *dev,
622 struct device_attribute *attr,
623 char *buf)
624{
625 struct rfkill *rfkill = to_rfkill(dev);
626
627 return sprintf(buf, "%d\n", rfkill->idx);
628}
629
Alan Jenkins464902e2009-06-16 14:54:04 +0100630static ssize_t rfkill_persistent_show(struct device *dev,
631 struct device_attribute *attr,
632 char *buf)
633{
634 struct rfkill *rfkill = to_rfkill(dev);
635
636 return sprintf(buf, "%d\n", rfkill->persistent);
637}
638
florian@mickler.org819bfec2010-03-13 13:31:05 +0100639static ssize_t rfkill_hard_show(struct device *dev,
florian@mickler.org6c263612010-02-26 12:01:34 +0100640 struct device_attribute *attr,
641 char *buf)
642{
643 struct rfkill *rfkill = to_rfkill(dev);
florian@mickler.org6c263612010-02-26 12:01:34 +0100644
florian@mickler.org819bfec2010-03-13 13:31:05 +0100645 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0 );
florian@mickler.org6c263612010-02-26 12:01:34 +0100646}
647
florian@mickler.org819bfec2010-03-13 13:31:05 +0100648static ssize_t rfkill_soft_show(struct device *dev,
florian@mickler.org6c263612010-02-26 12:01:34 +0100649 struct device_attribute *attr,
650 char *buf)
651{
652 struct rfkill *rfkill = to_rfkill(dev);
florian@mickler.org6c263612010-02-26 12:01:34 +0100653
florian@mickler.org819bfec2010-03-13 13:31:05 +0100654 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0 );
florian@mickler.org6c263612010-02-26 12:01:34 +0100655}
656
florian@mickler.org819bfec2010-03-13 13:31:05 +0100657static ssize_t rfkill_soft_store(struct device *dev,
florian@mickler.org6c263612010-02-26 12:01:34 +0100658 struct device_attribute *attr,
659 const char *buf, size_t count)
660{
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}
681
Johannes Berg19d337d2009-06-02 13:01:37 +0200682static u8 user_state_from_blocked(unsigned long state)
683{
684 if (state & RFKILL_BLOCK_HW)
685 return RFKILL_USER_STATE_HARD_BLOCKED;
686 if (state & RFKILL_BLOCK_SW)
687 return RFKILL_USER_STATE_SOFT_BLOCKED;
688
689 return RFKILL_USER_STATE_UNBLOCKED;
690}
691
692static ssize_t rfkill_state_show(struct device *dev,
693 struct device_attribute *attr,
694 char *buf)
695{
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
701static ssize_t rfkill_state_store(struct device *dev,
702 struct device_attribute *attr,
703 const char *buf, size_t count)
704{
Johannes Bergf54c1422009-07-10 21:41:39 +0200705 struct rfkill *rfkill = to_rfkill(dev);
706 unsigned long state;
707 int err;
Johannes Berg19d337d2009-06-02 13:01:37 +0200708
Johannes Bergf54c1422009-07-10 21:41:39 +0200709 if (!capable(CAP_NET_ADMIN))
710 return -EPERM;
711
Julia Lawall1bac92c2011-11-06 14:26:49 +0100712 err = kstrtoul(buf, 0, &state);
Johannes Bergf54c1422009-07-10 21:41:39 +0200713 if (err)
714 return err;
715
716 if (state != RFKILL_USER_STATE_SOFT_BLOCKED &&
717 state != RFKILL_USER_STATE_UNBLOCKED)
718 return -EINVAL;
719
720 mutex_lock(&rfkill_global_mutex);
721 rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED);
722 mutex_unlock(&rfkill_global_mutex);
723
Alan Cox6f7c9622012-10-25 15:18:34 +0100724 return count;
Johannes Berg19d337d2009-06-02 13:01:37 +0200725}
726
727static ssize_t rfkill_claim_show(struct device *dev,
728 struct device_attribute *attr,
729 char *buf)
730{
731 return sprintf(buf, "%d\n", 0);
732}
733
734static ssize_t rfkill_claim_store(struct device *dev,
735 struct device_attribute *attr,
736 const char *buf, size_t count)
737{
738 return -EOPNOTSUPP;
739}
740
741static struct device_attribute rfkill_dev_attrs[] = {
742 __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
743 __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
Johannes Bergc64fb012009-06-02 13:01:38 +0200744 __ATTR(index, S_IRUGO, rfkill_idx_show, NULL),
Alan Jenkins464902e2009-06-16 14:54:04 +0100745 __ATTR(persistent, S_IRUGO, rfkill_persistent_show, NULL),
Johannes Berg19d337d2009-06-02 13:01:37 +0200746 __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
747 __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
florian@mickler.org819bfec2010-03-13 13:31:05 +0100748 __ATTR(soft, S_IRUGO|S_IWUSR, rfkill_soft_show, rfkill_soft_store),
749 __ATTR(hard, S_IRUGO, rfkill_hard_show, NULL),
Johannes Berg19d337d2009-06-02 13:01:37 +0200750 __ATTR_NULL
751};
752
753static void rfkill_release(struct device *dev)
754{
755 struct rfkill *rfkill = to_rfkill(dev);
756
757 kfree(rfkill);
758}
759
760static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
761{
762 struct rfkill *rfkill = to_rfkill(dev);
763 unsigned long flags;
764 u32 state;
765 int error;
766
767 error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
768 if (error)
769 return error;
770 error = add_uevent_var(env, "RFKILL_TYPE=%s",
771 rfkill_get_type_str(rfkill->type));
772 if (error)
773 return error;
774 spin_lock_irqsave(&rfkill->lock, flags);
775 state = rfkill->state;
776 spin_unlock_irqrestore(&rfkill->lock, flags);
777 error = add_uevent_var(env, "RFKILL_STATE=%d",
778 user_state_from_blocked(state));
779 return error;
780}
781
782void rfkill_pause_polling(struct rfkill *rfkill)
783{
784 BUG_ON(!rfkill);
785
786 if (!rfkill->ops->poll)
787 return;
788
789 cancel_delayed_work_sync(&rfkill->poll_work);
790}
791EXPORT_SYMBOL(rfkill_pause_polling);
792
793void rfkill_resume_polling(struct rfkill *rfkill)
794{
795 BUG_ON(!rfkill);
796
797 if (!rfkill->ops->poll)
798 return;
799
800 schedule_work(&rfkill->poll_work.work);
801}
802EXPORT_SYMBOL(rfkill_resume_polling);
803
804static int rfkill_suspend(struct device *dev, pm_message_t state)
805{
806 struct rfkill *rfkill = to_rfkill(dev);
807
808 rfkill_pause_polling(rfkill);
809
Johannes Berg19d337d2009-06-02 13:01:37 +0200810 return 0;
811}
812
813static int rfkill_resume(struct device *dev)
814{
815 struct rfkill *rfkill = to_rfkill(dev);
816 bool cur;
817
Alan Jenkins06d5caf2009-06-16 15:39:51 +0100818 if (!rfkill->persistent) {
819 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
820 rfkill_set_block(rfkill, cur);
821 }
Johannes Berg19d337d2009-06-02 13:01:37 +0200822
Johannes Berg19d337d2009-06-02 13:01:37 +0200823 rfkill_resume_polling(rfkill);
824
825 return 0;
826}
827
828static struct class rfkill_class = {
829 .name = "rfkill",
830 .dev_release = rfkill_release,
831 .dev_attrs = rfkill_dev_attrs,
832 .dev_uevent = rfkill_dev_uevent,
833 .suspend = rfkill_suspend,
834 .resume = rfkill_resume,
835};
836
Johannes Berg60811622009-06-02 13:01:40 +0200837bool rfkill_blocked(struct rfkill *rfkill)
838{
839 unsigned long flags;
840 u32 state;
841
842 spin_lock_irqsave(&rfkill->lock, flags);
843 state = rfkill->state;
844 spin_unlock_irqrestore(&rfkill->lock, flags);
845
846 return !!(state & RFKILL_BLOCK_ANY);
847}
848EXPORT_SYMBOL(rfkill_blocked);
849
Johannes Berg19d337d2009-06-02 13:01:37 +0200850
851struct rfkill * __must_check rfkill_alloc(const char *name,
852 struct device *parent,
853 const enum rfkill_type type,
854 const struct rfkill_ops *ops,
855 void *ops_data)
856{
857 struct rfkill *rfkill;
858 struct device *dev;
859
860 if (WARN_ON(!ops))
861 return NULL;
862
863 if (WARN_ON(!ops->set_block))
864 return NULL;
865
866 if (WARN_ON(!name))
867 return NULL;
868
Johannes Bergc64fb012009-06-02 13:01:38 +0200869 if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES))
Johannes Berg19d337d2009-06-02 13:01:37 +0200870 return NULL;
871
872 rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
873 if (!rfkill)
874 return NULL;
875
876 spin_lock_init(&rfkill->lock);
877 INIT_LIST_HEAD(&rfkill->node);
878 rfkill->type = type;
879 rfkill->name = name;
880 rfkill->ops = ops;
881 rfkill->data = ops_data;
882
883 dev = &rfkill->dev;
884 dev->class = &rfkill_class;
885 dev->parent = parent;
886 device_initialize(dev);
887
888 return rfkill;
889}
890EXPORT_SYMBOL(rfkill_alloc);
891
892static void rfkill_poll(struct work_struct *work)
893{
894 struct rfkill *rfkill;
895
896 rfkill = container_of(work, struct rfkill, poll_work.work);
897
898 /*
899 * Poll hardware state -- driver will use one of the
900 * rfkill_set{,_hw,_sw}_state functions and use its
901 * return value to update the current status.
902 */
903 rfkill->ops->poll(rfkill, rfkill->data);
904
905 schedule_delayed_work(&rfkill->poll_work,
906 round_jiffies_relative(POLL_INTERVAL));
907}
908
909static void rfkill_uevent_work(struct work_struct *work)
910{
911 struct rfkill *rfkill;
912
913 rfkill = container_of(work, struct rfkill, uevent_work);
914
Johannes Bergc64fb012009-06-02 13:01:38 +0200915 mutex_lock(&rfkill_global_mutex);
916 rfkill_event(rfkill);
917 mutex_unlock(&rfkill_global_mutex);
Johannes Berg19d337d2009-06-02 13:01:37 +0200918}
919
920static void rfkill_sync_work(struct work_struct *work)
921{
922 struct rfkill *rfkill;
923 bool cur;
924
925 rfkill = container_of(work, struct rfkill, sync_work);
926
927 mutex_lock(&rfkill_global_mutex);
928 cur = rfkill_global_states[rfkill->type].cur;
929 rfkill_set_block(rfkill, cur);
930 mutex_unlock(&rfkill_global_mutex);
931}
932
933int __must_check rfkill_register(struct rfkill *rfkill)
934{
935 static unsigned long rfkill_no;
936 struct device *dev = &rfkill->dev;
937 int error;
938
939 BUG_ON(!rfkill);
940
941 mutex_lock(&rfkill_global_mutex);
942
943 if (rfkill->registered) {
944 error = -EALREADY;
945 goto unlock;
946 }
947
Johannes Bergc64fb012009-06-02 13:01:38 +0200948 rfkill->idx = rfkill_no;
Johannes Berg19d337d2009-06-02 13:01:37 +0200949 dev_set_name(dev, "rfkill%lu", rfkill_no);
950 rfkill_no++;
951
Johannes Berg19d337d2009-06-02 13:01:37 +0200952 list_add_tail(&rfkill->node, &rfkill_list);
953
954 error = device_add(dev);
955 if (error)
956 goto remove;
957
958 error = rfkill_led_trigger_register(rfkill);
959 if (error)
960 goto devdel;
961
962 rfkill->registered = true;
963
Johannes Berg2ec2c682009-06-03 09:55:29 +0200964 INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll);
965 INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work);
966 INIT_WORK(&rfkill->sync_work, rfkill_sync_work);
967
968 if (rfkill->ops->poll)
Johannes Berg19d337d2009-06-02 13:01:37 +0200969 schedule_delayed_work(&rfkill->poll_work,
970 round_jiffies_relative(POLL_INTERVAL));
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100971
972 if (!rfkill->persistent || rfkill_epo_lock_active) {
973 schedule_work(&rfkill->sync_work);
974 } else {
975#ifdef CONFIG_RFKILL_INPUT
976 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
977
978 if (!atomic_read(&rfkill_input_disabled))
979 __rfkill_switch_all(rfkill->type, soft_blocked);
980#endif
981 }
Johannes Berg2ec2c682009-06-03 09:55:29 +0200982
Johannes Bergc64fb012009-06-02 13:01:38 +0200983 rfkill_send_events(rfkill, RFKILL_OP_ADD);
Johannes Berg19d337d2009-06-02 13:01:37 +0200984
985 mutex_unlock(&rfkill_global_mutex);
986 return 0;
987
988 devdel:
989 device_del(&rfkill->dev);
990 remove:
991 list_del_init(&rfkill->node);
992 unlock:
993 mutex_unlock(&rfkill_global_mutex);
994 return error;
995}
996EXPORT_SYMBOL(rfkill_register);
997
998void rfkill_unregister(struct rfkill *rfkill)
999{
1000 BUG_ON(!rfkill);
1001
1002 if (rfkill->ops->poll)
1003 cancel_delayed_work_sync(&rfkill->poll_work);
1004
1005 cancel_work_sync(&rfkill->uevent_work);
1006 cancel_work_sync(&rfkill->sync_work);
1007
1008 rfkill->registered = false;
1009
1010 device_del(&rfkill->dev);
1011
1012 mutex_lock(&rfkill_global_mutex);
Johannes Bergc64fb012009-06-02 13:01:38 +02001013 rfkill_send_events(rfkill, RFKILL_OP_DEL);
Johannes Berg19d337d2009-06-02 13:01:37 +02001014 list_del_init(&rfkill->node);
1015 mutex_unlock(&rfkill_global_mutex);
1016
1017 rfkill_led_trigger_unregister(rfkill);
1018}
1019EXPORT_SYMBOL(rfkill_unregister);
1020
1021void rfkill_destroy(struct rfkill *rfkill)
1022{
1023 if (rfkill)
1024 put_device(&rfkill->dev);
1025}
1026EXPORT_SYMBOL(rfkill_destroy);
1027
Johannes Bergc64fb012009-06-02 13:01:38 +02001028static int rfkill_fop_open(struct inode *inode, struct file *file)
1029{
1030 struct rfkill_data *data;
1031 struct rfkill *rfkill;
1032 struct rfkill_int_event *ev, *tmp;
1033
1034 data = kzalloc(sizeof(*data), GFP_KERNEL);
1035 if (!data)
1036 return -ENOMEM;
1037
1038 INIT_LIST_HEAD(&data->events);
1039 mutex_init(&data->mtx);
1040 init_waitqueue_head(&data->read_wait);
1041
1042 mutex_lock(&rfkill_global_mutex);
1043 mutex_lock(&data->mtx);
1044 /*
1045 * start getting events from elsewhere but hold mtx to get
1046 * startup events added first
1047 */
Johannes Bergc64fb012009-06-02 13:01:38 +02001048
1049 list_for_each_entry(rfkill, &rfkill_list, node) {
1050 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1051 if (!ev)
1052 goto free;
1053 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD);
1054 list_add_tail(&ev->list, &data->events);
1055 }
Julia Lawallbd2281b2011-05-13 15:52:10 +02001056 list_add(&data->list, &rfkill_fds);
Johannes Bergc64fb012009-06-02 13:01:38 +02001057 mutex_unlock(&data->mtx);
1058 mutex_unlock(&rfkill_global_mutex);
1059
1060 file->private_data = data;
1061
1062 return nonseekable_open(inode, file);
1063
1064 free:
1065 mutex_unlock(&data->mtx);
1066 mutex_unlock(&rfkill_global_mutex);
1067 mutex_destroy(&data->mtx);
1068 list_for_each_entry_safe(ev, tmp, &data->events, list)
1069 kfree(ev);
1070 kfree(data);
1071 return -ENOMEM;
1072}
1073
1074static unsigned int rfkill_fop_poll(struct file *file, poll_table *wait)
1075{
1076 struct rfkill_data *data = file->private_data;
1077 unsigned int res = POLLOUT | POLLWRNORM;
1078
1079 poll_wait(file, &data->read_wait, wait);
1080
1081 mutex_lock(&data->mtx);
1082 if (!list_empty(&data->events))
1083 res = POLLIN | POLLRDNORM;
1084 mutex_unlock(&data->mtx);
1085
1086 return res;
1087}
1088
1089static bool rfkill_readable(struct rfkill_data *data)
1090{
1091 bool r;
1092
1093 mutex_lock(&data->mtx);
1094 r = !list_empty(&data->events);
1095 mutex_unlock(&data->mtx);
1096
1097 return r;
1098}
1099
1100static ssize_t rfkill_fop_read(struct file *file, char __user *buf,
1101 size_t count, loff_t *pos)
1102{
1103 struct rfkill_data *data = file->private_data;
1104 struct rfkill_int_event *ev;
1105 unsigned long sz;
1106 int ret;
1107
1108 mutex_lock(&data->mtx);
1109
1110 while (list_empty(&data->events)) {
1111 if (file->f_flags & O_NONBLOCK) {
1112 ret = -EAGAIN;
1113 goto out;
1114 }
1115 mutex_unlock(&data->mtx);
1116 ret = wait_event_interruptible(data->read_wait,
1117 rfkill_readable(data));
1118 mutex_lock(&data->mtx);
1119
1120 if (ret)
1121 goto out;
1122 }
1123
1124 ev = list_first_entry(&data->events, struct rfkill_int_event,
1125 list);
1126
1127 sz = min_t(unsigned long, sizeof(ev->ev), count);
1128 ret = sz;
1129 if (copy_to_user(buf, &ev->ev, sz))
1130 ret = -EFAULT;
1131
1132 list_del(&ev->list);
1133 kfree(ev);
1134 out:
1135 mutex_unlock(&data->mtx);
1136 return ret;
1137}
1138
1139static ssize_t rfkill_fop_write(struct file *file, const char __user *buf,
1140 size_t count, loff_t *pos)
1141{
1142 struct rfkill *rfkill;
1143 struct rfkill_event ev;
1144
1145 /* we don't need the 'hard' variable but accept it */
Johannes Berg1be491f2009-07-05 14:51:06 +02001146 if (count < RFKILL_EVENT_SIZE_V1 - 1)
Johannes Bergc64fb012009-06-02 13:01:38 +02001147 return -EINVAL;
1148
Johannes Berg1be491f2009-07-05 14:51:06 +02001149 /*
1150 * Copy as much data as we can accept into our 'ev' buffer,
1151 * but tell userspace how much we've copied so it can determine
1152 * our API version even in a write() call, if it cares.
1153 */
1154 count = min(count, sizeof(ev));
1155 if (copy_from_user(&ev, buf, count))
Johannes Bergc64fb012009-06-02 13:01:38 +02001156 return -EFAULT;
1157
1158 if (ev.op != RFKILL_OP_CHANGE && ev.op != RFKILL_OP_CHANGE_ALL)
1159 return -EINVAL;
1160
1161 if (ev.type >= NUM_RFKILL_TYPES)
1162 return -EINVAL;
1163
1164 mutex_lock(&rfkill_global_mutex);
1165
1166 if (ev.op == RFKILL_OP_CHANGE_ALL) {
1167 if (ev.type == RFKILL_TYPE_ALL) {
1168 enum rfkill_type i;
1169 for (i = 0; i < NUM_RFKILL_TYPES; i++)
1170 rfkill_global_states[i].cur = ev.soft;
1171 } else {
1172 rfkill_global_states[ev.type].cur = ev.soft;
1173 }
1174 }
1175
1176 list_for_each_entry(rfkill, &rfkill_list, node) {
1177 if (rfkill->idx != ev.idx && ev.op != RFKILL_OP_CHANGE_ALL)
1178 continue;
1179
1180 if (rfkill->type != ev.type && ev.type != RFKILL_TYPE_ALL)
1181 continue;
1182
1183 rfkill_set_block(rfkill, ev.soft);
1184 }
1185 mutex_unlock(&rfkill_global_mutex);
1186
1187 return count;
1188}
1189
1190static int rfkill_fop_release(struct inode *inode, struct file *file)
1191{
1192 struct rfkill_data *data = file->private_data;
1193 struct rfkill_int_event *ev, *tmp;
1194
1195 mutex_lock(&rfkill_global_mutex);
1196 list_del(&data->list);
1197 mutex_unlock(&rfkill_global_mutex);
1198
1199 mutex_destroy(&data->mtx);
1200 list_for_each_entry_safe(ev, tmp, &data->events, list)
1201 kfree(ev);
1202
1203#ifdef CONFIG_RFKILL_INPUT
1204 if (data->input_handler)
Johannes Berg207ee162009-06-07 12:26:52 +02001205 if (atomic_dec_return(&rfkill_input_disabled) == 0)
1206 printk(KERN_DEBUG "rfkill: input handler enabled\n");
Johannes Bergc64fb012009-06-02 13:01:38 +02001207#endif
1208
1209 kfree(data);
1210
1211 return 0;
1212}
1213
1214#ifdef CONFIG_RFKILL_INPUT
1215static long rfkill_fop_ioctl(struct file *file, unsigned int cmd,
1216 unsigned long arg)
1217{
1218 struct rfkill_data *data = file->private_data;
1219
1220 if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC)
1221 return -ENOSYS;
1222
1223 if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT)
1224 return -ENOSYS;
1225
1226 mutex_lock(&data->mtx);
1227
1228 if (!data->input_handler) {
Johannes Berg207ee162009-06-07 12:26:52 +02001229 if (atomic_inc_return(&rfkill_input_disabled) == 1)
1230 printk(KERN_DEBUG "rfkill: input handler disabled\n");
Johannes Bergc64fb012009-06-02 13:01:38 +02001231 data->input_handler = true;
1232 }
1233
1234 mutex_unlock(&data->mtx);
1235
1236 return 0;
1237}
1238#endif
1239
1240static const struct file_operations rfkill_fops = {
Johannes Berg45ba5642009-11-23 11:27:30 +01001241 .owner = THIS_MODULE,
Johannes Bergc64fb012009-06-02 13:01:38 +02001242 .open = rfkill_fop_open,
1243 .read = rfkill_fop_read,
1244 .write = rfkill_fop_write,
1245 .poll = rfkill_fop_poll,
1246 .release = rfkill_fop_release,
1247#ifdef CONFIG_RFKILL_INPUT
1248 .unlocked_ioctl = rfkill_fop_ioctl,
1249 .compat_ioctl = rfkill_fop_ioctl,
1250#endif
Arnd Bergmann6038f372010-08-15 18:52:59 +02001251 .llseek = no_llseek,
Johannes Bergc64fb012009-06-02 13:01:38 +02001252};
1253
1254static struct miscdevice rfkill_miscdev = {
1255 .name = "rfkill",
1256 .fops = &rfkill_fops,
1257 .minor = MISC_DYNAMIC_MINOR,
1258};
Johannes Berg19d337d2009-06-02 13:01:37 +02001259
1260static int __init rfkill_init(void)
1261{
1262 int error;
1263 int i;
1264
1265 for (i = 0; i < NUM_RFKILL_TYPES; i++)
Alan Jenkinsb3fa1322009-06-08 13:27:27 +01001266 rfkill_global_states[i].cur = !rfkill_default_state;
Johannes Berg19d337d2009-06-02 13:01:37 +02001267
1268 error = class_register(&rfkill_class);
1269 if (error)
1270 goto out;
1271
Johannes Bergc64fb012009-06-02 13:01:38 +02001272 error = misc_register(&rfkill_miscdev);
1273 if (error) {
1274 class_unregister(&rfkill_class);
1275 goto out;
1276 }
1277
Johannes Berg19d337d2009-06-02 13:01:37 +02001278#ifdef CONFIG_RFKILL_INPUT
1279 error = rfkill_handler_init();
Johannes Bergc64fb012009-06-02 13:01:38 +02001280 if (error) {
1281 misc_deregister(&rfkill_miscdev);
Johannes Berg19d337d2009-06-02 13:01:37 +02001282 class_unregister(&rfkill_class);
Johannes Bergc64fb012009-06-02 13:01:38 +02001283 goto out;
1284 }
Johannes Berg19d337d2009-06-02 13:01:37 +02001285#endif
1286
1287 out:
1288 return error;
1289}
1290subsys_initcall(rfkill_init);
1291
1292static void __exit rfkill_exit(void)
1293{
1294#ifdef CONFIG_RFKILL_INPUT
1295 rfkill_handler_exit();
1296#endif
Johannes Bergc64fb012009-06-02 13:01:38 +02001297 misc_deregister(&rfkill_miscdev);
Johannes Berg19d337d2009-06-02 13:01:37 +02001298 class_unregister(&rfkill_class);
1299}
1300module_exit(rfkill_exit);