rfkill: use killable locks instead of interruptible

[safe/jmp/linux-2.6] / net / rfkill / rfkill-input.c

diff --git a/net/rfkill/rfkill-input.c b/net/rfkill/rfkill-input.c
index 29c13d3..bfdade7 100644 (file)
--- a/net/rfkill/rfkill-input.c
+++ b/net/rfkill/rfkill-input.c
@@ -16,6 +16,7 @@
 #include <linux/workqueue.h>
 #include <linux/init.h>
 #include <linux/rfkill.h>
+#include <linux/sched.h>
 
 #include "rfkill-input.h"
 
@@ -30,36 +31,39 @@ struct rfkill_task {
        spinlock_t lock; /* for accessing last and desired state */
        unsigned long last; /* last schedule */
        enum rfkill_state desired_state; /* on/off */
-       enum rfkill_state current_state; /* on/off */
 };
 
 static void rfkill_task_handler(struct work_struct *work)
 {
        struct rfkill_task *task = container_of(work, struct rfkill_task, work);
-       enum rfkill_state state;
 
        mutex_lock(&task->mutex);
 
-       /*
-        * Use temp variable to fetch desired state to keep it
-        * consistent even if rfkill_schedule_toggle() runs in
-        * another thread or interrupts us.
-        */
-       state = task->desired_state;
-
-       if (state != task->current_state) {
-               rfkill_switch_all(task->type, state);
-               task->current_state = state;
-       }
+       rfkill_switch_all(task->type, task->desired_state);
 
        mutex_unlock(&task->mutex);
 }
 
