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
;
85 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
86 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
87 MODULE_DESCRIPTION("RF switch support");
88 MODULE_LICENSE("GPL");
92 * The locking here should be made much smarter, we currently have
93 * a bit of a stupid situation because drivers might want to register
94 * the rfkill struct under their own lock, and take this lock during
95 * rfkill method calls -- which will cause an AB-BA deadlock situation.
97 * To fix that, we need to rework this code here to be mostly lock-free
98 * and only use the mutex for list manipulations, not to protect the
99 * various other global variables. Then we can avoid holding the mutex
100 * around driver operations, and all is happy.
102 static LIST_HEAD(rfkill_list
); /* list of registered rf switches */
103 static DEFINE_MUTEX(rfkill_global_mutex
);
104 static LIST_HEAD(rfkill_fds
); /* list of open fds of /dev/rfkill */
106 static unsigned int rfkill_default_state
= 1;
107 module_param_named(default_state
, rfkill_default_state
, uint
, 0444);
108 MODULE_PARM_DESC(default_state
,
109 "Default initial state for all radio types, 0 = radio off");
113 } rfkill_global_states
[NUM_RFKILL_TYPES
];
115 static bool rfkill_epo_lock_active
;
118 #ifdef CONFIG_RFKILL_LEDS
119 static void rfkill_led_trigger_event(struct rfkill
*rfkill
)
121 struct led_trigger
*trigger
;
123 if (!rfkill
->registered
)
126 trigger
= &rfkill
->led_trigger
;
128 if (rfkill
->state
& RFKILL_BLOCK_ANY
)
129 led_trigger_event(trigger
, LED_OFF
);
131 led_trigger_event(trigger
, LED_FULL
);
134 static int rfkill_led_trigger_activate(struct led_classdev
*led
)
136 struct rfkill
*rfkill
;
138 rfkill
= container_of(led
->trigger
, struct rfkill
, led_trigger
);
140 rfkill_led_trigger_event(rfkill
);
145 const char *rfkill_get_led_trigger_name(struct rfkill
*rfkill
)
147 return rfkill
->led_trigger
.name
;
149 EXPORT_SYMBOL(rfkill_get_led_trigger_name
);
151 void rfkill_set_led_trigger_name(struct rfkill
*rfkill
, const char *name
)
155 rfkill
->ledtrigname
= name
;
157 EXPORT_SYMBOL(rfkill_set_led_trigger_name
);
159 static int rfkill_led_trigger_register(struct rfkill
*rfkill
)
161 rfkill
->led_trigger
.name
= rfkill
->ledtrigname
162 ? : dev_name(&rfkill
->dev
);
163 rfkill
->led_trigger
.activate
= rfkill_led_trigger_activate
;
164 return led_trigger_register(&rfkill
->led_trigger
);
167 static void rfkill_led_trigger_unregister(struct rfkill
*rfkill
)
169 led_trigger_unregister(&rfkill
->led_trigger
);
172 static struct led_trigger rfkill_any_led_trigger
;
173 static struct led_trigger rfkill_none_led_trigger
;
174 static struct work_struct rfkill_global_led_trigger_work
;
176 static void rfkill_global_led_trigger_worker(struct work_struct
*work
)
178 enum led_brightness brightness
= LED_OFF
;
179 struct rfkill
*rfkill
;
181 mutex_lock(&rfkill_global_mutex
);
182 list_for_each_entry(rfkill
, &rfkill_list
, node
) {
183 if (!(rfkill
->state
& RFKILL_BLOCK_ANY
)) {
184 brightness
= LED_FULL
;
188 mutex_unlock(&rfkill_global_mutex
);
190 led_trigger_event(&rfkill_any_led_trigger
, brightness
);
191 led_trigger_event(&rfkill_none_led_trigger
,
192 brightness
== LED_OFF
? LED_FULL
: LED_OFF
);
195 static void rfkill_global_led_trigger_event(void)
197 schedule_work(&rfkill_global_led_trigger_work
);
200 static int rfkill_global_led_trigger_register(void)
204 INIT_WORK(&rfkill_global_led_trigger_work
,
205 rfkill_global_led_trigger_worker
);
207 rfkill_any_led_trigger
.name
= "rfkill-any";
208 ret
= led_trigger_register(&rfkill_any_led_trigger
);
212 rfkill_none_led_trigger
.name
= "rfkill-none";
213 ret
= led_trigger_register(&rfkill_none_led_trigger
);
215 led_trigger_unregister(&rfkill_any_led_trigger
);
217 /* Delay activation until all global triggers are registered */
218 rfkill_global_led_trigger_event();
223 static void rfkill_global_led_trigger_unregister(void)
225 led_trigger_unregister(&rfkill_none_led_trigger
);
226 led_trigger_unregister(&rfkill_any_led_trigger
);
227 cancel_work_sync(&rfkill_global_led_trigger_work
);
230 static void rfkill_led_trigger_event(struct rfkill
*rfkill
)
234 static inline int rfkill_led_trigger_register(struct rfkill
*rfkill
)
239 static inline void rfkill_led_trigger_unregister(struct rfkill
*rfkill
)
243 static void rfkill_global_led_trigger_event(void)
247 static int rfkill_global_led_trigger_register(void)
252 static void rfkill_global_led_trigger_unregister(void)
255 #endif /* CONFIG_RFKILL_LEDS */
257 static void rfkill_fill_event(struct rfkill_event_ext
*ev
,
258 struct rfkill
*rfkill
,
259 enum rfkill_operation op
)
263 ev
->idx
= rfkill
->idx
;
264 ev
->type
= rfkill
->type
;
267 spin_lock_irqsave(&rfkill
->lock
, flags
);
268 ev
->hard
= !!(rfkill
->state
& RFKILL_BLOCK_HW
);
269 ev
->soft
= !!(rfkill
->state
& (RFKILL_BLOCK_SW
|
270 RFKILL_BLOCK_SW_PREV
));
271 ev
->hard_block_reasons
= rfkill
->hard_block_reasons
;
272 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
275 static void rfkill_send_events(struct rfkill
*rfkill
, enum rfkill_operation op
)
277 struct rfkill_data
*data
;
278 struct rfkill_int_event
*ev
;
280 list_for_each_entry(data
, &rfkill_fds
, list
) {
281 ev
= kzalloc(sizeof(*ev
), GFP_KERNEL
);
284 rfkill_fill_event(&ev
->ev
, rfkill
, op
);
285 mutex_lock(&data
->mtx
);
286 list_add_tail(&ev
->list
, &data
->events
);
287 mutex_unlock(&data
->mtx
);
288 wake_up_interruptible(&data
->read_wait
);
292 static void rfkill_event(struct rfkill
*rfkill
)
294 if (!rfkill
->registered
)
297 kobject_uevent(&rfkill
->dev
.kobj
, KOBJ_CHANGE
);
299 /* also send event to /dev/rfkill */
300 rfkill_send_events(rfkill
, RFKILL_OP_CHANGE
);
304 * rfkill_set_block - wrapper for set_block method
306 * @rfkill: the rfkill struct to use
307 * @blocked: the new software state
309 * Calls the set_block method (when applicable) and handles notifications
312 static void rfkill_set_block(struct rfkill
*rfkill
, bool blocked
)
318 if (unlikely(rfkill
->dev
.power
.power_state
.event
& PM_EVENT_SLEEP
))
322 * Some platforms (...!) generate input events which affect the
323 * _hard_ kill state -- whenever something tries to change the
324 * current software state query the hardware state too.
326 if (rfkill
->ops
->query
)
327 rfkill
->ops
->query(rfkill
, rfkill
->data
);
329 spin_lock_irqsave(&rfkill
->lock
, flags
);
330 prev
= rfkill
->state
& RFKILL_BLOCK_SW
;
333 rfkill
->state
|= RFKILL_BLOCK_SW_PREV
;
335 rfkill
->state
&= ~RFKILL_BLOCK_SW_PREV
;
338 rfkill
->state
|= RFKILL_BLOCK_SW
;
340 rfkill
->state
&= ~RFKILL_BLOCK_SW
;
342 rfkill
->state
|= RFKILL_BLOCK_SW_SETCALL
;
343 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
345 err
= rfkill
->ops
->set_block(rfkill
->data
, blocked
);
347 spin_lock_irqsave(&rfkill
->lock
, flags
);
350 * Failed -- reset status to _PREV, which may be different
351 * from what we have set _PREV to earlier in this function
352 * if rfkill_set_sw_state was invoked.
354 if (rfkill
->state
& RFKILL_BLOCK_SW_PREV
)
355 rfkill
->state
|= RFKILL_BLOCK_SW
;
357 rfkill
->state
&= ~RFKILL_BLOCK_SW
;
359 rfkill
->state
&= ~RFKILL_BLOCK_SW_SETCALL
;
360 rfkill
->state
&= ~RFKILL_BLOCK_SW_PREV
;
361 curr
= rfkill
->state
& RFKILL_BLOCK_SW
;
362 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
364 rfkill_led_trigger_event(rfkill
);
365 rfkill_global_led_trigger_event();
368 rfkill_event(rfkill
);
371 static void rfkill_update_global_state(enum rfkill_type type
, bool blocked
)
375 if (type
!= RFKILL_TYPE_ALL
) {
376 rfkill_global_states
[type
].cur
= blocked
;
380 for (i
= 0; i
< NUM_RFKILL_TYPES
; i
++)
381 rfkill_global_states
[i
].cur
= blocked
;
384 #ifdef CONFIG_RFKILL_INPUT
385 static atomic_t rfkill_input_disabled
= ATOMIC_INIT(0);
388 * __rfkill_switch_all - Toggle state of all switches of given type
389 * @type: type of interfaces to be affected
390 * @blocked: the new state
392 * This function sets the state of all switches of given type,
393 * unless a specific switch is suspended.
395 * Caller must have acquired rfkill_global_mutex.
397 static void __rfkill_switch_all(const enum rfkill_type type
, bool blocked
)
399 struct rfkill
*rfkill
;
401 rfkill_update_global_state(type
, blocked
);
402 list_for_each_entry(rfkill
, &rfkill_list
, node
) {
403 if (rfkill
->type
!= type
&& type
!= RFKILL_TYPE_ALL
)
406 rfkill_set_block(rfkill
, blocked
);
411 * rfkill_switch_all - Toggle state of all switches of given type
412 * @type: type of interfaces to be affected
413 * @blocked: the new state
415 * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
416 * Please refer to __rfkill_switch_all() for details.
418 * Does nothing if the EPO lock is active.
420 void rfkill_switch_all(enum rfkill_type type
, bool blocked
)
422 if (atomic_read(&rfkill_input_disabled
))
425 mutex_lock(&rfkill_global_mutex
);
427 if (!rfkill_epo_lock_active
)
428 __rfkill_switch_all(type
, blocked
);
430 mutex_unlock(&rfkill_global_mutex
);
434 * rfkill_epo - emergency power off all transmitters
436 * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
437 * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
439 * The global state before the EPO is saved and can be restored later
440 * using rfkill_restore_states().
442 void rfkill_epo(void)
444 struct rfkill
*rfkill
;
447 if (atomic_read(&rfkill_input_disabled
))
450 mutex_lock(&rfkill_global_mutex
);
452 rfkill_epo_lock_active
= true;
453 list_for_each_entry(rfkill
, &rfkill_list
, node
)
454 rfkill_set_block(rfkill
, true);
456 for (i
= 0; i
< NUM_RFKILL_TYPES
; i
++) {
457 rfkill_global_states
[i
].sav
= rfkill_global_states
[i
].cur
;
458 rfkill_global_states
[i
].cur
= true;
461 mutex_unlock(&rfkill_global_mutex
);
465 * rfkill_restore_states - restore global states
467 * Restore (and sync switches to) the global state from the
468 * states in rfkill_default_states. This can undo the effects of
469 * a call to rfkill_epo().
471 void rfkill_restore_states(void)
475 if (atomic_read(&rfkill_input_disabled
))
478 mutex_lock(&rfkill_global_mutex
);
480 rfkill_epo_lock_active
= false;
481 for (i
= 0; i
< NUM_RFKILL_TYPES
; i
++)
482 __rfkill_switch_all(i
, rfkill_global_states
[i
].sav
);
483 mutex_unlock(&rfkill_global_mutex
);
487 * rfkill_remove_epo_lock - unlock state changes
489 * Used by rfkill-input manually unlock state changes, when
490 * the EPO switch is deactivated.
492 void rfkill_remove_epo_lock(void)
494 if (atomic_read(&rfkill_input_disabled
))
497 mutex_lock(&rfkill_global_mutex
);
498 rfkill_epo_lock_active
= false;
499 mutex_unlock(&rfkill_global_mutex
);
503 * rfkill_is_epo_lock_active - returns true EPO is active
505 * Returns 0 (false) if there is NOT an active EPO condition,
506 * and 1 (true) if there is an active EPO condition, which
507 * locks all radios in one of the BLOCKED states.
509 * Can be called in atomic context.
511 bool rfkill_is_epo_lock_active(void)
513 return rfkill_epo_lock_active
;
517 * rfkill_get_global_sw_state - returns global state for a type
518 * @type: the type to get the global state of
520 * Returns the current global state for a given wireless
523 bool rfkill_get_global_sw_state(const enum rfkill_type type
)
525 return rfkill_global_states
[type
].cur
;
529 bool rfkill_set_hw_state_reason(struct rfkill
*rfkill
,
530 bool blocked
, unsigned long reason
)
538 ~(RFKILL_HARD_BLOCK_SIGNAL
| RFKILL_HARD_BLOCK_NOT_OWNER
),
539 "hw_state reason not supported: 0x%lx", reason
))
542 spin_lock_irqsave(&rfkill
->lock
, flags
);
543 prev
= !!(rfkill
->hard_block_reasons
& reason
);
545 rfkill
->state
|= RFKILL_BLOCK_HW
;
546 rfkill
->hard_block_reasons
|= reason
;
548 rfkill
->hard_block_reasons
&= ~reason
;
549 if (!rfkill
->hard_block_reasons
)
550 rfkill
->state
&= ~RFKILL_BLOCK_HW
;
552 ret
= !!(rfkill
->state
& RFKILL_BLOCK_ANY
);
553 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
555 rfkill_led_trigger_event(rfkill
);
556 rfkill_global_led_trigger_event();
558 if (rfkill
->registered
&& prev
!= blocked
)
559 schedule_work(&rfkill
->uevent_work
);
563 EXPORT_SYMBOL(rfkill_set_hw_state_reason
);
565 static void __rfkill_set_sw_state(struct rfkill
*rfkill
, bool blocked
)
567 u32 bit
= RFKILL_BLOCK_SW
;
569 /* if in a ops->set_block right now, use other bit */
570 if (rfkill
->state
& RFKILL_BLOCK_SW_SETCALL
)
571 bit
= RFKILL_BLOCK_SW_PREV
;
574 rfkill
->state
|= bit
;
576 rfkill
->state
&= ~bit
;
579 bool rfkill_set_sw_state(struct rfkill
*rfkill
, bool blocked
)
586 spin_lock_irqsave(&rfkill
->lock
, flags
);
587 prev
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
588 __rfkill_set_sw_state(rfkill
, blocked
);
589 hwblock
= !!(rfkill
->state
& RFKILL_BLOCK_HW
);
590 blocked
= blocked
|| hwblock
;
591 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
593 if (!rfkill
->registered
)
596 if (prev
!= blocked
&& !hwblock
)
597 schedule_work(&rfkill
->uevent_work
);
599 rfkill_led_trigger_event(rfkill
);
600 rfkill_global_led_trigger_event();
604 EXPORT_SYMBOL(rfkill_set_sw_state
);
606 void rfkill_init_sw_state(struct rfkill
*rfkill
, bool blocked
)
611 BUG_ON(rfkill
->registered
);
613 spin_lock_irqsave(&rfkill
->lock
, flags
);
614 __rfkill_set_sw_state(rfkill
, blocked
);
615 rfkill
->persistent
= true;
616 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
618 EXPORT_SYMBOL(rfkill_init_sw_state
);
620 void rfkill_set_states(struct rfkill
*rfkill
, bool sw
, bool hw
)
627 spin_lock_irqsave(&rfkill
->lock
, flags
);
630 * No need to care about prev/setblock ... this is for uevent only
631 * and that will get triggered by rfkill_set_block anyway.
633 swprev
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
634 hwprev
= !!(rfkill
->state
& RFKILL_BLOCK_HW
);
635 __rfkill_set_sw_state(rfkill
, sw
);
637 rfkill
->state
|= RFKILL_BLOCK_HW
;
639 rfkill
->state
&= ~RFKILL_BLOCK_HW
;
641 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
643 if (!rfkill
->registered
) {
644 rfkill
->persistent
= true;
646 if (swprev
!= sw
|| hwprev
!= hw
)
647 schedule_work(&rfkill
->uevent_work
);
649 rfkill_led_trigger_event(rfkill
);
650 rfkill_global_led_trigger_event();
653 EXPORT_SYMBOL(rfkill_set_states
);
655 static const char * const rfkill_types
[] = {
656 NULL
, /* RFKILL_TYPE_ALL */
667 enum rfkill_type
rfkill_find_type(const char *name
)
671 BUILD_BUG_ON(ARRAY_SIZE(rfkill_types
) != NUM_RFKILL_TYPES
);
674 return RFKILL_TYPE_ALL
;
676 for (i
= 1; i
< NUM_RFKILL_TYPES
; i
++)
677 if (!strcmp(name
, rfkill_types
[i
]))
679 return RFKILL_TYPE_ALL
;
681 EXPORT_SYMBOL(rfkill_find_type
);
683 static ssize_t
name_show(struct device
*dev
, struct device_attribute
*attr
,
686 struct rfkill
*rfkill
= to_rfkill(dev
);
688 return sprintf(buf
, "%s\n", rfkill
->name
);
690 static DEVICE_ATTR_RO(name
);
692 static ssize_t
type_show(struct device
*dev
, struct device_attribute
*attr
,
695 struct rfkill
*rfkill
= to_rfkill(dev
);
697 return sprintf(buf
, "%s\n", rfkill_types
[rfkill
->type
]);
699 static DEVICE_ATTR_RO(type
);
701 static ssize_t
index_show(struct device
*dev
, struct device_attribute
*attr
,
704 struct rfkill
*rfkill
= to_rfkill(dev
);
706 return sprintf(buf
, "%d\n", rfkill
->idx
);
708 static DEVICE_ATTR_RO(index
);
710 static ssize_t
persistent_show(struct device
*dev
,
711 struct device_attribute
*attr
, char *buf
)
713 struct rfkill
*rfkill
= to_rfkill(dev
);
715 return sprintf(buf
, "%d\n", rfkill
->persistent
);
717 static DEVICE_ATTR_RO(persistent
);
719 static ssize_t
hard_show(struct device
*dev
, struct device_attribute
*attr
,
722 struct rfkill
*rfkill
= to_rfkill(dev
);
724 return sprintf(buf
, "%d\n", (rfkill
->state
& RFKILL_BLOCK_HW
) ? 1 : 0 );
726 static DEVICE_ATTR_RO(hard
);
728 static ssize_t
soft_show(struct device
*dev
, struct device_attribute
*attr
,
731 struct rfkill
*rfkill
= to_rfkill(dev
);
733 return sprintf(buf
, "%d\n", (rfkill
->state
& RFKILL_BLOCK_SW
) ? 1 : 0 );
736 static ssize_t
soft_store(struct device
*dev
, struct device_attribute
*attr
,
737 const char *buf
, size_t count
)
739 struct rfkill
*rfkill
= to_rfkill(dev
);
743 if (!capable(CAP_NET_ADMIN
))
746 err
= kstrtoul(buf
, 0, &state
);
753 mutex_lock(&rfkill_global_mutex
);
754 rfkill_set_block(rfkill
, state
);
755 mutex_unlock(&rfkill_global_mutex
);
759 static DEVICE_ATTR_RW(soft
);
761 static ssize_t
hard_block_reasons_show(struct device
*dev
,
762 struct device_attribute
*attr
,
765 struct rfkill
*rfkill
= to_rfkill(dev
);
767 return sprintf(buf
, "0x%lx\n", rfkill
->hard_block_reasons
);
769 static DEVICE_ATTR_RO(hard_block_reasons
);
771 static u8
user_state_from_blocked(unsigned long state
)
773 if (state
& RFKILL_BLOCK_HW
)
774 return RFKILL_USER_STATE_HARD_BLOCKED
;
775 if (state
& RFKILL_BLOCK_SW
)
776 return RFKILL_USER_STATE_SOFT_BLOCKED
;
778 return RFKILL_USER_STATE_UNBLOCKED
;
781 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*attr
,
784 struct rfkill
*rfkill
= to_rfkill(dev
);
786 return sprintf(buf
, "%d\n", user_state_from_blocked(rfkill
->state
));
789 static ssize_t
state_store(struct device
*dev
, struct device_attribute
*attr
,
790 const char *buf
, size_t count
)
792 struct rfkill
*rfkill
= to_rfkill(dev
);
796 if (!capable(CAP_NET_ADMIN
))
799 err
= kstrtoul(buf
, 0, &state
);
803 if (state
!= RFKILL_USER_STATE_SOFT_BLOCKED
&&
804 state
!= RFKILL_USER_STATE_UNBLOCKED
)
807 mutex_lock(&rfkill_global_mutex
);
808 rfkill_set_block(rfkill
, state
== RFKILL_USER_STATE_SOFT_BLOCKED
);
809 mutex_unlock(&rfkill_global_mutex
);
813 static DEVICE_ATTR_RW(state
);
815 static struct attribute
*rfkill_dev_attrs
[] = {
818 &dev_attr_index
.attr
,
819 &dev_attr_persistent
.attr
,
820 &dev_attr_state
.attr
,
823 &dev_attr_hard_block_reasons
.attr
,
826 ATTRIBUTE_GROUPS(rfkill_dev
);
828 static void rfkill_release(struct device
*dev
)
830 struct rfkill
*rfkill
= to_rfkill(dev
);
835 static int rfkill_dev_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
837 struct rfkill
*rfkill
= to_rfkill(dev
);
839 unsigned long reasons
;
843 error
= add_uevent_var(env
, "RFKILL_NAME=%s", rfkill
->name
);
846 error
= add_uevent_var(env
, "RFKILL_TYPE=%s",
847 rfkill_types
[rfkill
->type
]);
850 spin_lock_irqsave(&rfkill
->lock
, flags
);
851 state
= rfkill
->state
;
852 reasons
= rfkill
->hard_block_reasons
;
853 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
854 error
= add_uevent_var(env
, "RFKILL_STATE=%d",
855 user_state_from_blocked(state
));
858 return add_uevent_var(env
, "RFKILL_HW_BLOCK_REASON=0x%lx", reasons
);
861 void rfkill_pause_polling(struct rfkill
*rfkill
)
865 if (!rfkill
->ops
->poll
)
868 rfkill
->polling_paused
= true;
869 cancel_delayed_work_sync(&rfkill
->poll_work
);
871 EXPORT_SYMBOL(rfkill_pause_polling
);
873 void rfkill_resume_polling(struct rfkill
*rfkill
)
877 if (!rfkill
->ops
->poll
)
880 rfkill
->polling_paused
= false;
882 if (rfkill
->suspended
)
885 queue_delayed_work(system_power_efficient_wq
,
886 &rfkill
->poll_work
, 0);
888 EXPORT_SYMBOL(rfkill_resume_polling
);
890 #ifdef CONFIG_PM_SLEEP
891 static int rfkill_suspend(struct device
*dev
)
893 struct rfkill
*rfkill
= to_rfkill(dev
);
895 rfkill
->suspended
= true;
896 cancel_delayed_work_sync(&rfkill
->poll_work
);
901 static int rfkill_resume(struct device
*dev
)
903 struct rfkill
*rfkill
= to_rfkill(dev
);
906 rfkill
->suspended
= false;
908 if (!rfkill
->registered
)
911 if (!rfkill
->persistent
) {
912 cur
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
913 rfkill_set_block(rfkill
, cur
);
916 if (rfkill
->ops
->poll
&& !rfkill
->polling_paused
)
917 queue_delayed_work(system_power_efficient_wq
,
918 &rfkill
->poll_work
, 0);
923 static SIMPLE_DEV_PM_OPS(rfkill_pm_ops
, rfkill_suspend
, rfkill_resume
);
924 #define RFKILL_PM_OPS (&rfkill_pm_ops)
926 #define RFKILL_PM_OPS NULL
929 static struct class rfkill_class
= {
931 .dev_release
= rfkill_release
,
932 .dev_groups
= rfkill_dev_groups
,
933 .dev_uevent
= rfkill_dev_uevent
,
937 bool rfkill_blocked(struct rfkill
*rfkill
)
942 spin_lock_irqsave(&rfkill
->lock
, flags
);
943 state
= rfkill
->state
;
944 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
946 return !!(state
& RFKILL_BLOCK_ANY
);
948 EXPORT_SYMBOL(rfkill_blocked
);
950 bool rfkill_soft_blocked(struct rfkill
*rfkill
)
955 spin_lock_irqsave(&rfkill
->lock
, flags
);
956 state
= rfkill
->state
;
957 spin_unlock_irqrestore(&rfkill
->lock
, flags
);
959 return !!(state
& RFKILL_BLOCK_SW
);
961 EXPORT_SYMBOL(rfkill_soft_blocked
);
963 struct rfkill
* __must_check
rfkill_alloc(const char *name
,
964 struct device
*parent
,
965 const enum rfkill_type type
,
966 const struct rfkill_ops
*ops
,
969 struct rfkill
*rfkill
;
975 if (WARN_ON(!ops
->set_block
))
981 if (WARN_ON(type
== RFKILL_TYPE_ALL
|| type
>= NUM_RFKILL_TYPES
))
984 rfkill
= kzalloc(sizeof(*rfkill
) + strlen(name
) + 1, GFP_KERNEL
);
988 spin_lock_init(&rfkill
->lock
);
989 INIT_LIST_HEAD(&rfkill
->node
);
991 strcpy(rfkill
->name
, name
);
993 rfkill
->data
= ops_data
;
996 dev
->class = &rfkill_class
;
997 dev
->parent
= parent
;
998 device_initialize(dev
);
1002 EXPORT_SYMBOL(rfkill_alloc
);
1004 static void rfkill_poll(struct work_struct
*work
)
1006 struct rfkill
*rfkill
;
1008 rfkill
= container_of(work
, struct rfkill
, poll_work
.work
);
1011 * Poll hardware state -- driver will use one of the
1012 * rfkill_set{,_hw,_sw}_state functions and use its
1013 * return value to update the current status.
1015 rfkill
->ops
->poll(rfkill
, rfkill
->data
);
1017 queue_delayed_work(system_power_efficient_wq
,
1019 round_jiffies_relative(POLL_INTERVAL
));
1022 static void rfkill_uevent_work(struct work_struct
*work
)
1024 struct rfkill
*rfkill
;
1026 rfkill
= container_of(work
, struct rfkill
, uevent_work
);
1028 mutex_lock(&rfkill_global_mutex
);
1029 rfkill_event(rfkill
);
1030 mutex_unlock(&rfkill_global_mutex
);
1033 static void rfkill_sync_work(struct work_struct
*work
)
1035 struct rfkill
*rfkill
;
1038 rfkill
= container_of(work
, struct rfkill
, sync_work
);
1040 mutex_lock(&rfkill_global_mutex
);
1041 cur
= rfkill_global_states
[rfkill
->type
].cur
;
1042 rfkill_set_block(rfkill
, cur
);
1043 mutex_unlock(&rfkill_global_mutex
);
1046 int __must_check
rfkill_register(struct rfkill
*rfkill
)
1048 static unsigned long rfkill_no
;
1057 mutex_lock(&rfkill_global_mutex
);
1059 if (rfkill
->registered
) {
1064 rfkill
->idx
= rfkill_no
;
1065 dev_set_name(dev
, "rfkill%lu", rfkill_no
);
1068 list_add_tail(&rfkill
->node
, &rfkill_list
);
1070 error
= device_add(dev
);
1074 error
= rfkill_led_trigger_register(rfkill
);
1078 rfkill
->registered
= true;
1080 INIT_DELAYED_WORK(&rfkill
->poll_work
, rfkill_poll
);
1081 INIT_WORK(&rfkill
->uevent_work
, rfkill_uevent_work
);
1082 INIT_WORK(&rfkill
->sync_work
, rfkill_sync_work
);
1084 if (rfkill
->ops
->poll
)
1085 queue_delayed_work(system_power_efficient_wq
,
1087 round_jiffies_relative(POLL_INTERVAL
));
1089 if (!rfkill
->persistent
|| rfkill_epo_lock_active
) {
1090 schedule_work(&rfkill
->sync_work
);
1092 #ifdef CONFIG_RFKILL_INPUT
1093 bool soft_blocked
= !!(rfkill
->state
& RFKILL_BLOCK_SW
);
1095 if (!atomic_read(&rfkill_input_disabled
))
1096 __rfkill_switch_all(rfkill
->type
, soft_blocked
);
1100 rfkill_global_led_trigger_event();
1101 rfkill_send_events(rfkill
, RFKILL_OP_ADD
);
1103 mutex_unlock(&rfkill_global_mutex
);
1107 device_del(&rfkill
->dev
);
1109 list_del_init(&rfkill
->node
);
1111 mutex_unlock(&rfkill_global_mutex
);
1114 EXPORT_SYMBOL(rfkill_register
);
1116 void rfkill_unregister(struct rfkill
*rfkill
)
1120 if (rfkill
->ops
->poll
)
1121 cancel_delayed_work_sync(&rfkill
->poll_work
);
1123 cancel_work_sync(&rfkill
->uevent_work
);
1124 cancel_work_sync(&rfkill
->sync_work
);
1126 rfkill
->registered
= false;
1128 device_del(&rfkill
->dev
);
1130 mutex_lock(&rfkill_global_mutex
);
1131 rfkill_send_events(rfkill
, RFKILL_OP_DEL
);
1132 list_del_init(&rfkill
->node
);
1133 rfkill_global_led_trigger_event();
1134 mutex_unlock(&rfkill_global_mutex
);
1136 rfkill_led_trigger_unregister(rfkill
);
1138 EXPORT_SYMBOL(rfkill_unregister
);
1140 void rfkill_destroy(struct rfkill
*rfkill
)
1143 put_device(&rfkill
->dev
);
1145 EXPORT_SYMBOL(rfkill_destroy
);
1147 static int rfkill_fop_open(struct inode
*inode
, struct file
*file
)
1149 struct rfkill_data
*data
;
1150 struct rfkill
*rfkill
;
1151 struct rfkill_int_event
*ev
, *tmp
;
1153 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
1157 data
->max_size
= RFKILL_EVENT_SIZE_V1
;
1159 INIT_LIST_HEAD(&data
->events
);
1160 mutex_init(&data
->mtx
);
1161 init_waitqueue_head(&data
->read_wait
);
1163 mutex_lock(&rfkill_global_mutex
);
1164 mutex_lock(&data
->mtx
);
1166 * start getting events from elsewhere but hold mtx to get
1167 * startup events added first
1170 list_for_each_entry(rfkill
, &rfkill_list
, node
) {
1171 ev
= kzalloc(sizeof(*ev
), GFP_KERNEL
);
1174 rfkill_fill_event(&ev
->ev
, rfkill
, RFKILL_OP_ADD
);
1175 list_add_tail(&ev
->list
, &data
->events
);
1177 list_add(&data
->list
, &rfkill_fds
);
1178 mutex_unlock(&data
->mtx
);
1179 mutex_unlock(&rfkill_global_mutex
);
1181 file
->private_data
= data
;
1183 return stream_open(inode
, file
);
1186 mutex_unlock(&data
->mtx
);
1187 mutex_unlock(&rfkill_global_mutex
);
1188 mutex_destroy(&data
->mtx
);
1189 list_for_each_entry_safe(ev
, tmp
, &data
->events
, list
)
1195 static __poll_t
rfkill_fop_poll(struct file
*file
, poll_table
*wait
)
1197 struct rfkill_data
*data
= file
->private_data
;
1198 __poll_t res
= EPOLLOUT
| EPOLLWRNORM
;
1200 poll_wait(file
, &data
->read_wait
, wait
);
1202 mutex_lock(&data
->mtx
);
1203 if (!list_empty(&data
->events
))
1204 res
= EPOLLIN
| EPOLLRDNORM
;
1205 mutex_unlock(&data
->mtx
);
1210 static ssize_t
rfkill_fop_read(struct file
*file
, char __user
*buf
,
1211 size_t count
, loff_t
*pos
)
1213 struct rfkill_data
*data
= file
->private_data
;
1214 struct rfkill_int_event
*ev
;
1218 mutex_lock(&data
->mtx
);
1220 while (list_empty(&data
->events
)) {
1221 if (file
->f_flags
& O_NONBLOCK
) {
1225 mutex_unlock(&data
->mtx
);
1226 /* since we re-check and it just compares pointers,
1227 * using !list_empty() without locking isn't a problem
1229 ret
= wait_event_interruptible(data
->read_wait
,
1230 !list_empty(&data
->events
));
1231 mutex_lock(&data
->mtx
);
1237 ev
= list_first_entry(&data
->events
, struct rfkill_int_event
,
1240 sz
= min_t(unsigned long, sizeof(ev
->ev
), count
);
1241 sz
= min_t(unsigned long, sz
, data
->max_size
);
1243 if (copy_to_user(buf
, &ev
->ev
, sz
))
1246 list_del(&ev
->list
);
1249 mutex_unlock(&data
->mtx
);
1253 static ssize_t
rfkill_fop_write(struct file
*file
, const char __user
*buf
,
1254 size_t count
, loff_t
*pos
)
1256 struct rfkill_data
*data
= file
->private_data
;
1257 struct rfkill
*rfkill
;
1258 struct rfkill_event_ext ev
;
1261 /* we don't need the 'hard' variable but accept it */
1262 if (count
< RFKILL_EVENT_SIZE_V1
- 1)
1266 * Copy as much data as we can accept into our 'ev' buffer,
1267 * but tell userspace how much we've copied so it can determine
1268 * our API version even in a write() call, if it cares.
1270 count
= min(count
, sizeof(ev
));
1271 count
= min_t(size_t, count
, data
->max_size
);
1272 if (copy_from_user(&ev
, buf
, count
))
1275 if (ev
.type
>= NUM_RFKILL_TYPES
)
1278 mutex_lock(&rfkill_global_mutex
);
1281 case RFKILL_OP_CHANGE_ALL
:
1282 rfkill_update_global_state(ev
.type
, ev
.soft
);
1283 list_for_each_entry(rfkill
, &rfkill_list
, node
)
1284 if (rfkill
->type
== ev
.type
||
1285 ev
.type
== RFKILL_TYPE_ALL
)
1286 rfkill_set_block(rfkill
, ev
.soft
);
1289 case RFKILL_OP_CHANGE
:
1290 list_for_each_entry(rfkill
, &rfkill_list
, node
)
1291 if (rfkill
->idx
== ev
.idx
&&
1292 (rfkill
->type
== ev
.type
||
1293 ev
.type
== RFKILL_TYPE_ALL
))
1294 rfkill_set_block(rfkill
, ev
.soft
);
1302 mutex_unlock(&rfkill_global_mutex
);
1304 return ret
?: count
;
1307 static int rfkill_fop_release(struct inode
*inode
, struct file
*file
)
1309 struct rfkill_data
*data
= file
->private_data
;
1310 struct rfkill_int_event
*ev
, *tmp
;
1312 mutex_lock(&rfkill_global_mutex
);
1313 list_del(&data
->list
);
1314 mutex_unlock(&rfkill_global_mutex
);
1316 mutex_destroy(&data
->mtx
);
1317 list_for_each_entry_safe(ev
, tmp
, &data
->events
, list
)
1320 #ifdef CONFIG_RFKILL_INPUT
1321 if (data
->input_handler
)
1322 if (atomic_dec_return(&rfkill_input_disabled
) == 0)
1323 printk(KERN_DEBUG
"rfkill: input handler enabled\n");
1331 static long rfkill_fop_ioctl(struct file
*file
, unsigned int cmd
,
1334 struct rfkill_data
*data
= file
->private_data
;
1338 if (_IOC_TYPE(cmd
) != RFKILL_IOC_MAGIC
)
1341 mutex_lock(&data
->mtx
);
1342 switch (_IOC_NR(cmd
)) {
1343 #ifdef CONFIG_RFKILL_INPUT
1344 case RFKILL_IOC_NOINPUT
:
1345 if (!data
->input_handler
) {
1346 if (atomic_inc_return(&rfkill_input_disabled
) == 1)
1347 printk(KERN_DEBUG
"rfkill: input handler disabled\n");
1348 data
->input_handler
= true;
1353 case RFKILL_IOC_MAX_SIZE
:
1354 if (get_user(size
, (__u32 __user
*)arg
)) {
1358 if (size
< RFKILL_EVENT_SIZE_V1
|| size
> U8_MAX
) {
1362 data
->max_size
= size
;
1368 mutex_unlock(&data
->mtx
);
1373 static const struct file_operations rfkill_fops
= {
1374 .owner
= THIS_MODULE
,
1375 .open
= rfkill_fop_open
,
1376 .read
= rfkill_fop_read
,
1377 .write
= rfkill_fop_write
,
1378 .poll
= rfkill_fop_poll
,
1379 .release
= rfkill_fop_release
,
1380 .unlocked_ioctl
= rfkill_fop_ioctl
,
1381 .compat_ioctl
= compat_ptr_ioctl
,
1382 .llseek
= no_llseek
,
1385 #define RFKILL_NAME "rfkill"
1387 static struct miscdevice rfkill_miscdev
= {
1388 .fops
= &rfkill_fops
,
1389 .name
= RFKILL_NAME
,
1390 .minor
= RFKILL_MINOR
,
1393 static int __init
rfkill_init(void)
1397 rfkill_update_global_state(RFKILL_TYPE_ALL
, !rfkill_default_state
);
1399 error
= class_register(&rfkill_class
);
1403 error
= misc_register(&rfkill_miscdev
);
1407 error
= rfkill_global_led_trigger_register();
1409 goto error_led_trigger
;
1411 #ifdef CONFIG_RFKILL_INPUT
1412 error
= rfkill_handler_init();
1419 #ifdef CONFIG_RFKILL_INPUT
1421 rfkill_global_led_trigger_unregister();
1424 misc_deregister(&rfkill_miscdev
);
1426 class_unregister(&rfkill_class
);
1430 subsys_initcall(rfkill_init
);
1432 static void __exit
rfkill_exit(void)
1434 #ifdef CONFIG_RFKILL_INPUT
1435 rfkill_handler_exit();
1437 rfkill_global_led_trigger_unregister();
1438 misc_deregister(&rfkill_miscdev
);
1439 class_unregister(&rfkill_class
);
1441 module_exit(rfkill_exit
);
1443 MODULE_ALIAS_MISCDEV(RFKILL_MINOR
);
1444 MODULE_ALIAS("devname:" RFKILL_NAME
);