1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2006 - 2007 Ivo van Doorn
4 * Copyright (C) 2007 Dmitry Torokhov
5 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/workqueue.h>
12 #include <linux/capability.h>
13 #include <linux/list.h>
14 #include <linux/mutex.h>
15 #include <linux/rfkill.h>
16 #include <linux/sched.h>
17 #include <linux/spinlock.h>
18 #include <linux/device.h>
19 #include <linux/miscdevice.h>
20 #include <linux/wait.h>
21 #include <linux/poll.h>
23 #include <linux/slab.h>
27 #define POLL_INTERVAL (5 * HZ)
29 #define RFKILL_BLOCK_HW BIT(0)
30 #define RFKILL_BLOCK_SW BIT(1)
31 #define RFKILL_BLOCK_SW_PREV BIT(2)
32 #define RFKILL_BLOCK_ANY (RFKILL_BLOCK_HW |\
35 #define RFKILL_BLOCK_SW_SETCALL BIT(31)
40 enum rfkill_type type
;
43 unsigned long hard_block_reasons
;
52 const struct rfkill_ops
*ops
;
55 #ifdef CONFIG_RFKILL_LEDS
56 struct led_trigger led_trigger
;
57 const char *ledtrigname
;
61 struct list_head node
;
63 struct delayed_work poll_work
;
64 struct work_struct uevent_work
;
65 struct work_struct sync_work
;
68 #define to_rfkill(d) container_of(d, struct rfkill, dev)
70 struct rfkill_int_event
{
71 struct list_head list
;
72 struct rfkill_event_ext ev
;
76 struct list_head list
;
77 struct list_head events
;
79 wait_queue_head_t read_wait
;
84 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
85 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
86 MODULE_DESCRIPTION("RF switch support");
87 MODULE_LICENSE("GPL");
91 * The locking here should be made much smarter, we currently have
92 * a bit of a stupid situation because drivers might want to register
93 * the rfkill struct under their own lock, and take this lock during
94 * rfkill method calls -- which will cause an AB-BA deadlock situation.
96 * To fix that, we need to rework this code here to be mostly lock-free
97 * and only use the mutex for list manipulations, not to protect the
98 * various other global variables. Then we can avoid holding the mutex
99 * around driver operations, and all is happy.
101 static LIST_HEAD(rfkill_list
); /* list of registered rf switches */
102 static DEFINE_MUTEX(rfkill_global_mutex
);
103 static LIST_HEAD(rfkill_fds
); /* list of open fds of /dev/rfkill */
105 static unsigned int rfkill_default_state
= 1;
106 module_param_named(default_state
, rfkill_default_state
, uint
, 0444);
107 MODULE_PARM_DESC(default_state
,
108 "Default initial state for all radio types, 0 = radio off");
112 } rfkill_global_states
[NUM_RFKILL_TYPES
];
114 static bool rfkill_epo_lock_active
;
117 #ifdef CONFIG_RFKILL_LEDS
118 static void rfkill_led_trigger_event(struct rfkill
*rfkill
)
120 struct led_trigger
*trigger
;
122 if (!rfkill
->registered
)
125 trigger
= &rfkill
->led_trigger
;
127 if (rfkill
->state
& RFKILL_BLOCK_ANY
)
128 led_trigger_event(trigger
, LED_OFF
);
130 led_trigger_event(trigger
, LED_FULL
);
133 static int rfkill_led_trigger_activate(struct led_classdev
*led
)
135 struct rfkill
*rfkill
;
137 rfkill
= container_of(led
->trigger
, struct rfkill
, led_trigger
);
139 rfkill_led_trigger_event(rfkill
);
144 const char *rfkill_get_led_trigger_name(struct rfkill
*rfkill
)
146 return rfkill
->led_trigger
.name
;
148 EXPORT_SYMBOL(rfkill_get_led_trigger_name
);
150 void rfkill_set_led_trigger_name(struct rfkill
*rfkill
, const char *name
)
154 rfkill
->ledtrigname
= name
;
156 EXPORT_SYMBOL(rfkill_set_led_trigger_name
);
158 static int rfkill_led_trigger_register(struct rfkill
*rfkill
)
160 rfkill
->led_trigger
.name
= rfkill
->ledtrigname
161 ? : dev_name(&rfkill
->dev
);
162 rfkill
->led_trigger
.activate
= rfkill_led_trigger_activate
;
163 return led_trigger_register(&rfkill
->led_trigger
);
166 static void rfkill_led_trigger_unregister(struct rfkill
*rfkill
)
168 led_trigger_unregister(&rfkill
->led_trigger
);
171 static struct led_trigger rfkill_any_led_trigger
;
172 static struct led_trigger rfkill_none_led_trigger
;
173 static struct work_struct rfkill_global_led_trigger_work
;
175 static void rfkill_global_led_trigger_worker(struct work_struct
*work
)
177 enum led_brightness brightness
= LED_OFF
;
178 struct rfkill
*rfkill
;
180 mutex_lock(&rfkill_global_mutex
);
181 list_for_each_entry(rfkill
, &rfkill_list
, node
) {
182 if (!(rfkill
->state
& RFKILL_BLOCK_ANY
)) {
183 brightness
= LED_FULL
;
187 mutex_unlock(&rfkill_global_mutex
);
189 led_trigger_event(&rfkill_any_led_trigger
, brightness
);
190 led_trigger_event(&rfkill_none_led_trigger
,
191 brightness
== LED_OFF
? LED_FULL
: LED_OFF
);
194 static void rfkill_global_led_trigger_event(void)
196 schedule_work(&rfkill_global_led_trigger_work
);
199 static int rfkill_global_led_trigger_register(void)
203 INIT_WORK(&rfkill_global_led_trigger_work
,
204 rfkill_global_led_trigger_worker
);
206 rfkill_any_led_trigger
.name
= "rfkill-any";
207 ret
= led_trigger_register(&rfkill_any_led_trigger
);
211 rfkill_none_led_trigger
.name
= "rfkill-none";
212 ret
= led_trigger_register(&rfkill_none_led_trigger
);
214 led_trigger_unregister(&rfkill_any_led_trigger
);
216 /* Delay activation until all global triggers are registered */
217 rfkill_global_led_trigger_event();
222 static void rfkill_global_led_trigger_unregister(void)
224 led_trigger_unregister(&rfkill_none_led_trigger
);
225 led_trigger_unregister(&rfkill_any_led_trigger
);
226 cancel_work_sync(&rfkill_global_led_trigger_work
);
229 static void rfkill_led_trigger_event(struct rfkill
*rfkill
)
233 static inline int rfkill_led_trigger_register(struct rfkill
*rfkill
)
238 static inline void rfkill_led_trigger_unregister(struct rfkill
*rfkill
)
242 static void rfkill_global_led_trigger_event(void)
246 static int rfkill_global_led_trigger_register(void)
251 static void rfkill_global_led_trigger_unregister(void)
254 #endif /* CONFIG_RFKILL_LEDS */
256 static void rfkill_fill_event(struct rfkill_event_ext
*ev
,
257 struct rfkill
*rfkill
,
258 enum rfkill_operation op
)
262 ev
->idx
= rfkill
->idx
;
263 ev
->type
= rfkill
->type
;
266 spin_lock_irqsave(&rfkill
->lock
, flags
);
267 ev
->hard
= !!(rfkill
->state
& RFKILL_BLOCK_HW
);
268 ev
->soft
= !!(rfkill
->state
& (RFKILL_BLOCK_SW
|
269 RFKILL_BLOCK_SW_PREV
));
270 ev
->hard_block_reasons
= rfkill
->hard_block_reasons
;
271 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
274 static void rfkill_send_events(struct rfkill
*rfkill
, enum rfkill_operation op
)
276 struct rfkill_data
*data
;
277 struct rfkill_int_event
*ev
;
279 list_for_each_entry(data
, &rfkill_fds
, list
) {
280 ev
= kzalloc(sizeof(*ev
), GFP_KERNEL
);
283 rfkill_fill_event(&ev
->ev
, rfkill
, op
);
284 mutex_lock(&data
->mtx
);
285 list_add_tail(&ev
->list
, &data
->events
);
286 mutex_unlock(&data
->mtx
);
287 wake_up_interruptible(&data
->read_wait
);
291 static void rfkill_event(struct rfkill
*rfkill
)
293 if (!rfkill
->registered
)
296 kobject_uevent(&rfkill
->dev
.kobj
, KOBJ_CHANGE
);
298 /* also send event to /dev/rfkill */
299 rfkill_send_events(rfkill
, RFKILL_OP_CHANGE
);
303 * rfkill_set_block - wrapper for set_block method
305 * @rfkill: the rfkill struct to use
306 * @blocked: the new software state
308 * Calls the set_block method (when applicable) and handles notifications
311 static void rfkill_set_block(struct rfkill
*rfkill
, bool blocked
)
317 if (unlikely(rfkill
->dev
.power
.power_state
.event
& PM_EVENT_SLEEP
))
321 * Some platforms (...!) generate input events which affect the
322 * _hard_ kill state -- whenever something tries to change the
323 * current software state query the hardware state too.
325 if (rfkill
->ops
->query
)
326 rfkill
->ops
->query(rfkill
, rfkill
->data
);
328 spin_lock_irqsave(&rfkill
->lock
, flags
);
329 prev
= rfkill
->state
& RFKILL_BLOCK_SW
;
332 rfkill
->state
|= RFKILL_BLOCK_SW_PREV
;
334 rfkill
->state
&= ~RFKILL_BLOCK_SW_PREV
;
337 rfkill
->state
|= RFKILL_BLOCK_SW
;
339 rfkill
->state
&= ~RFKILL_BLOCK_SW
;
341 rfkill
->state
|= RFKILL_BLOCK_SW_SETCALL
;
342 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
344 err
= rfkill
->ops
->set_block(rfkill
->data
, blocked
);
346 spin_lock_irqsave(&rfkill
->lock
, flags
);
349 * Failed -- reset status to _PREV, which may be different
350 * from what we have set _PREV to earlier in this function
351 * if rfkill_set_sw_state was invoked.
353 if (rfkill
->state
& RFKILL_BLOCK_SW_PREV
)
354 rfkill
->state
|= RFKILL_BLOCK_SW
;
356 rfkill
->state
&= ~RFKILL_BLOCK_SW
;
358 rfkill
->state
&= ~RFKILL_BLOCK_SW_SETCALL
;
359 rfkill
->state
&= ~RFKILL_BLOCK_SW_PREV
;
360 curr
= rfkill
->state
& RFKILL_BLOCK_SW
;
361 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
363 rfkill_led_trigger_event(rfkill
);
364 rfkill_global_led_trigger_event();
367 rfkill_event(rfkill
);
370 static void rfkill_update_global_state(enum rfkill_type type
, bool blocked
)
374 if (type
!= RFKILL_TYPE_ALL
) {
375 rfkill_global_states
[type
].cur
= blocked
;
379 for (i
= 0; i
< NUM_RFKILL_TYPES
; i
++)
380 rfkill_global_states
[i
].cur
= blocked
;
383 #ifdef CONFIG_RFKILL_INPUT
384 static atomic_t rfkill_input_disabled
= ATOMIC_INIT(0);
387 * __rfkill_switch_all - Toggle state of all switches of given type
388 * @type: type of interfaces to be affected
389 * @blocked: the new state
391 * This function sets the state of all switches of given type,
392 * unless a specific switch is suspended.
394 * Caller must have acquired rfkill_global_mutex.
396 static void __rfkill_switch_all(const enum rfkill_type type
, bool blocked
)
398 struct rfkill
*rfkill
;
400 rfkill_update_global_state(type
, blocked
);
401 list_for_each_entry(rfkill
, &rfkill_list
, node
) {
402 if (rfkill
->type
!= type
&& type
!= RFKILL_TYPE_ALL
)
405 rfkill_set_block(rfkill
, blocked
);
410 * rfkill_switch_all - Toggle state of all switches of given type
411 * @type: type of interfaces to be affected
412 * @blocked: the new state
414 * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
415 * Please refer to __rfkill_switch_all() for details.
417 * Does nothing if the EPO lock is active.
419 void rfkill_switch_all(enum rfkill_type type
, bool blocked
)
421 if (atomic_read(&rfkill_input_disabled
))
424 mutex_lock(&rfkill_global_mutex
);
426 if (!rfkill_epo_lock_active
)
427 __rfkill_switch_all(type
, blocked
);
429 mutex_unlock(&rfkill_global_mutex
);
433 * rfkill_epo - emergency power off all transmitters
435 * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
436 * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
438 * The global state before the EPO is saved and can be restored later
439 * using rfkill_restore_states().
441 void rfkill_epo(void)
443 struct rfkill
*rfkill
;
446 if (atomic_read(&rfkill_input_disabled
))
449 mutex_lock(&rfkill_global_mutex
);
451 rfkill_epo_lock_active
= true;
452 list_for_each_entry(rfkill
, &rfkill_list
, node
)
453 rfkill_set_block(rfkill
, true);
455 for (i
= 0; i
< NUM_RFKILL_TYPES
; i
++) {
456 rfkill_global_states
[i
].sav
= rfkill_global_states
[i
].cur
;
457 rfkill_global_states
[i
].cur
= true;
460 mutex_unlock(&rfkill_global_mutex
);
464 * rfkill_restore_states - restore global states
466 * Restore (and sync switches to) the global state from the
467 * states in rfkill_default_states. This can undo the effects of
468 * a call to rfkill_epo().
470 void rfkill_restore_states(void)
474 if (atomic_read(&rfkill_input_disabled
))
477 mutex_lock(&rfkill_global_mutex
);
479 rfkill_epo_lock_active
= false;
480 for (i
= 0; i
< NUM_RFKILL_TYPES
; i
++)
481 __rfkill_switch_all(i
, rfkill_global_states
[i
].sav
);
482 mutex_unlock(&rfkill_global_mutex
);
486 * rfkill_remove_epo_lock - unlock state changes
488 * Used by rfkill-input manually unlock state changes, when
489 * the EPO switch is deactivated.
491 void rfkill_remove_epo_lock(void)
493 if (atomic_read(&rfkill_input_disabled
))
496 mutex_lock(&rfkill_global_mutex
);
497 rfkill_epo_lock_active
= false;
498 mutex_unlock(&rfkill_global_mutex
);
502 * rfkill_is_epo_lock_active - returns true EPO is active
504 * Returns 0 (false) if there is NOT an active EPO condition,
505 * and 1 (true) if there is an active EPO condition, which
506 * locks all radios in one of the BLOCKED states.
508 * Can be called in atomic context.
510 bool rfkill_is_epo_lock_active(void)
512 return rfkill_epo_lock_active
;
516 * rfkill_get_global_sw_state - returns global state for a type
517 * @type: the type to get the global state of
519 * Returns the current global state for a given wireless
522 bool rfkill_get_global_sw_state(const enum rfkill_type type
)
524 return rfkill_global_states
[type
].cur
;
528 bool rfkill_set_hw_state_reason(struct rfkill
*rfkill
,
529 bool blocked
, unsigned long reason
)
537 ~(RFKILL_HARD_BLOCK_SIGNAL
| RFKILL_HARD_BLOCK_NOT_OWNER
),
538 "hw_state reason not supported: 0x%lx", reason
))
541 spin_lock_irqsave(&rfkill
->lock
, flags
);
542 prev
= !!(rfkill
->hard_block_reasons
& reason
);
544 rfkill
->state
|= RFKILL_BLOCK_HW
;
545 rfkill
->hard_block_reasons
|= reason
;
547 rfkill
->hard_block_reasons
&= ~reason
;
548 if (!rfkill
->hard_block_reasons
)
549 rfkill
->state
&= ~RFKILL_BLOCK_HW
;
551 ret
= !!(rfkill
->state
& RFKILL_BLOCK_ANY
);
552 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
554 rfkill_led_trigger_event(rfkill
);
555 rfkill_global_led_trigger_event();
557 if (rfkill
->registered
&& prev
!= blocked
)
558 schedule_work(&rfkill
->uevent_work
);
562 EXPORT_SYMBOL(rfkill_set_hw_state_reason
);
564 static void __rfkill_set_sw_state(struct rfkill
*rfkill
, bool blocked
)
566 u32 bit
= RFKILL_BLOCK_SW
;
568 /* if in a ops->set_block right now, use other bit */
569 if (rfkill
->state
& RFKILL_BLOCK_SW_SETCALL
)
570 bit
= RFKILL_BLOCK_SW_PREV
;
573 rfkill
->state
|= bit
;
575 rfkill
->state
&= ~bit
;
578 bool rfkill_set_sw_state(struct rfkill
*rfkill
, bool blocked
)
585 spin_lock_irqsave(&rfkill
->lock
, flags
);
586 prev
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
587 __rfkill_set_sw_state(rfkill
, blocked
);
588 hwblock
= !!(rfkill
->state
& RFKILL_BLOCK_HW
);
589 blocked
= blocked
|| hwblock
;
590 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
592 if (!rfkill
->registered
)
595 if (prev
!= blocked
&& !hwblock
)
596 schedule_work(&rfkill
->uevent_work
);
598 rfkill_led_trigger_event(rfkill
);
599 rfkill_global_led_trigger_event();
603 EXPORT_SYMBOL(rfkill_set_sw_state
);
605 void rfkill_init_sw_state(struct rfkill
*rfkill
, bool blocked
)
610 BUG_ON(rfkill
->registered
);
612 spin_lock_irqsave(&rfkill
->lock
, flags
);
613 __rfkill_set_sw_state(rfkill
, blocked
);
614 rfkill
->persistent
= true;
615 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
617 EXPORT_SYMBOL(rfkill_init_sw_state
);
619 void rfkill_set_states(struct rfkill
*rfkill
, bool sw
, bool hw
)
626 spin_lock_irqsave(&rfkill
->lock
, flags
);
629 * No need to care about prev/setblock ... this is for uevent only
630 * and that will get triggered by rfkill_set_block anyway.
632 swprev
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
633 hwprev
= !!(rfkill
->state
& RFKILL_BLOCK_HW
);
634 __rfkill_set_sw_state(rfkill
, sw
);
636 rfkill
->state
|= RFKILL_BLOCK_HW
;
638 rfkill
->state
&= ~RFKILL_BLOCK_HW
;
640 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
642 if (!rfkill
->registered
) {
643 rfkill
->persistent
= true;
645 if (swprev
!= sw
|| hwprev
!= hw
)
646 schedule_work(&rfkill
->uevent_work
);
648 rfkill_led_trigger_event(rfkill
);
649 rfkill_global_led_trigger_event();
652 EXPORT_SYMBOL(rfkill_set_states
);
654 static const char * const rfkill_types
[] = {
655 NULL
, /* RFKILL_TYPE_ALL */
666 enum rfkill_type
rfkill_find_type(const char *name
)
670 BUILD_BUG_ON(ARRAY_SIZE(rfkill_types
) != NUM_RFKILL_TYPES
);
673 return RFKILL_TYPE_ALL
;
675 for (i
= 1; i
< NUM_RFKILL_TYPES
; i
++)
676 if (!strcmp(name
, rfkill_types
[i
]))
678 return RFKILL_TYPE_ALL
;
680 EXPORT_SYMBOL(rfkill_find_type
);
682 static ssize_t
name_show(struct device
*dev
, struct device_attribute
*attr
,
685 struct rfkill
*rfkill
= to_rfkill(dev
);
687 return sprintf(buf
, "%s\n", rfkill
->name
);
689 static DEVICE_ATTR_RO(name
);
691 static ssize_t
type_show(struct device
*dev
, struct device_attribute
*attr
,
694 struct rfkill
*rfkill
= to_rfkill(dev
);
696 return sprintf(buf
, "%s\n", rfkill_types
[rfkill
->type
]);
698 static DEVICE_ATTR_RO(type
);
700 static ssize_t
index_show(struct device
*dev
, struct device_attribute
*attr
,
703 struct rfkill
*rfkill
= to_rfkill(dev
);
705 return sprintf(buf
, "%d\n", rfkill
->idx
);
707 static DEVICE_ATTR_RO(index
);
709 static ssize_t
persistent_show(struct device
*dev
,
710 struct device_attribute
*attr
, char *buf
)
712 struct rfkill
*rfkill
= to_rfkill(dev
);
714 return sprintf(buf
, "%d\n", rfkill
->persistent
);
716 static DEVICE_ATTR_RO(persistent
);
718 static ssize_t
hard_show(struct device
*dev
, struct device_attribute
*attr
,
721 struct rfkill
*rfkill
= to_rfkill(dev
);
723 return sprintf(buf
, "%d\n", (rfkill
->state
& RFKILL_BLOCK_HW
) ? 1 : 0 );
725 static DEVICE_ATTR_RO(hard
);
727 static ssize_t
soft_show(struct device
*dev
, struct device_attribute
*attr
,
730 struct rfkill
*rfkill
= to_rfkill(dev
);
732 return sprintf(buf
, "%d\n", (rfkill
->state
& RFKILL_BLOCK_SW
) ? 1 : 0 );
735 static ssize_t
soft_store(struct device
*dev
, struct device_attribute
*attr
,
736 const char *buf
, size_t count
)
738 struct rfkill
*rfkill
= to_rfkill(dev
);
742 if (!capable(CAP_NET_ADMIN
))
745 err
= kstrtoul(buf
, 0, &state
);
752 mutex_lock(&rfkill_global_mutex
);
753 rfkill_set_block(rfkill
, state
);
754 mutex_unlock(&rfkill_global_mutex
);
758 static DEVICE_ATTR_RW(soft
);
760 static ssize_t
hard_block_reasons_show(struct device
*dev
,
761 struct device_attribute
*attr
,
764 struct rfkill
*rfkill
= to_rfkill(dev
);
766 return sprintf(buf
, "0x%lx\n", rfkill
->hard_block_reasons
);
768 static DEVICE_ATTR_RO(hard_block_reasons
);
770 static u8
user_state_from_blocked(unsigned long state
)
772 if (state
& RFKILL_BLOCK_HW
)
773 return RFKILL_USER_STATE_HARD_BLOCKED
;
774 if (state
& RFKILL_BLOCK_SW
)
775 return RFKILL_USER_STATE_SOFT_BLOCKED
;
777 return RFKILL_USER_STATE_UNBLOCKED
;
780 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*attr
,
783 struct rfkill
*rfkill
= to_rfkill(dev
);
785 return sprintf(buf
, "%d\n", user_state_from_blocked(rfkill
->state
));
788 static ssize_t
state_store(struct device
*dev
, struct device_attribute
*attr
,
789 const char *buf
, size_t count
)
791 struct rfkill
*rfkill
= to_rfkill(dev
);
795 if (!capable(CAP_NET_ADMIN
))
798 err
= kstrtoul(buf
, 0, &state
);
802 if (state
!= RFKILL_USER_STATE_SOFT_BLOCKED
&&
803 state
!= RFKILL_USER_STATE_UNBLOCKED
)
806 mutex_lock(&rfkill_global_mutex
);
807 rfkill_set_block(rfkill
, state
== RFKILL_USER_STATE_SOFT_BLOCKED
);
808 mutex_unlock(&rfkill_global_mutex
);
812 static DEVICE_ATTR_RW(state
);
814 static struct attribute
*rfkill_dev_attrs
[] = {
817 &dev_attr_index
.attr
,
818 &dev_attr_persistent
.attr
,
819 &dev_attr_state
.attr
,
822 &dev_attr_hard_block_reasons
.attr
,
825 ATTRIBUTE_GROUPS(rfkill_dev
);
827 static void rfkill_release(struct device
*dev
)
829 struct rfkill
*rfkill
= to_rfkill(dev
);
834 static int rfkill_dev_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
836 struct rfkill
*rfkill
= to_rfkill(dev
);
838 unsigned long reasons
;
842 error
= add_uevent_var(env
, "RFKILL_NAME=%s", rfkill
->name
);
845 error
= add_uevent_var(env
, "RFKILL_TYPE=%s",
846 rfkill_types
[rfkill
->type
]);
849 spin_lock_irqsave(&rfkill
->lock
, flags
);
850 state
= rfkill
->state
;
851 reasons
= rfkill
->hard_block_reasons
;
852 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
853 error
= add_uevent_var(env
, "RFKILL_STATE=%d",
854 user_state_from_blocked(state
));
857 return add_uevent_var(env
, "RFKILL_HW_BLOCK_REASON=0x%lx", reasons
);
860 void rfkill_pause_polling(struct rfkill
*rfkill
)
864 if (!rfkill
->ops
->poll
)
867 rfkill
->polling_paused
= true;
868 cancel_delayed_work_sync(&rfkill
->poll_work
);
870 EXPORT_SYMBOL(rfkill_pause_polling
);
872 void rfkill_resume_polling(struct rfkill
*rfkill
)
876 if (!rfkill
->ops
->poll
)
879 rfkill
->polling_paused
= false;
881 if (rfkill
->suspended
)
884 queue_delayed_work(system_power_efficient_wq
,
885 &rfkill
->poll_work
, 0);
887 EXPORT_SYMBOL(rfkill_resume_polling
);
889 #ifdef CONFIG_PM_SLEEP
890 static int rfkill_suspend(struct device
*dev
)
892 struct rfkill
*rfkill
= to_rfkill(dev
);
894 rfkill
->suspended
= true;
895 cancel_delayed_work_sync(&rfkill
->poll_work
);
900 static int rfkill_resume(struct device
*dev
)
902 struct rfkill
*rfkill
= to_rfkill(dev
);
905 rfkill
->suspended
= false;
907 if (!rfkill
->registered
)
910 if (!rfkill
->persistent
) {
911 cur
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
912 rfkill_set_block(rfkill
, cur
);
915 if (rfkill
->ops
->poll
&& !rfkill
->polling_paused
)
916 queue_delayed_work(system_power_efficient_wq
,
917 &rfkill
->poll_work
, 0);
922 static SIMPLE_DEV_PM_OPS(rfkill_pm_ops
, rfkill_suspend
, rfkill_resume
);
923 #define RFKILL_PM_OPS (&rfkill_pm_ops)
925 #define RFKILL_PM_OPS NULL
928 static struct class rfkill_class
= {
930 .dev_release
= rfkill_release
,
931 .dev_groups
= rfkill_dev_groups
,
932 .dev_uevent
= rfkill_dev_uevent
,
936 bool rfkill_blocked(struct rfkill
*rfkill
)
941 spin_lock_irqsave(&rfkill
->lock
, flags
);
942 state
= rfkill
->state
;
943 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
945 return !!(state
& RFKILL_BLOCK_ANY
);
947 EXPORT_SYMBOL(rfkill_blocked
);
950 struct rfkill
* __must_check
rfkill_alloc(const char *name
,
951 struct device
*parent
,
952 const enum rfkill_type type
,
953 const struct rfkill_ops
*ops
,
956 struct rfkill
*rfkill
;
962 if (WARN_ON(!ops
->set_block
))
968 if (WARN_ON(type
== RFKILL_TYPE_ALL
|| type
>= NUM_RFKILL_TYPES
))
971 rfkill
= kzalloc(sizeof(*rfkill
) + strlen(name
) + 1, GFP_KERNEL
);
975 spin_lock_init(&rfkill
->lock
);
976 INIT_LIST_HEAD(&rfkill
->node
);
978 strcpy(rfkill
->name
, name
);
980 rfkill
->data
= ops_data
;
983 dev
->class = &rfkill_class
;
984 dev
->parent
= parent
;
985 device_initialize(dev
);
989 EXPORT_SYMBOL(rfkill_alloc
);
991 static void rfkill_poll(struct work_struct
*work
)
993 struct rfkill
*rfkill
;
995 rfkill
= container_of(work
, struct rfkill
, poll_work
.work
);
998 * Poll hardware state -- driver will use one of the
999 * rfkill_set{,_hw,_sw}_state functions and use its
1000 * return value to update the current status.
1002 rfkill
->ops
->poll(rfkill
, rfkill
->data
);
1004 queue_delayed_work(system_power_efficient_wq
,
1006 round_jiffies_relative(POLL_INTERVAL
));
1009 static void rfkill_uevent_work(struct work_struct
*work
)
1011 struct rfkill
*rfkill
;
1013 rfkill
= container_of(work
, struct rfkill
, uevent_work
);
1015 mutex_lock(&rfkill_global_mutex
);
1016 rfkill_event(rfkill
);
1017 mutex_unlock(&rfkill_global_mutex
);
1020 static void rfkill_sync_work(struct work_struct
*work
)
1022 struct rfkill
*rfkill
;
1025 rfkill
= container_of(work
, struct rfkill
, sync_work
);
1027 mutex_lock(&rfkill_global_mutex
);
1028 cur
= rfkill_global_states
[rfkill
->type
].cur
;
1029 rfkill_set_block(rfkill
, cur
);
1030 mutex_unlock(&rfkill_global_mutex
);
1033 int __must_check
rfkill_register(struct rfkill
*rfkill
)
1035 static unsigned long rfkill_no
;
1044 mutex_lock(&rfkill_global_mutex
);
1046 if (rfkill
->registered
) {
1051 rfkill
->idx
= rfkill_no
;
1052 dev_set_name(dev
, "rfkill%lu", rfkill_no
);
1055 list_add_tail(&rfkill
->node
, &rfkill_list
);
1057 error
= device_add(dev
);
1061 error
= rfkill_led_trigger_register(rfkill
);
1065 rfkill
->registered
= true;
1067 INIT_DELAYED_WORK(&rfkill
->poll_work
, rfkill_poll
);
1068 INIT_WORK(&rfkill
->uevent_work
, rfkill_uevent_work
);
1069 INIT_WORK(&rfkill
->sync_work
, rfkill_sync_work
);
1071 if (rfkill
->ops
->poll
)
1072 queue_delayed_work(system_power_efficient_wq
,
1074 round_jiffies_relative(POLL_INTERVAL
));
1076 if (!rfkill
->persistent
|| rfkill_epo_lock_active
) {
1077 schedule_work(&rfkill
->sync_work
);
1079 #ifdef CONFIG_RFKILL_INPUT
1080 bool soft_blocked
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
1082 if (!atomic_read(&rfkill_input_disabled
))
1083 __rfkill_switch_all(rfkill
->type
, soft_blocked
);
1087 rfkill_global_led_trigger_event();
1088 rfkill_send_events(rfkill
, RFKILL_OP_ADD
);
1090 mutex_unlock(&rfkill_global_mutex
);
1094 device_del(&rfkill
->dev
);
1096 list_del_init(&rfkill
->node
);
1098 mutex_unlock(&rfkill_global_mutex
);
1101 EXPORT_SYMBOL(rfkill_register
);
1103 void rfkill_unregister(struct rfkill
*rfkill
)
1107 if (rfkill
->ops
->poll
)
1108 cancel_delayed_work_sync(&rfkill
->poll_work
);
1110 cancel_work_sync(&rfkill
->uevent_work
);
1111 cancel_work_sync(&rfkill
->sync_work
);
1113 rfkill
->registered
= false;
1115 device_del(&rfkill
->dev
);
1117 mutex_lock(&rfkill_global_mutex
);
1118 rfkill_send_events(rfkill
, RFKILL_OP_DEL
);
1119 list_del_init(&rfkill
->node
);
1120 rfkill_global_led_trigger_event();
1121 mutex_unlock(&rfkill_global_mutex
);
1123 rfkill_led_trigger_unregister(rfkill
);
1125 EXPORT_SYMBOL(rfkill_unregister
);
1127 void rfkill_destroy(struct rfkill
*rfkill
)
1130 put_device(&rfkill
->dev
);
1132 EXPORT_SYMBOL(rfkill_destroy
);
1134 static int rfkill_fop_open(struct inode
*inode
, struct file
*file
)
1136 struct rfkill_data
*data
;
1137 struct rfkill
*rfkill
;
1138 struct rfkill_int_event
*ev
, *tmp
;
1140 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
1144 INIT_LIST_HEAD(&data
->events
);
1145 mutex_init(&data
->mtx
);
1146 init_waitqueue_head(&data
->read_wait
);
1148 mutex_lock(&rfkill_global_mutex
);
1149 mutex_lock(&data
->mtx
);
1151 * start getting events from elsewhere but hold mtx to get
1152 * startup events added first
1155 list_for_each_entry(rfkill
, &rfkill_list
, node
) {
1156 ev
= kzalloc(sizeof(*ev
), GFP_KERNEL
);
1159 rfkill_fill_event(&ev
->ev
, rfkill
, RFKILL_OP_ADD
);
1160 list_add_tail(&ev
->list
, &data
->events
);
1162 list_add(&data
->list
, &rfkill_fds
);
1163 mutex_unlock(&data
->mtx
);
1164 mutex_unlock(&rfkill_global_mutex
);
1166 file
->private_data
= data
;
1168 return stream_open(inode
, file
);
1171 mutex_unlock(&data
->mtx
);
1172 mutex_unlock(&rfkill_global_mutex
);
1173 mutex_destroy(&data
->mtx
);
1174 list_for_each_entry_safe(ev
, tmp
, &data
->events
, list
)
1180 static __poll_t
rfkill_fop_poll(struct file
*file
, poll_table
*wait
)
1182 struct rfkill_data
*data
= file
->private_data
;
1183 __poll_t res
= EPOLLOUT
| EPOLLWRNORM
;
1185 poll_wait(file
, &data
->read_wait
, wait
);
1187 mutex_lock(&data
->mtx
);
1188 if (!list_empty(&data
->events
))
1189 res
= EPOLLIN
| EPOLLRDNORM
;
1190 mutex_unlock(&data
->mtx
);
1195 static ssize_t
rfkill_fop_read(struct file
*file
, char __user
*buf
,
1196 size_t count
, loff_t
*pos
)
1198 struct rfkill_data
*data
= file
->private_data
;
1199 struct rfkill_int_event
*ev
;
1203 mutex_lock(&data
->mtx
);
1205 while (list_empty(&data
->events
)) {
1206 if (file
->f_flags
& O_NONBLOCK
) {
1210 mutex_unlock(&data
->mtx
);
1211 /* since we re-check and it just compares pointers,
1212 * using !list_empty() without locking isn't a problem
1214 ret
= wait_event_interruptible(data
->read_wait
,
1215 !list_empty(&data
->events
));
1216 mutex_lock(&data
->mtx
);
1222 ev
= list_first_entry(&data
->events
, struct rfkill_int_event
,
1225 sz
= min_t(unsigned long, sizeof(ev
->ev
), count
);
1227 if (copy_to_user(buf
, &ev
->ev
, sz
))
1230 list_del(&ev
->list
);
1233 mutex_unlock(&data
->mtx
);
1237 static ssize_t
rfkill_fop_write(struct file
*file
, const char __user
*buf
,
1238 size_t count
, loff_t
*pos
)
1240 struct rfkill
*rfkill
;
1241 struct rfkill_event_ext ev
;
1244 /* we don't need the 'hard' variable but accept it */
1245 if (count
< RFKILL_EVENT_SIZE_V1
- 1)
1249 * Copy as much data as we can accept into our 'ev' buffer,
1250 * but tell userspace how much we've copied so it can determine
1251 * our API version even in a write() call, if it cares.
1253 count
= min(count
, sizeof(ev
));
1254 if (copy_from_user(&ev
, buf
, count
))
1257 if (ev
.type
>= NUM_RFKILL_TYPES
)
1260 mutex_lock(&rfkill_global_mutex
);
1263 case RFKILL_OP_CHANGE_ALL
:
1264 rfkill_update_global_state(ev
.type
, ev
.soft
);
1265 list_for_each_entry(rfkill
, &rfkill_list
, node
)
1266 if (rfkill
->type
== ev
.type
||
1267 ev
.type
== RFKILL_TYPE_ALL
)
1268 rfkill_set_block(rfkill
, ev
.soft
);
1271 case RFKILL_OP_CHANGE
:
1272 list_for_each_entry(rfkill
, &rfkill_list
, node
)
1273 if (rfkill
->idx
== ev
.idx
&&
1274 (rfkill
->type
== ev
.type
||
1275 ev
.type
== RFKILL_TYPE_ALL
))
1276 rfkill_set_block(rfkill
, ev
.soft
);
1284 mutex_unlock(&rfkill_global_mutex
);
1286 return ret
?: count
;
1289 static int rfkill_fop_release(struct inode
*inode
, struct file
*file
)
1291 struct rfkill_data
*data
= file
->private_data
;
1292 struct rfkill_int_event
*ev
, *tmp
;
1294 mutex_lock(&rfkill_global_mutex
);
1295 list_del(&data
->list
);
1296 mutex_unlock(&rfkill_global_mutex
);
1298 mutex_destroy(&data
->mtx
);
1299 list_for_each_entry_safe(ev
, tmp
, &data
->events
, list
)
1302 #ifdef CONFIG_RFKILL_INPUT
1303 if (data
->input_handler
)
1304 if (atomic_dec_return(&rfkill_input_disabled
) == 0)
1305 printk(KERN_DEBUG
"rfkill: input handler enabled\n");
1313 #ifdef CONFIG_RFKILL_INPUT
1314 static long rfkill_fop_ioctl(struct file
*file
, unsigned int cmd
,
1317 struct rfkill_data
*data
= file
->private_data
;
1319 if (_IOC_TYPE(cmd
) != RFKILL_IOC_MAGIC
)
1322 if (_IOC_NR(cmd
) != RFKILL_IOC_NOINPUT
)
1325 mutex_lock(&data
->mtx
);
1327 if (!data
->input_handler
) {
1328 if (atomic_inc_return(&rfkill_input_disabled
) == 1)
1329 printk(KERN_DEBUG
"rfkill: input handler disabled\n");
1330 data
->input_handler
= true;
1333 mutex_unlock(&data
->mtx
);
1339 static const struct file_operations rfkill_fops
= {
1340 .owner
= THIS_MODULE
,
1341 .open
= rfkill_fop_open
,
1342 .read
= rfkill_fop_read
,
1343 .write
= rfkill_fop_write
,
1344 .poll
= rfkill_fop_poll
,
1345 .release
= rfkill_fop_release
,
1346 #ifdef CONFIG_RFKILL_INPUT
1347 .unlocked_ioctl
= rfkill_fop_ioctl
,
1348 .compat_ioctl
= compat_ptr_ioctl
,
1350 .llseek
= no_llseek
,
1353 #define RFKILL_NAME "rfkill"
1355 static struct miscdevice rfkill_miscdev
= {
1356 .fops
= &rfkill_fops
,
1357 .name
= RFKILL_NAME
,
1358 .minor
= RFKILL_MINOR
,
1361 static int __init
rfkill_init(void)
1365 rfkill_update_global_state(RFKILL_TYPE_ALL
, !rfkill_default_state
);
1367 error
= class_register(&rfkill_class
);
1371 error
= misc_register(&rfkill_miscdev
);
1375 error
= rfkill_global_led_trigger_register();
1377 goto error_led_trigger
;
1379 #ifdef CONFIG_RFKILL_INPUT
1380 error
= rfkill_handler_init();
1387 #ifdef CONFIG_RFKILL_INPUT
1389 rfkill_global_led_trigger_unregister();
1392 misc_deregister(&rfkill_miscdev
);
1394 class_unregister(&rfkill_class
);
1398 subsys_initcall(rfkill_init
);
1400 static void __exit
rfkill_exit(void)
1402 #ifdef CONFIG_RFKILL_INPUT
1403 rfkill_handler_exit();
1405 rfkill_global_led_trigger_unregister();
1406 misc_deregister(&rfkill_miscdev
);
1407 class_unregister(&rfkill_class
);
1409 module_exit(rfkill_exit
);
1411 MODULE_ALIAS_MISCDEV(RFKILL_MINOR
);
1412 MODULE_ALIAS("devname:" RFKILL_NAME
);