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

Pull input layer fixes from Dmitry Torokhov:
 "Fixes for v7 protocol for ALPS devices and few other driver fixes.

  Also users can request input events to be stamped with boot time
  timestamps, in addition to real and monotonic timestamps"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input:
  Input: hil_kbd - fix incorrect use of init_completion
  Input: alps - v7: document the v7 touchpad packet protocol
  Input: alps - v7: fix finger counting for > 2 fingers on clickpads
  Input: alps - v7: sometimes a single touch is reported in mt[1]
  Input: alps - v7: ignore new packets
  Input: evdev - add CLOCK_BOOTTIME support
  Input: psmouse - expose drift duration for IBM trackpoints
  Input: stmpe - bias keypad columns properly
  Input: stmpe - enforce device tree only mode
  mfd: stmpe: add pull up/down register offsets for STMPE
  Input: optimize events_per_packet count calculation
  Input: edt-ft5x06 - fixed a macro coding style issue
  Input: gpio_keys - replace timer and workqueue with delayed workqueue
  Input: gpio_keys - allow separating gpio and irq in device tree

4 files changed, 141 insertions, 121 deletions

diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 96ee26c555e0..a5d9b3f3c871 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -559,6 +559,7 @@ config KEYBOARD_SH_KEYSC
 config KEYBOARD_STMPE
         tristate "STMPE keypad support"
         depends on MFD_STMPE
