rfkill: rewrite

This patch completely rewrites the rfkill core to address
the following deficiencies:

 * all rfkill drivers need to implement polling where necessary
   rather than having one central implementation

 * updating the rfkill state cannot be done from arbitrary
   contexts, forcing drivers to use schedule_work and requiring
   lots of code

 * rfkill drivers need to keep track of soft/hard blocked
   internally -- the core should do this

 * the rfkill API has many unexpected quirks, for example being
   asymmetric wrt. alloc/free and register/unregister

 * rfkill can call back into a driver from within a function the
   driver called -- this is prone to deadlocks and generally
   should be avoided

 * rfkill-input pointlessly is a separate module

 * drivers need to #ifdef rfkill functions (unless they want to
   depend on or select RFKILL) -- rfkill should provide inlines
   that do nothing if it isn't compiled in

 * the rfkill structure is not opaque -- drivers need to initialise
   it correctly (lots of sanity checking code required) -- instead
   force drivers to pass the right variables to rfkill_alloc()

 * the documentation is hard to read because it always assumes the
   reader is completely clueless and contains way TOO MANY CAPS

 * the rfkill code needlessly uses a lot of locks and atomic
   operations in locked sections

 * fix LED trigger to actually change the LED when the radio state
   changes -- this wasn't done before

Tested-by: Alan Jenkins <alan-jenkins@tuffmail.co.uk>
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br> [thinkpad]
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 29 insertions, 70 deletions

diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 353a898c3693..1208d0cedd15 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -299,39 +299,22 @@ static int update_bl_status(struct backlight_device *bd)
  * Rfkill helpers
  */
 
-static int eeepc_wlan_rfkill_set(void *data, enum rfkill_state state)
-{
-        if (state == RFKILL_STATE_SOFT_BLOCKED)
-                return set_acpi(CM_ASL_WLAN, 0);
-        else
-                return set_acpi(CM_ASL_WLAN, 1);
-}
-
-static int eeepc_wlan_rfkill_state(void *data, enum rfkill_state *state)
+static bool eeepc_wlan_rfkill_blocked(void)
 {
         if (get_acpi(CM_ASL_WLAN) == 1)
-                *state = RFKILL_STATE_UNBLOCKED;
-        else
-                *state = RFKILL_STATE_SOFT_BLOCKED;
-        return 0;
+                return false;
+        return true;
 }
 
-static int eeepc_bluetooth_rfkill_set(void *data, enum rfkill_state state)
+static int eeepc_rfkill_set(void *data, bool blocked)
 {
-        if (state == RFKILL_STATE_SOFT_BLOCKED)
-                return set_acpi(CM_ASL_BLUETOOTH, 0);
-        else
-                return set_acpi(CM_ASL_BLUETOOTH, 1);
+        unsigned long asl = (unsigned long)data;
+        return set_acpi(asl, !blocked);
 }
 
-static int eeepc_bluetooth_rfkill_state(void *data, enum rfkill_state *state)
-{
-        if (get_acpi(CM_ASL_BLUETOOTH) == 1)
-                *state = RFKILL_STATE_UNBLOCKED;
-        else
-                *state = RFKILL_STATE_SOFT_BLOCKED;
-        return 0;
-}
+static const struct rfkill_ops eeepc_rfkill_ops = {
+        .set_block = eeepc_rfkill_set,
+};
 
 /*
  * Sys helpers
@@ -531,9 +514,9 @@ static int notify_brn(void)
 
 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
 {
-        enum rfkill_state state;
         struct pci_dev *dev;
         struct pci_bus *bus = pci_find_bus(0, 1);
+        bool blocked;
 
         if (event != ACPI_NOTIFY_BUS_CHECK)
                 return;
@@ -543,9 +526,8 @@ static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
                 return;
         }
 
-        eeepc_wlan_rfkill_state(ehotk->eeepc_wlan_rfkill, &state);
-
-        if (state == RFKILL_STATE_UNBLOCKED) {
+        blocked = eeepc_wlan_rfkill_blocked();
+        if (!blocked) {
                 dev = pci_get_slot(bus, 0);
                 if (dev) {
                         /* Device already present */
@@ -566,7 +548,7 @@ static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
                 }
         }
 
-        rfkill_force_state(ehotk->eeepc_wlan_rfkill, state);
+        rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill, blocked);
 }
 
 static void eeepc_hotk_notify(acpi_handle handle, u32 event, void *data)
