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