Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input

Pull 2nd round of input updates from Dmitry Torokhov:
 - update to Wacom driver to support wireless devices
 - update to Sentelci touchpad driver to support newer hardware
 - update to gpio-keys driver to support "interrupt-only" keys
 - fixups to earlier commits

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input:
  Input: wacom - check for allocation failure in probe()
  Input: tegra-kbc - allocate pdata before using it
  Input: amijoy - add missing platform check
  Input: wacom - wireless battery status
  Input: wacom - create inputs when wireless connect
  Input: wacom - wireless monitor framework
  Input: wacom - isolate input registration
  Input: sentelic - improve packet debugging information
  Input: sentelic - minor code cleanup
  Input: sentelic - enabling absolute coordinates output for newer hardware
  Input: sentelic - refactor code for upcoming new hardware support
  Input: gpio_keys - add support for interrupt only keys
  Input: gpio_keys - consolidate key destructor code
  Input: revert "gpio_keys - switch to using threaded IRQs"
  Input: gpio_keys - constify platform data
  Input: spear-keyboard - remove kbd_set_plat_data()

1 files changed, 169 insertions, 90 deletions

diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index ed1ed469d08..62bfce468f9 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -28,14 +28,18 @@
 #include <linux/gpio.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
+#include <linux/spinlock.h>
 
 struct gpio_button_data {
-        struct gpio_keys_button *button;
+        const struct gpio_keys_button *button;
         struct input_dev *input;
         struct timer_list timer;
         struct work_struct work;
-        int timer_debounce;     /* in msecs */
+        unsigned int timer_debounce;    /* in msecs */
+        unsigned int irq;
+        spinlock_t lock;
         bool disabled;
+        bool key_pressed;
 };
 
 struct gpio_keys_drvdata {
@@ -114,7 +118,7 @@ static void gpio_keys_disable_button(struct gpio_button_data *bdata)
                 /*
                  * Disable IRQ and possible debouncing timer.
                  */
-                disable_irq(gpio_to_irq(bdata->button->gpio));
+                disable_irq(bdata->irq);
                 if (bdata->timer_debounce)
                         del_timer_sync(&bdata->timer);
 
@@ -135,7 +139,7 @@ static void gpio_keys_disable_button(struct gpio_button_data *bdata)
 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
 {
         if (bdata->disabled) {
-                enable_irq(gpio_to_irq(bdata->button->gpio));
+                enable_irq(bdata->irq);
                 bdata->disabled = false;
         }
 }
@@ -195,7 +199,7 @@ static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
  * @type: button type (%EV_KEY, %EV_SW)
  *
  * This function parses stringified bitmap from @buf and disables/enables
- * GPIO buttons accordinly. Returns 0 on success and negative error
+ * GPIO buttons accordingly. Returns 0 on success and negative error
  * on failure.
  */
 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
@@ -320,9 +324,9 @@ static struct attribute_group gpio_keys_attr_group = {
         .attrs = gpio_keys_attrs,
 };
 
-static void gpio_keys_report_event(struct gpio_button_data *bdata)
+static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
 {
-        struct gpio_keys_button *button = bdata->button;
+        const struct gpio_keys_button *button = bdata->button;
         struct input_dev *input = bdata->input;
         unsigned int type = button->type ?: EV_KEY;
         int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;
@@ -336,27 +340,26 @@ static void gpio_keys_report_event(struct gpio_button_data *bdata)
         input_sync(input);
 }
 
-static void gpio_keys_work_func(struct work_struct *work)
+static void gpio_keys_gpio_work_func(struct work_struct *work)
 {
         struct gpio_button_data *bdata =
                 container_of(work, struct gpio_button_data, work);
 
-        gpio_keys_report_event(bdata);
+        gpio_keys_gpio_report_event(bdata);
 }
 
-static void gpio_keys_timer(unsigned long _data)
+static void gpio_keys_gpio_timer(unsigned long _data)
 {
-        struct gpio_button_data *data = (struct gpio_button_data *)_data;
+        struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
 
-        schedule_work(&data->work);
+        schedule_work(&bdata->work);
 }
 
-static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
+static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
 {
         struct gpio_button_data *bdata = dev_id;
-        struct gpio_keys_button *button = bdata->button;
 
-        BUG_ON(irq != gpio_to_irq(button->gpio));
+        BUG_ON(irq != bdata->irq);
 
         if (bdata->timer_debounce)
                 mod_timer(&bdata->timer,
@@ -367,50 +370,133 @@ static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+static void gpio_keys_irq_timer(unsigned long _data)
+{
+        struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
+        struct input_dev *input = bdata->input;
+        unsigned long flags;
+
+        spin_lock_irqsave(&bdata->lock, flags);
+        if (bdata->key_pressed) {
+                input_event(input, EV_KEY, bdata->button->code, 0);
+                input_sync(input);
+                bdata->key_pressed = false;
+        }
+        spin_unlock_irqrestore(&bdata->lock, flags);
+}
+
+static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
+{
+        struct gpio_button_data *bdata = dev_id;
+        const struct gpio_keys_button *button = bdata->button;
+        struct input_dev *input = bdata->input;
+        unsigned long flags;
+
+        BUG_ON(irq != bdata->irq);
+
+        spin_lock_irqsave(&bdata->lock, flags);
+
+        if (!bdata->key_pressed) {
+                input_event(input, EV_KEY, button->code, 1);
+                input_sync(input);
+
+                if (!bdata->timer_debounce) {
+                        input_event(input, EV_KEY, button->code, 0);
+                        input_sync(input);
+                        goto out;
+                }
+
+                bdata->key_pressed = true;
+        }
+
+        if (bdata->timer_debounce)
+                mod_timer(&bdata->timer,
+                        jiffies + msecs_to_jiffies(bdata->timer_debounce));
+out:
+        spin_unlock_irqrestore(&bdata->lock, flags);
+        return IRQ_HANDLED;
+}
+
 static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
+                                         struct input_dev *input,
                                          struct gpio_button_data *bdata,
-                                         struct gpio_keys_button *button)
+                                         const struct gpio_keys_button *button)
 {
         const char *desc = button->desc ? button->desc : "gpio_keys";
         struct device *dev = &pdev->dev;
+        irq_handler_t isr;
         unsigned long irqflags;
         int irq, error;
 
-        setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);
-        INIT_WORK(&bdata->work, gpio_keys_work_func);
+        bdata->input = input;
+        bdata->button = button;
+        spin_lock_init(&bdata->lock);
 
-        error = gpio_request(button->gpio, desc);
-        if (error < 0) {
-                dev_err(dev, "failed to request GPIO %d, error %d\n",
-                        button->gpio, error);
-                goto fail2;
-        }
+        if (gpio_is_valid(button->gpio)) {
 
-        error = gpio_direction_input(button->gpio);
-        if (error < 0) {
-                dev_err(dev, "failed to configure"
-                        " direction for GPIO %d, error %d\n",
-                        button->gpio, error);
-                goto fail3;
-        }
+                error = gpio_request(button->gpio, desc);
+                if (error < 0) {
+                        dev_err(dev, "Failed to request GPIO %d, error %d\n",
+                                button->gpio, error);
+                        return error;
+                }
 
-        if (button->debounce_interval) {
-                error = gpio_set_debounce(button->gpio,
-                                          button->debounce_interval * 1000);
-                /* use timer if gpiolib doesn't provide debounce */
-                if (error < 0)
-                        bdata->timer_debounce = button->debounce_interval;
-        }
+                error = gpio_direction_input(button->gpio);
+                if (error < 0) {
+                        dev_err(dev,
+                                "Failed to configure direction for GPIO %d, error %d\n",
+                                button->gpio, error);
+                        goto fail;
+                }
 
-        irq = gpio_to_irq(button->gpio);
-        if (irq < 0) {
-                error = irq;
-                dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n",
-                        button->gpio, error);
-                goto fail3;
+                if (button->debounce_interval) {
+                        error = gpio_set_debounce(button->gpio,
+                                        button->debounce_interval * 1000);
+                        /* use timer if gpiolib doesn't provide debounce */
+                        if (error < 0)
+                                bdata->timer_debounce =
+                                                button->debounce_interval;
+                }
+
+                irq = gpio_to_irq(button->gpio);
+                if (irq < 0) {
+                        error = irq;
+                        dev_err(dev,
+                                "Unable to get irq number for GPIO %d, error %d\n",
+                                button->gpio, error);
+                        goto fail;
+                }
+                bdata->irq = irq;
+
+                INIT_WORK(&bdata->work, gpio_keys_gpio_work_func);
+                setup_timer(&bdata->timer,
+                            gpio_keys_gpio_timer, (unsigned long)bdata);
+
+                isr = gpio_keys_gpio_isr;
+                irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
+
+        } else {
+                if (!button->irq) {
+                        dev_err(dev, "No IRQ specified\n");
+                        return -EINVAL;
+                }
+                bdata->irq = button->irq;
+
+                if (button->type && button->type != EV_KEY) {
+                        dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
+                        return -EINVAL;
+                }
+
+                bdata->timer_debounce = button->debounce_interval;
+                setup_timer(&bdata->timer,
+                            gpio_keys_irq_timer, (unsigned long)bdata);
+
+                isr = gpio_keys_irq_isr;
+                irqflags = 0;
         }
 
-        irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
+        input_set_capability(input, button->type ?: EV_KEY, button->code);
+
         /*
          * If platform has specified that the button can be disabled,
          * we don't want it to share the interrupt line.
@@ -418,18 +504,19 @@ static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
         if (!button->can_disable)
                 irqflags |= IRQF_SHARED;
 
-        error = request_threaded_irq(irq, NULL, gpio_keys_isr, irqflags, desc, bdata);
+        error = request_any_context_irq(bdata->irq, isr, irqflags, desc, bdata);
         if (error < 0) {
                 dev_err(dev, "Unable to claim irq %d; error %d\n",
-                        irq, error);
-                goto fail3;
+                        bdata->irq, error);
+                goto fail;
         }
 
         return 0;
 
-fail3:
-        gpio_free(button->gpio);
-fail2:
+fail:
+        if (gpio_is_valid(button->gpio))
+                gpio_free(button->gpio);
+
         return error;
 }
 
@@ -547,9 +634,19 @@ static int gpio_keys_get_devtree_pdata(struct device *dev,
 
 #endif
 
+static void gpio_remove_key(struct gpio_button_data *bdata)
+{
+        free_irq(bdata->irq, bdata);
+        if (bdata->timer_debounce)
+                del_timer_sync(&bdata->timer);
+        cancel_work_sync(&bdata->work);
+        if (gpio_is_valid(bdata->button->gpio))
+                gpio_free(bdata->button->gpio);
+}
+
 static int __devinit gpio_keys_probe(struct platform_device *pdev)
 {
-        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+        const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
         struct gpio_keys_drvdata *ddata;
         struct device *dev = &pdev->dev;
         struct gpio_keys_platform_data alt_pdata;
@@ -599,21 +696,15 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                 __set_bit(EV_REP, input->evbit);
 
         for (i = 0; i < pdata->nbuttons; i++) {
-                struct gpio_keys_button *button = &pdata->buttons[i];
+                const struct gpio_keys_button *button = &pdata->buttons[i];
                 struct gpio_button_data *bdata = &ddata->data[i];
-                unsigned int type = button->type ?: EV_KEY;
-
-                bdata->input = input;
-                bdata->button = button;
 
-                error = gpio_keys_setup_key(pdev, bdata, button);
+                error = gpio_keys_setup_key(pdev, input, bdata, button);
                 if (error)
                         goto fail2;
 
                 if (button->wakeup)
                         wakeup = 1;
-
-                input_set_capability(input, type, button->code);
         }
 
         error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
@@ -630,9 +721,12 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                 goto fail3;
         }
 
-        /* get current state of buttons */
-        for (i = 0; i < pdata->nbuttons; i++)
-                gpio_keys_report_event(&ddata->data[i]);
+        /* get current state of buttons that are connected to GPIOs */
+        for (i = 0; i < pdata->nbuttons; i++) {
+                struct gpio_button_data *bdata = &ddata->data[i];
+                if (gpio_is_valid(bdata->button->gpio))
+                        gpio_keys_gpio_report_event(bdata);
+        }
         input_sync(input);
 
         device_init_wakeup(&pdev->dev, wakeup);
@@ -642,13 +736,8 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
  fail3:
         sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
  fail2:
-        while (--i >= 0) {
-                free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
-                if (ddata->data[i].timer_debounce)
-                        del_timer_sync(&ddata->data[i].timer);
-                cancel_work_sync(&ddata->data[i].work);
-                gpio_free(pdata->buttons[i].gpio);
-        }
+        while (--i >= 0)
+                gpio_remove_key(&ddata->data[i]);
 
         platform_set_drvdata(pdev, NULL);
  fail1:
@@ -671,14 +760,8 @@ static int __devexit gpio_keys_remove(struct platform_device *pdev)
 
         device_init_wakeup(&pdev->dev, 0);
 
-        for (i = 0; i < ddata->n_buttons; i++) {
-                int irq = gpio_to_irq(ddata->data[i].button->gpio);
-                free_irq(irq, &ddata->data[i]);
-                if (ddata->data[i].timer_debounce)
-                        del_timer_sync(&ddata->data[i].timer);
-                cancel_work_sync(&ddata->data[i].work);
-                gpio_free(ddata->data[i].button->gpio);
-        }
+        for (i = 0; i < ddata->n_buttons; i++)
+                gpio_remove_key(&ddata->data[i]);
 
         input_unregister_device(input);
 
@@ -703,11 +786,9 @@ static int gpio_keys_suspend(struct device *dev)
 
         if (device_may_wakeup(dev)) {
                 for (i = 0; i < ddata->n_buttons; i++) {
-                        struct gpio_keys_button *button = ddata->data[i].button;
-                        if (button->wakeup) {
-                                int irq = gpio_to_irq(button->gpio);
-                                enable_irq_wake(irq);
-                        }
+                        struct gpio_button_data *bdata = &ddata->data[i];
+                        if (bdata->button->wakeup)
+                                enable_irq_wake(bdata->irq);
                 }
         }
 
@@ -720,14 +801,12 @@ static int gpio_keys_resume(struct device *dev)
         int i;
 
         for (i = 0; i < ddata->n_buttons; i++) {
+                struct gpio_button_data *bdata = &ddata->data[i];
+                if (bdata->button->wakeup && device_may_wakeup(dev))
+                        disable_irq_wake(bdata->irq);
 
-                struct gpio_keys_button *button = ddata->data[i].button;
-                if (button->wakeup && device_may_wakeup(dev)) {
-                        int irq = gpio_to_irq(button->gpio);
-                        disable_irq_wake(irq);
-                }
-
-                gpio_keys_report_event(&ddata->data[i]);
+                if (gpio_is_valid(bdata->button->gpio))
+                        gpio_keys_gpio_report_event(bdata);
         }
         input_sync(ddata->input);