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>

11 files changed, 53 insertions, 116 deletions

diff --git a/drivers/net/wireless/b43/Kconfig b/drivers/net/wireless/b43/Kconfig
index 21572e40b79d..07a99e3faf94 100644
--- a/drivers/net/wireless/b43/Kconfig
+++ b/drivers/net/wireless/b43/Kconfig
@@ -102,7 +102,7 @@ config B43_LEDS
 # if it's possible.
 config B43_RFKILL
         bool
-        depends on B43 && (RFKILL = y || RFKILL = B43) && RFKILL_INPUT && (INPUT_POLLDEV = y || INPUT_POLLDEV = B43)
+        depends on B43 && (RFKILL = y || RFKILL = B43)
         default y
 
 # This config option automatically enables b43 HW-RNG support,
diff --git a/drivers/net/wireless/b43/leds.c b/drivers/net/wireless/b43/leds.c
index 76f4c7bad8b8..9a498d3fc653 100644
--- a/drivers/net/wireless/b43/leds.c
+++ b/drivers/net/wireless/b43/leds.c
@@ -87,7 +87,7 @@ static void b43_led_brightness_set(struct led_classdev *led_dev,
 }
 
 static int b43_register_led(struct b43_wldev *dev, struct b43_led *led,
-                            const char *name, char *default_trigger,
+                            const char *name, const char *default_trigger,
                             u8 led_index, bool activelow)
 {
         int err;
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index cb4a8712946a..1d3e40095ada 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -3470,7 +3470,7 @@ static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
 
         if (!!conf->radio_enabled != phy->radio_on) {
                 if (conf->radio_enabled) {
-                        b43_software_rfkill(dev, RFKILL_STATE_UNBLOCKED);
+                        b43_software_rfkill(dev, false);
                         b43info(dev->wl, "Radio turned on by software\n");
                         if (!dev->radio_hw_enable) {
                                 b43info(dev->wl, "The hardware RF-kill button "
@@ -3478,7 +3478,7 @@ static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
                                         "Press the button to turn it on.\n");
                         }
                 } else {
-                        b43_software_rfkill(dev, RFKILL_STATE_SOFT_BLOCKED);
+                        b43_software_rfkill(dev, true);
                         b43info(dev->wl, "Radio turned off by software\n");
                 }
         }
diff --git a/drivers/net/wireless/b43/phy_a.c b/drivers/net/wireless/b43/phy_a.c
index c836c077d51d..816e028a2620 100644
--- a/drivers/net/wireless/b43/phy_a.c
+++ b/drivers/net/wireless/b43/phy_a.c
@@ -480,11 +480,11 @@ static bool b43_aphy_op_supports_hwpctl(struct b43_wldev *dev)
 }
 
 static void b43_aphy_op_software_rfkill(struct b43_wldev *dev,
-                                        enum rfkill_state state)
+                                        bool blocked)
 {
         struct b43_phy *phy = &dev->phy;
 
-        if (state == RFKILL_STATE_UNBLOCKED) {
+        if (!blocked) {
                 if (phy->radio_on)
                         return;
                 b43_radio_write16(dev, 0x0004, 0x00C0);
diff --git a/drivers/net/wireless/b43/phy_common.c b/drivers/net/wireless/b43/phy_common.c
index e176b6e0d9cf..6d241622210e 100644
--- a/drivers/net/wireless/b43/phy_common.c
+++ b/drivers/net/wireless/b43/phy_common.c
@@ -84,7 +84,7 @@ int b43_phy_init(struct b43_wldev *dev)
 
         phy->channel = ops->get_default_chan(dev);
 
-        ops->software_rfkill(dev, RFKILL_STATE_UNBLOCKED);
+        ops->software_rfkill(dev, false);
         err = ops->init(dev);
         if (err) {
                 b43err(dev->wl, "PHY init failed\n");
@@ -104,7 +104,7 @@ err_phy_exit:
         if (ops->exit)
                 ops->exit(dev);
 err_block_rf:
-        ops->software_rfkill(dev, RFKILL_STATE_SOFT_BLOCKED);
+        ops->software_rfkill(dev, true);
 
         return err;
 }
@@ -113,7 +113,7 @@ void b43_phy_exit(struct b43_wldev *dev)
 {
         const struct b43_phy_operations *ops = dev->phy.ops;
 
-        ops->software_rfkill(dev, RFKILL_STATE_SOFT_BLOCKED);
+        ops->software_rfkill(dev, true);
         if (ops->exit)
                 ops->exit(dev);
 }
@@ -295,18 +295,13 @@ err_restore_cookie:
         return err;
 }
 
-void b43_software_rfkill(struct b43_wldev *dev, enum rfkill_state state)
+void b43_software_rfkill(struct b43_wldev *dev, bool blocked)
 {
         struct b43_phy *phy = &dev->phy;
 
-        if (state == RFKILL_STATE_HARD_BLOCKED) {
-                /* We cannot hardware-block the device */
-                state = RFKILL_STATE_SOFT_BLOCKED;
-        }
-
         b43_mac_suspend(dev);
-        phy->ops->software_rfkill(dev, state);
-        phy->radio_on = (state == RFKILL_STATE_UNBLOCKED);
+        phy->ops->software_rfkill(dev, blocked);
+        phy->radio_on = !blocked;
         b43_mac_enable(dev);
 }
 
diff --git a/drivers/net/wireless/b43/phy_common.h b/drivers/net/wireless/b43/phy_common.h
index b2d99101947b..f4c2d79cbc89 100644
--- a/drivers/net/wireless/b43/phy_common.h
+++ b/drivers/net/wireless/b43/phy_common.h
@@ -159,7 +159,7 @@ struct b43_phy_operations {
 
         /* Radio */
         bool (*supports_hwpctl)(struct b43_wldev *dev);
-        void (*software_rfkill)(struct b43_wldev *dev, enum rfkill_state state);
+        void (*software_rfkill)(struct b43_wldev *dev, bool blocked);
         void (*switch_analog)(struct b43_wldev *dev, bool on);
         int (*switch_channel)(struct b43_wldev *dev, unsigned int new_channel);
         unsigned int (*get_default_chan)(struct b43_wldev *dev);
@@ -364,7 +364,7 @@ int b43_switch_channel(struct b43_wldev *dev, unsigned int new_channel);
 /**
  * b43_software_rfkill - Turn the radio ON or OFF in software.
  */
-void b43_software_rfkill(struct b43_wldev *dev, enum rfkill_state state);
+void b43_software_rfkill(struct b43_wldev *dev, bool blocked);
 
 /**
  * b43_phy_txpower_check - Check TX power output.
diff --git a/drivers/net/wireless/b43/phy_g.c b/drivers/net/wireless/b43/phy_g.c
index e7b98f013b0f..5300232449f6 100644
--- a/drivers/net/wireless/b43/phy_g.c
+++ b/drivers/net/wireless/b43/phy_g.c
@@ -2592,7 +2592,7 @@ static bool b43_gphy_op_supports_hwpctl(struct b43_wldev *dev)
 }
 
 static void b43_gphy_op_software_rfkill(struct b43_wldev *dev,
-                                        enum rfkill_state state)
+                                        bool blocked)
 {
         struct b43_phy *phy = &dev->phy;
         struct b43_phy_g *gphy = phy->g;
@@ -2600,7 +2600,7 @@ static void b43_gphy_op_software_rfkill(struct b43_wldev *dev,
 
         might_sleep();
 
-        if (state == RFKILL_STATE_UNBLOCKED) {
+        if (!blocked) {
                 /* Turn radio ON */
                 if (phy->radio_on)
                         return;
diff --git a/drivers/net/wireless/b43/phy_lp.c b/drivers/net/wireless/b43/phy_lp.c
index 58e319d6b1ed..ea0d3a3a6a64 100644
--- a/drivers/net/wireless/b43/phy_lp.c
+++ b/drivers/net/wireless/b43/phy_lp.c
@@ -488,7 +488,7 @@ static void b43_lpphy_op_radio_write(struct b43_wldev *dev, u16 reg, u16 value)
 }
 
 static void b43_lpphy_op_software_rfkill(struct b43_wldev *dev,
-                                         enum rfkill_state state)
+                                         bool blocked)
 {
         //TODO
 }
diff --git a/drivers/net/wireless/b43/phy_n.c b/drivers/net/wireless/b43/phy_n.c
index 8bcfda5f3f07..be7b5604947b 100644
--- a/drivers/net/wireless/b43/phy_n.c
+++ b/drivers/net/wireless/b43/phy_n.c
@@ -579,7 +579,7 @@ static void b43_nphy_op_radio_write(struct b43_wldev *dev, u16 reg, u16 value)
 }
 
 static void b43_nphy_op_software_rfkill(struct b43_wldev *dev,
-                                        enum rfkill_state state)
+                                        bool blocked)
 {//TODO
 }
 
diff --git a/drivers/net/wireless/b43/rfkill.c b/drivers/net/wireless/b43/rfkill.c
index 9e1d00bc24d3..96047843cd56 100644
--- a/drivers/net/wireless/b43/rfkill.c
+++ b/drivers/net/wireless/b43/rfkill.c
@@ -45,12 +45,11 @@ static bool b43_is_hw_radio_enabled(struct b43_wldev *dev)
 }
 
 /* The poll callback for the hardware button. */
-static void b43_rfkill_poll(struct input_polled_dev *poll_dev)
+static void b43_rfkill_poll(struct rfkill *rfkill, void *data)
 {
-        struct b43_wldev *dev = poll_dev->private;
+        struct b43_wldev *dev = data;
         struct b43_wl *wl = dev->wl;
         bool enabled;
-        bool report_change = 0;
 
         mutex_lock(&wl->mutex);
         if (unlikely(b43_status(dev) < B43_STAT_INITIALIZED)) {
@@ -60,68 +59,55 @@ static void b43_rfkill_poll(struct input_polled_dev *poll_dev)
         enabled = b43_is_hw_radio_enabled(dev);
         if (unlikely(enabled != dev->radio_hw_enable)) {
                 dev->radio_hw_enable = enabled;
-                report_change = 1;
                 b43info(wl, "Radio hardware status changed to %s\n",
                         enabled ? "ENABLED" : "DISABLED");
+                enabled = !rfkill_set_hw_state(rfkill, !enabled);
+                if (enabled != dev->phy.radio_on)
+                        b43_software_rfkill(dev, !enabled);
         }
         mutex_unlock(&wl->mutex);
-
-        /* send the radio switch event to the system - note both a key press
-         * and a release are required */
-        if (unlikely(report_change)) {
-                input_report_key(poll_dev->input, KEY_WLAN, 1);
-                input_report_key(poll_dev->input, KEY_WLAN, 0);
-        }
 }
 
 /* Called when the RFKILL toggled in software. */
-static int b43_rfkill_soft_toggle(void *data, enum rfkill_state state)
+static int b43_rfkill_soft_set(void *data, bool blocked)
 {
         struct b43_wldev *dev = data;
         struct b43_wl *wl = dev->wl;
-        int err = -EBUSY;
+        int err = -EINVAL;
 
-        if (!wl->rfkill.registered)
-                return 0;
+        if (WARN_ON(!wl->rfkill.registered))
+                return -EINVAL;
 
         mutex_lock(&wl->mutex);
+
         if (b43_status(dev) < B43_STAT_INITIALIZED)
                 goto out_unlock;
+
+        if (!dev->radio_hw_enable)
+                goto out_unlock;
+
+        if (!blocked != dev->phy.radio_on)
+                b43_software_rfkill(dev, blocked);
         err = 0;
-        switch (state) {
-        case RFKILL_STATE_UNBLOCKED:
-                if (!dev->radio_hw_enable) {
-                        /* No luck. We can't toggle the hardware RF-kill
-                         * button from software. */
-                        err = -EBUSY;
-                        goto out_unlock;
-                }
-                if (!dev->phy.radio_on)
-                        b43_software_rfkill(dev, state);
-                break;
-        case RFKILL_STATE_SOFT_BLOCKED:
-                if (dev->phy.radio_on)
-                        b43_software_rfkill(dev, state);
-                break;
-        default:
-                b43warn(wl, "Received unexpected rfkill state %d.\n", state);
-                break;
-        }
 out_unlock:
         mutex_unlock(&wl->mutex);
-
         return err;
 }
 
-char *b43_rfkill_led_name(struct b43_wldev *dev)
+const char *b43_rfkill_led_name(struct b43_wldev *dev)
 {
         struct b43_rfkill *rfk = &(dev->wl->rfkill);
 
         if (!rfk->registered)
                 return NULL;
-        return rfkill_get_led_name(rfk->rfkill);
+        return rfkill_get_led_trigger_name(rfk->rfkill);
 }
 
+static const struct rfkill_ops b43_rfkill_ops = {
+        .set_block = b43_rfkill_soft_set,
+        .poll = b43_rfkill_poll,
+};
+
 void b43_rfkill_init(struct b43_wldev *dev)
 {
         struct b43_wl *wl = dev->wl;
@@ -130,65 +116,26 @@ void b43_rfkill_init(struct b43_wldev *dev)
 
         rfk->registered = 0;
 
-        rfk->rfkill = rfkill_allocate(dev->dev->dev, RFKILL_TYPE_WLAN);
-        if (!rfk->rfkill)
-                goto out_error;
         snprintf(rfk->name, sizeof(rfk->name),
                  "b43-%s", wiphy_name(wl->hw->wiphy));
-        rfk->rfkill->name = rfk->name;
-        rfk->rfkill->state = RFKILL_STATE_UNBLOCKED;
-        rfk->rfkill->data = dev;
-        rfk->rfkill->toggle_radio = b43_rfkill_soft_toggle;
-
-        rfk->poll_dev = input_allocate_polled_device();
-        if (!rfk->poll_dev) {
-                rfkill_free(rfk->rfkill);
-                goto err_freed_rfk;
-        }
-
-        rfk->poll_dev->private = dev;
-        rfk->poll_dev->poll = b43_rfkill_poll;
-        rfk->poll_dev->poll_interval = 1000; /* msecs */
 
-        rfk->poll_dev->input->name = rfk->name;
-        rfk->poll_dev->input->id.bustype = BUS_HOST;
-        rfk->poll_dev->input->id.vendor = dev->dev->bus->boardinfo.vendor;
-        rfk->poll_dev->input->evbit[0] = BIT(EV_KEY);
-        set_bit(KEY_WLAN, rfk->poll_dev->input->keybit);
+        rfk->rfkill = rfkill_alloc(rfk->name,
+                                   dev->dev->dev,
+                                   RFKILL_TYPE_WLAN,
+                                   &b43_rfkill_ops, dev);
+        if (!rfk->rfkill)
+                goto out_error;
 
         err = rfkill_register(rfk->rfkill);
         if (err)
-                goto err_free_polldev;
-
-#ifdef CONFIG_RFKILL_INPUT_MODULE
-        /* B43 RF-kill isn't useful without the rfkill-input subsystem.
-         * Try to load the module. */
-        err = request_module("rfkill-input");
-        if (err)
-                b43warn(wl, "Failed to load the rfkill-input module. "
-                        "The built-in radio LED will not work.\n");
-#endif /* CONFIG_RFKILL_INPUT */
-
-#if !defined(CONFIG_RFKILL_INPUT) && !defined(CONFIG_RFKILL_INPUT_MODULE)
-        b43warn(wl, "The rfkill-input subsystem is not available. "
-                "The built-in radio LED will not work.\n");
-#endif
-
-        err = input_register_polled_device(rfk->poll_dev);
-        if (err)
-                goto err_unreg_rfk;
+                goto err_free;
 
         rfk->registered = 1;
 
         return;
-err_unreg_rfk:
-        rfkill_unregister(rfk->rfkill);
-err_free_polldev:
-        input_free_polled_device(rfk->poll_dev);
-        rfk->poll_dev = NULL;
-err_freed_rfk:
-        rfk->rfkill = NULL;
-out_error:
+ err_free:
+        rfkill_destroy(rfk->rfkill);
+ out_error:
         rfk->registered = 0;
         b43warn(wl, "RF-kill button init failed\n");
 }
@@ -201,9 +148,7 @@ void b43_rfkill_exit(struct b43_wldev *dev)
                 return;
         rfk->registered = 0;
 
-        input_unregister_polled_device(rfk->poll_dev);
         rfkill_unregister(rfk->rfkill);
-        input_free_polled_device(rfk->poll_dev);
-        rfk->poll_dev = NULL;
+        rfkill_destroy(rfk->rfkill);
         rfk->rfkill = NULL;
 }
diff --git a/drivers/net/wireless/b43/rfkill.h b/drivers/net/wireless/b43/rfkill.h
index adacf936d815..da497e01bbb1 100644
--- a/drivers/net/wireless/b43/rfkill.h
+++ b/drivers/net/wireless/b43/rfkill.h
@@ -7,14 +7,11 @@ struct b43_wldev;
 #ifdef CONFIG_B43_RFKILL
 
 #include <linux/rfkill.h>
-#include <linux/input-polldev.h>
 
 
 struct b43_rfkill {
         /* The RFKILL subsystem data structure */
         struct rfkill *rfkill;
-        /* The poll device for the RFKILL input button */
-        struct input_polled_dev *poll_dev;
         /* Did initialization succeed? Used for freeing. */
         bool registered;
         /* The unique name of this rfkill switch */
@@ -26,7 +23,7 @@ struct b43_rfkill {
 void b43_rfkill_init(struct b43_wldev *dev);
 void b43_rfkill_exit(struct b43_wldev *dev);
 
-char * b43_rfkill_led_name(struct b43_wldev *dev);
+const char *b43_rfkill_led_name(struct b43_wldev *dev);
 
 
 #else /* CONFIG_B43_RFKILL */