blob: a9a7128f039e36547bf64f12d1f660d8ac934b26 [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
Jeff Kirsher8232f1f2013-12-06 03:32:14 -080017 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Johannes Berg19d337d2009-06-02 13:01:37 +020018 */
19
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/init.h>
23#include <linux/workqueue.h>
24#include <linux/capability.h>
25#include <linux/list.h>
26#include <linux/mutex.h>
27#include <linux/rfkill.h>
Alexey Dobriyana99bbaf2009-10-04 16:11:37 +040028#include <linux/sched.h>
Johannes Berg19d337d2009-06-02 13:01:37 +020029#include <linux/spinlock.h>
Paul Gortmaker51990e82012-01-22 11:23:42 -050030#include <linux/device.h>
Johannes Bergc64fb012009-06-02 13:01:38 +020031#include <linux/miscdevice.h>
32#include <linux/wait.h>
33#include <linux/poll.h>
34#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090035#include <linux/slab.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
Johannes Berg19d337d2009-06-02 13:01:37 +020052 enum rfkill_type type;
53
54 unsigned long state;
55
Johannes Bergc64fb012009-06-02 13:01:38 +020056 u32 idx;
57
Johannes Berg19d337d2009-06-02 13:01:37 +020058 bool registered;
Alan Jenkinsb3fa1322009-06-08 13:27:27 +010059 bool persistent;
Johannes Bergdd21dfc2016-01-20 10:39:23 +010060 bool polling_paused;
61 bool suspended;
Johannes Berg19d337d2009-06-02 13:01:37 +020062
63 const struct rfkill_ops *ops;
64 void *data;
65
66#ifdef CONFIG_RFKILL_LEDS
67 struct led_trigger led_trigger;
68 const char *ledtrigname;
69#endif
70
71 struct device dev;
72 struct list_head node;
73
74 struct delayed_work poll_work;
75 struct work_struct uevent_work;
76 struct work_struct sync_work;
Johannes Bergb7bb1102015-12-10 10:37:51 +010077 char name[];
Johannes Berg19d337d2009-06-02 13:01:37 +020078};
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
Johannes Berg19d337d2009-06-02 13:01:37 +0200238/**
239 * rfkill_set_block - wrapper for set_block method
240 *
241 * @rfkill: the rfkill struct to use
242 * @blocked: the new software state
243 *
244 * Calls the set_block method (when applicable) and handles notifications
245 * etc. as well.
246 */
247static void rfkill_set_block(struct rfkill *rfkill, bool blocked)
248{
249 unsigned long flags;
Vitaly Wooleab48342012-09-06 16:06:52 +0200250 bool prev, curr;
Johannes Berg19d337d2009-06-02 13:01:37 +0200251 int err;
252
Alan Jenkins7fa20a72009-06-16 14:53:24 +0100253 if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
254 return;
255
Johannes Berg19d337d2009-06-02 13:01:37 +0200256 /*
257 * Some platforms (...!) generate input events which affect the
258 * _hard_ kill state -- whenever something tries to change the
259 * current software state query the hardware state too.
260 */
261 if (rfkill->ops->query)
262 rfkill->ops->query(rfkill, rfkill->data);
263
264 spin_lock_irqsave(&rfkill->lock, flags);
Vitaly Wooleab48342012-09-06 16:06:52 +0200265 prev = rfkill->state & RFKILL_BLOCK_SW;
266
João Paulo Rechi Vitaf3e7fae2016-01-19 10:42:37 -0500267 if (prev)
Johannes Berg19d337d2009-06-02 13:01:37 +0200268 rfkill->state |= RFKILL_BLOCK_SW_PREV;
269 else
270 rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
271
272 if (blocked)
273 rfkill->state |= RFKILL_BLOCK_SW;
274 else
275 rfkill->state &= ~RFKILL_BLOCK_SW;
276
277 rfkill->state |= RFKILL_BLOCK_SW_SETCALL;
278 spin_unlock_irqrestore(&rfkill->lock, flags);
279
Johannes Berg19d337d2009-06-02 13:01:37 +0200280 err = rfkill->ops->set_block(rfkill->data, blocked);
281
282 spin_lock_irqsave(&rfkill->lock, flags);
283 if (err) {
284 /*
João Paulo Rechi Vita3ff707d2016-02-22 11:36:32 -0500285 * Failed -- reset status to _PREV, which may be different
286 * from what we have set _PREV to earlier in this function
Johannes Berg19d337d2009-06-02 13:01:37 +0200287 * if rfkill_set_sw_state was invoked.
288 */
289 if (rfkill->state & RFKILL_BLOCK_SW_PREV)
290 rfkill->state |= RFKILL_BLOCK_SW;
291 else
292 rfkill->state &= ~RFKILL_BLOCK_SW;
293 }
294 rfkill->state &= ~RFKILL_BLOCK_SW_SETCALL;
295 rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
Vitaly Wooleab48342012-09-06 16:06:52 +0200296 curr = rfkill->state & RFKILL_BLOCK_SW;
Johannes Berg19d337d2009-06-02 13:01:37 +0200297 spin_unlock_irqrestore(&rfkill->lock, flags);
298
299 rfkill_led_trigger_event(rfkill);
Vitaly Wooleab48342012-09-06 16:06:52 +0200300
301 if (prev != curr)
302 rfkill_event(rfkill);
Johannes Berg19d337d2009-06-02 13:01:37 +0200303}
304
João Paulo Rechi Vita9487bd62016-02-22 11:36:36 -0500305static void rfkill_update_global_state(enum rfkill_type type, bool blocked)
306{
307 int i;
308
309 if (type != RFKILL_TYPE_ALL) {
310 rfkill_global_states[type].cur = blocked;
311 return;
312 }
313
314 for (i = 0; i < NUM_RFKILL_TYPES; i++)
315 rfkill_global_states[i].cur = blocked;
316}
317
Johannes Bergc64fb012009-06-02 13:01:38 +0200318#ifdef CONFIG_RFKILL_INPUT
319static atomic_t rfkill_input_disabled = ATOMIC_INIT(0);
320
Johannes Berg19d337d2009-06-02 13:01:37 +0200321/**
322 * __rfkill_switch_all - Toggle state of all switches of given type
323 * @type: type of interfaces to be affected
Fabian Frederick2f29fed2014-10-07 22:20:23 +0200324 * @blocked: the new state
Johannes Berg19d337d2009-06-02 13:01:37 +0200325 *
326 * This function sets the state of all switches of given type,
João Paulo Rechi Vitae2a35e82016-01-19 10:42:39 -0500327 * unless a specific switch is suspended.
Johannes Berg19d337d2009-06-02 13:01:37 +0200328 *
329 * Caller must have acquired rfkill_global_mutex.
330 */
331static void __rfkill_switch_all(const enum rfkill_type type, bool blocked)
332{
333 struct rfkill *rfkill;
334
João Paulo Rechi Vita9487bd62016-02-22 11:36:36 -0500335 rfkill_update_global_state(type, blocked);
Johannes Berg19d337d2009-06-02 13:01:37 +0200336 list_for_each_entry(rfkill, &rfkill_list, node) {
Alex Hung27e49ca2012-05-23 14:11:52 +0800337 if (rfkill->type != type && type != RFKILL_TYPE_ALL)
Johannes Berg19d337d2009-06-02 13:01:37 +0200338 continue;
339
340 rfkill_set_block(rfkill, blocked);
341 }
342}
343
344/**
345 * rfkill_switch_all - Toggle state of all switches of given type
346 * @type: type of interfaces to be affected
Fabian Frederick2f29fed2014-10-07 22:20:23 +0200347 * @blocked: the new state
Johannes Berg19d337d2009-06-02 13:01:37 +0200348 *
349 * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
350 * Please refer to __rfkill_switch_all() for details.
351 *
352 * Does nothing if the EPO lock is active.
353 */
354void rfkill_switch_all(enum rfkill_type type, bool blocked)
355{
Johannes Bergc64fb012009-06-02 13:01:38 +0200356 if (atomic_read(&rfkill_input_disabled))
357 return;
358
Johannes Berg19d337d2009-06-02 13:01:37 +0200359 mutex_lock(&rfkill_global_mutex);
360
361 if (!rfkill_epo_lock_active)
362 __rfkill_switch_all(type, blocked);
363
364 mutex_unlock(&rfkill_global_mutex);
365}
366
367/**
368 * rfkill_epo - emergency power off all transmitters
369 *
370 * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
371 * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
372 *
373 * The global state before the EPO is saved and can be restored later
374 * using rfkill_restore_states().
375 */
376void rfkill_epo(void)
377{
378 struct rfkill *rfkill;
379 int i;
380
Johannes Bergc64fb012009-06-02 13:01:38 +0200381 if (atomic_read(&rfkill_input_disabled))
382 return;
383
Johannes Berg19d337d2009-06-02 13:01:37 +0200384 mutex_lock(&rfkill_global_mutex);
385
386 rfkill_epo_lock_active = true;
387 list_for_each_entry(rfkill, &rfkill_list, node)
388 rfkill_set_block(rfkill, true);
389
390 for (i = 0; i < NUM_RFKILL_TYPES; i++) {
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100391 rfkill_global_states[i].sav = rfkill_global_states[i].cur;
Johannes Berg19d337d2009-06-02 13:01:37 +0200392 rfkill_global_states[i].cur = true;
393 }
Johannes Bergc64fb012009-06-02 13:01:38 +0200394
Johannes Berg19d337d2009-06-02 13:01:37 +0200395 mutex_unlock(&rfkill_global_mutex);
396}
397
398/**
399 * rfkill_restore_states - restore global states
400 *
401 * Restore (and sync switches to) the global state from the
402 * states in rfkill_default_states. This can undo the effects of
403 * a call to rfkill_epo().
404 */
405void rfkill_restore_states(void)
406{
407 int i;
408
Johannes Bergc64fb012009-06-02 13:01:38 +0200409 if (atomic_read(&rfkill_input_disabled))
410 return;
411
Johannes Berg19d337d2009-06-02 13:01:37 +0200412 mutex_lock(&rfkill_global_mutex);
413
414 rfkill_epo_lock_active = false;
415 for (i = 0; i < NUM_RFKILL_TYPES; i++)
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100416 __rfkill_switch_all(i, rfkill_global_states[i].sav);
Johannes Berg19d337d2009-06-02 13:01:37 +0200417 mutex_unlock(&rfkill_global_mutex);
418}
419
420/**
421 * rfkill_remove_epo_lock - unlock state changes
422 *
423 * Used by rfkill-input manually unlock state changes, when
424 * the EPO switch is deactivated.
425 */
426void rfkill_remove_epo_lock(void)
427{
Johannes Bergc64fb012009-06-02 13:01:38 +0200428 if (atomic_read(&rfkill_input_disabled))
429 return;
430
Johannes Berg19d337d2009-06-02 13:01:37 +0200431 mutex_lock(&rfkill_global_mutex);
432 rfkill_epo_lock_active = false;
433 mutex_unlock(&rfkill_global_mutex);
434}
435
436/**
437 * rfkill_is_epo_lock_active - returns true EPO is active
438 *
439 * Returns 0 (false) if there is NOT an active EPO contidion,
440 * and 1 (true) if there is an active EPO contition, which
441 * locks all radios in one of the BLOCKED states.
442 *
443 * Can be called in atomic context.
444 */
445bool rfkill_is_epo_lock_active(void)
446{
447 return rfkill_epo_lock_active;
448}
449
450/**
451 * rfkill_get_global_sw_state - returns global state for a type
452 * @type: the type to get the global state of
453 *
454 * Returns the current global state for a given wireless
455 * device type.
456 */
457bool rfkill_get_global_sw_state(const enum rfkill_type type)
458{
459 return rfkill_global_states[type].cur;
460}
Johannes Bergc64fb012009-06-02 13:01:38 +0200461#endif
Johannes Berg19d337d2009-06-02 13:01:37 +0200462
Johannes Berg19d337d2009-06-02 13:01:37 +0200463bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
464{
João Paulo Rechi Vita1926e262016-01-19 10:42:38 -0500465 unsigned long flags;
466 bool ret, prev;
Johannes Berg19d337d2009-06-02 13:01:37 +0200467
João Paulo Rechi Vita1926e262016-01-19 10:42:38 -0500468 BUG_ON(!rfkill);
469
470 spin_lock_irqsave(&rfkill->lock, flags);
471 prev = !!(rfkill->state & RFKILL_BLOCK_HW);
472 if (blocked)
473 rfkill->state |= RFKILL_BLOCK_HW;
474 else
475 rfkill->state &= ~RFKILL_BLOCK_HW;
476 ret = !!(rfkill->state & RFKILL_BLOCK_ANY);
477 spin_unlock_irqrestore(&rfkill->lock, flags);
478
479 rfkill_led_trigger_event(rfkill);
Johannes Berg19d337d2009-06-02 13:01:37 +0200480
481 if (!rfkill->registered)
482 return ret;
483
João Paulo Rechi Vita1926e262016-01-19 10:42:38 -0500484 if (prev != blocked)
Johannes Berg19d337d2009-06-02 13:01:37 +0200485 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
Heikki Krogerus648b50d2016-01-25 12:03:46 +0300579static const char * const rfkill_types[] = {
580 NULL, /* RFKILL_TYPE_ALL */
581 "wlan",
582 "bluetooth",
583 "ultrawideband",
584 "wimax",
585 "wwan",
586 "gps",
587 "fm",
588 "nfc",
589};
590
591enum rfkill_type rfkill_find_type(const char *name)
592{
593 int i;
594
595 BUILD_BUG_ON(ARRAY_SIZE(rfkill_types) != NUM_RFKILL_TYPES);
596
597 if (!name)
598 return RFKILL_TYPE_ALL;
599
600 for (i = 1; i < NUM_RFKILL_TYPES; i++)
601 if (!strcmp(name, rfkill_types[i]))
602 return i;
603 return RFKILL_TYPE_ALL;
604}
605EXPORT_SYMBOL(rfkill_find_type);
606
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700607static ssize_t name_show(struct device *dev, struct device_attribute *attr,
608 char *buf)
Johannes Berg19d337d2009-06-02 13:01:37 +0200609{
610 struct rfkill *rfkill = to_rfkill(dev);
611
612 return sprintf(buf, "%s\n", rfkill->name);
613}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700614static DEVICE_ATTR_RO(name);
Johannes Berg19d337d2009-06-02 13:01:37 +0200615
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700616static ssize_t type_show(struct device *dev, struct device_attribute *attr,
617 char *buf)
Johannes Berg19d337d2009-06-02 13:01:37 +0200618{
619 struct rfkill *rfkill = to_rfkill(dev);
620
Heikki Krogerus648b50d2016-01-25 12:03:46 +0300621 return sprintf(buf, "%s\n", rfkill_types[rfkill->type]);
Johannes Berg19d337d2009-06-02 13:01:37 +0200622}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700623static DEVICE_ATTR_RO(type);
Johannes Berg19d337d2009-06-02 13:01:37 +0200624
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700625static ssize_t index_show(struct device *dev, struct device_attribute *attr,
626 char *buf)
Johannes Bergc64fb012009-06-02 13:01:38 +0200627{
628 struct rfkill *rfkill = to_rfkill(dev);
629
630 return sprintf(buf, "%d\n", rfkill->idx);
631}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700632static DEVICE_ATTR_RO(index);
Johannes Bergc64fb012009-06-02 13:01:38 +0200633
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700634static ssize_t persistent_show(struct device *dev,
635 struct device_attribute *attr, char *buf)
Alan Jenkins464902e2009-06-16 14:54:04 +0100636{
637 struct rfkill *rfkill = to_rfkill(dev);
638
639 return sprintf(buf, "%d\n", rfkill->persistent);
640}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700641static DEVICE_ATTR_RO(persistent);
Alan Jenkins464902e2009-06-16 14:54:04 +0100642
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700643static ssize_t hard_show(struct device *dev, struct device_attribute *attr,
644 char *buf)
florian@mickler.org6c263612010-02-26 12:01:34 +0100645{
646 struct rfkill *rfkill = to_rfkill(dev);
florian@mickler.org6c263612010-02-26 12:01:34 +0100647
florian@mickler.org819bfec2010-03-13 13:31:05 +0100648 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0 );
florian@mickler.org6c263612010-02-26 12:01:34 +0100649}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700650static DEVICE_ATTR_RO(hard);
florian@mickler.org6c263612010-02-26 12:01:34 +0100651
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700652static ssize_t soft_show(struct device *dev, struct device_attribute *attr,
653 char *buf)
florian@mickler.org6c263612010-02-26 12:01:34 +0100654{
655 struct rfkill *rfkill = to_rfkill(dev);
florian@mickler.org6c263612010-02-26 12:01:34 +0100656
florian@mickler.org819bfec2010-03-13 13:31:05 +0100657 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0 );
florian@mickler.org6c263612010-02-26 12:01:34 +0100658}
659
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700660static ssize_t soft_store(struct device *dev, struct device_attribute *attr,
661 const char *buf, size_t count)
florian@mickler.org6c263612010-02-26 12:01:34 +0100662{
663 struct rfkill *rfkill = to_rfkill(dev);
664 unsigned long state;
665 int err;
666
667 if (!capable(CAP_NET_ADMIN))
668 return -EPERM;
669
Julia Lawall1bac92c2011-11-06 14:26:49 +0100670 err = kstrtoul(buf, 0, &state);
florian@mickler.org6c263612010-02-26 12:01:34 +0100671 if (err)
672 return err;
673
674 if (state > 1 )
675 return -EINVAL;
676
677 mutex_lock(&rfkill_global_mutex);
678 rfkill_set_block(rfkill, state);
679 mutex_unlock(&rfkill_global_mutex);
680
Alan Cox6f7c9622012-10-25 15:18:34 +0100681 return count;
florian@mickler.org6c263612010-02-26 12:01:34 +0100682}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700683static DEVICE_ATTR_RW(soft);
florian@mickler.org6c263612010-02-26 12:01:34 +0100684
Johannes Berg19d337d2009-06-02 13:01:37 +0200685static u8 user_state_from_blocked(unsigned long state)
686{
687 if (state & RFKILL_BLOCK_HW)
688 return RFKILL_USER_STATE_HARD_BLOCKED;
689 if (state & RFKILL_BLOCK_SW)
690 return RFKILL_USER_STATE_SOFT_BLOCKED;
691
692 return RFKILL_USER_STATE_UNBLOCKED;
693}
694
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700695static ssize_t state_show(struct device *dev, struct device_attribute *attr,
696 char *buf)
Johannes Berg19d337d2009-06-02 13:01:37 +0200697{
698 struct rfkill *rfkill = to_rfkill(dev);
Johannes Berg19d337d2009-06-02 13:01:37 +0200699
florian@mickler.org819bfec2010-03-13 13:31:05 +0100700 return sprintf(buf, "%d\n", user_state_from_blocked(rfkill->state));
Johannes Berg19d337d2009-06-02 13:01:37 +0200701}
702
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700703static ssize_t state_store(struct device *dev, struct device_attribute *attr,
704 const char *buf, size_t count)
Johannes Berg19d337d2009-06-02 13:01:37 +0200705{
Johannes Bergf54c1422009-07-10 21:41:39 +0200706 struct rfkill *rfkill = to_rfkill(dev);
707 unsigned long state;
708 int err;
Johannes Berg19d337d2009-06-02 13:01:37 +0200709
Johannes Bergf54c1422009-07-10 21:41:39 +0200710 if (!capable(CAP_NET_ADMIN))
711 return -EPERM;
712
Julia Lawall1bac92c2011-11-06 14:26:49 +0100713 err = kstrtoul(buf, 0, &state);
Johannes Bergf54c1422009-07-10 21:41:39 +0200714 if (err)
715 return err;
716
717 if (state != RFKILL_USER_STATE_SOFT_BLOCKED &&
718 state != RFKILL_USER_STATE_UNBLOCKED)
719 return -EINVAL;
720
721 mutex_lock(&rfkill_global_mutex);
722 rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED);
723 mutex_unlock(&rfkill_global_mutex);
724
Alan Cox6f7c9622012-10-25 15:18:34 +0100725 return count;
Johannes Berg19d337d2009-06-02 13:01:37 +0200726}
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700727static DEVICE_ATTR_RW(state);
Johannes Berg19d337d2009-06-02 13:01:37 +0200728
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700729static struct attribute *rfkill_dev_attrs[] = {
730 &dev_attr_name.attr,
731 &dev_attr_type.attr,
732 &dev_attr_index.attr,
733 &dev_attr_persistent.attr,
734 &dev_attr_state.attr,
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700735 &dev_attr_soft.attr,
736 &dev_attr_hard.attr,
737 NULL,
Johannes Berg19d337d2009-06-02 13:01:37 +0200738};
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700739ATTRIBUTE_GROUPS(rfkill_dev);
Johannes Berg19d337d2009-06-02 13:01:37 +0200740
741static void rfkill_release(struct device *dev)
742{
743 struct rfkill *rfkill = to_rfkill(dev);
744
745 kfree(rfkill);
746}
747
748static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
749{
750 struct rfkill *rfkill = to_rfkill(dev);
751 unsigned long flags;
752 u32 state;
753 int error;
754
755 error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
756 if (error)
757 return error;
758 error = add_uevent_var(env, "RFKILL_TYPE=%s",
Heikki Krogerus648b50d2016-01-25 12:03:46 +0300759 rfkill_types[rfkill->type]);
Johannes Berg19d337d2009-06-02 13:01:37 +0200760 if (error)
761 return error;
762 spin_lock_irqsave(&rfkill->lock, flags);
763 state = rfkill->state;
764 spin_unlock_irqrestore(&rfkill->lock, flags);
765 error = add_uevent_var(env, "RFKILL_STATE=%d",
766 user_state_from_blocked(state));
767 return error;
768}
769
770void rfkill_pause_polling(struct rfkill *rfkill)
771{
772 BUG_ON(!rfkill);
773
774 if (!rfkill->ops->poll)
775 return;
776
Johannes Bergdd21dfc2016-01-20 10:39:23 +0100777 rfkill->polling_paused = true;
Johannes Berg19d337d2009-06-02 13:01:37 +0200778 cancel_delayed_work_sync(&rfkill->poll_work);
779}
780EXPORT_SYMBOL(rfkill_pause_polling);
781
782void rfkill_resume_polling(struct rfkill *rfkill)
783{
784 BUG_ON(!rfkill);
785
786 if (!rfkill->ops->poll)
787 return;
788
Johannes Bergdd21dfc2016-01-20 10:39:23 +0100789 rfkill->polling_paused = false;
790
791 if (rfkill->suspended)
792 return;
793
Shaibal Dutta67235cb2014-01-30 14:43:34 -0800794 queue_delayed_work(system_power_efficient_wq,
795 &rfkill->poll_work, 0);
Johannes Berg19d337d2009-06-02 13:01:37 +0200796}
797EXPORT_SYMBOL(rfkill_resume_polling);
798
Arnd Bergmannfaad2b82017-05-10 11:21:25 +0200799static __maybe_unused int rfkill_suspend(struct device *dev)
Johannes Berg19d337d2009-06-02 13:01:37 +0200800{
801 struct rfkill *rfkill = to_rfkill(dev);
802
Johannes Bergdd21dfc2016-01-20 10:39:23 +0100803 rfkill->suspended = true;
804 cancel_delayed_work_sync(&rfkill->poll_work);
Johannes Berg19d337d2009-06-02 13:01:37 +0200805
Johannes Berg19d337d2009-06-02 13:01:37 +0200806 return 0;
807}
808
Arnd Bergmannfaad2b82017-05-10 11:21:25 +0200809static __maybe_unused int rfkill_resume(struct device *dev)
Johannes Berg19d337d2009-06-02 13:01:37 +0200810{
811 struct rfkill *rfkill = to_rfkill(dev);
812 bool cur;
813
Johannes Bergdd21dfc2016-01-20 10:39:23 +0100814 rfkill->suspended = false;
815
Alan Jenkins06d5caf2009-06-16 15:39:51 +0100816 if (!rfkill->persistent) {
817 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
818 rfkill_set_block(rfkill, cur);
819 }
Johannes Berg19d337d2009-06-02 13:01:37 +0200820
Johannes Bergdd21dfc2016-01-20 10:39:23 +0100821 if (rfkill->ops->poll && !rfkill->polling_paused)
822 queue_delayed_work(system_power_efficient_wq,
823 &rfkill->poll_work, 0);
Johannes Berg19d337d2009-06-02 13:01:37 +0200824
825 return 0;
826}
827
Lars-Peter Clausen28f297a2015-05-16 14:23:55 +0200828static SIMPLE_DEV_PM_OPS(rfkill_pm_ops, rfkill_suspend, rfkill_resume);
Lars-Peter Clausen28f297a2015-05-16 14:23:55 +0200829
Johannes Berg19d337d2009-06-02 13:01:37 +0200830static struct class rfkill_class = {
831 .name = "rfkill",
832 .dev_release = rfkill_release,
Greg Kroah-Hartmane49df672013-07-24 15:05:36 -0700833 .dev_groups = rfkill_dev_groups,
Johannes Berg19d337d2009-06-02 13:01:37 +0200834 .dev_uevent = rfkill_dev_uevent,
Arnd Bergmannfaad2b82017-05-10 11:21:25 +0200835 .pm = IS_ENABLED(CONFIG_RFKILL_PM) ? &rfkill_pm_ops : NULL,
Johannes Berg19d337d2009-06-02 13:01:37 +0200836};
837
Johannes Berg60811622009-06-02 13:01:40 +0200838bool rfkill_blocked(struct rfkill *rfkill)
839{
840 unsigned long flags;
841 u32 state;
842
843 spin_lock_irqsave(&rfkill->lock, flags);
844 state = rfkill->state;
845 spin_unlock_irqrestore(&rfkill->lock, flags);
846
847 return !!(state & RFKILL_BLOCK_ANY);
848}
849EXPORT_SYMBOL(rfkill_blocked);
850
Johannes Berg19d337d2009-06-02 13:01:37 +0200851
852struct rfkill * __must_check rfkill_alloc(const char *name,
853 struct device *parent,
854 const enum rfkill_type type,
855 const struct rfkill_ops *ops,
856 void *ops_data)
857{
858 struct rfkill *rfkill;
859 struct device *dev;
860
861 if (WARN_ON(!ops))
862 return NULL;
863
864 if (WARN_ON(!ops->set_block))
865 return NULL;
866
867 if (WARN_ON(!name))
868 return NULL;
869
Johannes Bergc64fb012009-06-02 13:01:38 +0200870 if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES))
Johannes Berg19d337d2009-06-02 13:01:37 +0200871 return NULL;
872
Johannes Bergb7bb1102015-12-10 10:37:51 +0100873 rfkill = kzalloc(sizeof(*rfkill) + strlen(name) + 1, GFP_KERNEL);
Johannes Berg19d337d2009-06-02 13:01:37 +0200874 if (!rfkill)
875 return NULL;
876
877 spin_lock_init(&rfkill->lock);
878 INIT_LIST_HEAD(&rfkill->node);
879 rfkill->type = type;
Johannes Bergb7bb1102015-12-10 10:37:51 +0100880 strcpy(rfkill->name, name);
Johannes Berg19d337d2009-06-02 13:01:37 +0200881 rfkill->ops = ops;
882 rfkill->data = ops_data;
883
884 dev = &rfkill->dev;
885 dev->class = &rfkill_class;
886 dev->parent = parent;
887 device_initialize(dev);
888
889 return rfkill;
890}
891EXPORT_SYMBOL(rfkill_alloc);
892
893static void rfkill_poll(struct work_struct *work)
894{
895 struct rfkill *rfkill;
896
897 rfkill = container_of(work, struct rfkill, poll_work.work);
898
899 /*
900 * Poll hardware state -- driver will use one of the
901 * rfkill_set{,_hw,_sw}_state functions and use its
902 * return value to update the current status.
903 */
904 rfkill->ops->poll(rfkill, rfkill->data);
905
Shaibal Dutta67235cb2014-01-30 14:43:34 -0800906 queue_delayed_work(system_power_efficient_wq,
907 &rfkill->poll_work,
Johannes Berg19d337d2009-06-02 13:01:37 +0200908 round_jiffies_relative(POLL_INTERVAL));
909}
910
911static void rfkill_uevent_work(struct work_struct *work)
912{
913 struct rfkill *rfkill;
914
915 rfkill = container_of(work, struct rfkill, uevent_work);
916
Johannes Bergc64fb012009-06-02 13:01:38 +0200917 mutex_lock(&rfkill_global_mutex);
918 rfkill_event(rfkill);
919 mutex_unlock(&rfkill_global_mutex);
Johannes Berg19d337d2009-06-02 13:01:37 +0200920}
921
922static void rfkill_sync_work(struct work_struct *work)
923{
924 struct rfkill *rfkill;
925 bool cur;
926
927 rfkill = container_of(work, struct rfkill, sync_work);
928
929 mutex_lock(&rfkill_global_mutex);
930 cur = rfkill_global_states[rfkill->type].cur;
931 rfkill_set_block(rfkill, cur);
932 mutex_unlock(&rfkill_global_mutex);
933}
934
935int __must_check rfkill_register(struct rfkill *rfkill)
936{
937 static unsigned long rfkill_no;
938 struct device *dev = &rfkill->dev;
939 int error;
940
941 BUG_ON(!rfkill);
942
943 mutex_lock(&rfkill_global_mutex);
944
945 if (rfkill->registered) {
946 error = -EALREADY;
947 goto unlock;
948 }
949
Johannes Bergc64fb012009-06-02 13:01:38 +0200950 rfkill->idx = rfkill_no;
Johannes Berg19d337d2009-06-02 13:01:37 +0200951 dev_set_name(dev, "rfkill%lu", rfkill_no);
952 rfkill_no++;
953
Johannes Berg19d337d2009-06-02 13:01:37 +0200954 list_add_tail(&rfkill->node, &rfkill_list);
955
956 error = device_add(dev);
957 if (error)
958 goto remove;
959
960 error = rfkill_led_trigger_register(rfkill);
961 if (error)
962 goto devdel;
963
964 rfkill->registered = true;
965
Johannes Berg2ec2c682009-06-03 09:55:29 +0200966 INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll);
967 INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work);
968 INIT_WORK(&rfkill->sync_work, rfkill_sync_work);
969
970 if (rfkill->ops->poll)
Shaibal Dutta67235cb2014-01-30 14:43:34 -0800971 queue_delayed_work(system_power_efficient_wq,
972 &rfkill->poll_work,
Johannes Berg19d337d2009-06-02 13:01:37 +0200973 round_jiffies_relative(POLL_INTERVAL));
Alan Jenkinsb3fa1322009-06-08 13:27:27 +0100974
975 if (!rfkill->persistent || rfkill_epo_lock_active) {
976 schedule_work(&rfkill->sync_work);
977 } else {
978#ifdef CONFIG_RFKILL_INPUT
979 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
980
981 if (!atomic_read(&rfkill_input_disabled))
982 __rfkill_switch_all(rfkill->type, soft_blocked);
983#endif
984 }
Johannes Berg2ec2c682009-06-03 09:55:29 +0200985
Johannes Bergc64fb012009-06-02 13:01:38 +0200986 rfkill_send_events(rfkill, RFKILL_OP_ADD);
Johannes Berg19d337d2009-06-02 13:01:37 +0200987
988 mutex_unlock(&rfkill_global_mutex);
989 return 0;
990
991 devdel:
992 device_del(&rfkill->dev);
993 remove:
994 list_del_init(&rfkill->node);
995 unlock:
996 mutex_unlock(&rfkill_global_mutex);
997 return error;
998}
999EXPORT_SYMBOL(rfkill_register);
1000
1001void rfkill_unregister(struct rfkill *rfkill)
1002{
1003 BUG_ON(!rfkill);
1004
1005 if (rfkill->ops->poll)
1006 cancel_delayed_work_sync(&rfkill->poll_work);
1007
1008 cancel_work_sync(&rfkill->uevent_work);
1009 cancel_work_sync(&rfkill->sync_work);
1010
1011 rfkill->registered = false;
1012
1013 device_del(&rfkill->dev);
1014
1015 mutex_lock(&rfkill_global_mutex);
Johannes Bergc64fb012009-06-02 13:01:38 +02001016 rfkill_send_events(rfkill, RFKILL_OP_DEL);
Johannes Berg19d337d2009-06-02 13:01:37 +02001017 list_del_init(&rfkill->node);
1018 mutex_unlock(&rfkill_global_mutex);
1019
1020 rfkill_led_trigger_unregister(rfkill);
1021}
1022EXPORT_SYMBOL(rfkill_unregister);
1023
1024void rfkill_destroy(struct rfkill *rfkill)
1025{
1026 if (rfkill)
1027 put_device(&rfkill->dev);
1028}
1029EXPORT_SYMBOL(rfkill_destroy);
1030
Johannes Bergc64fb012009-06-02 13:01:38 +02001031static int rfkill_fop_open(struct inode *inode, struct file *file)
1032{
1033 struct rfkill_data *data;
1034 struct rfkill *rfkill;
1035 struct rfkill_int_event *ev, *tmp;
1036
1037 data = kzalloc(sizeof(*data), GFP_KERNEL);
1038 if (!data)
1039 return -ENOMEM;
1040
1041 INIT_LIST_HEAD(&data->events);
1042 mutex_init(&data->mtx);
1043 init_waitqueue_head(&data->read_wait);
1044
1045 mutex_lock(&rfkill_global_mutex);
1046 mutex_lock(&data->mtx);
1047 /*
1048 * start getting events from elsewhere but hold mtx to get
1049 * startup events added first
1050 */
Johannes Bergc64fb012009-06-02 13:01:38 +02001051
1052 list_for_each_entry(rfkill, &rfkill_list, node) {
1053 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1054 if (!ev)
1055 goto free;
1056 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD);
1057 list_add_tail(&ev->list, &data->events);
1058 }
Julia Lawallbd2281b2011-05-13 15:52:10 +02001059 list_add(&data->list, &rfkill_fds);
Johannes Bergc64fb012009-06-02 13:01:38 +02001060 mutex_unlock(&data->mtx);
1061 mutex_unlock(&rfkill_global_mutex);
1062
1063 file->private_data = data;
1064
1065 return nonseekable_open(inode, file);
1066
1067 free:
1068 mutex_unlock(&data->mtx);
1069 mutex_unlock(&rfkill_global_mutex);
1070 mutex_destroy(&data->mtx);
1071 list_for_each_entry_safe(ev, tmp, &data->events, list)
1072 kfree(ev);
1073 kfree(data);
1074 return -ENOMEM;
1075}
1076
1077static unsigned int rfkill_fop_poll(struct file *file, poll_table *wait)
1078{
1079 struct rfkill_data *data = file->private_data;
1080 unsigned int res = POLLOUT | POLLWRNORM;
1081
1082 poll_wait(file, &data->read_wait, wait);
1083
1084 mutex_lock(&data->mtx);
1085 if (!list_empty(&data->events))
1086 res = POLLIN | POLLRDNORM;
1087 mutex_unlock(&data->mtx);
1088
1089 return res;
1090}
1091
Johannes Bergc64fb012009-06-02 13:01:38 +02001092static ssize_t rfkill_fop_read(struct file *file, char __user *buf,
1093 size_t count, loff_t *pos)
1094{
1095 struct rfkill_data *data = file->private_data;
1096 struct rfkill_int_event *ev;
1097 unsigned long sz;
1098 int ret;
1099
1100 mutex_lock(&data->mtx);
1101
1102 while (list_empty(&data->events)) {
1103 if (file->f_flags & O_NONBLOCK) {
1104 ret = -EAGAIN;
1105 goto out;
1106 }
1107 mutex_unlock(&data->mtx);
Johannes Berg6736fde2016-01-26 11:29:03 +01001108 /* since we re-check and it just compares pointers,
1109 * using !list_empty() without locking isn't a problem
1110 */
Johannes Bergc64fb012009-06-02 13:01:38 +02001111 ret = wait_event_interruptible(data->read_wait,
Johannes Berg6736fde2016-01-26 11:29:03 +01001112 !list_empty(&data->events));
Johannes Bergc64fb012009-06-02 13:01:38 +02001113 mutex_lock(&data->mtx);
1114
1115 if (ret)
1116 goto out;
1117 }
1118
1119 ev = list_first_entry(&data->events, struct rfkill_int_event,
1120 list);
1121
1122 sz = min_t(unsigned long, sizeof(ev->ev), count);
1123 ret = sz;
1124 if (copy_to_user(buf, &ev->ev, sz))
1125 ret = -EFAULT;
1126
1127 list_del(&ev->list);
1128 kfree(ev);
1129 out:
1130 mutex_unlock(&data->mtx);
1131 return ret;
1132}
1133
1134static ssize_t rfkill_fop_write(struct file *file, const char __user *buf,
1135 size_t count, loff_t *pos)
1136{
1137 struct rfkill *rfkill;
1138 struct rfkill_event ev;
João Paulo Rechi Vita1948b2a2016-02-22 11:36:39 -05001139 int ret;
Johannes Bergc64fb012009-06-02 13:01:38 +02001140
1141 /* we don't need the 'hard' variable but accept it */
Johannes Berg1be491f2009-07-05 14:51:06 +02001142 if (count < RFKILL_EVENT_SIZE_V1 - 1)
Johannes Bergc64fb012009-06-02 13:01:38 +02001143 return -EINVAL;
1144
Johannes Berg1be491f2009-07-05 14:51:06 +02001145 /*
1146 * Copy as much data as we can accept into our 'ev' buffer,
1147 * but tell userspace how much we've copied so it can determine
1148 * our API version even in a write() call, if it cares.
1149 */
1150 count = min(count, sizeof(ev));
1151 if (copy_from_user(&ev, buf, count))
Johannes Bergc64fb012009-06-02 13:01:38 +02001152 return -EFAULT;
1153
Johannes Bergc64fb012009-06-02 13:01:38 +02001154 if (ev.type >= NUM_RFKILL_TYPES)
1155 return -EINVAL;
1156
1157 mutex_lock(&rfkill_global_mutex);
1158
João Paulo Rechi Vita1948b2a2016-02-22 11:36:39 -05001159 switch (ev.op) {
1160 case RFKILL_OP_CHANGE_ALL:
João Paulo Rechi Vita9487bd62016-02-22 11:36:36 -05001161 rfkill_update_global_state(ev.type, ev.soft);
João Paulo Rechi Vita1948b2a2016-02-22 11:36:39 -05001162 list_for_each_entry(rfkill, &rfkill_list, node)
1163 if (rfkill->type == ev.type ||
1164 ev.type == RFKILL_TYPE_ALL)
1165 rfkill_set_block(rfkill, ev.soft);
1166 ret = 0;
1167 break;
1168 case RFKILL_OP_CHANGE:
1169 list_for_each_entry(rfkill, &rfkill_list, node)
1170 if (rfkill->idx == ev.idx &&
1171 (rfkill->type == ev.type ||
1172 ev.type == RFKILL_TYPE_ALL))
1173 rfkill_set_block(rfkill, ev.soft);
1174 ret = 0;
1175 break;
1176 default:
1177 ret = -EINVAL;
1178 break;
Johannes Bergc64fb012009-06-02 13:01:38 +02001179 }
João Paulo Rechi Vita1948b2a2016-02-22 11:36:39 -05001180
Johannes Bergc64fb012009-06-02 13:01:38 +02001181 mutex_unlock(&rfkill_global_mutex);
1182
João Paulo Rechi Vita1948b2a2016-02-22 11:36:39 -05001183 return ret ?: count;
Johannes Bergc64fb012009-06-02 13:01:38 +02001184}
1185
1186static int rfkill_fop_release(struct inode *inode, struct file *file)
1187{
1188 struct rfkill_data *data = file->private_data;
1189 struct rfkill_int_event *ev, *tmp;
1190
1191 mutex_lock(&rfkill_global_mutex);
1192 list_del(&data->list);
1193 mutex_unlock(&rfkill_global_mutex);
1194
1195 mutex_destroy(&data->mtx);
1196 list_for_each_entry_safe(ev, tmp, &data->events, list)
1197 kfree(ev);
1198
1199#ifdef CONFIG_RFKILL_INPUT
1200 if (data->input_handler)
Johannes Berg207ee162009-06-07 12:26:52 +02001201 if (atomic_dec_return(&rfkill_input_disabled) == 0)
1202 printk(KERN_DEBUG "rfkill: input handler enabled\n");
Johannes Bergc64fb012009-06-02 13:01:38 +02001203#endif
1204
1205 kfree(data);
1206
1207 return 0;
1208}
1209
1210#ifdef CONFIG_RFKILL_INPUT
1211static long rfkill_fop_ioctl(struct file *file, unsigned int cmd,
1212 unsigned long arg)
1213{
1214 struct rfkill_data *data = file->private_data;
1215
1216 if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC)
1217 return -ENOSYS;
1218
1219 if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT)
1220 return -ENOSYS;
1221
1222 mutex_lock(&data->mtx);
1223
1224 if (!data->input_handler) {
Johannes Berg207ee162009-06-07 12:26:52 +02001225 if (atomic_inc_return(&rfkill_input_disabled) == 1)
1226 printk(KERN_DEBUG "rfkill: input handler disabled\n");
Johannes Bergc64fb012009-06-02 13:01:38 +02001227 data->input_handler = true;
1228 }
1229
1230 mutex_unlock(&data->mtx);
1231
1232 return 0;
1233}
1234#endif
1235
1236static const struct file_operations rfkill_fops = {
Johannes Berg45ba5642009-11-23 11:27:30 +01001237 .owner = THIS_MODULE,
Johannes Bergc64fb012009-06-02 13:01:38 +02001238 .open = rfkill_fop_open,
1239 .read = rfkill_fop_read,
1240 .write = rfkill_fop_write,
1241 .poll = rfkill_fop_poll,
1242 .release = rfkill_fop_release,
1243#ifdef CONFIG_RFKILL_INPUT
1244 .unlocked_ioctl = rfkill_fop_ioctl,
1245 .compat_ioctl = rfkill_fop_ioctl,
1246#endif
Arnd Bergmann6038f372010-08-15 18:52:59 +02001247 .llseek = no_llseek,
Johannes Bergc64fb012009-06-02 13:01:38 +02001248};
1249
1250static struct miscdevice rfkill_miscdev = {
1251 .name = "rfkill",
1252 .fops = &rfkill_fops,
1253 .minor = MISC_DYNAMIC_MINOR,
1254};
Johannes Berg19d337d2009-06-02 13:01:37 +02001255
1256static int __init rfkill_init(void)
1257{
1258 int error;
Johannes Berg19d337d2009-06-02 13:01:37 +02001259
João Paulo Rechi Vita9487bd62016-02-22 11:36:36 -05001260 rfkill_update_global_state(RFKILL_TYPE_ALL, !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);