+        depends on OF
         select INPUT_MATRIXKMAP
         help
           Say Y here if you want to use the keypad controller on STMPE I/O
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index d4dd78a7d56b..883d6aed5b9a 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -35,9 +35,13 @@
 struct gpio_button_data {
         const struct gpio_keys_button *button;
         struct input_dev *input;
-        struct timer_list timer;
-        struct work_struct work;
-        unsigned int timer_debounce;    /* in msecs */
+
+        struct timer_list release_timer;
+        unsigned int release_delay;     /* in msecs, for IRQ-only buttons */
+
+        struct delayed_work work;
+        unsigned int software_debounce; /* in msecs, for GPIO-driven buttons */
+
         unsigned int irq;
         spinlock_t lock;
         bool disabled;
@@ -116,11 +120,14 @@ static void gpio_keys_disable_button(struct gpio_button_data *bdata)
 {
         if (!bdata->disabled) {
                 /*
-                 * Disable IRQ and possible debouncing timer.
+                 * Disable IRQ and associated timer/work structure.
                  */
                 disable_irq(bdata->irq);
-                if (bdata->timer_debounce)
-                        del_timer_sync(&bdata->timer);
+
+                if (gpio_is_valid(bdata->button->gpio))
+                        cancel_delayed_work_sync(&bdata->work);
+                else
+                        del_timer_sync(&bdata->release_timer);
 
                 bdata->disabled = true;
         }
@@ -343,7 +350,7 @@ static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
 static void gpio_keys_gpio_work_func(struct work_struct *work)
 {
         struct gpio_button_data *bdata =
-                container_of(work, struct gpio_button_data, work);
+                container_of(work, struct gpio_button_data, work.work);
 
         gpio_keys_gpio_report_event(bdata);
 
@@ -351,13 +358,6 @@ static void gpio_keys_gpio_work_func(struct work_struct *work)
                 pm_relax(bdata->input->dev.parent);
 }
 
-static void gpio_keys_gpio_timer(unsigned long _data)
-{
-        struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
-
-        schedule_work(&bdata->work);
-}
-
 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
 {
         struct gpio_button_data *bdata = dev_id;
@@ -366,11 +366,10 @@ static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
 
         if (bdata->button->wakeup)
                 pm_stay_awake(bdata->input->dev.parent);
-        if (bdata->timer_debounce)
-                mod_timer(&bdata->timer,
-                        jiffies + msecs_to_jiffies(bdata->timer_debounce));
-        else
-                schedule_work(&bdata->work);
+
+        mod_delayed_work(system_wq,
+                         &bdata->work,
+                         msecs_to_jiffies(bdata->software_debounce));
 
         return IRQ_HANDLED;
 }
@@ -408,7 +407,7 @@ static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
                 input_event(input, EV_KEY, button->code, 1);
                 input_sync(input);
 
-                if (!bdata->timer_debounce) {
+                if (!bdata->release_delay) {
                         input_event(input, EV_KEY, button->code, 0);
                         input_sync(input);
                         goto out;
@@ -417,9 +416,9 @@ static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
                 bdata->key_pressed = true;
         }
 
-        if (bdata->timer_debounce)
-                mod_timer(&bdata->timer,
-                        jiffies + msecs_to_jiffies(bdata->timer_debounce));
+        if (bdata->release_delay)
+                mod_timer(&bdata->release_timer,
+                        jiffies + msecs_to_jiffies(bdata->release_delay));
 out:
         spin_unlock_irqrestore(&bdata->lock, flags);
         return IRQ_HANDLED;
@@ -429,10 +428,10 @@ static void gpio_keys_quiesce_key(void *data)
 {
         struct gpio_button_data *bdata = data;
 
-        if (bdata->timer_debounce)
-                del_timer_sync(&bdata->timer);
-
-        cancel_work_sync(&bdata->work);
+        if (gpio_is_valid(bdata->button->gpio))
+                cancel_delayed_work_sync(&bdata->work);
+        else
+                del_timer_sync(&bdata->release_timer);
 }
 
 static int gpio_keys_setup_key(struct platform_device *pdev,
@@ -466,23 +465,25 @@ static int gpio_keys_setup_key(struct platform_device *pdev,
                                         button->debounce_interval * 1000);
                         /* use timer if gpiolib doesn't provide debounce */
                         if (error < 0)
-                                bdata->timer_debounce =
+                                bdata->software_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);
-                        return error;
+                if (button->irq) {
+                        bdata->irq = button->irq;
+                } else {
+                        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);
+                                return error;
+                        }
+                        bdata->irq = irq;
                 }
-                bdata->irq = irq;
 
-                INIT_WORK(&bdata->work, gpio_keys_gpio_work_func);
-                setup_timer(&bdata->timer,
-                            gpio_keys_gpio_timer, (unsigned long)bdata);
+                INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
 
                 isr = gpio_keys_gpio_isr;
                 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
@@ -499,8 +500,8 @@ static int gpio_keys_setup_key(struct platform_device *pdev,
                         return -EINVAL;
                 }
 
-                bdata->timer_debounce = button->debounce_interval;
-                setup_timer(&bdata->timer,
+                bdata->release_delay = button->debounce_interval;
+                setup_timer(&bdata->release_timer,
                             gpio_keys_irq_timer, (unsigned long)bdata);
 
                 isr = gpio_keys_irq_isr;
@@ -510,7 +511,7 @@ static int gpio_keys_setup_key(struct platform_device *pdev,
         input_set_capability(input, button->type ?: EV_KEY, button->code);
 
         /*
-         * Install custom action to cancel debounce timer and
+         * Install custom action to cancel release timer and
          * workqueue item.
          */
         error = devm_add_action(&pdev->dev, gpio_keys_quiesce_key, bdata);
@@ -618,33 +619,30 @@ gpio_keys_get_devtree_pdata(struct device *dev)
 
         i = 0;
         for_each_child_of_node(node, pp) {
-                int gpio = -1;
                 enum of_gpio_flags flags;
 
                 button = &pdata->buttons[i++];
 
-                if (!of_find_property(pp, "gpios", NULL)) {
-                        button->irq = irq_of_parse_and_map(pp, 0);
-                        if (button->irq == 0) {
-                                i--;
-                                pdata->nbuttons--;
-                                dev_warn(dev, "Found button without gpios or irqs\n");
-                                continue;
-                        }
-                } else {
-                        gpio = of_get_gpio_flags(pp, 0, &flags);
-                        if (gpio < 0) {
-                                error = gpio;
+                button->gpio = of_get_gpio_flags(pp, 0, &flags);
+                if (button->gpio < 0) {
+                        error = button->gpio;
+                        if (error != -ENOENT) {
                                 if (error != -EPROBE_DEFER)
                                         dev_err(dev,
                                                 "Failed to get gpio flags, error: %d\n",
                                                 error);
                                 return ERR_PTR(error);
                         }
+                } else {
+                        button->active_low = flags & OF_GPIO_ACTIVE_LOW;
                 }
 
-                button->gpio = gpio;
-                button->active_low = flags & OF_GPIO_ACTIVE_LOW;
+                button->irq = irq_of_parse_and_map(pp, 0);
+
+                if (!gpio_is_valid(button->gpio) && !button->irq) {
+                        dev_err(dev, "Found button without gpios or irqs\n");
+                        return ERR_PTR(-EINVAL);
+                }
 
                 if (of_property_read_u32(pp, "linux,code", &button->code)) {
                         dev_err(dev, "Button without keycode: 0x%x\n",
@@ -659,6 +657,8 @@ gpio_keys_get_devtree_pdata(struct device *dev)
 
                 button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
 
+                button->can_disable = !!of_get_property(pp, "linux,can-disable", NULL);
+
                 if (of_property_read_u32(pp, "debounce-interval",
                                          &button->debounce_interval))
                         button->debounce_interval = 5;
diff --git a/drivers/input/keyboard/hil_kbd.c b/drivers/input/keyboard/hil_kbd.c
index 610a8af795a1..5b152f25a8e1 100644
--- a/drivers/input/keyboard/hil_kbd.c
+++ b/drivers/input/keyboard/hil_kbd.c
@@ -473,7 +473,7 @@ static int hil_dev_connect(struct serio *serio, struct serio_driver *drv)
         if (error)
                 goto bail1;
 
-        init_completion(&dev->cmd_done);
+        reinit_completion(&dev->cmd_done);
         serio_write(serio, 0);
         serio_write(serio, 0);
         serio_write(serio, HIL_PKT_CMD >> 8);
@@ -482,7 +482,7 @@ static int hil_dev_connect(struct serio *serio, struct serio_driver *drv)
         if (error)
                 goto bail1;
 
-        init_completion(&dev->cmd_done);
+        reinit_completion(&dev->cmd_done);
         serio_write(serio, 0);
         serio_write(serio, 0);
         serio_write(serio, HIL_PKT_CMD >> 8);
@@ -491,7 +491,7 @@ static int hil_dev_connect(struct serio *serio, struct serio_driver *drv)
         if (error)
                 goto bail1;
 
-        init_completion(&dev->cmd_done);
+        reinit_completion(&dev->cmd_done);
         serio_write(serio, 0);
         serio_write(serio, 0);
         serio_write(serio, HIL_PKT_CMD >> 8);
diff --git a/drivers/input/keyboard/stmpe-keypad.c b/drivers/input/keyboard/stmpe-keypad.c
index ef5e67fb567e..fe6e3f22eed7 100644
--- a/drivers/input/keyboard/stmpe-keypad.c
+++ b/drivers/input/keyboard/stmpe-keypad.c
@@ -45,13 +45,14 @@
 #define STMPE_KEYPAD_MAX_ROWS           8
 #define STMPE_KEYPAD_MAX_COLS           8
 #define STMPE_KEYPAD_ROW_SHIFT          3
-#define STMPE_KEYPAD_KEYMAP_SIZE        \
+#define STMPE_KEYPAD_KEYMAP_MAX_SIZE \
         (STMPE_KEYPAD_MAX_ROWS * STMPE_KEYPAD_MAX_COLS)
 
 /**
  * struct stmpe_keypad_variant - model-specific attributes
  * @auto_increment: whether the KPC_DATA_BYTE register address
  *                  auto-increments on multiple read
+ * @set_pullup: whether the pins need to have their pull-ups set
  * @num_data: number of data bytes
  * @num_normal_data: number of normal keys' data bytes
  * @max_cols: maximum number of columns supported
@@ -61,6 +62,7 @@
  */
 struct stmpe_keypad_variant {
         bool            auto_increment;
+        bool            set_pullup;
         int             num_data;
         int             num_normal_data;
         int             max_cols;
@@ -81,6 +83,7 @@ static const struct stmpe_keypad_variant stmpe_keypad_variants[] = {
         },
         [STMPE2401] = {
                 .auto_increment         = false,
+                .set_pullup             = true,
                 .num_data               = 3,
                 .num_normal_data        = 2,
                 .max_cols               = 8,
@@ -90,6 +93,7 @@ static const struct stmpe_keypad_variant stmpe_keypad_variants[] = {
         },
         [STMPE2403] = {
                 .auto_increment         = true,
+                .set_pullup             = true,
                 .num_data               = 5,
                 .num_normal_data        = 3,
                 .max_cols               = 8,
@@ -99,16 +103,30 @@ static const struct stmpe_keypad_variant stmpe_keypad_variants[] = {
         },
 };
 
+/**
+ * struct stmpe_keypad - STMPE keypad state container
+ * @stmpe: pointer to parent STMPE device
+ * @input: spawned input device
+ * @variant: STMPE variant
+ * @debounce_ms: debounce interval, in ms.  Maximum is
+ *               %STMPE_KEYPAD_MAX_DEBOUNCE.
+ * @scan_count: number of key scanning cycles to confirm key data.
+ *              Maximum is %STMPE_KEYPAD_MAX_SCAN_COUNT.
+ * @no_autorepeat: disable key autorepeat
+ * @rows: bitmask for the rows
+ * @cols: bitmask for the columns
+ * @keymap: the keymap
+ */
 struct stmpe_keypad {
         struct stmpe *stmpe;
         struct input_dev *input;
         const struct stmpe_keypad_variant *variant;
-        const struct stmpe_keypad_platform_data *plat;
-
+        unsigned int debounce_ms;
+        unsigned int scan_count;
+        bool no_autorepeat;
         unsigned int rows;
         unsigned int cols;
-
-        unsigned short keymap[STMPE_KEYPAD_KEYMAP_SIZE];
+        unsigned short keymap[STMPE_KEYPAD_KEYMAP_MAX_SIZE];
 };
 
 static int stmpe_keypad_read_data(struct stmpe_keypad *keypad, u8 *data)
@@ -171,7 +189,10 @@ static int stmpe_keypad_altfunc_init(struct stmpe_keypad *keypad)
         unsigned int col_gpios = variant->col_gpios;
         unsigned int row_gpios = variant->row_gpios;
         struct stmpe *stmpe = keypad->stmpe;
+        u8 pureg = stmpe->regs[STMPE_IDX_GPPUR_LSB];
         unsigned int pins = 0;
+        unsigned int pu_pins = 0;
+        int ret;
         int i;
 
         /*
@@ -188,8 +209,10 @@ static int stmpe_keypad_altfunc_init(struct stmpe_keypad *keypad)
         for (i = 0; i < variant->max_cols; i++) {
                 int num = __ffs(col_gpios);
 
-                if (keypad->cols & (1 << i))
+                if (keypad->cols & (1 << i)) {
                         pins |= 1 << num;
+                        pu_pins |= 1 << num;
+                }
 
                 col_gpios &= ~(1 << num);
         }
@@ -203,20 +226,43 @@ static int stmpe_keypad_altfunc_init(struct stmpe_keypad *keypad)
                 row_gpios &= ~(1 << num);
         }
 
-        return stmpe_set_altfunc(stmpe, pins, STMPE_BLOCK_KEYPAD);
+        ret = stmpe_set_altfunc(stmpe, pins, STMPE_BLOCK_KEYPAD);
+        if (ret)
+                return ret;
+
+        /*
+         * On STMPE24xx, set pin bias to pull-up on all keypad input
+         * pins (columns), this incidentally happen to be maximum 8 pins
+         * and placed at GPIO0-7 so only the LSB of the pull up register
+         * ever needs to be written.
+         */
+        if (variant->set_pullup) {
+                u8 val;
+
+                ret = stmpe_reg_read(stmpe, pureg);
+                if (ret)
+                        return ret;
+
+                /* Do not touch unused pins, may be used for GPIO */
+                val = ret & ~pu_pins;
+                val |= pu_pins;
+
+                ret = stmpe_reg_write(stmpe, pureg, val);
+        }
+
+        return 0;
 }
 
 static int stmpe_keypad_chip_init(struct stmpe_keypad *keypad)
 {
-        const struct stmpe_keypad_platform_data *plat = keypad->plat;
         const struct stmpe_keypad_variant *variant = keypad->variant;
         struct stmpe *stmpe = keypad->stmpe;
         int ret;
 
-        if (plat->debounce_ms > STMPE_KEYPAD_MAX_DEBOUNCE)
+        if (keypad->debounce_ms > STMPE_KEYPAD_MAX_DEBOUNCE)
                 return -EINVAL;
 
-        if (plat->scan_count > STMPE_KEYPAD_MAX_SCAN_COUNT)
+        if (keypad->scan_count > STMPE_KEYPAD_MAX_SCAN_COUNT)
                 return -EINVAL;
 
         ret = stmpe_enable(stmpe, STMPE_BLOCK_KEYPAD);
@@ -245,7 +291,7 @@ static int stmpe_keypad_chip_init(struct stmpe_keypad *keypad)
 
         ret = stmpe_set_bits(stmpe, STMPE_KPC_CTRL_MSB,
                              STMPE_KPC_CTRL_MSB_SCAN_COUNT,
-                             plat->scan_count << 4);
+                             keypad->scan_count << 4);
         if (ret < 0)
                 return ret;
 
@@ -253,17 +299,18 @@ static int stmpe_keypad_chip_init(struct stmpe_keypad *keypad)
                               STMPE_KPC_CTRL_LSB_SCAN |
                               STMPE_KPC_CTRL_LSB_DEBOUNCE,
                               STMPE_KPC_CTRL_LSB_SCAN |
-                              (plat->debounce_ms << 1));
+                              (keypad->debounce_ms << 1));
 }
 
-static void stmpe_keypad_fill_used_pins(struct stmpe_keypad *keypad)
+static void stmpe_keypad_fill_used_pins(struct stmpe_keypad *keypad,
+                                        u32 used_rows, u32 used_cols)
 {
         int row, col;
 
-        for (row = 0; row < STMPE_KEYPAD_MAX_ROWS; row++) {
-                for (col = 0; col < STMPE_KEYPAD_MAX_COLS; col++) {
+        for (row = 0; row < used_rows; row++) {
+                for (col = 0; col < used_cols; col++) {
                         int code = MATRIX_SCAN_CODE(row, col,
-                                                STMPE_KEYPAD_ROW_SHIFT);
+                                                    STMPE_KEYPAD_ROW_SHIFT);
                         if (keypad->keymap[code] != KEY_RESERVED) {
                                 keypad->rows |= 1 << row;
                                 keypad->cols |= 1 << col;
@@ -272,51 +319,17 @@ static void stmpe_keypad_fill_used_pins(struct stmpe_keypad *keypad)
         }
 }
 
-#ifdef CONFIG_OF
-static const struct stmpe_keypad_platform_data *
-stmpe_keypad_of_probe(struct device *dev)
-{
-        struct device_node *np = dev->of_node;
-        struct stmpe_keypad_platform_data *plat;
-
-        if (!np)
-                return ERR_PTR(-ENODEV);
-
-        plat = devm_kzalloc(dev, sizeof(*plat), GFP_KERNEL);
-        if (!plat)
-                return ERR_PTR(-ENOMEM);
-
-        of_property_read_u32(np, "debounce-interval", &plat->debounce_ms);
-        of_property_read_u32(np, "st,scan-count", &plat->scan_count);
-
-        plat->no_autorepeat = of_property_read_bool(np, "st,no-autorepeat");
-
-        return plat;
-}
-#else
-static inline const struct stmpe_keypad_platform_data *
-stmpe_keypad_of_probe(struct device *dev)
-{
-        return ERR_PTR(-EINVAL);
-}
-#endif
-
 static int stmpe_keypad_probe(struct platform_device *pdev)
 {
         struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent);
-        const struct stmpe_keypad_platform_data *plat;
+        struct device_node *np = pdev->dev.of_node;
         struct stmpe_keypad *keypad;
         struct input_dev *input;
+        u32 rows;
+        u32 cols;
         int error;
         int irq;
 
-        plat = stmpe->pdata->keypad;
-        if (!plat) {
-                plat = stmpe_keypad_of_probe(&pdev->dev);
-                if (IS_ERR(plat))
-                        return PTR_ERR(plat);
-        }
-
         irq = platform_get_irq(pdev, 0);
         if (irq < 0)
                 return irq;
@@ -326,6 +339,13 @@ static int stmpe_keypad_probe(struct platform_device *pdev)
         if (!keypad)
                 return -ENOMEM;
 
+        keypad->stmpe = stmpe;
+        keypad->variant = &stmpe_keypad_variants[stmpe->partnum];
+
+        of_property_read_u32(np, "debounce-interval", &keypad->debounce_ms);
+        of_property_read_u32(np, "st,scan-count", &keypad->scan_count);
+        keypad->no_autorepeat = of_property_read_bool(np, "st,no-autorepeat");
+
         input = devm_input_allocate_device(&pdev->dev);
         if (!input)
                 return -ENOMEM;
@@ -334,23 +354,22 @@ static int stmpe_keypad_probe(struct platform_device *pdev)
         input->id.bustype = BUS_I2C;
         input->dev.parent = &pdev->dev;
 
-        error = matrix_keypad_build_keymap(plat->keymap_data, NULL,
-                                           STMPE_KEYPAD_MAX_ROWS,
-                                           STMPE_KEYPAD_MAX_COLS,
+        error = matrix_keypad_parse_of_params(&pdev->dev, &rows, &cols);
+        if (error)
+                return error;
+
+        error = matrix_keypad_build_keymap(NULL, NULL, rows, cols,
                                            keypad->keymap, input);
         if (error)
                 return error;
 
         input_set_capability(input, EV_MSC, MSC_SCAN);
-        if (!plat->no_autorepeat)
+        if (!keypad->no_autorepeat)
                 __set_bit(EV_REP, input->evbit);
 
-        stmpe_keypad_fill_used_pins(keypad);
+        stmpe_keypad_fill_used_pins(keypad, rows, cols);
 
-        keypad->stmpe = stmpe;
-        keypad->plat = plat;
         keypad->input = input;
-        keypad->variant = &stmpe_keypad_variants[stmpe->partnum];
 
         error = stmpe_keypad_chip_init(keypad);
         if (error < 0)