+static void rfkill_task_epo_handler(struct work_struct *work)
+{
+       rfkill_epo();
+}
+
+static DECLARE_WORK(epo_work, rfkill_task_epo_handler);
+
+static void rfkill_schedule_epo(void)
+{
+       schedule_work(&epo_work);
+}
+
 static void rfkill_schedule_set(struct rfkill_task *task,
                                enum rfkill_state desired_state)
 {
        unsigned long flags;
 
+       if (unlikely(work_pending(&epo_work)))
+               return;
+
        spin_lock_irqsave(&task->lock, flags);
 
        if (time_after(jiffies, task->last + msecs_to_jiffies(200))) {
@@ -75,10 +79,14 @@ static void rfkill_schedule_toggle(struct rfkill_task *task)
 {
        unsigned long flags;
 
+       if (unlikely(work_pending(&epo_work)))
+               return;
+
        spin_lock_irqsave(&task->lock, flags);
 
        if (time_after(jiffies, task->last + msecs_to_jiffies(200))) {
-               task->desired_state = !task->desired_state;
+               task->desired_state =
+                               rfkill_state_complement(task->desired_state);
                task->last = jiffies;
                schedule_work(&task->work);
        }
@@ -86,15 +94,14 @@ static void rfkill_schedule_toggle(struct rfkill_task *task)
        spin_unlock_irqrestore(&task->lock, flags);
 }
 
-#define DEFINE_RFKILL_TASK(n, t)                       \
-       struct rfkill_task n = {                        \
-               .work = __WORK_INITIALIZER(n.work,      \
-                               rfkill_task_handler),   \
-               .type = t,                              \
-               .mutex = __MUTEX_INITIALIZER(n.mutex),  \
-               .lock = __SPIN_LOCK_UNLOCKED(n.lock),   \
-               .desired_state = RFKILL_STATE_ON,       \
-               .current_state = RFKILL_STATE_ON,       \
+#define DEFINE_RFKILL_TASK(n, t)                               \
+       struct rfkill_task n = {                                \
+               .work = __WORK_INITIALIZER(n.work,              \
+                               rfkill_task_handler),           \
+               .type = t,                                      \
+               .mutex = __MUTEX_INITIALIZER(n.mutex),          \
+               .lock = __SPIN_LOCK_UNLOCKED(n.lock),           \
+               .desired_state = RFKILL_STATE_UNBLOCKED,        \
        }
 
 static DEFINE_RFKILL_TASK(rfkill_wlan, RFKILL_TYPE_WLAN);
@@ -103,6 +110,25 @@ static DEFINE_RFKILL_TASK(rfkill_uwb, RFKILL_TYPE_UWB);
 static DEFINE_RFKILL_TASK(rfkill_wimax, RFKILL_TYPE_WIMAX);
 static DEFINE_RFKILL_TASK(rfkill_wwan, RFKILL_TYPE_WWAN);
 
+static void rfkill_schedule_evsw_rfkillall(int state)
+{
+       /* EVERY radio type. state != 0 means radios ON */
+       /* handle EPO (emergency power off) through shortcut */
+       if (state) {
+               rfkill_schedule_set(&rfkill_wwan,
+                                   RFKILL_STATE_UNBLOCKED);
+               rfkill_schedule_set(&rfkill_wimax,
+                                   RFKILL_STATE_UNBLOCKED);
+               rfkill_schedule_set(&rfkill_uwb,
+                                   RFKILL_STATE_UNBLOCKED);
+               rfkill_schedule_set(&rfkill_bt,
+                                   RFKILL_STATE_UNBLOCKED);
+               rfkill_schedule_set(&rfkill_wlan,
+                                   RFKILL_STATE_UNBLOCKED);
+       } else
+               rfkill_schedule_epo();
+}
+
 static void rfkill_event(struct input_handle *handle, unsigned int type,
                        unsigned int code, int data)
 {
@@ -126,22 +152,7 @@ static void rfkill_event(struct input_handle *handle, unsigned int type,
        } else if (type == EV_SW) {
                switch (code) {
                case SW_RFKILL_ALL:
-                       /* EVERY radio type. data != 0 means radios ON */
-                       rfkill_schedule_set(&rfkill_wwan,
-                                           (data)? RFKILL_STATE_ON:
-                                                   RFKILL_STATE_OFF);
-                       rfkill_schedule_set(&rfkill_wimax,
-                                           (data)? RFKILL_STATE_ON:
-                                                   RFKILL_STATE_OFF);
-                       rfkill_schedule_set(&rfkill_uwb,
-                                           (data)? RFKILL_STATE_ON:
-                                                   RFKILL_STATE_OFF);
-                       rfkill_schedule_set(&rfkill_bt,
-                                           (data)? RFKILL_STATE_ON:
-                                                   RFKILL_STATE_OFF);
-                       rfkill_schedule_set(&rfkill_wlan,
-                                           (data)? RFKILL_STATE_ON:
-                                                   RFKILL_STATE_OFF);
+                       rfkill_schedule_evsw_rfkillall(data);
                        break;
                default:
                        break;
@@ -163,6 +174,7 @@ static int rfkill_connect(struct input_handler *handler, struct input_dev *dev,
        handle->handler = handler;
        handle->name = "rfkill";
 
+       /* causes rfkill_start() to be called */
        error = input_register_handle(handle);
        if (error)
                goto err_free_handle;
@@ -180,6 +192,23 @@ static int rfkill_connect(struct input_handler *handler, struct input_dev *dev,
        return error;
 }
 
+static void rfkill_start(struct input_handle *handle)
+{
+       /* Take event_lock to guard against configuration changes, we
+        * should be able to deal with concurrency with rfkill_event()
+        * just fine (which event_lock will also avoid). */
+       spin_lock_irq(&handle->dev->event_lock);
+
+       if (test_bit(EV_SW, handle->dev->evbit)) {
+               if (test_bit(SW_RFKILL_ALL, handle->dev->swbit))
+                       rfkill_schedule_evsw_rfkillall(test_bit(SW_RFKILL_ALL,
+                                                       handle->dev->sw));
+               /* add resync for further EV_SW events here */
+       }
+
+       spin_unlock_irq(&handle->dev->event_lock);
+}
+
 static void rfkill_disconnect(struct input_handle *handle)
 {
        input_close_device(handle);
@@ -220,12 +249,18 @@ static struct input_handler rfkill_handler = {
        .event =        rfkill_event,
        .connect =      rfkill_connect,
        .disconnect =   rfkill_disconnect,
+       .start =        rfkill_start,
        .name =         "rfkill",
        .id_table =     rfkill_ids,
 };
 
 static int __init rfkill_handler_init(void)
 {
+       unsigned long last_run = jiffies - msecs_to_jiffies(500);
+       rfkill_wlan.last = last_run;
+       rfkill_bt.last = last_run;
+       rfkill_uwb.last = last_run;
+       rfkill_wimax.last = last_run;
        return input_register_handler(&rfkill_handler);
 }