@@ -684,26 +666,17 @@ static int eeepc_hotk_add(struct acpi_device *device)
         eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
 
         if (get_acpi(CM_ASL_WLAN) != -1) {
-                ehotk->eeepc_wlan_rfkill = rfkill_allocate(&device->dev,
-                                                           RFKILL_TYPE_WLAN);
+                ehotk->eeepc_wlan_rfkill = rfkill_alloc("eeepc-wlan",
+                                                        &device->dev,
+                                                        RFKILL_TYPE_WLAN,
+                                                        &eeepc_rfkill_ops,
+                                                        (void *)CM_ASL_WLAN);
 
                 if (!ehotk->eeepc_wlan_rfkill)
                         goto wlan_fail;
 
-                ehotk->eeepc_wlan_rfkill->name = "eeepc-wlan";
-                ehotk->eeepc_wlan_rfkill->toggle_radio = eeepc_wlan_rfkill_set;
-                ehotk->eeepc_wlan_rfkill->get_state = eeepc_wlan_rfkill_state;
-                if (get_acpi(CM_ASL_WLAN) == 1) {
-                        ehotk->eeepc_wlan_rfkill->state =
-                                RFKILL_STATE_UNBLOCKED;
-                        rfkill_set_default(RFKILL_TYPE_WLAN,
-                                           RFKILL_STATE_UNBLOCKED);
-                } else {
-                        ehotk->eeepc_wlan_rfkill->state =
-                                RFKILL_STATE_SOFT_BLOCKED;
-                        rfkill_set_default(RFKILL_TYPE_WLAN,
-                                           RFKILL_STATE_SOFT_BLOCKED);
-                }
+                rfkill_set_global_sw_state(RFKILL_TYPE_WLAN,
+                                           get_acpi(CM_ASL_WLAN) != 1);
                 result = rfkill_register(ehotk->eeepc_wlan_rfkill);
                 if (result)
                         goto wlan_fail;
@@ -711,28 +684,17 @@ static int eeepc_hotk_add(struct acpi_device *device)
 
         if (get_acpi(CM_ASL_BLUETOOTH) != -1) {
                 ehotk->eeepc_bluetooth_rfkill =
-                        rfkill_allocate(&device->dev, RFKILL_TYPE_BLUETOOTH);
+                        rfkill_alloc("eeepc-bluetooth",
+                                     &device->dev,
+                                     RFKILL_TYPE_BLUETOOTH,
+                                     &eeepc_rfkill_ops,
+                                     (void *)CM_ASL_BLUETOOTH);
 
                 if (!ehotk->eeepc_bluetooth_rfkill)
                         goto bluetooth_fail;
 
-                ehotk->eeepc_bluetooth_rfkill->name = "eeepc-bluetooth";
-                ehotk->eeepc_bluetooth_rfkill->toggle_radio =
-                        eeepc_bluetooth_rfkill_set;
-                ehotk->eeepc_bluetooth_rfkill->get_state =
-                        eeepc_bluetooth_rfkill_state;
-                if (get_acpi(CM_ASL_BLUETOOTH) == 1) {
-                        ehotk->eeepc_bluetooth_rfkill->state =
-                                RFKILL_STATE_UNBLOCKED;
-                        rfkill_set_default(RFKILL_TYPE_BLUETOOTH,
-                                           RFKILL_STATE_UNBLOCKED);
-                } else {
-                        ehotk->eeepc_bluetooth_rfkill->state =
-                                RFKILL_STATE_SOFT_BLOCKED;
-                        rfkill_set_default(RFKILL_TYPE_BLUETOOTH,
-                                           RFKILL_STATE_SOFT_BLOCKED);
-                }
-
+                rfkill_set_global_sw_state(RFKILL_TYPE_BLUETOOTH,
+                                           get_acpi(CM_ASL_BLUETOOTH) != 1);
                 result = rfkill_register(ehotk->eeepc_bluetooth_rfkill);
                 if (result)
                         goto bluetooth_fail;
@@ -741,13 +703,10 @@ static int eeepc_hotk_add(struct acpi_device *device)
         return 0;
 
  bluetooth_fail:
-        if (ehotk->eeepc_bluetooth_rfkill)
-                rfkill_free(ehotk->eeepc_bluetooth_rfkill);
+        rfkill_destroy(ehotk->eeepc_bluetooth_rfkill);
         rfkill_unregister(ehotk->eeepc_wlan_rfkill);
-        ehotk->eeepc_wlan_rfkill = NULL;
  wlan_fail:
-        if (ehotk->eeepc_wlan_rfkill)
-                rfkill_free(ehotk->eeepc_wlan_rfkill);
+        rfkill_destroy(ehotk->eeepc_wlan_rfkill);
         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
  ehotk_fail: