6 files changed, 352 insertions, 52 deletions

diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 1acfa3a05aad..cbe21bc96b52 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -269,4 +269,14 @@ config INPUT_DM355EVM
 
           To compile this driver as a module, choose M here: the
           module will be called dm355evm_keys.
+
+config INPUT_BFIN_ROTARY
+        tristate "Blackfin Rotary support"
+        depends on BF54x || BF52x
+        help
+          Say Y here if you want to use the Blackfin Rotary.
+
+          To compile this driver as a module, choose M here: the
+          module will be called bfin-rotary.
+
 endif
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 0d979fd4cd57..79c1e9a5ea31 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_INPUT_APANEL)		+= apanel.o
 obj-$(CONFIG_INPUT_ATI_REMOTE)          += ati_remote.o
 obj-$(CONFIG_INPUT_ATI_REMOTE2)         += ati_remote2.o
 obj-$(CONFIG_INPUT_ATLAS_BTNS)          += atlas_btns.o
+obj-$(CONFIG_INPUT_BFIN_ROTARY)         += bfin_rotary.o
 obj-$(CONFIG_INPUT_CM109)               += cm109.o
 obj-$(CONFIG_INPUT_COBALT_BTNS)         += cobalt_btns.o
 obj-$(CONFIG_INPUT_DM355EVM)            += dm355evm_keys.o
diff --git a/drivers/input/misc/bfin_rotary.c b/drivers/input/misc/bfin_rotary.c
new file mode 100644
index 000000000000..690f3fafa03b
--- /dev/null
+++ b/drivers/input/misc/bfin_rotary.c
@@ -0,0 +1,283 @@
+/*
+ * Rotary counter driver for Analog Devices Blackfin Processors
+ *
+ * Copyright 2008-2009 Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+
+#include <asm/portmux.h>
+#include <asm/bfin_rotary.h>
+
+static const u16 per_cnt[] = {
+        P_CNT_CUD,
+        P_CNT_CDG,
+        P_CNT_CZM,
+        0
+};
+
+struct bfin_rot {
+        struct input_dev *input;
+        int irq;
+        unsigned int up_key;
+        unsigned int down_key;
+        unsigned int button_key;
+        unsigned int rel_code;
+        unsigned short cnt_config;
+        unsigned short cnt_imask;
+        unsigned short cnt_debounce;
+};
+
+static void report_key_event(struct input_dev *input, int keycode)
+{
+        /* simulate a press-n-release */
+        input_report_key(input, keycode, 1);
+        input_sync(input);
+        input_report_key(input, keycode, 0);
+        input_sync(input);
+}
+
+static void report_rotary_event(struct bfin_rot *rotary, int delta)
+{
+        struct input_dev *input = rotary->input;
+
+        if (rotary->up_key) {
+                report_key_event(input,
+                                 delta > 0 ? rotary->up_key : rotary->down_key);
+        } else {
+                input_report_rel(input, rotary->rel_code, delta);
+                input_sync(input);
+        }
+}
+
+static irqreturn_t bfin_rotary_isr(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct bfin_rot *rotary = platform_get_drvdata(pdev);
+        int delta;
+
+        switch (bfin_read_CNT_STATUS()) {
+
+        case ICII:
+                break;
+
+        case UCII:
+        case DCII:
+                delta = bfin_read_CNT_COUNTER();
+                if (delta)
+                        report_rotary_event(rotary, delta);
+                break;
+
+        case CZMII:
+                report_key_event(rotary->input, rotary->button_key);
+                break;
+
+        default:
+                break;
+        }
+
+        bfin_write_CNT_COMMAND(W1LCNT_ZERO);    /* Clear COUNTER */
+        bfin_write_CNT_STATUS(-1);      /* Clear STATUS */
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit bfin_rotary_probe(struct platform_device *pdev)
+{
+        struct bfin_rotary_platform_data *pdata = pdev->dev.platform_data;
+        struct bfin_rot *rotary;
+        struct input_dev *input;
+        int error;
+
+        /* Basic validation */
+        if ((pdata->rotary_up_key && !pdata->rotary_down_key) ||
+            (!pdata->rotary_up_key && pdata->rotary_down_key)) {
+                return -EINVAL;
+        }
+
+        error = peripheral_request_list(per_cnt, dev_name(&pdev->dev));
+        if (error) {
+                dev_err(&pdev->dev, "requesting peripherals failed\n");
+                return error;
+        }
+
+        rotary = kzalloc(sizeof(struct bfin_rot), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!rotary || !input) {
+                error = -ENOMEM;
+                goto out1;
+        }
+
+        rotary->input = input;
+
+        rotary->up_key = pdata->rotary_up_key;
+        rotary->down_key = pdata->rotary_down_key;
+        rotary->button_key = pdata->rotary_button_key;
+        rotary->rel_code = pdata->rotary_rel_code;
+
+        error = rotary->irq = platform_get_irq(pdev, 0);
+        if (error < 0)
+                goto out1;
+
+        input->name = pdev->name;
+        input->phys = "bfin-rotary/input0";
+        input->dev.parent = &pdev->dev;
+
+        input_set_drvdata(input, rotary);
+
+        input->id.bustype = BUS_HOST;
+        input->id.vendor = 0x0001;
+        input->id.product = 0x0001;
+        input->id.version = 0x0100;
+
+        if (rotary->up_key) {
+                __set_bit(EV_KEY, input->evbit);
+                __set_bit(rotary->up_key, input->keybit);
+                __set_bit(rotary->down_key, input->keybit);
+        } else {
+                __set_bit(EV_REL, input->evbit);
+                __set_bit(rotary->rel_code, input->relbit);
+        }
+
+        if (rotary->button_key) {
+                __set_bit(EV_KEY, input->evbit);
+                __set_bit(rotary->button_key, input->keybit);
+        }
+
+        error = request_irq(rotary->irq, bfin_rotary_isr,
+                            0, dev_name(&pdev->dev), pdev);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to claim irq %d; error %d\n",
+                        rotary->irq, error);
+                goto out1;
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to register input device (%d)\n", error);
+                goto out2;
+        }
+
+        if (pdata->rotary_button_key)
+                bfin_write_CNT_IMASK(CZMIE);
+
+        if (pdata->mode & ROT_DEBE)
+                bfin_write_CNT_DEBOUNCE(pdata->debounce & DPRESCALE);
+
+        if (pdata->mode)
+                bfin_write_CNT_CONFIG(bfin_read_CNT_CONFIG() |
+                                        (pdata->mode & ~CNTE));
+
+        bfin_write_CNT_IMASK(bfin_read_CNT_IMASK() | UCIE | DCIE);
+        bfin_write_CNT_CONFIG(bfin_read_CNT_CONFIG() | CNTE);
+
+        platform_set_drvdata(pdev, rotary);
+        device_init_wakeup(&pdev->dev, 1);
+
+        return 0;
+
+out2:
+        free_irq(rotary->irq, pdev);
+out1:
+        input_free_device(input);
+        kfree(rotary);
+        peripheral_free_list(per_cnt);
+
+        return error;
+}
+
+static int __devexit bfin_rotary_remove(struct platform_device *pdev)
+{
+        struct bfin_rot *rotary = platform_get_drvdata(pdev);
+
+        bfin_write_CNT_CONFIG(0);
+        bfin_write_CNT_IMASK(0);
+
+        free_irq(rotary->irq, pdev);
+        input_unregister_device(rotary->input);
+        peripheral_free_list(per_cnt);
+
+        kfree(rotary);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int bfin_rotary_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct bfin_rot *rotary = platform_get_drvdata(pdev);
+
+        rotary->cnt_config = bfin_read_CNT_CONFIG();
+        rotary->cnt_imask = bfin_read_CNT_IMASK();
+        rotary->cnt_debounce = bfin_read_CNT_DEBOUNCE();
+
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(rotary->irq);
+
+        return 0;
+}
+
+static int bfin_rotary_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct bfin_rot *rotary = platform_get_drvdata(pdev);
+
+        bfin_write_CNT_DEBOUNCE(rotary->cnt_debounce);
+        bfin_write_CNT_IMASK(rotary->cnt_imask);
+        bfin_write_CNT_CONFIG(rotary->cnt_config & ~CNTE);
+
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(rotary->irq);
+
+        if (rotary->cnt_config & CNTE)
+                bfin_write_CNT_CONFIG(rotary->cnt_config);
+
+        return 0;
+}
+
+static struct dev_pm_ops bfin_rotary_pm_ops = {
+        .suspend        = bfin_rotary_suspend,
+        .resume         = bfin_rotary_resume,
+};
+#endif
+
+static struct platform_driver bfin_rotary_device_driver = {
+        .probe          = bfin_rotary_probe,
+        .remove         = __devexit_p(bfin_rotary_remove),
+        .driver         = {
+                .name   = "bfin-rotary",
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &bfin_rotary_pm_ops,
+#endif
+        },
+};
+
+static int __init bfin_rotary_init(void)
+{
+        return platform_driver_register(&bfin_rotary_device_driver);
+}
+module_init(bfin_rotary_init);
+
+static void __exit bfin_rotary_exit(void)
+{
+        platform_driver_unregister(&bfin_rotary_device_driver);
+}
+module_exit(bfin_rotary_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Rotary Counter driver for Blackfin Processors");
+MODULE_ALIAS("platform:bfin-rotary");
diff --git a/drivers/input/misc/cobalt_btns.c b/drivers/input/misc/cobalt_btns.c
index d114d3a9e1e9..ee73d7219c92 100644
--- a/drivers/input/misc/cobalt_btns.c
+++ b/drivers/input/misc/cobalt_btns.c
@@ -116,7 +116,7 @@ static int __devinit cobalt_buttons_probe(struct platform_device *pdev)
         }
 
         bdev->poll_dev = poll_dev;
-        bdev->reg = ioremap(res->start, res->end - res->start + 1);
+        bdev->reg = ioremap(res->start, resource_size(res));
         dev_set_drvdata(&pdev->dev, bdev);
 
         error = input_register_polled_device(poll_dev);
diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c
index a63315ce4a6c..0918acae584a 100644
--- a/drivers/input/misc/dm355evm_keys.c
+++ b/drivers/input/misc/dm355evm_keys.c
@@ -23,30 +23,16 @@
  * pressed, or its autorepeat kicks in, an event is sent.  This driver
  * read those events from the small (32 event) queue and reports them.
  *
- * Because we communicate with the MSP430 using I2C, and all I2C calls
- * in Linux sleep, we need to cons up a kind of threaded IRQ handler
- * using a work_struct.  The IRQ is active low, but we use it through
- * the GPIO controller so we can trigger on falling edges.
- *
  * Note that physically there can only be one of these devices.
  *
  * This driver was tested with firmware revision A4.
  */
 struct dm355evm_keys {
-        struct work_struct      work;
         struct input_dev        *input;
         struct device           *dev;
         int                     irq;
 };
 
-static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
-{
-        struct dm355evm_keys    *keys = _keys;
-
-        schedule_work(&keys->work);
-        return IRQ_HANDLED;
-}
-
 /* These initial keycodes can be remapped by dm355evm_setkeycode(). */
 static struct {
         u16     event;
@@ -110,13 +96,12 @@ static struct {
         { 0x3169, KEY_PAUSE, },
 };
 
-static void dm355evm_keys_work(struct work_struct *work)
+/* runs in an IRQ thread -- can (and will!) sleep */
+static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
 {
-        struct dm355evm_keys    *keys;
+        struct dm355evm_keys    *keys = _keys;
         int                     status;
 
-        keys = container_of(work, struct dm355evm_keys, work);
-
         /* For simplicity we ignore INPUT_COUNT and just read
          * events until we get the "queue empty" indicator.
          * Reading INPUT_LOW decrements the count.
@@ -183,6 +168,19 @@ static void dm355evm_keys_work(struct work_struct *work)
                 input_report_key(keys->input, keycode, 0);
                 input_sync(keys->input);
         }
+        return IRQ_HANDLED;
+}
+
+/*
+ * Because we communicate with the MSP430 using I2C, and all I2C calls
+ * in Linux sleep, we use a threaded IRQ handler.  The IRQ itself is
+ * active low, but we go through the GPIO controller so we can trigger
+ * on falling edges and not worry about enabling/disabling the IRQ in
+ * the keypress handling path.
+ */
+static irqreturn_t dm355evm_keys_hardirq(int irq, void *_keys)
+{
+        return IRQ_WAKE_THREAD;
 }
 
 static int dm355evm_setkeycode(struct input_dev *dev, int index, int keycode)
@@ -233,7 +231,6 @@ static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
 
         keys->dev = &pdev->dev;
         keys->input = input;
-        INIT_WORK(&keys->work, dm355evm_keys_work);
 
         /* set up "threaded IRQ handler" */
         status = platform_get_irq(pdev, 0);
@@ -260,9 +257,10 @@ static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
 
         /* REVISIT:  flush the event queue? */
 
-        status = request_irq(keys->irq, dm355evm_keys_irq,
-                             IRQF_TRIGGER_FALLING,
-                             dev_name(&pdev->dev), keys);
+        status = request_threaded_irq(keys->irq,
+                        dm355evm_keys_hardirq, dm355evm_keys_irq,
+                        IRQF_TRIGGER_FALLING,
+                        dev_name(&pdev->dev), keys);
         if (status < 0)
                 goto fail1;
 
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
index 27ee976eb54c..ebb08cfe2731 100644
--- a/drivers/input/misc/wistron_btns.c
+++ b/drivers/input/misc/wistron_btns.c
@@ -243,9 +243,9 @@ enum { KE_END, KE_KEY, KE_SW, KE_WIFI, KE_BLUETOOTH };
 #define FE_UNTESTED 0x80
 
 static struct key_entry *keymap; /* = NULL; Current key map */
-static int have_wifi;
-static int have_bluetooth;
-static int have_leds;
+static bool have_wifi;
+static bool have_bluetooth;
+static int leds_present;        /* bitmask of leds present */
 
 static int __init dmi_matched(const struct dmi_system_id *dmi)
 {
@@ -254,11 +254,11 @@ static int __init dmi_matched(const struct dmi_system_id *dmi)
         keymap = dmi->driver_data;
         for (key = keymap; key->type != KE_END; key++) {
                 if (key->type == KE_WIFI)
-                        have_wifi = 1;
+                        have_wifi = true;
                 else if (key->type == KE_BLUETOOTH)
-                        have_bluetooth = 1;
+                        have_bluetooth = true;
         }
-        have_leds = key->code & (FE_MAIL_LED | FE_WIFI_LED);
+        leds_present = key->code & (FE_MAIL_LED | FE_WIFI_LED);
 
         return 1;
 }
@@ -1009,8 +1009,8 @@ static int __init select_keymap(void)
 
 static struct input_polled_dev *wistron_idev;
 static unsigned long jiffies_last_press;
-static int wifi_enabled;
-static int bluetooth_enabled;
+static bool wifi_enabled;
+static bool bluetooth_enabled;
 
 static void report_key(struct input_dev *dev, unsigned int keycode)
 {
@@ -1053,24 +1053,24 @@ static struct led_classdev wistron_wifi_led = {
 
 static void __devinit wistron_led_init(struct device *parent)
 {
-        if (have_leds & FE_WIFI_LED) {
+        if (leds_present & FE_WIFI_LED) {
                 u16 wifi = bios_get_default_setting(WIFI);
                 if (wifi & 1) {
                         wistron_wifi_led.brightness = (wifi & 2) ? LED_FULL : LED_OFF;
                         if (led_classdev_register(parent, &wistron_wifi_led))
-                                have_leds &= ~FE_WIFI_LED;
+                                leds_present &= ~FE_WIFI_LED;
                         else
                                 bios_set_state(WIFI, wistron_wifi_led.brightness);
 
                 } else
-                        have_leds &= ~FE_WIFI_LED;
+                        leds_present &= ~FE_WIFI_LED;
         }
 
-        if (have_leds & FE_MAIL_LED) {
+        if (leds_present & FE_MAIL_LED) {
                 /* bios_get_default_setting(MAIL) always retuns 0, so just turn the led off */
                 wistron_mail_led.brightness = LED_OFF;
                 if (led_classdev_register(parent, &wistron_mail_led))
-                        have_leds &= ~FE_MAIL_LED;
+                        leds_present &= ~FE_MAIL_LED;
                 else
                         bios_set_state(MAIL_LED, wistron_mail_led.brightness);
         }
@@ -1078,28 +1078,28 @@ static void __devinit wistron_led_init(struct device *parent)
 
 static void __devexit wistron_led_remove(void)
 {
-        if (have_leds & FE_MAIL_LED)
+        if (leds_present & FE_MAIL_LED)
                 led_classdev_unregister(&wistron_mail_led);
 
-        if (have_leds & FE_WIFI_LED)
+        if (leds_present & FE_WIFI_LED)
                 led_classdev_unregister(&wistron_wifi_led);
 }
 
 static inline void wistron_led_suspend(void)
 {
-        if (have_leds & FE_MAIL_LED)
+        if (leds_present & FE_MAIL_LED)
                 led_classdev_suspend(&wistron_mail_led);
 
-        if (have_leds & FE_WIFI_LED)
+        if (leds_present & FE_WIFI_LED)
                 led_classdev_suspend(&wistron_wifi_led);
 }
 
 static inline void wistron_led_resume(void)
 {
-        if (have_leds & FE_MAIL_LED)
+        if (leds_present & FE_MAIL_LED)
                 led_classdev_resume(&wistron_mail_led);
 
-        if (have_leds & FE_WIFI_LED)
+        if (leds_present & FE_WIFI_LED)
                 led_classdev_resume(&wistron_wifi_led);
 }
 
@@ -1312,7 +1312,7 @@ static int __devinit wistron_probe(struct platform_device *dev)
         if (have_wifi) {
                 u16 wifi = bios_get_default_setting(WIFI);
                 if (wifi & 1)
-                        wifi_enabled = (wifi & 2) ? 1 : 0;
+                        wifi_enabled = wifi & 2;
                 else
                         have_wifi = 0;
 
@@ -1323,15 +1323,16 @@ static int __devinit wistron_probe(struct platform_device *dev)
         if (have_bluetooth) {
                 u16 bt = bios_get_default_setting(BLUETOOTH);
                 if (bt & 1)
-                        bluetooth_enabled = (bt & 2) ? 1 : 0;
+                        bluetooth_enabled = bt & 2;
                 else
-                        have_bluetooth = 0;
+                        have_bluetooth = false;
 
                 if (have_bluetooth)
                         bios_set_state(BLUETOOTH, bluetooth_enabled);
         }
 
         wistron_led_init(&dev->dev);
+
         err = setup_input_dev();
         if (err) {
                 bios_detach();
@@ -1352,7 +1353,7 @@ static int __devexit wistron_remove(struct platform_device *dev)
 }
 
 #ifdef CONFIG_PM
-static int wistron_suspend(struct platform_device *dev, pm_message_t state)
+static int wistron_suspend(struct device *dev)
 {
         if (have_wifi)
                 bios_set_state(WIFI, 0);
@@ -1361,10 +1362,11 @@ static int wistron_suspend(struct platform_device *dev, pm_message_t state)
                 bios_set_state(BLUETOOTH, 0);
 
         wistron_led_suspend();
+
         return 0;
 }
 
-static int wistron_resume(struct platform_device *dev)
+static int wistron_resume(struct device *dev)
 {
         if (have_wifi)
                 bios_set_state(WIFI, wifi_enabled);
@@ -1373,24 +1375,30 @@ static int wistron_resume(struct platform_device *dev)
                 bios_set_state(BLUETOOTH, bluetooth_enabled);
 
         wistron_led_resume();
+
         poll_bios(true);
 
         return 0;
 }
-#else
-#define wistron_suspend         NULL
-#define wistron_resume          NULL
+
+static const struct dev_pm_ops wistron_pm_ops = {
+        .suspend        = wistron_suspend,
+        .resume         = wistron_resume,
+        .poweroff       = wistron_suspend,
+        .restore        = wistron_resume,
+};
 #endif
 
 static struct platform_driver wistron_driver = {
         .driver         = {
                 .name   = "wistron-bios",
                 .owner  = THIS_MODULE,
+#if CONFIG_PM
+                .pm     = &wistron_pm_ops,
+#endif
         },
         .probe          = wistron_probe,
         .remove         = __devexit_p(wistron_remove),
-        .suspend        = wistron_suspend,
-        .resume         = wistron_resume,
 };
 
 static int __init wb_module_init(void)