Merge branch 'drm-next-merged' of git://people.freedesktop.org/~airlied/linux into v4l_for_linus

* 'drm-next-merged' of git://people.freedesktop.org/~airlied/linux: (9717 commits)
  media-bus: Fixup RGB444_1X12, RGB565_1X16, and YUV8_1X24 media bus format
  hexdump: avoid warning in test function
  fs: take i_mutex during prepare_binprm for set[ug]id executables
  smp: Fix error case handling in smp_call_function_*()
  iommu-common: Fix PARISC compile-time warnings
  sparc: Make LDC use common iommu poll management functions
  sparc: Make sparc64 use scalable lib/iommu-common.c functions
  Break up monolithic iommu table/lock into finer graularity pools and lock
  sparc: Revert generic IOMMU allocator.
  tools/power turbostat: correct dumped pkg-cstate-limit value
  tools/power turbostat: calculate TSC frequency from CPUID(0x15) on SKL
  tools/power turbostat: correct DRAM RAPL units on recent Xeon processors
  tools/power turbostat: Initial Skylake support
  tools/power turbostat: Use $(CURDIR) instead of $(PWD) and add support for O= option in Makefile
  tools/power turbostat: modprobe msr, if needed
  tools/power turbostat: dump MSR_TURBO_RATIO_LIMIT2
  tools/power turbostat: use new MSR_TURBO_RATIO_LIMIT names
  Bluetooth: hidp: Fix regression with older userspace and flags validation
  config: Enable NEED_DMA_MAP_STATE by default when SWIOTLB is selected
  perf/x86/intel/pt: Fix and clean up error handling in pt_event_add()
  ...

That solves several merge conflicts:
	Documentation/DocBook/media/v4l/subdev-formats.xml
	Documentation/devicetree/bindings/vendor-prefixes.txt
	drivers/staging/media/mn88473/mn88473.c
	include/linux/kconfig.h
	include/uapi/linux/media-bus-format.h

The ones at subdev-formats.xml and media-bus-format.h are not trivial.
That's why we opted to merge from DRM.

49 files changed, 3894 insertions, 308 deletions

diff --git a/drivers/input/input-mt.c b/drivers/input/input-mt.c
index cb150a1dbaff..54fce56c8023 100644
--- a/drivers/input/input-mt.c
+++ b/drivers/input/input-mt.c
@@ -88,10 +88,13 @@ int input_mt_init_slots(struct input_dev *dev, unsigned int num_slots,
                         goto err_mem;
         }
 
-        /* Mark slots as 'unused' */
+        /* Mark slots as 'inactive' */
         for (i = 0; i < num_slots; i++)
                 input_mt_set_value(&mt->slots[i], ABS_MT_TRACKING_ID, -1);
 
+        /* Mark slots as 'unused' */
+        mt->frame = 1;
+
         dev->mt = mt;
         return 0;
 err_mem:
@@ -365,27 +368,35 @@ static void input_mt_set_slots(struct input_mt *mt,
                                int *slots, int num_pos)
 {
         struct input_mt_slot *s;
-        int *w = mt->red, *p;
+        int *w = mt->red, j;
 
-        for (p = slots; p != slots + num_pos; p++)
-                *p = -1;
+        for (j = 0; j != num_pos; j++)
+                slots[j] = -1;
 
         for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
                 if (!input_mt_is_active(s))
                         continue;
-                for (p = slots; p != slots + num_pos; p++)
-                        if (*w++ < 0)
-                                *p = s - mt->slots;
+
+                for (j = 0; j != num_pos; j++) {
+                        if (w[j] < 0) {
+                                slots[j] = s - mt->slots;
+                                break;
+                        }
+                }
+
+                w += num_pos;
         }
 
         for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
                 if (input_mt_is_active(s))
                         continue;
-                for (p = slots; p != slots + num_pos; p++)
-                        if (*p < 0) {
-                                *p = s - mt->slots;
+
+                for (j = 0; j != num_pos; j++) {
+                        if (slots[j] < 0) {
+                                slots[j] = s - mt->slots;
                                 break;
                         }
+                }
         }
 }
 
@@ -439,6 +450,8 @@ EXPORT_SYMBOL(input_mt_assign_slots);
  * set the key on the first unused slot and return.
  *
  * If no available slot can be found, -1 is returned.
+ * Note that for this function to work properly, input_mt_sync_frame() has
+ * to be called at each frame.
  */
 int input_mt_get_slot_by_key(struct input_dev *dev, int key)
 {
@@ -453,7 +466,7 @@ int input_mt_get_slot_by_key(struct input_dev *dev, int key)
                         return s - mt->slots;
 
         for (s = mt->slots; s != mt->slots + mt->num_slots; s++)
-                if (!input_mt_is_active(s)) {
+                if (!input_mt_is_active(s) && !input_mt_is_used(mt, s)) {
                         s->key = key;
                         return s - mt->slots;
                 }
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index a89ba7cb96f1..106fbac7f8c5 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -588,6 +588,16 @@ config KEYBOARD_DAVINCI
           To compile this driver as a module, choose M here: the
           module will be called davinci_keyscan.
 
+config KEYBOARD_IPAQ_MICRO
+        tristate "Buttons on Micro SoC (iPaq h3100,h3600,h3700)"
+        depends on MFD_IPAQ_MICRO
+        help
+          Say Y to enable support for the buttons attached to
+          Micro peripheral controller on iPAQ h3100/h3600/h3700
+
+          To compile this driver as a module, choose M here: the
+          module will be called ipaq-micro-keys.
+
 config KEYBOARD_OMAP
         tristate "TI OMAP keypad support"
         depends on ARCH_OMAP1
@@ -686,4 +696,15 @@ config KEYBOARD_CAP11XX
           To compile this driver as a module, choose M here: the
           module will be called cap11xx.
 
+config KEYBOARD_BCM
+        tristate "Broadcom keypad driver"
+        depends on OF && HAVE_CLK
+        select INPUT_MATRIXKMAP
+        default ARCH_BCM_CYGNUS
+        help
+          Say Y here if you want to use Broadcom keypad.
+
+          To compile this driver as a module, choose M here: the
+          module will be called bcm-keypad.
+
 endif
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 470767884bd8..df28d5553c05 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_KEYBOARD_ADP5589)		+= adp5589-keys.o
 obj-$(CONFIG_KEYBOARD_AMIGA)            += amikbd.o
 obj-$(CONFIG_KEYBOARD_ATARI)            += atakbd.o
 obj-$(CONFIG_KEYBOARD_ATKBD)            += atkbd.o
+obj-$(CONFIG_KEYBOARD_BCM)              += bcm-keypad.o
 obj-$(CONFIG_KEYBOARD_BFIN)             += bf54x-keys.o
 obj-$(CONFIG_KEYBOARD_CAP11XX)          += cap11xx.o
 obj-$(CONFIG_KEYBOARD_CLPS711X)         += clps711x-keypad.o
@@ -23,6 +24,7 @@ obj-$(CONFIG_KEYBOARD_TCA6416)		+= tca6416-keypad.o
 obj-$(CONFIG_KEYBOARD_TCA8418)          += tca8418_keypad.o
 obj-$(CONFIG_KEYBOARD_HIL)              += hil_kbd.o
 obj-$(CONFIG_KEYBOARD_HIL_OLD)          += hilkbd.o
+obj-$(CONFIG_KEYBOARD_IPAQ_MICRO)       += ipaq-micro-keys.o
 obj-$(CONFIG_KEYBOARD_IMX)              += imx_keypad.o
 obj-$(CONFIG_KEYBOARD_HP6XX)            += jornada680_kbd.o
 obj-$(CONFIG_KEYBOARD_HP7XX)            += jornada720_kbd.o
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index 387c51f4b4e4..ec876b5b1382 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -1653,6 +1653,12 @@ static int __init atkbd_deactivate_fixup(const struct dmi_system_id *id)
         return 1;
 }
 
+/*
+ * NOTE: do not add any more "force release" quirks to this table.  The
+ * task of adjusting list of keys that should be "released" automatically
+ * by the driver is now delegated to userspace tools, such as udev, so
+ * submit such quirks there.
+ */
 static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
         {
                 .matches = {
diff --git a/drivers/input/keyboard/bcm-keypad.c b/drivers/input/keyboard/bcm-keypad.c
new file mode 100644
index 000000000000..86a8b723ae15
--- /dev/null
+++ b/drivers/input/keyboard/bcm-keypad.c
@@ -0,0 +1,458 @@
+/*
+ * Copyright (C) 2014 Broadcom Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/bitops.h>
+#include <linux/clk.h>
+#include <linux/gfp.h>
+#include <linux/io.h>
+#include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/stddef.h>
+#include <linux/types.h>
+
+#define DEFAULT_CLK_HZ                  31250
+#define MAX_ROWS                        8
+#define MAX_COLS                        8
+
+/* Register/field definitions */
+#define KPCR_OFFSET                     0x00000080
+#define KPCR_MODE                       0x00000002
+#define KPCR_MODE_SHIFT                 1
+#define KPCR_MODE_MASK                  1
+#define KPCR_ENABLE                     0x00000001
+#define KPCR_STATUSFILTERENABLE         0x00008000
+#define KPCR_STATUSFILTERTYPE_SHIFT     12
+#define KPCR_COLFILTERENABLE            0x00000800
+#define KPCR_COLFILTERTYPE_SHIFT        8
+#define KPCR_ROWWIDTH_SHIFT             20
+#define KPCR_COLUMNWIDTH_SHIFT          16
+
+#define KPIOR_OFFSET                    0x00000084
+#define KPIOR_ROWOCONTRL_SHIFT          24
+#define KPIOR_ROWOCONTRL_MASK           0xFF000000
+#define KPIOR_COLUMNOCONTRL_SHIFT       16
+#define KPIOR_COLUMNOCONTRL_MASK        0x00FF0000
+#define KPIOR_COLUMN_IO_DATA_SHIFT      0
+
+#define KPEMR0_OFFSET                   0x00000090
+#define KPEMR1_OFFSET                   0x00000094
+#define KPEMR2_OFFSET                   0x00000098
+#define KPEMR3_OFFSET                   0x0000009C
+#define KPEMR_EDGETYPE_BOTH             3
+
+#define KPSSR0_OFFSET                   0x000000A0
+#define KPSSR1_OFFSET                   0x000000A4
+#define KPSSRN_OFFSET(reg_n)            (KPSSR0_OFFSET + 4 * (reg_n))
+#define KPIMR0_OFFSET                   0x000000B0
+#define KPIMR1_OFFSET                   0x000000B4
+#define KPICR0_OFFSET                   0x000000B8
+#define KPICR1_OFFSET                   0x000000BC
+#define KPICRN_OFFSET(reg_n)            (KPICR0_OFFSET + 4 * (reg_n))
+#define KPISR0_OFFSET                   0x000000C0
+#define KPISR1_OFFSET                   0x000000C4
+
+#define KPCR_STATUSFILTERTYPE_MAX       7
+#define KPCR_COLFILTERTYPE_MAX          7
+
+/* Macros to determine the row/column from a bit that is set in SSR0/1. */
+#define BIT_TO_ROW_SSRN(bit_nr, reg_n)  (((bit_nr) >> 3) + 4 * (reg_n))
+#define BIT_TO_COL(bit_nr)              ((bit_nr) % 8)
+
+/* Structure representing various run-time entities */
+struct bcm_kp {
+        void __iomem *base;
+        int irq;
+        struct clk *clk;
+        struct input_dev *input_dev;
+        unsigned long last_state[2];
+        unsigned int n_rows;
+        unsigned int n_cols;
+        u32 kpcr;
+        u32 kpior;
+        u32 kpemr;
+        u32 imr0_val;
+        u32 imr1_val;
+};
+
+/*
+ * Returns the keycode from the input device keymap given the row and
+ * column.
+ */
+static int bcm_kp_get_keycode(struct bcm_kp *kp, int row, int col)
+{
+        unsigned int row_shift = get_count_order(kp->n_cols);
+        unsigned short *keymap = kp->input_dev->keycode;
+
+        return keymap[MATRIX_SCAN_CODE(row, col, row_shift)];
+}
+
+static void bcm_kp_report_keys(struct bcm_kp *kp, int reg_num, int pull_mode)
+{
+        unsigned long state, change;
+        int bit_nr;
+        int key_press;
+        int row, col;
+        unsigned int keycode;
+
+        /* Clear interrupts */
+        writel(0xFFFFFFFF, kp->base + KPICRN_OFFSET(reg_num));
+
+        state = readl(kp->base + KPSSRN_OFFSET(reg_num));
+        change = kp->last_state[reg_num] ^ state;
+        kp->last_state[reg_num] = state;
+
+        for_each_set_bit(bit_nr, &change, BITS_PER_LONG) {
+                key_press = state & BIT(bit_nr);
+                /* The meaning of SSR register depends on pull mode. */
+                key_press = pull_mode ? !key_press : key_press;
+                row = BIT_TO_ROW_SSRN(bit_nr, reg_num);
+                col = BIT_TO_COL(bit_nr);
+                keycode = bcm_kp_get_keycode(kp, row, col);
+                input_report_key(kp->input_dev, keycode, key_press);
+        }
+}
+
+static irqreturn_t bcm_kp_isr_thread(int irq, void *dev_id)
+{
+        struct bcm_kp *kp = dev_id;
+        int pull_mode = (kp->kpcr >> KPCR_MODE_SHIFT) & KPCR_MODE_MASK;
+        int reg_num;
+
+        for (reg_num = 0; reg_num <= 1; reg_num++)
+                bcm_kp_report_keys(kp, reg_num, pull_mode);
+
+        input_sync(kp->input_dev);
+
+        return IRQ_HANDLED;
+}
+
+static int bcm_kp_start(struct bcm_kp *kp)
+{
+        int error;
+
+        if (kp->clk) {
+                error = clk_prepare_enable(kp->clk);
+                if (error)
+                        return error;
+        }
+
+        writel(kp->kpior, kp->base + KPIOR_OFFSET);
+
+        writel(kp->imr0_val, kp->base + KPIMR0_OFFSET);
+        writel(kp->imr1_val, kp->base + KPIMR1_OFFSET);
+
+        writel(kp->kpemr, kp->base + KPEMR0_OFFSET);
+        writel(kp->kpemr, kp->base + KPEMR1_OFFSET);
+        writel(kp->kpemr, kp->base + KPEMR2_OFFSET);
+        writel(kp->kpemr, kp->base + KPEMR3_OFFSET);
+
+        writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
+        writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);
+
+        kp->last_state[0] = readl(kp->base + KPSSR0_OFFSET);
+        kp->last_state[0] = readl(kp->base + KPSSR1_OFFSET);
+
+        writel(kp->kpcr | KPCR_ENABLE, kp->base + KPCR_OFFSET);
+
+        return 0;
+}
+
+static void bcm_kp_stop(const struct bcm_kp *kp)
+{
+        u32 val;
+
+        val = readl(kp->base + KPCR_OFFSET);
+        val &= ~KPCR_ENABLE;
+        writel(0, kp->base + KPCR_OFFSET);
+        writel(0, kp->base + KPIMR0_OFFSET);
+        writel(0, kp->base + KPIMR1_OFFSET);
+        writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
+        writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);
+
+        if (kp->clk)
+                clk_disable_unprepare(kp->clk);
+}
+
+static int bcm_kp_open(struct input_dev *dev)
+{
+        struct bcm_kp *kp = input_get_drvdata(dev);
+
+        return bcm_kp_start(kp);
+}
+
+static void bcm_kp_close(struct input_dev *dev)
+{
+        struct bcm_kp *kp = input_get_drvdata(dev);
+
+        bcm_kp_stop(kp);
+}
+
+static int bcm_kp_matrix_key_parse_dt(struct bcm_kp *kp)
+{
+        struct device *dev = kp->input_dev->dev.parent;
+        struct device_node *np = dev->of_node;
+        int error;
+        unsigned int dt_val;
+        unsigned int i;
+        unsigned int num_rows, col_mask, rows_set;
+
+        /* Initialize the KPCR Keypad Configuration Register */
+        kp->kpcr = KPCR_STATUSFILTERENABLE | KPCR_COLFILTERENABLE;
+
+        error = matrix_keypad_parse_of_params(dev, &kp->n_rows, &kp->n_cols);
+        if (error) {
+                dev_err(dev, "failed to parse kp params\n");
+                return error;
+        }
+
+        /* Set row width for the ASIC block. */
+        kp->kpcr |= (kp->n_rows - 1) << KPCR_ROWWIDTH_SHIFT;
+
+        /* Set column width for the ASIC block. */
+        kp->kpcr |= (kp->n_cols - 1) << KPCR_COLUMNWIDTH_SHIFT;
+
+        /* Configure the IMR registers */
+
+        /*
+         * IMR registers contain interrupt enable bits for 8x8 matrix
+         * IMR0 register format: <row3> <row2> <row1> <row0>
+         * IMR1 register format: <row7> <row6> <row5> <row4>
+         */
+        col_mask = (1 << (kp->n_cols)) - 1;
+        num_rows = kp->n_rows;
+
+        /* Set column bits in rows 0 to 3 in IMR0 */
+        kp->imr0_val = col_mask;
+
+        rows_set = 1;
+        while (--num_rows && rows_set++ < 4)
+                kp->imr0_val |= kp->imr0_val << MAX_COLS;
+
+        /* Set column bits in rows 4 to 7 in IMR1 */
+        kp->imr1_val = 0;
+        if (num_rows) {
+                kp->imr1_val = col_mask;
+                while (--num_rows)
+                        kp->imr1_val |= kp->imr1_val << MAX_COLS;
+        }
+
+        /* Initialize the KPEMR Keypress Edge Mode Registers */
+        /* Trigger on both edges */
+        kp->kpemr = 0;
+        for (i = 0; i <= 30; i += 2)
+                kp->kpemr |= (KPEMR_EDGETYPE_BOTH << i);
+
+        /*
+         * Obtain the Status filter debounce value and verify against the
+         * possible values specified in the DT binding.
+         */
+        of_property_read_u32(np, "status-debounce-filter-period", &dt_val);
+
+        if (dt_val > KPCR_STATUSFILTERTYPE_MAX) {
+                dev_err(dev, "Invalid Status filter debounce value %d\n",
+                        dt_val);
+                return -EINVAL;
+        }
+
+        kp->kpcr |= dt_val << KPCR_STATUSFILTERTYPE_SHIFT;
+
+        /*
+         * Obtain the Column filter debounce value and verify against the
+         * possible values specified in the DT binding.
+         */
+        of_property_read_u32(np, "col-debounce-filter-period", &dt_val);
+
+        if (dt_val > KPCR_COLFILTERTYPE_MAX) {
+                dev_err(dev, "Invalid Column filter debounce value %d\n",
+                        dt_val);
+                return -EINVAL;
+        }
+
+        kp->kpcr |= dt_val << KPCR_COLFILTERTYPE_SHIFT;
+
+        /*
+         * Determine between the row and column,
+         * which should be configured as output.
+         */
+        if (of_property_read_bool(np, "row-output-enabled")) {
+                /*
+                * Set RowOContrl or ColumnOContrl in KPIOR
+                * to the number of pins to drive as outputs
+                */
+                kp->kpior = ((1 << kp->n_rows) - 1) <<
+                                KPIOR_ROWOCONTRL_SHIFT;
+        } else {
+                kp->kpior = ((1 << kp->n_cols) - 1) <<
+                                KPIOR_COLUMNOCONTRL_SHIFT;
+        }
+
+        /*
+         * Determine if the scan pull up needs to be enabled
+         */
+        if (of_property_read_bool(np, "pull-up-enabled"))
+                kp->kpcr |= KPCR_MODE;
+
+        dev_dbg(dev, "n_rows=%d n_col=%d kpcr=%x kpior=%x kpemr=%x\n",
+                kp->n_rows, kp->n_cols,
+                kp->kpcr, kp->kpior, kp->kpemr);
+
+        return 0;
+}
+
+
+static int bcm_kp_probe(struct platform_device *pdev)
+{
+        struct bcm_kp *kp;
+        struct input_dev *input_dev;
+        struct resource *res;
+        int error;
+
+        kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
+        if (!kp)
+                return -ENOMEM;
+
+        input_dev = devm_input_allocate_device(&pdev->dev);
+        if (!input_dev) {
+                dev_err(&pdev->dev, "failed to allocate the input device\n");
+                return -ENOMEM;
+        }
+
+        __set_bit(EV_KEY, input_dev->evbit);
+
+        /* Enable auto repeat feature of Linux input subsystem */
+        if (of_property_read_bool(pdev->dev.of_node, "autorepeat"))
+                __set_bit(EV_REP, input_dev->evbit);
+
+        input_dev->name = pdev->name;
+        input_dev->phys = "keypad/input0";
+        input_dev->dev.parent = &pdev->dev;
+        input_dev->open = bcm_kp_open;
+        input_dev->close = bcm_kp_close;
+
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->id.vendor = 0x0001;
+        input_dev->id.product = 0x0001;
+        input_dev->id.version = 0x0100;
+
+        input_set_drvdata(input_dev, kp);
+
+        kp->input_dev = input_dev;
+
+        platform_set_drvdata(pdev, kp);
+
+        error = bcm_kp_matrix_key_parse_dt(kp);
+        if (error)
+                return error;
+
+        error = matrix_keypad_build_keymap(NULL, NULL,
+                                           kp->n_rows, kp->n_cols,
+                                           NULL, input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to build keymap\n");
+                return error;
+        }
+
+        /* Get the KEYPAD base address */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Missing keypad base address resource\n");
+                return -ENODEV;
+        }
+
+        kp->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(kp->base))
+                return PTR_ERR(kp->base);
+
+        /* Enable clock */
+        kp->clk = devm_clk_get(&pdev->dev, "peri_clk");
+        if (IS_ERR(kp->clk)) {
+                error = PTR_ERR(kp->clk);
+                if (error != -ENOENT) {
+                        if (error != -EPROBE_DEFER)
+                                dev_err(&pdev->dev, "Failed to get clock\n");
+                        return error;
+                }
+                dev_dbg(&pdev->dev,
+                        "No clock specified. Assuming it's enabled\n");
+                kp->clk = NULL;
+        } else {
+                unsigned int desired_rate;
+                long actual_rate;
+
+                error = of_property_read_u32(pdev->dev.of_node,
+                                             "clock-frequency", &desired_rate);
+                if (error < 0)
+                        desired_rate = DEFAULT_CLK_HZ;
+
+                actual_rate = clk_round_rate(kp->clk, desired_rate);
+                if (actual_rate <= 0)
+                        return -EINVAL;
+
+                error = clk_set_rate(kp->clk, actual_rate);
+                if (error)
+                        return error;
+
+                error = clk_prepare_enable(kp->clk);
+                if (error)
+                        return error;
+        }
+
+        /* Put the kp into a known sane state */
+        bcm_kp_stop(kp);
+
+        kp->irq = platform_get_irq(pdev, 0);
+        if (kp->irq < 0) {
+                dev_err(&pdev->dev, "no IRQ specified\n");
+                return -EINVAL;
+        }
+
+        error = devm_request_threaded_irq(&pdev->dev, kp->irq,
+                                          NULL, bcm_kp_isr_thread,
+                                          IRQF_ONESHOT, pdev->name, kp);
+        if (error) {
+                dev_err(&pdev->dev, "failed to request IRQ\n");
+                return error;
+        }
+
+        error = input_register_device(input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                return error;
+        }
+
+        return 0;
+}
+
+static const struct of_device_id bcm_kp_of_match[] = {
+        { .compatible = "brcm,bcm-keypad" },
+        { },
+};
+MODULE_DEVICE_TABLE(of, bcm_kp_of_match);
+
+static struct platform_driver bcm_kp_device_driver = {
+        .probe          = bcm_kp_probe,
+        .driver         = {
+                .name   = "bcm-keypad",
+                .of_match_table = of_match_ptr(bcm_kp_of_match),
+        }
+};
+
+module_platform_driver(bcm_kp_device_driver);
+
+MODULE_AUTHOR("Broadcom Corporation");
+MODULE_DESCRIPTION("BCM Keypad Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/keyboard/cros_ec_keyb.c b/drivers/input/keyboard/cros_ec_keyb.c
index ffa989f2c785..64b9b59ad4cb 100644
--- a/drivers/input/keyboard/cros_ec_keyb.c
+++ b/drivers/input/keyboard/cros_ec_keyb.c
@@ -338,7 +338,7 @@ static int cros_ec_keyb_resume(struct device *dev)
          * wake source (e.g. the lid is open and the user might press a key to
          * wake) then the key scan buffer should be preserved.
          */
-        if (ckdev->ec->was_wake_device)
+        if (!ckdev->ec->was_wake_device)
                 cros_ec_keyb_clear_keyboard(ckdev);
 
         return 0;
diff --git a/drivers/input/keyboard/gpio_keys_polled.c b/drivers/input/keyboard/gpio_keys_polled.c
index 90df4df58b07..097d7216d98e 100644
--- a/drivers/input/keyboard/gpio_keys_polled.c
+++ b/drivers/input/keyboard/gpio_keys_polled.c
@@ -125,7 +125,7 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
         device_for_each_child_node(dev, child) {
                 struct gpio_desc *desc;
 
-                desc = devm_get_gpiod_from_child(dev, child);
+                desc = devm_get_gpiod_from_child(dev, NULL, child);
                 if (IS_ERR(desc)) {
                         error = PTR_ERR(desc);
                         if (error != -EPROBE_DEFER)
diff --git a/drivers/input/keyboard/ipaq-micro-keys.c b/drivers/input/keyboard/ipaq-micro-keys.c
new file mode 100644
index 000000000000..602900d1f937
--- /dev/null
+++ b/drivers/input/keyboard/ipaq-micro-keys.c
@@ -0,0 +1,168 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * h3600 atmel micro companion support, key subdevice
+ * based on previous kernel 2.4 version
+ * Author : Alessandro Gardich <gremlin@gremlin.it>
+ * Author : Linus Walleij <linus.walleij@linaro.org>
+ *
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/pm.h>
+#include <linux/sysctl.h>
+#include <linux/proc_fs.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/ipaq-micro.h>
+
+struct ipaq_micro_keys {
+        struct ipaq_micro *micro;
+        struct input_dev *input;
+        u16 *codes;
+};
+
+static const u16 micro_keycodes[] = {
+        KEY_RECORD,             /* 1:  Record button                    */
+        KEY_CALENDAR,           /* 2:  Calendar                         */
+        KEY_ADDRESSBOOK,        /* 3:  Contacts (looks like Outlook)    */
+        KEY_MAIL,               /* 4:  Envelope (Q on older iPAQs)      */
+        KEY_HOMEPAGE,           /* 5:  Start (looks like swoopy arrow)  */
+        KEY_UP,                 /* 6:  Up                               */
+        KEY_RIGHT,              /* 7:  Right                            */
+        KEY_LEFT,               /* 8:  Left                             */
+        KEY_DOWN,               /* 9:  Down                             */
+};
+
+static void micro_key_receive(void *data, int len, unsigned char *msg)
+{
+        struct ipaq_micro_keys *keys = data;
+        int key, down;
+
+        down = 0x80 & msg[0];
+        key  = 0x7f & msg[0];
+
+        if (key < ARRAY_SIZE(micro_keycodes)) {
+                input_report_key(keys->input, keys->codes[key], down);
+                input_sync(keys->input);
+        }
+}
+
+static void micro_key_start(struct ipaq_micro_keys *keys)
+{
+        spin_lock(&keys->micro->lock);
+        keys->micro->key = micro_key_receive;
+        keys->micro->key_data = keys;
+        spin_unlock(&keys->micro->lock);
+}
+
+static void micro_key_stop(struct ipaq_micro_keys *keys)
+{
+        spin_lock(&keys->micro->lock);
+        keys->micro->key = NULL;
+        keys->micro->key_data = NULL;
+        spin_unlock(&keys->micro->lock);
+}
+
+static int micro_key_open(struct input_dev *input)
+{
+        struct ipaq_micro_keys *keys = input_get_drvdata(input);
+
+        micro_key_start(keys);
+
+        return 0;
+}
+
+static void micro_key_close(struct input_dev *input)
+{
+        struct ipaq_micro_keys *keys = input_get_drvdata(input);
+
+        micro_key_stop(keys);
+}
+
+static int micro_key_probe(struct platform_device *pdev)
+{
+        struct ipaq_micro_keys *keys;
+        int error;
+        int i;
+
+        keys = devm_kzalloc(&pdev->dev, sizeof(*keys), GFP_KERNEL);
+        if (!keys)
+                return -ENOMEM;
+
+        keys->micro = dev_get_drvdata(pdev->dev.parent);
+
+        keys->input = devm_input_allocate_device(&pdev->dev);
+        if (!keys->input)
+                return -ENOMEM;
+
+        keys->input->keycodesize = sizeof(micro_keycodes[0]);
+        keys->input->keycodemax = ARRAY_SIZE(micro_keycodes);
+        keys->codes = devm_kmemdup(&pdev->dev, micro_keycodes,
+                           keys->input->keycodesize * keys->input->keycodemax,
+                           GFP_KERNEL);
+        keys->input->keycode = keys->codes;
+
+        __set_bit(EV_KEY, keys->input->evbit);
+        for (i = 0; i < ARRAY_SIZE(micro_keycodes); i++)
+                __set_bit(micro_keycodes[i], keys->input->keybit);
+
+        keys->input->name = "h3600 micro keys";
+        keys->input->open = micro_key_open;
+        keys->input->close = micro_key_close;
+        input_set_drvdata(keys->input, keys);
+
+        error = input_register_device(keys->input);
+        if (error)
+                return error;
+
+        platform_set_drvdata(pdev, keys);
+        return 0;
+}
+
+static int __maybe_unused micro_key_suspend(struct device *dev)
+{
+        struct ipaq_micro_keys *keys = dev_get_drvdata(dev);
+
+        micro_key_stop(keys);
+
+        return 0;
+}
+
+static int __maybe_unused micro_key_resume(struct device *dev)
+{
+        struct ipaq_micro_keys *keys = dev_get_drvdata(dev);
+        struct input_dev *input = keys->input;
+
+        mutex_lock(&input->mutex);
+
+        if (input->users)
+                micro_key_start(keys);
+
+        mutex_unlock(&input->mutex);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(micro_key_dev_pm_ops,
+                         micro_key_suspend, micro_key_resume);
+
+static struct platform_driver micro_key_device_driver = {
+        .driver = {
+                .name    = "ipaq-micro-keys",
+                .pm     = &micro_key_dev_pm_ops,
+        },
+        .probe   = micro_key_probe,
+};
+module_platform_driver(micro_key_device_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("driver for iPAQ Atmel micro keys");
+MODULE_ALIAS("platform:ipaq-micro-keys");
diff --git a/drivers/input/keyboard/tc3589x-keypad.c b/drivers/input/keyboard/tc3589x-keypad.c
index 8ff612d160b0..31c606a4dd31 100644
--- a/drivers/input/keyboard/tc3589x-keypad.c
+++ b/drivers/input/keyboard/tc3589x-keypad.c
@@ -70,6 +70,28 @@
 #define TC3589x_KBD_INT_CLR     0x1
 
 /**
+ * struct tc35893_keypad_platform_data - platform specific keypad data
+ * @keymap_data:        matrix scan code table for keycodes
+ * @krow:               mask for available rows, value is 0xFF
+ * @kcol:               mask for available columns, value is 0xFF
+ * @debounce_period:    platform specific debounce time
+ * @settle_time:        platform specific settle down time
+ * @irqtype:            type of interrupt, falling or rising edge
+ * @enable_wakeup:      specifies if keypad event can wake up system from sleep
+ * @no_autorepeat:      flag for auto repetition
+ */
+struct tc3589x_keypad_platform_data {
+        const struct matrix_keymap_data *keymap_data;
+        u8                      krow;
+        u8                      kcol;
+        u8                      debounce_period;
+        u8                      settle_time;
+        unsigned long           irqtype;
+        bool                    enable_wakeup;
+        bool                    no_autorepeat;
+};
+
+/**
  * struct tc_keypad - data structure used by keypad driver
  * @tc3589x:    pointer to tc35893
  * @input:      pointer to input device object
@@ -296,7 +318,6 @@ static void tc3589x_keypad_close(struct input_dev *input)
         tc3589x_keypad_disable(keypad);
 }
 
-#ifdef CONFIG_OF
 static const struct tc3589x_keypad_platform_data *
 tc3589x_keypad_of_probe(struct device *dev)
 {
@@ -346,14 +367,6 @@ tc3589x_keypad_of_probe(struct device *dev)
 
         return plat;
 }
-#else
-static inline const struct tc3589x_keypad_platform_data *
-tc3589x_keypad_of_probe(struct device *dev)
-{
-        return ERR_PTR(-ENODEV);
-}
-#endif
-
 
 static int tc3589x_keypad_probe(struct platform_device *pdev)
 {
@@ -363,13 +376,10 @@ static int tc3589x_keypad_probe(struct platform_device *pdev)
         const struct tc3589x_keypad_platform_data *plat;
         int error, irq;
 
-        plat = tc3589x->pdata->keypad;
-        if (!plat) {
-                plat = tc3589x_keypad_of_probe(&pdev->dev);
-                if (IS_ERR(plat)) {
-                        dev_err(&pdev->dev, "invalid keypad platform data\n");
-                        return PTR_ERR(plat);
-                }
+        plat = tc3589x_keypad_of_probe(&pdev->dev);
+        if (IS_ERR(plat)) {
+                dev_err(&pdev->dev, "invalid keypad platform data\n");
+                return PTR_ERR(plat);
         }
 
         irq = platform_get_irq(pdev, 0);
@@ -411,9 +421,9 @@ static int tc3589x_keypad_probe(struct platform_device *pdev)
 
         input_set_drvdata(input, keypad);
 
-        error = request_threaded_irq(irq, NULL,
-                        tc3589x_keypad_irq, plat->irqtype,
-                        "tc3589x-keypad", keypad);
+        error = request_threaded_irq(irq, NULL, tc3589x_keypad_irq,
+                                     plat->irqtype | IRQF_ONESHOT,
+                                     "tc3589x-keypad", keypad);
         if (error < 0) {
                 dev_err(&pdev->dev,
                                 "Could not allocate irq %d,error %d\n",
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 6deb8dae3205..4436ab1b9735 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -115,6 +115,18 @@ config INPUT_PCSPKR
           To compile this driver as a module, choose M here: the
           module will be called pcspkr.
 
+config INPUT_PM8941_PWRKEY
+        tristate "Qualcomm PM8941 power key support"
+        depends on MFD_SPMI_PMIC
+        help
+          Say Y here if you want support for the power key usually found
+          on boards using a Qualcomm PM8941 compatible PMIC.
+
+          If unsure, say Y.
+
+          To compile this driver as a module, choose M here: the module
+          will be called pm8941-pwrkey.
+
 config INPUT_PM8XXX_VIBRATOR
         tristate "Qualcomm PM8XXX vibrator support"
         depends on MFD_PM8XXX
@@ -165,6 +177,18 @@ config INPUT_MAX77693_HAPTIC
           To compile this driver as module, choose M here: the
           module will be called max77693-haptic.
 
+config INPUT_MAX77843_HAPTIC
+    tristate "MAXIM MAX77843 haptic controller support"
+    depends on MFD_MAX77843 && REGULATOR
+    select INPUT_FF_MEMLESS
+    help
+      This option enables support for the haptic controller on
+      MAXIM MAX77843 chip. The driver supports ff-memless interface
+      from input framework.
+
+      To compile this driver as module, choose M here: the
+      module will be called max77843-haptic.
+
 config INPUT_MAX8925_ONKEY
         tristate "MAX8925 ONKEY support"
         depends on MFD_MAX8925
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 403a1a54a76c..78ba4c1b8532 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -39,6 +39,7 @@ obj-$(CONFIG_INPUT_KEYSPAN_REMOTE)	+= keyspan_remote.o
 obj-$(CONFIG_INPUT_KXTJ9)               += kxtj9.o
 obj-$(CONFIG_INPUT_M68K_BEEP)           += m68kspkr.o
 obj-$(CONFIG_INPUT_MAX77693_HAPTIC)     += max77693-haptic.o
+obj-$(CONFIG_INPUT_MAX77843_HAPTIC)     += max77843-haptic.o
 obj-$(CONFIG_INPUT_MAX8925_ONKEY)       += max8925_onkey.o
 obj-$(CONFIG_INPUT_MAX8997_HAPTIC)      += max8997_haptic.o
 obj-$(CONFIG_INPUT_MC13783_PWRBUTTON)   += mc13783-pwrbutton.o
@@ -49,6 +50,7 @@ obj-$(CONFIG_INPUT_PCAP)		+= pcap_keys.o
 obj-$(CONFIG_INPUT_PCF50633_PMU)        += pcf50633-input.o
 obj-$(CONFIG_INPUT_PCF8574)             += pcf8574_keypad.o
 obj-$(CONFIG_INPUT_PCSPKR)              += pcspkr.o
+obj-$(CONFIG_INPUT_PM8941_PWRKEY)       += pm8941-pwrkey.o
 obj-$(CONFIG_INPUT_PM8XXX_VIBRATOR)     += pm8xxx-vibrator.o
 obj-$(CONFIG_INPUT_PMIC8XXX_PWRKEY)     += pmic8xxx-pwrkey.o
 obj-$(CONFIG_INPUT_POWERMATE)           += powermate.o
diff --git a/drivers/input/misc/max77843-haptic.c b/drivers/input/misc/max77843-haptic.c
new file mode 100644
index 000000000000..dccbb465a055
--- /dev/null
+++ b/drivers/input/misc/max77843-haptic.c
@@ -0,0 +1,358 @@
+/*
+ * MAXIM MAX77693 Haptic device driver
+ *
+ * Copyright (C) 2015 Samsung Electronics
+ * Author: Jaewon Kim <jaewon02.kim@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/mfd/max77843-private.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pwm.h>
+#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+
+#define MAX_MAGNITUDE_SHIFT        16
+
+enum max77843_haptic_motor_type {
+        MAX77843_HAPTIC_ERM = 0,
+        MAX77843_HAPTIC_LRA,
+};
+
+enum max77843_haptic_pwm_divisor {
+        MAX77843_HAPTIC_PWM_DIVISOR_32 = 0,
+        MAX77843_HAPTIC_PWM_DIVISOR_64,
+        MAX77843_HAPTIC_PWM_DIVISOR_128,
+        MAX77843_HAPTIC_PWM_DIVISOR_256,
+};
+
+struct max77843_haptic {
+        struct regmap *regmap_haptic;
+        struct device *dev;
+        struct input_dev *input_dev;
+        struct pwm_device *pwm_dev;
+        struct regulator *motor_reg;
+        struct work_struct work;
+        struct mutex mutex;
+
+        unsigned int magnitude;
+        unsigned int pwm_duty;
+
+        bool active;
+        bool suspended;
+
+        enum max77843_haptic_motor_type type;
+        enum max77843_haptic_pwm_divisor pwm_divisor;
+};
+
+static int max77843_haptic_set_duty_cycle(struct max77843_haptic *haptic)
+{
+        int delta = (haptic->pwm_dev->period + haptic->pwm_duty) / 2;
+        int error;
+
+        error = pwm_config(haptic->pwm_dev, delta, haptic->pwm_dev->period);
+        if (error) {
+                dev_err(haptic->dev, "failed to configure pwm: %d\n", error);
+                return error;
+        }
+
+        return 0;
+}
+
+static int max77843_haptic_bias(struct max77843_haptic *haptic, bool on)
+{
+        int error;
+
+        error = regmap_update_bits(haptic->regmap_haptic,
+                                   MAX77843_SYS_REG_MAINCTRL1,
+                                   MAX77843_MAINCTRL1_BIASEN_MASK,
+                                   on << MAINCTRL1_BIASEN_SHIFT);
+        if (error) {
+                dev_err(haptic->dev, "failed to %s bias: %d\n",
+                        on ? "enable" : "disable", error);
+                return error;
+        }
+
+        return 0;
+}
+
+static int max77843_haptic_config(struct max77843_haptic *haptic, bool enable)
+{
+        unsigned int value;
+        int error;
+
+        value = (haptic->type << MCONFIG_MODE_SHIFT) |
+                (enable << MCONFIG_MEN_SHIFT) |
+                (haptic->pwm_divisor << MCONFIG_PDIV_SHIFT);
+
+        error = regmap_write(haptic->regmap_haptic,
+                             MAX77843_HAP_REG_MCONFIG, value);
+        if (error) {
+                dev_err(haptic->dev,
+                        "failed to update haptic config: %d\n", error);
+                return error;
+        }
+
+        return 0;
+}
+
+static int max77843_haptic_enable(struct max77843_haptic *haptic)
+{
+        int error;
+
+        if (haptic->active)
+                return 0;
+
+        error = pwm_enable(haptic->pwm_dev);
+        if (error) {
+                dev_err(haptic->dev,
+                        "failed to enable pwm device: %d\n", error);
+                return error;
+        }
+
+        error = max77843_haptic_config(haptic, true);
+        if (error)
+                goto err_config;
+
+        haptic->active = true;
+
+        return 0;
+
+err_config:
+        pwm_disable(haptic->pwm_dev);
+
+        return error;
+}
+
+static int max77843_haptic_disable(struct max77843_haptic *haptic)
+{
+        int error;
+
+        if (!haptic->active)
+                return 0;
+
+        error = max77843_haptic_config(haptic, false);
+        if (error)
+                return error;
+
+        pwm_disable(haptic->pwm_dev);
+
+        haptic->active = false;
+
+        return 0;
+}
+
+static void max77843_haptic_play_work(struct work_struct *work)
+{
+        struct max77843_haptic *haptic =
+                        container_of(work, struct max77843_haptic, work);
+        int error;
+
+        mutex_lock(&haptic->mutex);
+
+        if (haptic->suspended)
+                goto out_unlock;
+
+        if (haptic->magnitude) {
+                error = max77843_haptic_set_duty_cycle(haptic);
+                if (error) {
+                        dev_err(haptic->dev,
+                                "failed to set duty cycle: %d\n", error);
+                        goto out_unlock;
+                }
+
+                error = max77843_haptic_enable(haptic);
+                if (error)
+                        dev_err(haptic->dev,
+                                "cannot enable haptic: %d\n", error);
+        } else {
+                error = max77843_haptic_disable(haptic);
+                if (error)
+                        dev_err(haptic->dev,
+                                "cannot disable haptic: %d\n", error);
+        }
+
+out_unlock:
+        mutex_unlock(&haptic->mutex);
+}
+
+static int max77843_haptic_play_effect(struct input_dev *dev, void *data,
+                struct ff_effect *effect)
+{
+        struct max77843_haptic *haptic = input_get_drvdata(dev);
+        u64 period_mag_multi;
+
+        haptic->magnitude = effect->u.rumble.strong_magnitude;
+        if (!haptic->magnitude)
+                haptic->magnitude = effect->u.rumble.weak_magnitude;
+
+        period_mag_multi = (u64)haptic->pwm_dev->period * haptic->magnitude;
+        haptic->pwm_duty = (unsigned int)(period_mag_multi >>
+                                                MAX_MAGNITUDE_SHIFT);
+
+        schedule_work(&haptic->work);
+
+        return 0;
+}
+
+static int max77843_haptic_open(struct input_dev *dev)
+{
+        struct max77843_haptic *haptic = input_get_drvdata(dev);
+        int error;
+
+        error = max77843_haptic_bias(haptic, true);
+        if (error)
+                return error;
+
+        error = regulator_enable(haptic->motor_reg);
+        if (error) {
+                dev_err(haptic->dev,
+                        "failed to enable regulator: %d\n", error);
+                return error;
+        }
+
+        return 0;
+}
+
+static void max77843_haptic_close(struct input_dev *dev)
+{
+        struct max77843_haptic *haptic = input_get_drvdata(dev);
+        int error;
+
+        cancel_work_sync(&haptic->work);
+        max77843_haptic_disable(haptic);
+
+        error = regulator_disable(haptic->motor_reg);
+        if (error)
+                dev_err(haptic->dev,
+                        "failed to disable regulator: %d\n", error);
+
+        max77843_haptic_bias(haptic, false);
+}
+
+static int max77843_haptic_probe(struct platform_device *pdev)
+{
+        struct max77843 *max77843 = dev_get_drvdata(pdev->dev.parent);
+        struct max77843_haptic *haptic;
+        int error;
+
+        haptic = devm_kzalloc(&pdev->dev, sizeof(*haptic), GFP_KERNEL);
+        if (!haptic)
+                return -ENOMEM;
+
+        haptic->regmap_haptic = max77843->regmap;
+        haptic->dev = &pdev->dev;
+        haptic->type = MAX77843_HAPTIC_LRA;
+        haptic->pwm_divisor = MAX77843_HAPTIC_PWM_DIVISOR_128;
+
+        INIT_WORK(&haptic->work, max77843_haptic_play_work);
+        mutex_init(&haptic->mutex);
+
+        haptic->pwm_dev = devm_pwm_get(&pdev->dev, NULL);
+        if (IS_ERR(haptic->pwm_dev)) {
+                dev_err(&pdev->dev, "failed to get pwm device\n");
+                return PTR_ERR(haptic->pwm_dev);
+        }
+
+        haptic->motor_reg = devm_regulator_get_exclusive(&pdev->dev, "haptic");
+        if (IS_ERR(haptic->motor_reg)) {
+                dev_err(&pdev->dev, "failed to get regulator\n");
+                return PTR_ERR(haptic->motor_reg);
+        }
+
+        haptic->input_dev = devm_input_allocate_device(&pdev->dev);
+        if (!haptic->input_dev) {
+                dev_err(&pdev->dev, "failed to allocate input device\n");
+                return -ENOMEM;
+        }
+
+        haptic->input_dev->name = "max77843-haptic";
+        haptic->input_dev->id.version = 1;
+        haptic->input_dev->dev.parent = &pdev->dev;
+        haptic->input_dev->open = max77843_haptic_open;
+        haptic->input_dev->close = max77843_haptic_close;
+        input_set_drvdata(haptic->input_dev, haptic);
+        input_set_capability(haptic->input_dev, EV_FF, FF_RUMBLE);
+
+        error = input_ff_create_memless(haptic->input_dev, NULL,
+                        max77843_haptic_play_effect);
+        if (error) {
+                dev_err(&pdev->dev, "failed to create force-feedback\n");
+                return error;
+        }
+
+        error = input_register_device(haptic->input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                return error;
+        }
+
+        platform_set_drvdata(pdev, haptic);
+
+        return 0;
+}
+
+static int __maybe_unused max77843_haptic_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct max77843_haptic *haptic = platform_get_drvdata(pdev);
+        int error;
+
+        error = mutex_lock_interruptible(&haptic->mutex);
+        if (error)
+                return error;
+
+        max77843_haptic_disable(haptic);
+
+        haptic->suspended = true;
+
+        mutex_unlock(&haptic->mutex);
+
+        return 0;
+}
+
+static int __maybe_unused max77843_haptic_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct max77843_haptic *haptic = platform_get_drvdata(pdev);
+        unsigned int magnitude;
+
+        mutex_lock(&haptic->mutex);
+
+        haptic->suspended = false;
+
+        magnitude = ACCESS_ONCE(haptic->magnitude);
+        if (magnitude)
+                max77843_haptic_enable(haptic);
+
+        mutex_unlock(&haptic->mutex);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(max77843_haptic_pm_ops,
+                max77843_haptic_suspend, max77843_haptic_resume);
+
+static struct platform_driver max77843_haptic_driver = {
+        .driver         = {
+                .name   = "max77843-haptic",
+                .pm     = &max77843_haptic_pm_ops,
+        },
+        .probe          = max77843_haptic_probe,
+};
+module_platform_driver(max77843_haptic_driver);
+
+MODULE_AUTHOR("Jaewon Kim <jaewon02.kim@samsung.com>");
+MODULE_DESCRIPTION("MAXIM MAX77843 Haptic driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/mma8450.c b/drivers/input/misc/mma8450.c
index 59d4dcddf6de..19c73574458e 100644
--- a/drivers/input/misc/mma8450.c
+++ b/drivers/input/misc/mma8450.c
@@ -174,12 +174,13 @@ static int mma8450_probe(struct i2c_client *c,
         struct mma8450 *m;
         int err;
 
-        m = kzalloc(sizeof(struct mma8450), GFP_KERNEL);
-        idev = input_allocate_polled_device();
-        if (!m || !idev) {
-                err = -ENOMEM;
-                goto err_free_mem;
-        }
+        m = devm_kzalloc(&c->dev, sizeof(*m), GFP_KERNEL);
+        if (!m)
+                return -ENOMEM;
+
+        idev = devm_input_allocate_polled_device(&c->dev);
+        if (!idev)
+                return -ENOMEM;
 
         m->client = c;
         m->idev = idev;
@@ -201,29 +202,12 @@ static int mma8450_probe(struct i2c_client *c,
         err = input_register_polled_device(idev);
         if (err) {
                 dev_err(&c->dev, "failed to register polled input device\n");
-                goto err_free_mem;
+                return err;
         }
 
         i2c_set_clientdata(c, m);
 
         return 0;
-
-err_free_mem:
-        input_free_polled_device(idev);
-        kfree(m);
-        return err;
-}
-
-static int mma8450_remove(struct i2c_client *c)
-{
-        struct mma8450 *m = i2c_get_clientdata(c);
-        struct input_polled_dev *idev = m->idev;
-
-        input_unregister_polled_device(idev);
-        input_free_polled_device(idev);
-        kfree(m);
-
-        return 0;
 }
 
 static const struct i2c_device_id mma8450_id[] = {
@@ -241,11 +225,9 @@ MODULE_DEVICE_TABLE(of, mma8450_dt_ids);
 static struct i2c_driver mma8450_driver = {
         .driver = {
                 .name   = MMA8450_DRV_NAME,
-                .owner  = THIS_MODULE,
                 .of_match_table = mma8450_dt_ids,
         },
         .probe          = mma8450_probe,
-        .remove         = mma8450_remove,
         .id_table       = mma8450_id,
 };
 
diff --git a/drivers/input/misc/palmas-pwrbutton.c b/drivers/input/misc/palmas-pwrbutton.c
index 1f9b5ee92746..1e1baed63929 100644
--- a/drivers/input/misc/palmas-pwrbutton.c
+++ b/drivers/input/misc/palmas-pwrbutton.c
@@ -304,7 +304,7 @@ static SIMPLE_DEV_PM_OPS(palmas_pwron_pm,
                          palmas_pwron_suspend, palmas_pwron_resume);
 
 #ifdef CONFIG_OF
-static struct of_device_id of_palmas_pwr_match[] = {
+static const struct of_device_id of_palmas_pwr_match[] = {
         { .compatible = "ti,palmas-pwrbutton" },
         { },
 };
diff --git a/drivers/input/misc/pm8941-pwrkey.c b/drivers/input/misc/pm8941-pwrkey.c
new file mode 100644
index 000000000000..867db8a91372
--- /dev/null
+++ b/drivers/input/misc/pm8941-pwrkey.c
@@ -0,0 +1,293 @@
+/*
+ * Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ * Copyright (c) 2014, Sony Mobile Communications Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/log2.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <linux/regmap.h>
+
+#define PON_REV2                        0x01
+
+#define PON_RT_STS                      0x10
+#define  PON_KPDPWR_N_SET               BIT(0)
+
+#define PON_PS_HOLD_RST_CTL             0x5a
+#define PON_PS_HOLD_RST_CTL2            0x5b
+#define  PON_PS_HOLD_ENABLE             BIT(7)
+#define  PON_PS_HOLD_TYPE_MASK          0x0f
+#define  PON_PS_HOLD_TYPE_SHUTDOWN      4
+#define  PON_PS_HOLD_TYPE_HARD_RESET    7
+
+#define PON_PULL_CTL                    0x70
+#define  PON_KPDPWR_PULL_UP             BIT(1)
+
+#define PON_DBC_CTL                     0x71
+#define  PON_DBC_DELAY_MASK             0x7
+
+
+struct pm8941_pwrkey {
+        struct device *dev;
+        int irq;
+        u32 baseaddr;
+        struct regmap *regmap;
+        struct input_dev *input;
+
+        unsigned int revision;
+        struct notifier_block reboot_notifier;
+};
+
+static int pm8941_reboot_notify(struct notifier_block *nb,
+                                unsigned long code, void *unused)
+{
+        struct pm8941_pwrkey *pwrkey = container_of(nb, struct pm8941_pwrkey,
+                                                    reboot_notifier);
+        unsigned int enable_reg;
+        unsigned int reset_type;
+        int error;
+
+        /* PMICs with revision 0 have the enable bit in same register as ctrl */
+        if (pwrkey->revision == 0)
+                enable_reg = PON_PS_HOLD_RST_CTL;
+        else
+                enable_reg = PON_PS_HOLD_RST_CTL2;
+
+        error = regmap_update_bits(pwrkey->regmap,
+                                   pwrkey->baseaddr + enable_reg,
+                                   PON_PS_HOLD_ENABLE,
+                                   0);
+        if (error)
+                dev_err(pwrkey->dev,
+                        "unable to clear ps hold reset enable: %d\n",
+                        error);
+
+        /*
+         * Updates of PON_PS_HOLD_ENABLE requires 3 sleep cycles between
+         * writes.
+         */
+        usleep_range(100, 1000);
+
+        switch (code) {
+        case SYS_HALT:
+        case SYS_POWER_OFF:
+                reset_type = PON_PS_HOLD_TYPE_SHUTDOWN;
+                break;
+        case SYS_RESTART:
+        default:
+                reset_type = PON_PS_HOLD_TYPE_HARD_RESET;
+                break;
+        };
+
+        error = regmap_update_bits(pwrkey->regmap,
+                                   pwrkey->baseaddr + PON_PS_HOLD_RST_CTL,
+                                   PON_PS_HOLD_TYPE_MASK,
+                                   reset_type);
+        if (error)
+                dev_err(pwrkey->dev, "unable to set ps hold reset type: %d\n",
+                        error);
+
+        error = regmap_update_bits(pwrkey->regmap,
+                                   pwrkey->baseaddr + enable_reg,
+                                   PON_PS_HOLD_ENABLE,
+                                   PON_PS_HOLD_ENABLE);
+        if (error)
+                dev_err(pwrkey->dev, "unable to re-set enable: %d\n", error);
+
+        return NOTIFY_DONE;
+}
+
+static irqreturn_t pm8941_pwrkey_irq(int irq, void *_data)
+{
+        struct pm8941_pwrkey *pwrkey = _data;
+        unsigned int sts;
+        int error;
+
+        error = regmap_read(pwrkey->regmap,
+                            pwrkey->baseaddr + PON_RT_STS, &sts);
+        if (error)
+                return IRQ_HANDLED;
+
+        input_report_key(pwrkey->input, KEY_POWER, !!(sts & PON_KPDPWR_N_SET));
+        input_sync(pwrkey->input);
+
+        return IRQ_HANDLED;
+}
+
+static int __maybe_unused pm8941_pwrkey_suspend(struct device *dev)
+{
+        struct pm8941_pwrkey *pwrkey = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                enable_irq_wake(pwrkey->irq);
+
+        return 0;
+}
+
+static int __maybe_unused pm8941_pwrkey_resume(struct device *dev)
+{
+        struct pm8941_pwrkey *pwrkey = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(pwrkey->irq);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(pm8941_pwr_key_pm_ops,
+                         pm8941_pwrkey_suspend, pm8941_pwrkey_resume);
+
+static int pm8941_pwrkey_probe(struct platform_device *pdev)
+{
+        struct pm8941_pwrkey *pwrkey;
+        bool pull_up;
+        u32 req_delay;
+        int error;
+
+        if (of_property_read_u32(pdev->dev.of_node, "debounce", &req_delay))
+                req_delay = 15625;
+
+        if (req_delay > 2000000 || req_delay == 0) {
+                dev_err(&pdev->dev, "invalid debounce time: %u\n", req_delay);
+                return -EINVAL;
+        }
+
+        pull_up = of_property_read_bool(pdev->dev.of_node, "bias-pull-up");
+
+        pwrkey = devm_kzalloc(&pdev->dev, sizeof(*pwrkey), GFP_KERNEL);
+        if (!pwrkey)
+                return -ENOMEM;
+
+        pwrkey->dev = &pdev->dev;
+
+        pwrkey->regmap = dev_get_regmap(pdev->dev.parent, NULL);
+        if (!pwrkey->regmap) {
+                dev_err(&pdev->dev, "failed to locate regmap\n");
+                return -ENODEV;
+        }
+
+        pwrkey->irq = platform_get_irq(pdev, 0);
+        if (pwrkey->irq < 0) {
+                dev_err(&pdev->dev, "failed to get irq\n");
+                return pwrkey->irq;
+        }
+
+        error = of_property_read_u32(pdev->dev.of_node, "reg",
+                                     &pwrkey->baseaddr);
+        if (error)
+                return error;
+
+        error = regmap_read(pwrkey->regmap, pwrkey->baseaddr + PON_REV2,
+                            &pwrkey->revision);
+        if (error) {
+                dev_err(&pdev->dev, "failed to set debounce: %d\n", error);
+                return error;
+        }
+
+        pwrkey->input = devm_input_allocate_device(&pdev->dev);
+        if (!pwrkey->input) {
+                dev_dbg(&pdev->dev, "unable to allocate input device\n");
+                return -ENOMEM;
+        }
+
+        input_set_capability(pwrkey->input, EV_KEY, KEY_POWER);
+
+        pwrkey->input->name = "pm8941_pwrkey";
+        pwrkey->input->phys = "pm8941_pwrkey/input0";
+
+        req_delay = (req_delay << 6) / USEC_PER_SEC;
+        req_delay = ilog2(req_delay);
+
+        error = regmap_update_bits(pwrkey->regmap,
+                                   pwrkey->baseaddr + PON_DBC_CTL,
+                                   PON_DBC_DELAY_MASK,
+                                   req_delay);
+        if (error) {
+                dev_err(&pdev->dev, "failed to set debounce: %d\n", error);
+                return error;
+        }
+
+        error = regmap_update_bits(pwrkey->regmap,
+                                   pwrkey->baseaddr + PON_PULL_CTL,
+                                   PON_KPDPWR_PULL_UP,
+                                   pull_up ? PON_KPDPWR_PULL_UP : 0);
+        if (error) {
+                dev_err(&pdev->dev, "failed to set pull: %d\n", error);
+                return error;
+        }
+
+        error = devm_request_threaded_irq(&pdev->dev, pwrkey->irq,
+                                          NULL, pm8941_pwrkey_irq,
+                                          IRQF_ONESHOT,
+                                          "pm8941_pwrkey", pwrkey);
+        if (error) {
+                dev_err(&pdev->dev, "failed requesting IRQ: %d\n", error);
+                return error;
+        }
+
+        error = input_register_device(pwrkey->input);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register input device: %d\n",
+                        error);
+                return error;
+        }
+
+        pwrkey->reboot_notifier.notifier_call = pm8941_reboot_notify,
+        error = register_reboot_notifier(&pwrkey->reboot_notifier);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register reboot notifier: %d\n",
+                        error);
+                return error;
+        }
+
+        platform_set_drvdata(pdev, pwrkey);
+        device_init_wakeup(&pdev->dev, 1);
+
+        return 0;
+}
+
+static int pm8941_pwrkey_remove(struct platform_device *pdev)
+{
+        struct pm8941_pwrkey *pwrkey = platform_get_drvdata(pdev);
+
+        device_init_wakeup(&pdev->dev, 0);
+        unregister_reboot_notifier(&pwrkey->reboot_notifier);
+
+        return 0;
+}
+
+static const struct of_device_id pm8941_pwr_key_id_table[] = {
+        { .compatible = "qcom,pm8941-pwrkey" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, pm8941_pwr_key_id_table);
+
+static struct platform_driver pm8941_pwrkey_driver = {
+        .probe = pm8941_pwrkey_probe,
+        .remove = pm8941_pwrkey_remove,
+        .driver = {
+                .name = "pm8941-pwrkey",
+                .pm = &pm8941_pwr_key_pm_ops,
+                .of_match_table = of_match_ptr(pm8941_pwr_key_id_table),
+        },
+};
+module_platform_driver(pm8941_pwrkey_driver);
+
+MODULE_DESCRIPTION("PM8941 Power Key driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/misc/pwm-beeper.c b/drivers/input/misc/pwm-beeper.c
index a28ee70ff158..e82edf810d1f 100644
--- a/drivers/input/misc/pwm-beeper.c
+++ b/drivers/input/misc/pwm-beeper.c
@@ -50,7 +50,6 @@ static int pwm_beeper_event(struct input_dev *input,
         }
 
         if (value == 0) {
-                pwm_config(beeper->pwm, 0, 0);
                 pwm_disable(beeper->pwm);
         } else {
                 period = HZ_TO_NANOSECONDS(value);
@@ -169,12 +168,6 @@ static int __maybe_unused pwm_beeper_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(pwm_beeper_pm_ops,
                          pwm_beeper_suspend, pwm_beeper_resume);
 
-#ifdef CONFIG_PM_SLEEP
-#define PWM_BEEPER_PM_OPS (&pwm_beeper_pm_ops)
-#else
-#define PWM_BEEPER_PM_OPS NULL
-#endif
-
 #ifdef CONFIG_OF
 static const struct of_device_id pwm_beeper_match[] = {
         { .compatible = "pwm-beeper", },
@@ -187,7 +180,7 @@ static struct platform_driver pwm_beeper_driver = {
         .remove = pwm_beeper_remove,
         .driver = {
                 .name   = "pwm-beeper",
-                .pm     = PWM_BEEPER_PM_OPS,
+                .pm     = &pwm_beeper_pm_ops,
                 .of_match_table = of_match_ptr(pwm_beeper_match),
         },
 };
diff --git a/drivers/input/misc/regulator-haptic.c b/drivers/input/misc/regulator-haptic.c
index 132eb914ea3e..6bf3f1082f71 100644
--- a/drivers/input/misc/regulator-haptic.c
+++ b/drivers/input/misc/regulator-haptic.c
@@ -245,7 +245,7 @@ static int __maybe_unused regulator_haptic_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(regulator_haptic_pm_ops,
                 regulator_haptic_suspend, regulator_haptic_resume);
 
-static struct of_device_id regulator_haptic_dt_match[] = {
+static const struct of_device_id regulator_haptic_dt_match[] = {
         { .compatible = "regulator-haptic" },
         { /* sentinel */ },
 };
diff --git a/drivers/input/misc/tps65218-pwrbutton.c b/drivers/input/misc/tps65218-pwrbutton.c
index 54508dec4eb3..a39b62651a4b 100644
--- a/drivers/input/misc/tps65218-pwrbutton.c
+++ b/drivers/input/misc/tps65218-pwrbutton.c
@@ -106,7 +106,7 @@ static int tps65218_pwron_probe(struct platform_device *pdev)
         return 0;
 }
 
-static struct of_device_id of_tps65218_pwr_match[] = {
+static const struct of_device_id of_tps65218_pwr_match[] = {
         { .compatible = "ti,tps65218-pwrbutton" },
         { },
 };
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index d28726a0ef85..e6708f6efb4d 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -153,10 +153,18 @@ static const struct alps_protocol_info alps_v7_protocol_data = {
         ALPS_PROTO_V7, 0x48, 0x48, ALPS_DUALPOINT
 };
 
+static const struct alps_protocol_info alps_v8_protocol_data = {
+        ALPS_PROTO_V8, 0x18, 0x18, 0
+};
+
 static void alps_set_abs_params_st(struct alps_data *priv,
                                    struct input_dev *dev1);
 static void alps_set_abs_params_mt(struct alps_data *priv,
                                    struct input_dev *dev1);
+static void alps_set_abs_params_v7(struct alps_data *priv,
+                                   struct input_dev *dev1);
+static void alps_set_abs_params_ss4_v2(struct alps_data *priv,
+                                       struct input_dev *dev1);
 
 /* Packet formats are described in Documentation/input/alps.txt */
 
@@ -243,6 +251,14 @@ static void alps_process_packet_v1_v2(struct psmouse *psmouse)
                 return;
         }
 
+        /* Non interleaved V2 dualpoint has separate stick button bits */
+        if (priv->proto_version == ALPS_PROTO_V2 &&
+            priv->flags == (ALPS_PASS | ALPS_DUALPOINT)) {
+                left |= packet[0] & 1;
+                right |= packet[0] & 2;
+                middle |= packet[0] & 4;
+        }
+
         alps_report_buttons(dev, dev2, left, right, middle);
 
         /* Convert hardware tap to a reasonable Z value */
@@ -1085,6 +1101,176 @@ static void alps_process_packet_v7(struct psmouse *psmouse)
                 alps_process_touchpad_packet_v7(psmouse);
 }
 
+static unsigned char alps_get_pkt_id_ss4_v2(unsigned char *byte)
+{
+        unsigned char pkt_id = SS4_PACKET_ID_IDLE;
+
+        if (byte[0] == 0x18 && byte[1] == 0x10 && byte[2] == 0x00 &&
+            (byte[3] & 0x88) == 0x08 && byte[4] == 0x10 && byte[5] == 0x00) {
+                pkt_id = SS4_PACKET_ID_IDLE;
+        } else if (!(byte[3] & 0x10)) {
+                pkt_id = SS4_PACKET_ID_ONE;
+        } else if (!(byte[3] & 0x20)) {
+                pkt_id = SS4_PACKET_ID_TWO;
+        } else {
+                pkt_id = SS4_PACKET_ID_MULTI;
+        }
+
+        return pkt_id;
+}
+
+static int alps_decode_ss4_v2(struct alps_fields *f,
+                              unsigned char *p, struct psmouse *psmouse)
+{
+        struct alps_data *priv = psmouse->private;
+        unsigned char pkt_id;
+        unsigned int no_data_x, no_data_y;
+
+        pkt_id = alps_get_pkt_id_ss4_v2(p);
+
+        /* Current packet is 1Finger coordinate packet */
+        switch (pkt_id) {
+        case SS4_PACKET_ID_ONE:
+                f->mt[0].x = SS4_1F_X_V2(p);
+                f->mt[0].y = SS4_1F_Y_V2(p);
+                f->pressure = ((SS4_1F_Z_V2(p)) * 2) & 0x7f;
+                f->fingers = 1;
+                f->first_mp = 0;
+                f->is_mp = 0;
+                break;
+
+        case SS4_PACKET_ID_TWO:
+                if (priv->flags & ALPS_BUTTONPAD) {
+                        f->mt[0].x = SS4_BTL_MF_X_V2(p, 0);
+                        f->mt[0].y = SS4_BTL_MF_Y_V2(p, 0);
+                        f->mt[1].x = SS4_BTL_MF_X_V2(p, 1);
+                        f->mt[1].y = SS4_BTL_MF_Y_V2(p, 1);
+                } else {
+                        f->mt[0].x = SS4_STD_MF_X_V2(p, 0);
+                        f->mt[0].y = SS4_STD_MF_Y_V2(p, 0);
+                        f->mt[1].x = SS4_STD_MF_X_V2(p, 1);
+                        f->mt[1].y = SS4_STD_MF_Y_V2(p, 1);
+                }
+                f->pressure = SS4_MF_Z_V2(p, 0) ? 0x30 : 0;
+
+                if (SS4_IS_MF_CONTINUE(p)) {
+                        f->first_mp = 1;
+                } else {
+                        f->fingers = 2;
+                        f->first_mp = 0;
+                }
+                f->is_mp = 0;
+
+                break;
+
+        case SS4_PACKET_ID_MULTI:
+                if (priv->flags & ALPS_BUTTONPAD) {
+                        f->mt[2].x = SS4_BTL_MF_X_V2(p, 0);
+                        f->mt[2].y = SS4_BTL_MF_Y_V2(p, 0);
+                        f->mt[3].x = SS4_BTL_MF_X_V2(p, 1);
+                        f->mt[3].y = SS4_BTL_MF_Y_V2(p, 1);
+                        no_data_x = SS4_MFPACKET_NO_AX_BL;
+                        no_data_y = SS4_MFPACKET_NO_AY_BL;
+                } else {
+                        f->mt[2].x = SS4_STD_MF_X_V2(p, 0);
+                        f->mt[2].y = SS4_STD_MF_Y_V2(p, 0);
+                        f->mt[3].x = SS4_STD_MF_X_V2(p, 1);
+                        f->mt[3].y = SS4_STD_MF_Y_V2(p, 1);
+                        no_data_x = SS4_MFPACKET_NO_AX;
+                        no_data_y = SS4_MFPACKET_NO_AY;
+                }
+
+                f->first_mp = 0;
+                f->is_mp = 1;
+
+                if (SS4_IS_5F_DETECTED(p)) {
+                        f->fingers = 5;
+                } else if (f->mt[3].x == no_data_x &&
+                             f->mt[3].y == no_data_y) {
+                        f->mt[3].x = 0;
+                        f->mt[3].y = 0;
+                        f->fingers = 3;
+                } else {
+                        f->fingers = 4;
+                }
+                break;
+
+        case SS4_PACKET_ID_IDLE:
+        default:
+                memset(f, 0, sizeof(struct alps_fields));
+                break;
+        }
+
+        f->left = !!(SS4_BTN_V2(p) & 0x01);
+        if (!(priv->flags & ALPS_BUTTONPAD)) {
+                f->right = !!(SS4_BTN_V2(p) & 0x02);
+                f->middle = !!(SS4_BTN_V2(p) & 0x04);
+        }
+
+        return 0;
+}
+
+static void alps_process_packet_ss4_v2(struct psmouse *psmouse)
+{
+        struct alps_data *priv = psmouse->private;
+        unsigned char *packet = psmouse->packet;
+        struct input_dev *dev = psmouse->dev;
+        struct alps_fields *f = &priv->f;
+
+        memset(f, 0, sizeof(struct alps_fields));
+        priv->decode_fields(f, packet, psmouse);
+        if (priv->multi_packet) {
+                /*
+                 * Sometimes the first packet will indicate a multi-packet
+                 * sequence, but sometimes the next multi-packet would not
+                 * come. Check for this, and when it happens process the
+                 * position packet as usual.
+                 */
+                if (f->is_mp) {
+                        /* Now process the 1st packet */
+                        priv->decode_fields(f, priv->multi_data, psmouse);
+                } else {
+                        priv->multi_packet = 0;
+                }
+        }
+
+        /*
+         * "f.is_mp" would always be '0' after merging the 1st and 2nd packet.
+         * When it is set, it means 2nd packet comes without 1st packet come.
+         */
+        if (f->is_mp)
+                return;
+
+        /* Save the first packet */
+        if (!priv->multi_packet && f->first_mp) {
+                priv->multi_packet = 1;
+                memcpy(priv->multi_data, packet, sizeof(priv->multi_data));
+                return;
+        }
+
+        priv->multi_packet = 0;
+
+        alps_report_mt_data(psmouse, (f->fingers <= 4) ? f->fingers : 4);
+
+        input_mt_report_finger_count(dev, f->fingers);
+
+        input_report_key(dev, BTN_LEFT, f->left);
+        input_report_key(dev, BTN_RIGHT, f->right);
+        input_report_key(dev, BTN_MIDDLE, f->middle);
+
+        input_report_abs(dev, ABS_PRESSURE, f->pressure);
+        input_sync(dev);
+}
+
+static bool alps_is_valid_package_ss4_v2(struct psmouse *psmouse)
+{
+        if (psmouse->pktcnt == 4 && ((psmouse->packet[3] & 0x08) != 0x08))
+                return false;
+        if (psmouse->pktcnt == 6 && ((psmouse->packet[5] & 0x10) != 0x0))
+                return false;
+        return true;
+}
+
 static DEFINE_MUTEX(alps_mutex);
 
 static void alps_register_bare_ps2_mouse(struct work_struct *work)
@@ -1154,12 +1340,31 @@ out:
         mutex_unlock(&alps_mutex);
 }
 
-static void alps_report_bare_ps2_packet(struct input_dev *dev,
+static void alps_report_bare_ps2_packet(struct psmouse *psmouse,
                                         unsigned char packet[],
                                         bool report_buttons)
 {
+        struct alps_data *priv = psmouse->private;
+        struct input_dev *dev, *dev2 = NULL;
+
+        /* Figure out which device to use to report the bare packet */
+        if (priv->proto_version == ALPS_PROTO_V2 &&
+            (priv->flags & ALPS_DUALPOINT)) {
+                /* On V2 devices the DualPoint Stick reports bare packets */
+                dev = priv->dev2;
+                dev2 = psmouse->dev;
+        } else if (unlikely(IS_ERR_OR_NULL(priv->dev3))) {
+                /* Register dev3 mouse if we received PS/2 packet first time */
+                if (!IS_ERR(priv->dev3))
+                        psmouse_queue_work(psmouse, &priv->dev3_register_work,
+                                           0);
+                return;
+        } else {
+                dev = priv->dev3;
+        }
+
         if (report_buttons)
-                alps_report_buttons(dev, NULL,
+                alps_report_buttons(dev, dev2,
                                 packet[0] & 1, packet[0] & 2, packet[0] & 4);
 
         input_report_rel(dev, REL_X,
@@ -1232,8 +1437,8 @@ static psmouse_ret_t alps_handle_interleaved_ps2(struct psmouse *psmouse)
                  * de-synchronization.
                  */
 
-                alps_report_bare_ps2_packet(priv->dev2,
-                                            &psmouse->packet[3], false);
+                alps_report_bare_ps2_packet(psmouse, &psmouse->packet[3],
+                                            false);
 
                 /*
                  * Continue with the standard ALPS protocol handling,
@@ -1287,20 +1492,15 @@ static psmouse_ret_t alps_process_byte(struct psmouse *psmouse)
          * a device connected to the external PS/2 port. Because bare PS/2
          * protocol does not have enough constant bits to self-synchronize
          * properly we only do this if the device is fully synchronized.
+         * Can not distinguish V8's first byte from PS/2 packet's
          */
-        if (!psmouse->out_of_sync_cnt && (psmouse->packet[0] & 0xc8) == 0x08) {
-
-                /* Register dev3 mouse if we received PS/2 packet first time */
-                if (unlikely(!priv->dev3))
-                        psmouse_queue_work(psmouse,
-                                           &priv->dev3_register_work, 0);
+        if (priv->proto_version != ALPS_PROTO_V8 &&
+            !psmouse->out_of_sync_cnt &&
+            (psmouse->packet[0] & 0xc8) == 0x08) {
 
                 if (psmouse->pktcnt == 3) {
-                        /* Once dev3 mouse device is registered report data */
-                        if (likely(!IS_ERR_OR_NULL(priv->dev3)))
-                                alps_report_bare_ps2_packet(priv->dev3,
-                                                            psmouse->packet,
-                                                            true);
+                        alps_report_bare_ps2_packet(psmouse, psmouse->packet,
+                                                    true);
                         return PSMOUSE_FULL_PACKET;
                 }
                 return PSMOUSE_GOOD_DATA;
@@ -1345,8 +1545,10 @@ static psmouse_ret_t alps_process_byte(struct psmouse *psmouse)
                 return PSMOUSE_BAD_DATA;
         }
 
-        if (priv->proto_version == ALPS_PROTO_V7 &&
-            !alps_is_valid_package_v7(psmouse)) {
+        if ((priv->proto_version == ALPS_PROTO_V7 &&
+                        !alps_is_valid_package_v7(psmouse)) ||
+            (priv->proto_version == ALPS_PROTO_V8 &&
+                        !alps_is_valid_package_ss4_v2(psmouse))) {
                 psmouse_dbg(psmouse, "refusing packet[%i] = %x\n",
                             psmouse->pktcnt - 1,
                             psmouse->packet[psmouse->pktcnt - 1]);
@@ -2121,6 +2323,88 @@ error:
         return -1;
 }
 
+static int alps_get_otp_values_ss4_v2(struct psmouse *psmouse,
+                                      unsigned char index, unsigned char otp[])
+{
+        struct ps2dev *ps2dev = &psmouse->ps2dev;
+
+        switch (index) {
+        case 0:
+                if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSTREAM)  ||
+                    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSTREAM)  ||
+                    ps2_command(ps2dev, otp, PSMOUSE_CMD_GETINFO))
+                        return -1;
+
+                break;
+
+        case 1:
+                if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETPOLL)  ||
+                    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETPOLL)  ||
+                    ps2_command(ps2dev, otp, PSMOUSE_CMD_GETINFO))
+                        return -1;
+
+                break;
+        }
+
+        return 0;
+}
+
+static int alps_update_device_area_ss4_v2(unsigned char otp[][4],
+                                          struct alps_data *priv)
+{
+        int num_x_electrode;
+        int num_y_electrode;
+        int x_pitch, y_pitch, x_phys, y_phys;
+
+        num_x_electrode = SS4_NUMSENSOR_XOFFSET + (otp[1][0] & 0x0F);
+        num_y_electrode = SS4_NUMSENSOR_YOFFSET + ((otp[1][0] >> 4) & 0x0F);
+
+        priv->x_max = (num_x_electrode - 1) * SS4_COUNT_PER_ELECTRODE;
+        priv->y_max = (num_y_electrode - 1) * SS4_COUNT_PER_ELECTRODE;
+
+        x_pitch = ((otp[1][2] >> 2) & 0x07) + SS4_MIN_PITCH_MM;
+        y_pitch = ((otp[1][2] >> 5) & 0x07) + SS4_MIN_PITCH_MM;
+
+        x_phys = x_pitch * (num_x_electrode - 1); /* In 0.1 mm units */
+        y_phys = y_pitch * (num_y_electrode - 1); /* In 0.1 mm units */
+
+        priv->x_res = priv->x_max * 10 / x_phys; /* units / mm */
+        priv->y_res = priv->y_max * 10 / y_phys; /* units / mm */
+
+        return 0;
+}
+
+static int alps_update_btn_info_ss4_v2(unsigned char otp[][4],
+                                       struct alps_data *priv)
+{
+        unsigned char is_btnless;
+
+        is_btnless = (otp[1][1] >> 3) & 0x01;
+
+        if (is_btnless)
+                priv->flags |= ALPS_BUTTONPAD;
+
+        return 0;
+}
+
+static int alps_set_defaults_ss4_v2(struct psmouse *psmouse,
+                                    struct alps_data *priv)
+{
+        unsigned char otp[2][4];
+
+        memset(otp, 0, sizeof(otp));
+
+        if (alps_get_otp_values_ss4_v2(psmouse, 0, &otp[0][0]) ||
+            alps_get_otp_values_ss4_v2(psmouse, 1, &otp[1][0]))
+                return -1;
+
+        alps_update_device_area_ss4_v2(otp, priv);
+
+        alps_update_btn_info_ss4_v2(otp, priv);
+
+        return 0;
+}
+
 static int alps_dolphin_get_device_area(struct psmouse *psmouse,
                                         struct alps_data *priv)
 {
@@ -2213,6 +2497,35 @@ error:
         return ret;
 }
 
+static int alps_hw_init_ss4_v2(struct psmouse *psmouse)
+{
+        struct ps2dev *ps2dev = &psmouse->ps2dev;
+        char param[2] = {0x64, 0x28};
+        int ret = -1;
+
+        /* enter absolute mode */
+        if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSTREAM) ||
+            ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSTREAM) ||
+            ps2_command(ps2dev, &param[0], PSMOUSE_CMD_SETRATE) ||
+            ps2_command(ps2dev, &param[1], PSMOUSE_CMD_SETRATE)) {
+                goto error;
+        }
+
+        /* T.B.D. Decread noise packet number, delete in the future */
+        if (alps_exit_command_mode(psmouse) ||
+            alps_enter_command_mode(psmouse) ||
+            alps_command_mode_write_reg(psmouse, 0x001D, 0x20)) {
+                goto error;
+        }
+        alps_exit_command_mode(psmouse);
+
+        return ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE);
+
+error:
+        alps_exit_command_mode(psmouse);
+        return ret;
+}
+
 static int alps_set_protocol(struct psmouse *psmouse,
                              struct alps_data *priv,
                              const struct alps_protocol_info *protocol)
@@ -2281,10 +2594,12 @@ static int alps_set_protocol(struct psmouse *psmouse,
                 priv->set_abs_params = alps_set_abs_params_mt;
                 priv->nibble_commands = alps_v3_nibble_commands;
                 priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
-                priv->x_max = 1360;
-                priv->y_max = 660;
                 priv->x_bits = 23;
                 priv->y_bits = 12;
+
+                if (alps_dolphin_get_device_area(psmouse, priv))
+                        return -EIO;
+
                 break;
 
         case ALPS_PROTO_V6:
@@ -2300,17 +2615,29 @@ static int alps_set_protocol(struct psmouse *psmouse,
                 priv->hw_init = alps_hw_init_v7;
                 priv->process_packet = alps_process_packet_v7;
                 priv->decode_fields = alps_decode_packet_v7;
-                priv->set_abs_params = alps_set_abs_params_mt;
+                priv->set_abs_params = alps_set_abs_params_v7;
                 priv->nibble_commands = alps_v3_nibble_commands;
                 priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
-
-                if (alps_dolphin_get_device_area(psmouse, priv))
-                        return -EIO;
+                priv->x_max = 0xfff;
+                priv->y_max = 0x7ff;
 
                 if (priv->fw_ver[1] != 0xba)
                         priv->flags |= ALPS_BUTTONPAD;
 
                 break;
+
+        case ALPS_PROTO_V8:
+                priv->hw_init = alps_hw_init_ss4_v2;
+                priv->process_packet = alps_process_packet_ss4_v2;
+                priv->decode_fields = alps_decode_ss4_v2;
+                priv->set_abs_params = alps_set_abs_params_ss4_v2;
+                priv->nibble_commands = alps_v3_nibble_commands;
+                priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
+
+                if (alps_set_defaults_ss4_v2(psmouse, priv))
+                        return -EIO;
+
+                break;
         }
 
         return 0;
@@ -2379,6 +2706,9 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
                 } else if (ec[0] == 0x88 && ec[1] == 0x07 &&
                            ec[2] >= 0x90 && ec[2] <= 0x9d) {
                         protocol = &alps_v3_protocol_data;
+                } else if (e7[0] == 0x73 && e7[1] == 0x03 &&
+                           e7[2] == 0x14 && ec[1] == 0x02) {
+                        protocol = &alps_v8_protocol_data;
                 } else {
                         psmouse_dbg(psmouse,
                                     "Likely not an ALPS touchpad: E7=%3ph, EC=%3ph\n", e7, ec);
@@ -2427,10 +2757,11 @@ static void alps_set_abs_params_st(struct alps_data *priv,
 {
         input_set_abs_params(dev1, ABS_X, 0, priv->x_max, 0, 0);
         input_set_abs_params(dev1, ABS_Y, 0, priv->y_max, 0, 0);
+        input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0);
 }
 
-static void alps_set_abs_params_mt(struct alps_data *priv,
-                                   struct input_dev *dev1)
+static void alps_set_abs_params_mt_common(struct alps_data *priv,
+                                          struct input_dev *dev1)
 {
         input_set_abs_params(dev1, ABS_MT_POSITION_X, 0, priv->x_max, 0, 0);
         input_set_abs_params(dev1, ABS_MT_POSITION_Y, 0, priv->y_max, 0, 0);
@@ -2438,15 +2769,44 @@ static void alps_set_abs_params_mt(struct alps_data *priv,
         input_abs_set_res(dev1, ABS_MT_POSITION_X, priv->x_res);
         input_abs_set_res(dev1, ABS_MT_POSITION_Y, priv->y_res);
 
-        input_mt_init_slots(dev1, MAX_TOUCHES, INPUT_MT_POINTER |
-                INPUT_MT_DROP_UNUSED | INPUT_MT_TRACK | INPUT_MT_SEMI_MT);
-
         set_bit(BTN_TOOL_TRIPLETAP, dev1->keybit);
         set_bit(BTN_TOOL_QUADTAP, dev1->keybit);
+}
+
+static void alps_set_abs_params_mt(struct alps_data *priv,
+                                   struct input_dev *dev1)
+{
+        alps_set_abs_params_mt_common(priv, dev1);
+        input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0);
+
+        input_mt_init_slots(dev1, MAX_TOUCHES,
+                            INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
+                                INPUT_MT_TRACK | INPUT_MT_SEMI_MT);
+}
 
-        /* V7 is real multi-touch */
-        if (priv->proto_version == ALPS_PROTO_V7)
-                clear_bit(INPUT_PROP_SEMI_MT, dev1->propbit);
+static void alps_set_abs_params_v7(struct alps_data *priv,
+                                   struct input_dev *dev1)
+{
+        alps_set_abs_params_mt_common(priv, dev1);
+        set_bit(BTN_TOOL_QUINTTAP, dev1->keybit);
+
+        input_mt_init_slots(dev1, MAX_TOUCHES,
+                            INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
+                                INPUT_MT_TRACK);
+
+        set_bit(BTN_TOOL_QUINTTAP, dev1->keybit);
+}
+
+static void alps_set_abs_params_ss4_v2(struct alps_data *priv,
+                                       struct input_dev *dev1)
+{
+        alps_set_abs_params_mt_common(priv, dev1);
+        input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0);
+        set_bit(BTN_TOOL_QUINTTAP, dev1->keybit);
+
+        input_mt_init_slots(dev1, MAX_TOUCHES,
+                            INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
+                                INPUT_MT_TRACK);
 }
 
 int alps_init(struct psmouse *psmouse)
@@ -2479,9 +2839,6 @@ int alps_init(struct psmouse *psmouse)
         dev1->evbit[BIT_WORD(EV_ABS)] |= BIT_MASK(EV_ABS);
 
         priv->set_abs_params(priv, dev1);
-        /* No pressure on V7 */
-        if (priv->proto_version != ALPS_PROTO_V7)
-                input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0);
 
         if (priv->flags & ALPS_WHEEL) {
                 dev1->evbit[BIT_WORD(EV_REL)] |= BIT_MASK(EV_REL);
@@ -2605,8 +2962,10 @@ int alps_detect(struct psmouse *psmouse, bool set_properties)
                 return -ENOMEM;
 
         error = alps_identify(psmouse, priv);
-        if (error)
+        if (error) {
+                kfree(priv);
                 return error;
+        }
 
         if (set_properties) {
                 psmouse->vendor = "ALPS";
diff --git a/drivers/input/mouse/alps.h b/drivers/input/mouse/alps.h
index 02513c0502fc..6dfdccc3a7c6 100644
--- a/drivers/input/mouse/alps.h
+++ b/drivers/input/mouse/alps.h
@@ -22,14 +22,90 @@
 #define ALPS_PROTO_V5           0x500
 #define ALPS_PROTO_V6           0x600
 #define ALPS_PROTO_V7           0x700   /* t3btl t4s */
+#define ALPS_PROTO_V8           0x800   /* SS4btl SS4s */
 
-#define MAX_TOUCHES     2
+#define MAX_TOUCHES     4
 
 #define DOLPHIN_COUNT_PER_ELECTRODE     64
 #define DOLPHIN_PROFILE_XOFFSET         8       /* x-electrode offset */
 #define DOLPHIN_PROFILE_YOFFSET         1       /* y-electrode offset */
 
 /*
+ * enum SS4_PACKET_ID - defines the packet type for V8
+ * SS4_PACKET_ID_IDLE: There's no finger and no button activity.
+ * SS4_PACKET_ID_ONE: There's one finger on touchpad
+ *  or there's button activities.
+ * SS4_PACKET_ID_TWO: There's two or more fingers on touchpad
+ * SS4_PACKET_ID_MULTI: There's three or more fingers on touchpad
+*/
+enum SS4_PACKET_ID {
+        SS4_PACKET_ID_IDLE = 0,
+        SS4_PACKET_ID_ONE,
+        SS4_PACKET_ID_TWO,
+        SS4_PACKET_ID_MULTI,
+};
+
+#define SS4_COUNT_PER_ELECTRODE         256
+#define SS4_NUMSENSOR_XOFFSET           7
+#define SS4_NUMSENSOR_YOFFSET           7
+#define SS4_MIN_PITCH_MM                50
+
+#define SS4_MASK_NORMAL_BUTTONS         0x07
+
+#define SS4_1F_X_V2(_b)         ((_b[0] & 0x0007) |             \
+                                 ((_b[1] << 3) & 0x0078) |      \
+                                 ((_b[1] << 2) & 0x0380) |      \
+                                 ((_b[2] << 5) & 0x1C00)        \
+                                )
+
+#define SS4_1F_Y_V2(_b)         (((_b[2]) & 0x000F) |           \
+                                 ((_b[3] >> 2) & 0x0030) |      \
+                                 ((_b[4] << 6) & 0x03C0) |      \
+                                 ((_b[4] << 5) & 0x0C00)        \
+                                )
+
+#define SS4_1F_Z_V2(_b)         (((_b[5]) & 0x0F) |             \
+                                 ((_b[5] >> 1) & 0x70) |        \
+                                 ((_b[4]) & 0x80)               \
+                                )
+
+#define SS4_1F_LFB_V2(_b)       (((_b[2] >> 4) & 0x01) == 0x01)
+
+#define SS4_MF_LF_V2(_b, _i)    ((_b[1 + (_i) * 3] & 0x0004) == 0x0004)
+
+#define SS4_BTN_V2(_b)          ((_b[0] >> 5) & SS4_MASK_NORMAL_BUTTONS)
+
+#define SS4_STD_MF_X_V2(_b, _i) (((_b[0 + (_i) * 3] << 5) & 0x00E0) |   \
+                                 ((_b[1 + _i * 3]  << 5) & 0x1F00)      \
+                                )
+
+#define SS4_STD_MF_Y_V2(_b, _i) (((_b[1 + (_i) * 3] << 3) & 0x0010) |   \
+                                 ((_b[2 + (_i) * 3] << 5) & 0x01E0) |   \
+                                 ((_b[2 + (_i) * 3] << 4) & 0x0E00)     \
+                                )
+
+#define SS4_BTL_MF_X_V2(_b, _i) (SS4_STD_MF_X_V2(_b, _i) |              \
+                                 ((_b[0 + (_i) * 3] >> 3) & 0x0010)     \
+                                )
+
+#define SS4_BTL_MF_Y_V2(_b, _i) (SS4_STD_MF_Y_V2(_b, _i) | \
+                                 ((_b[0 + (_i) * 3] >> 3) & 0x0008)     \
+                                )
+
+#define SS4_MF_Z_V2(_b, _i)     (((_b[1 + (_i) * 3]) & 0x0001) |        \
+                                 ((_b[1 + (_i) * 3] >> 1) & 0x0002)     \
+                                )
+
+#define SS4_IS_MF_CONTINUE(_b)  ((_b[2] & 0x10) == 0x10)
+#define SS4_IS_5F_DETECTED(_b)  ((_b[2] & 0x10) == 0x10)
+
+
+#define SS4_MFPACKET_NO_AX      8160    /* X-Coordinate value */
+#define SS4_MFPACKET_NO_AY      4080    /* Y-Coordinate value */
+#define SS4_MFPACKET_NO_AX_BL   8176    /* Buttonless X-Coordinate value */
+#define SS4_MFPACKET_NO_AY_BL   4088    /* Buttonless Y-Coordinate value */
+
+/*
  * enum V7_PACKET_ID - defines the packet type for V7
  * V7_PACKET_ID_IDLE: There's no finger and no button activity.
  * V7_PACKET_ID_TWO: There's one or two non-resting fingers on touchpad
diff --git a/drivers/input/mouse/cyapa_gen3.c b/drivers/input/mouse/cyapa_gen3.c
index 77e9d70a986b..1e2291c378fe 100644
--- a/drivers/input/mouse/cyapa_gen3.c
+++ b/drivers/input/mouse/cyapa_gen3.c
@@ -20,7 +20,7 @@
 #include <linux/input/mt.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/unaligned/access_ok.h>
+#include <asm/unaligned.h>
 #include "cyapa.h"
 
 
diff --git a/drivers/input/mouse/cyapa_gen5.c b/drivers/input/mouse/cyapa_gen5.c
index ddf5393a1180..5b611dd71e79 100644
--- a/drivers/input/mouse/cyapa_gen5.c
+++ b/drivers/input/mouse/cyapa_gen5.c
@@ -17,7 +17,7 @@
 #include <linux/mutex.h>
 #include <linux/completion.h>
 #include <linux/slab.h>
-#include <linux/unaligned/access_ok.h>
+#include <asm/unaligned.h>
 #include <linux/crc-itu-t.h>
 #include "cyapa.h"
 
@@ -1926,7 +1926,7 @@ static int cyapa_gen5_read_idac_data(struct cyapa *cyapa,
                                 electrodes_tx = cyapa->electrodes_x;
                         max_element_cnt = ((cyapa->aligned_electrodes_rx + 7) &
                                                 ~7u) * electrodes_tx;
-                } else if (idac_data_type == GEN5_RETRIEVE_SELF_CAP_PWC_DATA) {
+                } else {
                         offset = 2;
                         max_element_cnt = cyapa->electrodes_x +
                                                 cyapa->electrodes_y;
diff --git a/drivers/input/mouse/elan_i2c.h b/drivers/input/mouse/elan_i2c.h
index e100c1b31597..9b2dc015f20c 100644
--- a/drivers/input/mouse/elan_i2c.h
+++ b/drivers/input/mouse/elan_i2c.h
@@ -17,7 +17,7 @@
  */
 
 #ifndef _ELAN_I2C_H
-#define _ELAN_i2C_H
+#define _ELAN_I2C_H
 
 #include <linux/types.h>
 
diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c
index 7ce8bfe22d7e..375d98f47483 100644
--- a/drivers/input/mouse/elan_i2c_core.c
+++ b/drivers/input/mouse/elan_i2c_core.c
@@ -99,7 +99,7 @@ static int elan_enable_power(struct elan_tp_data *data)
         error = regulator_enable(data->vcc);
         if (error) {
                 dev_err(&data->client->dev,
-                        "Failed to enable regulator: %d\n", error);
+                        "failed to enable regulator: %d\n", error);
                 return error;
         }
 
@@ -111,6 +111,7 @@ static int elan_enable_power(struct elan_tp_data *data)
                 msleep(30);
         } while (--repeat > 0);
 
+        dev_err(&data->client->dev, "failed to enable power: %d\n", error);
         return error;
 }
 
@@ -125,7 +126,7 @@ static int elan_disable_power(struct elan_tp_data *data)
                         error = regulator_disable(data->vcc);
                         if (error) {
                                 dev_err(&data->client->dev,
-                                        "Failed to disable regulator: %d\n",
+                                        "failed to disable regulator: %d\n",
                                         error);
                                 /* Attempt to power the chip back up */
                                 data->ops->power_control(data->client, true);
@@ -138,6 +139,7 @@ static int elan_disable_power(struct elan_tp_data *data)
                 msleep(30);
         } while (--repeat > 0);
 
+        dev_err(&data->client->dev, "failed to disable power: %d\n", error);
         return error;
 }
 
@@ -196,7 +198,6 @@ static int elan_initialize(struct elan_tp_data *data)
                 if (!error)
                         return 0;
 
-                repeat--;
                 msleep(30);
         } while (--repeat > 0);
 
@@ -1084,16 +1085,18 @@ static int __maybe_unused elan_resume(struct device *dev)
         }
 
         error = elan_enable_power(data);
-        if (error)
+        if (error) {
                 dev_err(dev, "power up when resuming failed: %d\n", error);
+                goto err;
+        }
 
         error = elan_initialize(data);
         if (error)
                 dev_err(dev, "initialize when resuming failed: %d\n", error);
 
+err:
         enable_irq(data->client->irq);
-
-        return 0;
+        return error;
 }
 
 static SIMPLE_DEV_PM_OPS(elan_pm_ops, elan_suspend, elan_resume);
diff --git a/drivers/input/mouse/elan_i2c_i2c.c b/drivers/input/mouse/elan_i2c_i2c.c
index 029941f861af..6cf0def6d35e 100644
--- a/drivers/input/mouse/elan_i2c_i2c.c
+++ b/drivers/input/mouse/elan_i2c_i2c.c
@@ -117,7 +117,15 @@ static int elan_i2c_write_cmd(struct i2c_client *client, u16 reg, u16 cmd)
         int ret;
 
         ret = i2c_transfer(client->adapter, &msg, 1);
-        return ret == 1 ? 0 : (ret < 0 ? ret : -EIO);
+        if (ret != 1) {
+                if (ret >= 0)
+                        ret = -EIO;
+                dev_err(&client->dev, "writing cmd (0x%04x) failed: %d\n",
+                        reg, ret);
+                return ret;
+        }
+
+        return 0;
 }
 
 static int elan_i2c_initialize(struct i2c_client *client)
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index 6e22682c8255..991dc6b20a58 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -893,6 +893,21 @@ static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
 }
 
 /*
+ * This writes the reg_07 value again to the hardware at the end of every
+ * set_rate call because the register loses its value. reg_07 allows setting
+ * absolute mode on v4 hardware
+ */
+static void elantech_set_rate_restore_reg_07(struct psmouse *psmouse,
+                unsigned int rate)
+{
+        struct elantech_data *etd = psmouse->private;
+
+        etd->original_set_rate(psmouse, rate);
+        if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
+                psmouse_err(psmouse, "restoring reg_07 failed\n");
+}
+
+/*
  * Put the touchpad into absolute mode
  */
 static int elantech_set_absolute_mode(struct psmouse *psmouse)
@@ -1094,6 +1109,8 @@ static int elantech_get_resolution_v4(struct psmouse *psmouse,
  * Asus K53SV              0x450f01        78, 15, 0c      2 hw buttons
  * Asus G46VW              0x460f02        00, 18, 0c      2 hw buttons
  * Asus G750JX             0x360f00        00, 16, 0c      2 hw buttons
+ * Asus TP500LN            0x381f17        10, 14, 0e      clickpad
+ * Asus X750JN             0x381f17        10, 14, 0e      clickpad
  * Asus UX31               0x361f00        20, 15, 0e      clickpad
  * Asus UX32VD             0x361f02        00, 15, 0e      clickpad
  * Avatar AVIU-145A2       0x361f00        ?               clickpad
@@ -1635,6 +1652,11 @@ int elantech_init(struct psmouse *psmouse)
                 goto init_fail;
         }
 
+        if (etd->fw_version == 0x381f17) {
+                etd->original_set_rate = psmouse->set_rate;
+                psmouse->set_rate = elantech_set_rate_restore_reg_07;
+        }
+
         if (elantech_set_input_params(psmouse)) {
                 psmouse_err(psmouse, "failed to query touchpad range.\n");
                 goto init_fail;
diff --git a/drivers/input/mouse/elantech.h b/drivers/input/mouse/elantech.h
index 6f3afec02f03..f965d1569cc3 100644
--- a/drivers/input/mouse/elantech.h
+++ b/drivers/input/mouse/elantech.h
@@ -142,6 +142,7 @@ struct elantech_data {
         struct finger_pos mt[ETP_MAX_FINGERS];
         unsigned char parity[256];
         int (*send_cmd)(struct psmouse *psmouse, unsigned char c, unsigned char *param);
+        void (*original_set_rate)(struct psmouse *psmouse, unsigned int rate);
 };
 
 #ifdef CONFIG_MOUSE_PS2_ELANTECH
diff --git a/drivers/input/mouse/focaltech.c b/drivers/input/mouse/focaltech.c
index 757f78a94aec..23d259416f2f 100644
--- a/drivers/input/mouse/focaltech.c
+++ b/drivers/input/mouse/focaltech.c
@@ -67,9 +67,6 @@ static void focaltech_reset(struct psmouse *psmouse)
 
 #define FOC_MAX_FINGERS 5
 
-#define FOC_MAX_X 2431
-#define FOC_MAX_Y 1663
-
 /*
  * Current state of a single finger on the touchpad.
  */
@@ -129,9 +126,17 @@ static void focaltech_report_state(struct psmouse *psmouse)
                 input_mt_slot(dev, i);
                 input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
                 if (active) {
-                        input_report_abs(dev, ABS_MT_POSITION_X, finger->x);
+                        unsigned int clamped_x, clamped_y;
+                        /*
+                         * The touchpad might report invalid data, so we clamp
+                         * the resulting values so that we do not confuse
+                         * userspace.
+                         */
+                        clamped_x = clamp(finger->x, 0U, priv->x_max);
+                        clamped_y = clamp(finger->y, 0U, priv->y_max);
+                        input_report_abs(dev, ABS_MT_POSITION_X, clamped_x);
                         input_report_abs(dev, ABS_MT_POSITION_Y,
-                                         FOC_MAX_Y - finger->y);
+                                         priv->y_max - clamped_y);
                 }
         }
         input_mt_report_pointer_emulation(dev, true);
@@ -180,16 +185,6 @@ static void focaltech_process_abs_packet(struct psmouse *psmouse,
 
         state->pressed = (packet[0] >> 4) & 1;
 
-        /*
-         * packet[5] contains some kind of tool size in the most
-         * significant nibble. 0xff is a special value (latching) that
-         * signals a large contact area.
-         */
-        if (packet[5] == 0xff) {
-                state->fingers[finger].valid = false;
-                return;
-        }
-
         state->fingers[finger].x = ((packet[1] & 0xf) << 8) | packet[2];
         state->fingers[finger].y = (packet[3] << 8) | packet[4];
         state->fingers[finger].valid = true;
@@ -381,6 +376,23 @@ static int focaltech_read_size(struct psmouse *psmouse)
 
         return 0;
 }
+
+void focaltech_set_resolution(struct psmouse *psmouse, unsigned int resolution)
+{
+        /* not supported yet */
+}
+
+static void focaltech_set_rate(struct psmouse *psmouse, unsigned int rate)
+{
+        /* not supported yet */
+}
+
+static void focaltech_set_scale(struct psmouse *psmouse,
+                                enum psmouse_scale scale)
+{
+        /* not supported yet */
+}
+
 int focaltech_init(struct psmouse *psmouse)
 {
         struct focaltech_data *priv;
@@ -415,6 +427,14 @@ int focaltech_init(struct psmouse *psmouse)
         psmouse->cleanup = focaltech_reset;
         /* resync is not supported yet */
         psmouse->resync_time = 0;
+        /*
+         * rate/resolution/scale changes are not supported yet, and
+         * the generic implementations of these functions seem to
+         * confuse some touchpads
+         */
+        psmouse->set_resolution = focaltech_set_resolution;
+        psmouse->set_rate = focaltech_set_rate;
+        psmouse->set_scale = focaltech_set_scale;
 
         return 0;
 
diff --git a/drivers/input/mouse/lifebook.c b/drivers/input/mouse/lifebook.c
index 23222dd5a66f..e5ed216824e9 100644
--- a/drivers/input/mouse/lifebook.c
+++ b/drivers/input/mouse/lifebook.c
@@ -256,8 +256,8 @@ static void lifebook_disconnect(struct psmouse *psmouse)
 
 int lifebook_detect(struct psmouse *psmouse, bool set_properties)
 {
-        if (!lifebook_present)
-                return -1;
+        if (!lifebook_present)
+                return -1;
 
         if (desired_serio_phys &&
             strcmp(psmouse->ps2dev.serio->phys, desired_serio_phys))
@@ -268,7 +268,7 @@ int lifebook_detect(struct psmouse *psmouse, bool set_properties)
                 psmouse->name = "Lifebook TouchScreen";
         }
 
-        return 0;
+        return 0;
 }
 
 static int lifebook_create_relative_device(struct psmouse *psmouse)
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 4ccd01d7a48d..27057df7ba74 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -454,6 +454,17 @@ static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate)
 }
 
 /*
+ * Here we set the mouse scaling.
+ */
+
+static void psmouse_set_scale(struct psmouse *psmouse, enum psmouse_scale scale)
+{
+        ps2_command(&psmouse->ps2dev, NULL,
+                    scale == PSMOUSE_SCALE21 ? PSMOUSE_CMD_SETSCALE21 :
+                                               PSMOUSE_CMD_SETSCALE11);
+}
+
+/*
  * psmouse_poll() - default poll handler. Everyone except for ALPS uses it.
  */
 
@@ -463,19 +474,45 @@ static int psmouse_poll(struct psmouse *psmouse)
                            PSMOUSE_CMD_POLL | (psmouse->pktsize << 8));
 }
 
+static bool psmouse_check_pnp_id(const char *id, const char * const ids[])
+{
+        int i;
+
+        for (i = 0; ids[i]; i++)
+                if (!strcasecmp(id, ids[i]))
+                        return true;
+
+        return false;
+}
+
 /*
  * psmouse_matches_pnp_id - check if psmouse matches one of the passed in ids.
  */
 bool psmouse_matches_pnp_id(struct psmouse *psmouse, const char * const ids[])
 {
-        int i;
-
-        if (!strncmp(psmouse->ps2dev.serio->firmware_id, "PNP:", 4))
-                for (i = 0; ids[i]; i++)
-                        if (strstr(psmouse->ps2dev.serio->firmware_id, ids[i]))
-                                return true;
+        struct serio *serio = psmouse->ps2dev.serio;
+        char *p, *fw_id_copy, *save_ptr;
+        bool found = false;
+
+        if (strncmp(serio->firmware_id, "PNP: ", 5))
+                return false;
+
+        fw_id_copy = kstrndup(&serio->firmware_id[5],
+                              sizeof(serio->firmware_id) - 5,
+                              GFP_KERNEL);
+        if (!fw_id_copy)
+                return false;
+
+        save_ptr = fw_id_copy;
+        while ((p = strsep(&fw_id_copy, " ")) != NULL) {
+                if (psmouse_check_pnp_id(p, ids)) {
+                        found = true;
+                        break;
+                }
+        }
 
-        return false;
+        kfree(save_ptr);
+        return found;
 }
 
 /*
@@ -689,6 +726,7 @@ static void psmouse_apply_defaults(struct psmouse *psmouse)
 
         psmouse->set_rate = psmouse_set_rate;
         psmouse->set_resolution = psmouse_set_resolution;
+        psmouse->set_scale = psmouse_set_scale;
         psmouse->poll = psmouse_poll;
         psmouse->protocol_handler = psmouse_process_byte;
         psmouse->pktsize = 3;
@@ -1160,7 +1198,7 @@ static void psmouse_initialize(struct psmouse *psmouse)
         if (psmouse_max_proto != PSMOUSE_PS2) {
                 psmouse->set_rate(psmouse, psmouse->rate);
                 psmouse->set_resolution(psmouse, psmouse->resolution);
-                ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
+                psmouse->set_scale(psmouse, PSMOUSE_SCALE11);
         }
 }
 
diff --git a/drivers/input/mouse/psmouse.h b/drivers/input/mouse/psmouse.h
index c2ff137ecbdb..d02e1bdc9ae4 100644
--- a/drivers/input/mouse/psmouse.h
+++ b/drivers/input/mouse/psmouse.h
@@ -36,6 +36,11 @@ typedef enum {
         PSMOUSE_FULL_PACKET
 } psmouse_ret_t;
 
+enum psmouse_scale {
+        PSMOUSE_SCALE11,
+        PSMOUSE_SCALE21
+};
+
 struct psmouse {
         void *private;
         struct input_dev *dev;
@@ -67,6 +72,7 @@ struct psmouse {
         psmouse_ret_t (*protocol_handler)(struct psmouse *psmouse);
         void (*set_rate)(struct psmouse *psmouse, unsigned int rate);
         void (*set_resolution)(struct psmouse *psmouse, unsigned int resolution);
+        void (*set_scale)(struct psmouse *psmouse, enum psmouse_scale scale);
 
         int (*reconnect)(struct psmouse *psmouse);
         void (*disconnect)(struct psmouse *psmouse);
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index f2cceb6493a0..630af73e98c4 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -123,32 +123,46 @@ void synaptics_reset(struct psmouse *psmouse)
 
 static bool cr48_profile_sensor;
 
+#define ANY_BOARD_ID 0
 struct min_max_quirk {
         const char * const *pnp_ids;
+        struct {
+                unsigned long int min, max;
+        } board_id;
         int x_min, x_max, y_min, y_max;
 };
 
 static const struct min_max_quirk min_max_pnpid_table[] = {
         {
                 (const char * const []){"LEN0033", NULL},
+                {ANY_BOARD_ID, ANY_BOARD_ID},
                 1024, 5052, 2258, 4832
         },
         {
-                (const char * const []){"LEN0035", "LEN0042", NULL},
+                (const char * const []){"LEN0042", NULL},
+                {ANY_BOARD_ID, ANY_BOARD_ID},
                 1232, 5710, 1156, 4696
         },
         {
                 (const char * const []){"LEN0034", "LEN0036", "LEN0037",
                                         "LEN0039", "LEN2002", "LEN2004",
                                         NULL},
+                {ANY_BOARD_ID, 2961},
                 1024, 5112, 2024, 4832
         },
         {
                 (const char * const []){"LEN2001", NULL},
+                {ANY_BOARD_ID, ANY_BOARD_ID},
                 1024, 5022, 2508, 4832
         },
         {
                 (const char * const []){"LEN2006", NULL},
+                {2691, 2691},
+                1024, 5045, 2457, 4832
+        },
+        {
+                (const char * const []){"LEN2006", NULL},
+                {ANY_BOARD_ID, ANY_BOARD_ID},
                 1264, 5675, 1171, 4688
         },
         { }
@@ -175,9 +189,7 @@ static const char * const topbuttonpad_pnp_ids[] = {
         "LEN0041",
         "LEN0042", /* Yoga */
         "LEN0045",
-        "LEN0046",
         "LEN0047",
-        "LEN0048",
         "LEN0049",
         "LEN2000",
         "LEN2001", /* Edge E431 */
@@ -185,7 +197,7 @@ static const char * const topbuttonpad_pnp_ids[] = {
         "LEN2003",
         "LEN2004", /* L440 */
         "LEN2005",
-        "LEN2006",
+        "LEN2006", /* Edge E440/E540 */
         "LEN2007",
         "LEN2008",
         "LEN2009",
@@ -194,6 +206,13 @@ static const char * const topbuttonpad_pnp_ids[] = {
         NULL
 };
 
+/* This list has been kindly provided by Synaptics. */
+static const char * const forcepad_pnp_ids[] = {
+        "SYN300D",
+        "SYN3014",
+        NULL
+};
+
 /*****************************************************************************
  *      Synaptics communications functions
  ****************************************************************************/
@@ -235,18 +254,39 @@ static int synaptics_model_id(struct psmouse *psmouse)
         return 0;
 }
 
+static int synaptics_more_extended_queries(struct psmouse *psmouse)
+{
+        struct synaptics_data *priv = psmouse->private;
+        unsigned char buf[3];
+
+        if (synaptics_send_cmd(psmouse, SYN_QUE_MEXT_CAPAB_10, buf))
+                return -1;
+
+        priv->ext_cap_10 = (buf[0]<<16) | (buf[1]<<8) | buf[2];
+
+        return 0;
+}
+
 /*
- * Read the board id from the touchpad
+ * Read the board id and the "More Extended Queries" from the touchpad
  * The board id is encoded in the "QUERY MODES" response
  */
-static int synaptics_board_id(struct psmouse *psmouse)
+static int synaptics_query_modes(struct psmouse *psmouse)
 {
         struct synaptics_data *priv = psmouse->private;
         unsigned char bid[3];
 
+        /* firmwares prior 7.5 have no board_id encoded */
+        if (SYN_ID_FULL(priv->identity) < 0x705)
+                return 0;
+
         if (synaptics_send_cmd(psmouse, SYN_QUE_MODES, bid))
                 return -1;
         priv->board_id = ((bid[0] & 0xfc) << 6) | bid[1];
+
+        if (SYN_MEXT_CAP_BIT(bid[0]))
+                return synaptics_more_extended_queries(psmouse);
+
         return 0;
 }
 
@@ -346,7 +386,6 @@ static int synaptics_resolution(struct psmouse *psmouse)
 {
         struct synaptics_data *priv = psmouse->private;
         unsigned char resp[3];
-        int i;
 
         if (SYN_ID_MAJOR(priv->identity) < 4)
                 return 0;
@@ -358,17 +397,6 @@ static int synaptics_resolution(struct psmouse *psmouse)
                 }
         }
 
-        for (i = 0; min_max_pnpid_table[i].pnp_ids; i++) {
-                if (psmouse_matches_pnp_id(psmouse,
-                                           min_max_pnpid_table[i].pnp_ids)) {
-                        priv->x_min = min_max_pnpid_table[i].x_min;
-                        priv->x_max = min_max_pnpid_table[i].x_max;
-                        priv->y_min = min_max_pnpid_table[i].y_min;
-                        priv->y_max = min_max_pnpid_table[i].y_max;
-                        return 0;
-                }
-        }
-
         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
             SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_MAX_COORDS, resp)) {
@@ -377,23 +405,69 @@ static int synaptics_resolution(struct psmouse *psmouse)
                 } else {
                         priv->x_max = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
                         priv->y_max = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
+                        psmouse_info(psmouse,
+                                     "queried max coordinates: x [..%d], y [..%d]\n",
+                                     priv->x_max, priv->y_max);
                 }
         }
 
-        if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 7 &&
-            SYN_CAP_MIN_DIMENSIONS(priv->ext_cap_0c)) {
+        if (SYN_CAP_MIN_DIMENSIONS(priv->ext_cap_0c) &&
+            (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 7 ||
+             /*
+              * Firmware v8.1 does not report proper number of extended
+              * capabilities, but has been proven to report correct min
+              * coordinates.
+              */
+             SYN_ID_FULL(priv->identity) == 0x801)) {
                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_MIN_COORDS, resp)) {
                         psmouse_warn(psmouse,
                                      "device claims to have min coordinates query, but I'm not able to read it.\n");
                 } else {
                         priv->x_min = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
                         priv->y_min = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
+                        psmouse_info(psmouse,
+                                     "queried min coordinates: x [%d..], y [%d..]\n",
+                                     priv->x_min, priv->y_min);
                 }
         }
 
         return 0;
 }
 
+/*
+ * Apply quirk(s) if the hardware matches
+ */
+
+static void synaptics_apply_quirks(struct psmouse *psmouse)
+{
+        struct synaptics_data *priv = psmouse->private;
+        int i;
+
+        for (i = 0; min_max_pnpid_table[i].pnp_ids; i++) {
+                if (!psmouse_matches_pnp_id(psmouse,
+                                            min_max_pnpid_table[i].pnp_ids))
+                        continue;
+
+                if (min_max_pnpid_table[i].board_id.min != ANY_BOARD_ID &&
+                    priv->board_id < min_max_pnpid_table[i].board_id.min)
+                        continue;
+
+                if (min_max_pnpid_table[i].board_id.max != ANY_BOARD_ID &&
+                    priv->board_id > min_max_pnpid_table[i].board_id.max)
+                        continue;
+
+                priv->x_min = min_max_pnpid_table[i].x_min;
+                priv->x_max = min_max_pnpid_table[i].x_max;
+                priv->y_min = min_max_pnpid_table[i].y_min;
+                priv->y_max = min_max_pnpid_table[i].y_max;
+                psmouse_info(psmouse,
+                             "quirked min/max coordinates: x [%d..%d], y [%d..%d]\n",
+                             priv->x_min, priv->x_max,
+                             priv->y_min, priv->y_max);
+                break;
+        }
+}
+
 static int synaptics_query_hardware(struct psmouse *psmouse)
 {
         if (synaptics_identify(psmouse))
@@ -402,13 +476,15 @@ static int synaptics_query_hardware(struct psmouse *psmouse)
                 return -1;
         if (synaptics_firmware_id(psmouse))
                 return -1;
-        if (synaptics_board_id(psmouse))
+        if (synaptics_query_modes(psmouse))
                 return -1;
         if (synaptics_capability(psmouse))
                 return -1;
         if (synaptics_resolution(psmouse))
                 return -1;
 
+        synaptics_apply_quirks(psmouse);
+
         return 0;
 }
 
@@ -516,18 +592,22 @@ static int synaptics_is_pt_packet(unsigned char *buf)
         return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
 }
 
-static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet)
+static void synaptics_pass_pt_packet(struct psmouse *psmouse,
+                                     struct serio *ptport,
+                                     unsigned char *packet)
 {
+        struct synaptics_data *priv = psmouse->private;
         struct psmouse *child = serio_get_drvdata(ptport);
 
         if (child && child->state == PSMOUSE_ACTIVATED) {
-                serio_interrupt(ptport, packet[1], 0);
+                serio_interrupt(ptport, packet[1] | priv->pt_buttons, 0);
                 serio_interrupt(ptport, packet[4], 0);
                 serio_interrupt(ptport, packet[5], 0);
                 if (child->pktsize == 4)
                         serio_interrupt(ptport, packet[2], 0);
-        } else
+        } else {
                 serio_interrupt(ptport, packet[1], 0);
+        }
 }
 
 static void synaptics_pt_activate(struct psmouse *psmouse)
@@ -605,7 +685,17 @@ static void synaptics_parse_agm(const unsigned char buf[],
         }
 }
 
-static bool is_forcepad;
+static void synaptics_parse_ext_buttons(const unsigned char buf[],
+                                        struct synaptics_data *priv,
+                                        struct synaptics_hw_state *hw)
+{
+        unsigned int ext_bits =
+                (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) + 1) >> 1;
+        unsigned int ext_mask = GENMASK(ext_bits - 1, 0);
+
+        hw->ext_buttons = buf[4] & ext_mask;
+        hw->ext_buttons |= (buf[5] & ext_mask) << ext_bits;
+}
 
 static int synaptics_parse_hw_state(const unsigned char buf[],
                                     struct synaptics_data *priv,
@@ -636,7 +726,7 @@ static int synaptics_parse_hw_state(const unsigned char buf[],
                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
                 hw->right = (buf[0] & 0x02) ? 1 : 0;
 
-                if (is_forcepad) {
+                if (priv->is_forcepad) {
                         /*
                          * ForcePads, like Clickpads, use middle button
                          * bits to report primary button clicks.
@@ -691,28 +781,9 @@ static int synaptics_parse_hw_state(const unsigned char buf[],
                         hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
                 }
 
-                if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
+                if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) > 0 &&
                     ((buf[0] ^ buf[3]) & 0x02)) {
-                        switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
-                        default:
-                                /*
-                                 * if nExtBtn is greater than 8 it should be
-                                 * considered invalid and treated as 0
-                                 */
-                                break;
-                        case 8:
-                                hw->ext_buttons |= ((buf[5] & 0x08)) ? 0x80 : 0;
-                                hw->ext_buttons |= ((buf[4] & 0x08)) ? 0x40 : 0;
-                        case 6:
-                                hw->ext_buttons |= ((buf[5] & 0x04)) ? 0x20 : 0;
-                                hw->ext_buttons |= ((buf[4] & 0x04)) ? 0x10 : 0;
-                        case 4:
-                                hw->ext_buttons |= ((buf[5] & 0x02)) ? 0x08 : 0;
-                                hw->ext_buttons |= ((buf[4] & 0x02)) ? 0x04 : 0;
-                        case 2:
-                                hw->ext_buttons |= ((buf[5] & 0x01)) ? 0x02 : 0;
-                                hw->ext_buttons |= ((buf[4] & 0x01)) ? 0x01 : 0;
-                        }
+                        synaptics_parse_ext_buttons(buf, priv, hw);
                 }
         } else {
                 hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
@@ -774,12 +845,54 @@ static void synaptics_report_semi_mt_data(struct input_dev *dev,
         }
 }
 
+static void synaptics_report_ext_buttons(struct psmouse *psmouse,
+                                         const struct synaptics_hw_state *hw)
+{
+        struct input_dev *dev = psmouse->dev;
+        struct synaptics_data *priv = psmouse->private;
+        int ext_bits = (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) + 1) >> 1;
+        char buf[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+        int i;
+
+        if (!SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap))
+                return;
+
+        /* Bug in FW 8.1, buttons are reported only when ExtBit is 1 */
+        if (SYN_ID_FULL(priv->identity) == 0x801 &&
+            !((psmouse->packet[0] ^ psmouse->packet[3]) & 0x02))
+                return;
+
+        if (!SYN_CAP_EXT_BUTTONS_STICK(priv->ext_cap_10)) {
+                for (i = 0; i < ext_bits; i++) {
+                        input_report_key(dev, BTN_0 + 2 * i,
+                                hw->ext_buttons & (1 << i));
+                        input_report_key(dev, BTN_1 + 2 * i,
+                                hw->ext_buttons & (1 << (i + ext_bits)));
+                }
+                return;
+        }
+
+        /*
+         * This generation of touchpads has the trackstick buttons
+         * physically wired to the touchpad. Re-route them through
+         * the pass-through interface.
+         */
+        if (!priv->pt_port)
+                return;
+
+        /* The trackstick expects at most 3 buttons */
+        priv->pt_buttons = SYN_CAP_EXT_BUTTON_STICK_L(hw->ext_buttons)      |
+                           SYN_CAP_EXT_BUTTON_STICK_R(hw->ext_buttons) << 1 |
+                           SYN_CAP_EXT_BUTTON_STICK_M(hw->ext_buttons) << 2;
+
+        synaptics_pass_pt_packet(psmouse, priv->pt_port, buf);
+}
+
 static void synaptics_report_buttons(struct psmouse *psmouse,
                                      const struct synaptics_hw_state *hw)
 {
         struct input_dev *dev = psmouse->dev;
         struct synaptics_data *priv = psmouse->private;
-        int i;
 
         input_report_key(dev, BTN_LEFT, hw->left);
         input_report_key(dev, BTN_RIGHT, hw->right);
@@ -792,8 +905,7 @@ static void synaptics_report_buttons(struct psmouse *psmouse,
                 input_report_key(dev, BTN_BACK, hw->down);
         }
 
-        for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
-                input_report_key(dev, BTN_0 + i, hw->ext_buttons & (1 << i));
+        synaptics_report_ext_buttons(psmouse, hw);
 }
 
 static void synaptics_report_mt_data(struct psmouse *psmouse,
@@ -1014,7 +1126,8 @@ static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
                 if (SYN_CAP_PASS_THROUGH(priv->capabilities) &&
                     synaptics_is_pt_packet(psmouse->packet)) {
                         if (priv->pt_port)
-                                synaptics_pass_pt_packet(priv->pt_port, psmouse->packet);
+                                synaptics_pass_pt_packet(psmouse, priv->pt_port,
+                                                         psmouse->packet);
                 } else
                         synaptics_process_packet(psmouse);
 
@@ -1081,7 +1194,7 @@ static void set_input_params(struct psmouse *psmouse,
                                         ABS_MT_POSITION_Y);
                 /* Image sensors can report per-contact pressure */
                 input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
-                input_mt_init_slots(dev, 2, INPUT_MT_POINTER | INPUT_MT_TRACK);
+                input_mt_init_slots(dev, 3, INPUT_MT_POINTER | INPUT_MT_TRACK);
 
                 /* Image sensors can signal 4 and 5 finger clicks */
                 __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
@@ -1116,8 +1229,9 @@ static void set_input_params(struct psmouse *psmouse,
                 __set_bit(BTN_BACK, dev->keybit);
         }
 
-        for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
-                __set_bit(BTN_0 + i, dev->keybit);
+        if (!SYN_CAP_EXT_BUTTONS_STICK(priv->ext_cap_10))
+                for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
+                        __set_bit(BTN_0 + i, dev->keybit);
 
         __clear_bit(EV_REL, dev->evbit);
         __clear_bit(REL_X, dev->relbit);
@@ -1125,7 +1239,8 @@ static void set_input_params(struct psmouse *psmouse,
 
         if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
                 __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
-                if (psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids))
+                if (psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
+                    !SYN_CAP_EXT_BUTTONS_STICK(priv->ext_cap_10))
                         __set_bit(INPUT_PROP_TOPBUTTONPAD, dev->propbit);
                 /* Clickpads report only left button */
                 __clear_bit(BTN_RIGHT, dev->keybit);
@@ -1311,29 +1426,11 @@ static const struct dmi_system_id __initconst cr48_dmi_table[] = {
         { }
 };
 
-static const struct dmi_system_id forcepad_dmi_table[] __initconst = {
-#if defined(CONFIG_DMI) && defined(CONFIG_X86)
-        {
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook Folio 1040 G1"),
-                },
-        },
-#endif
-        { }
-};
-
 void __init synaptics_module_init(void)
 {
         impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
         broken_olpc_ec = dmi_check_system(olpc_dmi_table);
         cr48_profile_sensor = dmi_check_system(cr48_dmi_table);
-
-        /*
-         * Unfortunately ForcePad capability is not exported over PS/2,
-         * so we have to resort to checking DMI.
-         */
-        is_forcepad = dmi_check_system(forcepad_dmi_table);
 }
 
 static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
@@ -1368,6 +1465,12 @@ static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
         if (SYN_ID_DISGEST_SUPPORTED(priv->identity))
                 priv->disable_gesture = true;
 
+        /*
+         * Unfortunately ForcePad capability is not exported over PS/2,
+         * so we have to resort to checking PNP IDs.
+         */
+        priv->is_forcepad = psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids);
+
         if (synaptics_set_mode(psmouse)) {
                 psmouse_err(psmouse, "Unable to initialize device.\n");
                 goto init_fail;
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index aedc3299b14e..56faa7ec4434 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -22,6 +22,7 @@
 #define SYN_QUE_EXT_CAPAB_0C            0x0c
 #define SYN_QUE_EXT_MAX_COORDS          0x0d
 #define SYN_QUE_EXT_MIN_COORDS          0x0f
+#define SYN_QUE_MEXT_CAPAB_10           0x10
 
 /* synatics modes */
 #define SYN_BIT_ABSOLUTE_MODE           (1 << 7)
@@ -53,6 +54,7 @@
 #define SYN_EXT_CAP_REQUESTS(c)         (((c) & 0x700000) >> 20)
 #define SYN_CAP_MULTI_BUTTON_NO(ec)     (((ec) & 0x00f000) >> 12)
 #define SYN_CAP_PRODUCT_ID(ec)          (((ec) & 0xff0000) >> 16)
+#define SYN_MEXT_CAP_BIT(m)             ((m) & (1 << 1))
 
 /*
  * The following describes response for the 0x0c query.
@@ -89,6 +91,30 @@
 #define SYN_CAP_REDUCED_FILTERING(ex0c) ((ex0c) & 0x000400)
 #define SYN_CAP_IMAGE_SENSOR(ex0c)      ((ex0c) & 0x000800)
 
+/*
+ * The following descibes response for the 0x10 query.
+ *
+ * byte mask    name                    meaning
+ * ---- ----    -------                 ------------
+ * 1    0x01    ext buttons are stick   buttons exported in the extended
+ *                                      capability are actually meant to be used
+ *                                      by the tracktick (pass-through).
+ * 1    0x02    SecurePad               the touchpad is a SecurePad, so it
+ *                                      contains a built-in fingerprint reader.
+ * 1    0xe0    more ext count          how many more extented queries are
+ *                                      available after this one.
+ * 2    0xff    SecurePad width         the width of the SecurePad fingerprint
+ *                                      reader.
+ * 3    0xff    SecurePad height        the height of the SecurePad fingerprint
+ *                                      reader.
+ */
+#define SYN_CAP_EXT_BUTTONS_STICK(ex10) ((ex10) & 0x010000)
+#define SYN_CAP_SECUREPAD(ex10)         ((ex10) & 0x020000)
+
+#define SYN_CAP_EXT_BUTTON_STICK_L(eb)  (!!((eb) & 0x01))
+#define SYN_CAP_EXT_BUTTON_STICK_M(eb)  (!!((eb) & 0x02))
+#define SYN_CAP_EXT_BUTTON_STICK_R(eb)  (!!((eb) & 0x04))
+
 /* synaptics modes query bits */
 #define SYN_MODE_ABSOLUTE(m)            ((m) & (1 << 7))
 #define SYN_MODE_RATE(m)                ((m) & (1 << 6))
@@ -143,6 +169,7 @@ struct synaptics_data {
         unsigned long int capabilities;         /* Capabilities */
         unsigned long int ext_cap;              /* Extended Capabilities */
         unsigned long int ext_cap_0c;           /* Ext Caps from 0x0c query */
+        unsigned long int ext_cap_10;           /* Ext Caps from 0x10 query */
         unsigned long int identity;             /* Identification */
         unsigned int x_res, y_res;              /* X/Y resolution in units/mm */
         unsigned int x_max, y_max;              /* Max coordinates (from FW) */
@@ -156,6 +183,7 @@ struct synaptics_data {
         bool disable_gesture;                   /* disable gestures */
 
         struct serio *pt_port;                  /* Pass-through serio port */
+        unsigned char pt_buttons;               /* Pass-through buttons */
 
         /*
          * Last received Advanced Gesture Mode (AGM) packet. An AGM packet
@@ -168,6 +196,7 @@ struct synaptics_data {
         unsigned long                           press_start;
         bool                                    press;
         bool                                    report_press;
+        bool                                    is_forcepad;
 };
 
 void synaptics_module_init(void);
diff --git a/drivers/input/serio/gscps2.c b/drivers/input/serio/gscps2.c
index 94ab494a6ade..ecba666afadb 100644
--- a/drivers/input/serio/gscps2.c
+++ b/drivers/input/serio/gscps2.c
@@ -31,7 +31,6 @@
 #include <linux/spinlock.h>
 #include <linux/delay.h>
 #include <linux/ioport.h>
-#include <linux/pci_ids.h>
 
 #include <asm/irq.h>
 #include <asm/io.h>
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index 986a71c614b0..cb5ece77fd7d 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -1162,13 +1162,32 @@ static int i8042_controller_resume(bool force_reset)
 
 static int i8042_pm_suspend(struct device *dev)
 {
+        int i;
+
         i8042_controller_reset(true);
 
+        /* Set up serio interrupts for system wakeup. */
+        for (i = 0; i < I8042_NUM_PORTS; i++) {
+                struct serio *serio = i8042_ports[i].serio;
+
+                if (serio && device_may_wakeup(&serio->dev))
+                        enable_irq_wake(i8042_ports[i].irq);
+        }
+
         return 0;
 }
 
 static int i8042_pm_resume(struct device *dev)
 {
+        int i;
+
+        for (i = 0; i < I8042_NUM_PORTS; i++) {
+                struct serio *serio = i8042_ports[i].serio;
+
+                if (serio && device_may_wakeup(&serio->dev))
+                        disable_irq_wake(i8042_ports[i].irq);
+        }
+
         /*
          * On resume from S2R we always try to reset the controller
          * to bring it in a sane state. (In case of S2D we expect
@@ -1300,13 +1319,16 @@ static void __init i8042_register_ports(void)
         int i;
 
         for (i = 0; i < I8042_NUM_PORTS; i++) {
-                if (i8042_ports[i].serio) {
+                struct serio *serio = i8042_ports[i].serio;
+
+                if (serio) {
                         printk(KERN_INFO "serio: %s at %#lx,%#lx irq %d\n",
-                                i8042_ports[i].serio->name,
+                                serio->name,
                                 (unsigned long) I8042_DATA_REG,
                                 (unsigned long) I8042_COMMAND_REG,
                                 i8042_ports[i].irq);
-                        serio_register_port(i8042_ports[i].serio);
+                        serio_register_port(serio);
+                        device_set_wakeup_capable(&serio->dev, true);
                 }
         }
 }
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index f8d16f15c1d1..80f6386709bf 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -140,6 +140,19 @@ config TOUCHSCREEN_BU21013
           To compile this driver as a module, choose M here: the
           module will be called bu21013_ts.
 
+config TOUCHSCREEN_CHIPONE_ICN8318
+        tristate "chipone icn8318 touchscreen controller"
+        depends on GPIOLIB
+        depends on I2C
+        depends on OF
+        help
+          Say Y here if you have a ChipOne icn8318 based I2C touchscreen.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called chipone_icn8318.
+
 config TOUCHSCREEN_CY8CTMG110
         tristate "cy8ctmg110 touchscreen"
         depends on I2C
@@ -297,11 +310,12 @@ config TOUCHSCREEN_FUJITSU
 
 config TOUCHSCREEN_GOODIX
         tristate "Goodix I2C touchscreen"
-        depends on I2C && ACPI
+        depends on I2C
         help
           Say Y here if you have the Goodix touchscreen (such as one
           installed in Onda v975w tablets) connected to your
-          system.
+          system. It also supports 5-finger chip models, which can be
+          found on ARM tablets, like Wexler TAB7200 and MSI Primo73.
 
           If unsure, say N.
 
@@ -323,6 +337,18 @@ config TOUCHSCREEN_ILI210X
           To compile this driver as a module, choose M here: the
           module will be called ili210x.
 
+config TOUCHSCREEN_IPROC
+        tristate "IPROC touch panel driver support"
+        depends on ARCH_BCM_IPROC || COMPILE_TEST
+        help
+          Say Y here if you want to add support for the IPROC touch
+          controller to your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called bcm_iproc_tsc.
+
 config TOUCHSCREEN_S3C2410
         tristate "Samsung S3C2410/generic touchscreen input driver"
         depends on ARCH_S3C24XX || SAMSUNG_DEV_TS
@@ -943,6 +969,7 @@ config TOUCHSCREEN_SUN4I
         tristate "Allwinner sun4i resistive touchscreen controller support"
         depends on ARCH_SUNXI || COMPILE_TEST
         depends on HWMON
+        depends on THERMAL || !THERMAL_OF
         help
           This selects support for the resistive touchscreen controller
           found on Allwinner sunxi SoCs.
@@ -963,6 +990,17 @@ config TOUCHSCREEN_SUR40
           To compile this driver as a module, choose M here: the
           module will be called sur40.
 
+config TOUCHSCREEN_SX8654
+        tristate "Semtech SX8654 touchscreen"
+        depends on I2C
+        help
+          Say Y here if you have a Semtech SX8654 touchscreen controller.
+
+          If unsure, say N
+
+          To compile this driver as a module, choose M here: the
+          module will be called sx8654.
+
 config TOUCHSCREEN_TPS6507X
         tristate "TPS6507x based touchscreens"
         depends on I2C
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 0242fea2102a..44deea743d02 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -17,6 +17,7 @@ obj-$(CONFIG_TOUCHSCREEN_AR1021_I2C)	+= ar1021_i2c.o
 obj-$(CONFIG_TOUCHSCREEN_ATMEL_MXT)     += atmel_mxt_ts.o
 obj-$(CONFIG_TOUCHSCREEN_AUO_PIXCIR)    += auo-pixcir-ts.o
 obj-$(CONFIG_TOUCHSCREEN_BU21013)       += bu21013_ts.o
+obj-$(CONFIG_TOUCHSCREEN_CHIPONE_ICN8318)       += chipone_icn8318.o
 obj-$(CONFIG_TOUCHSCREEN_CY8CTMG110)    += cy8ctmg110_ts.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP_CORE)   += cyttsp_core.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP_I2C)    += cyttsp_i2c.o cyttsp_i2c_common.o
@@ -39,6 +40,7 @@ obj-$(CONFIG_TOUCHSCREEN_GOODIX)	+= goodix.o
 obj-$(CONFIG_TOUCHSCREEN_ILI210X)       += ili210x.o
 obj-$(CONFIG_TOUCHSCREEN_INEXIO)        += inexio.o
 obj-$(CONFIG_TOUCHSCREEN_INTEL_MID)     += intel-mid-touch.o
+obj-$(CONFIG_TOUCHSCREEN_IPROC)         += bcm_iproc_tsc.o
 obj-$(CONFIG_TOUCHSCREEN_LPC32XX)       += lpc32xx_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MAX11801)      += max11801_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MC13783)       += mc13783_ts.o
@@ -79,5 +81,6 @@ obj-$(CONFIG_TOUCHSCREEN_WM97XX_ATMEL)	+= atmel-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_MAINSTONE)      += mainstone-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_ZYLONITE)       += zylonite-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_W90X900)       += w90p910_ts.o
+obj-$(CONFIG_TOUCHSCREEN_SX8654)        += sx8654.o
 obj-$(CONFIG_TOUCHSCREEN_TPS6507X)      += tps6507x-ts.o
 obj-$(CONFIG_TOUCHSCREEN_ZFORCE)        += zforce_ts.o
diff --git a/drivers/input/touchscreen/ar1021_i2c.c b/drivers/input/touchscreen/ar1021_i2c.c
index ba30578e296e..f0b954d46a25 100644
--- a/drivers/input/touchscreen/ar1021_i2c.c
+++ b/drivers/input/touchscreen/ar1021_i2c.c
@@ -157,7 +157,7 @@ static const struct i2c_device_id ar1021_i2c_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, ar1021_i2c_id);
 
-static struct of_device_id ar1021_i2c_of_match[] = {
+static const struct of_device_id ar1021_i2c_of_match[] = {
         { .compatible = "microchip,ar1021-i2c", },
         { }
 };
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 95ee92a91bd2..2875ddf37289 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -25,6 +25,7 @@
 #include <linux/interrupt.h>
 #include <linux/of.h>
 #include <linux/slab.h>
+#include <asm/unaligned.h>
 
 /* Version */
 #define MXT_VER_20              20
@@ -79,6 +80,7 @@
 #define MXT_SPT_DIGITIZER_T43           43
 #define MXT_SPT_MESSAGECOUNT_T44        44
 #define MXT_SPT_CTECONFIG_T46           46
+#define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
 
 /* MXT_GEN_MESSAGE_T5 object */
 #define MXT_RPTID_NOMSG         0xff
@@ -185,6 +187,36 @@ struct t9_range {
 #define MXT_RESET_VALUE         0x01
 #define MXT_BACKUP_VALUE        0x55
 
+/* T100 Multiple Touch Touchscreen */
+#define MXT_T100_CTRL           0
+#define MXT_T100_CFG1           1
+#define MXT_T100_TCHAUX         3
+#define MXT_T100_XRANGE         13
+#define MXT_T100_YRANGE         24
+
+#define MXT_T100_CFG_SWITCHXY   BIT(5)
+
+#define MXT_T100_TCHAUX_VECT    BIT(0)
+#define MXT_T100_TCHAUX_AMPL    BIT(1)
+#define MXT_T100_TCHAUX_AREA    BIT(2)
+
+#define MXT_T100_DETECT         BIT(7)
+#define MXT_T100_TYPE_MASK      0x70
+
+enum t100_type {
+        MXT_T100_TYPE_FINGER            = 1,
+        MXT_T100_TYPE_PASSIVE_STYLUS    = 2,
+        MXT_T100_TYPE_HOVERING_FINGER   = 4,
+        MXT_T100_TYPE_GLOVE             = 5,
+        MXT_T100_TYPE_LARGE_TOUCH       = 6,
+};
+
+#define MXT_DISTANCE_ACTIVE_TOUCH       0
+#define MXT_DISTANCE_HOVERING           1
+
+#define MXT_TOUCH_MAJOR_DEFAULT         1
+#define MXT_PRESSURE_DEFAULT            1
+
 /* Delay times */
 #define MXT_BACKUP_TIME         50      /* msec */
 #define MXT_RESET_TIME          200     /* msec */
@@ -244,6 +276,9 @@ struct mxt_data {
         unsigned int max_y;
         bool in_bootloader;
         u16 mem_size;
+        u8 t100_aux_ampl;
+        u8 t100_aux_area;
+        u8 t100_aux_vect;
         u8 max_reportid;
         u32 config_crc;
         u32 info_crc;
@@ -253,6 +288,7 @@ struct mxt_data {
         bool update_input;
         u8 last_message_count;
         u8 num_touchids;
+        u8 multitouch;
 
         /* Cached parameters from object table */
         u16 T5_address;
@@ -264,6 +300,8 @@ struct mxt_data {
         u8 T9_reportid_max;
         u8 T19_reportid;
         u16 T44_address;
+        u8 T100_reportid_min;
+        u8 T100_reportid_max;
 
         /* for fw update in bootloader */
         struct completion bl_completion;
@@ -771,6 +809,114 @@ static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
         data->update_input = true;
 }
 
+static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
+{
+        struct device *dev = &data->client->dev;
+        struct input_dev *input_dev = data->input_dev;
+        int id;
+        u8 status;
+        u8 type = 0;
+        u16 x;
+        u16 y;
+        int distance = 0;
+        int tool = 0;
+        u8 major = 0;
+        u8 pressure = 0;
+        u8 orientation = 0;
+
+        id = message[0] - data->T100_reportid_min - 2;
+
+        /* ignore SCRSTATUS events */
+        if (id < 0)
+                return;
+
+        status = message[1];
+        x = get_unaligned_le16(&message[2]);
+        y = get_unaligned_le16(&message[4]);
+
+        if (status & MXT_T100_DETECT) {
+                type = (status & MXT_T100_TYPE_MASK) >> 4;
+
+                switch (type) {
+                case MXT_T100_TYPE_HOVERING_FINGER:
+                        tool = MT_TOOL_FINGER;
+                        distance = MXT_DISTANCE_HOVERING;
+
+                        if (data->t100_aux_vect)
+                                orientation = message[data->t100_aux_vect];
+
+                        break;
+
+                case MXT_T100_TYPE_FINGER:
+                case MXT_T100_TYPE_GLOVE:
+                        tool = MT_TOOL_FINGER;
+                        distance = MXT_DISTANCE_ACTIVE_TOUCH;
+
+                        if (data->t100_aux_area)
+                                major = message[data->t100_aux_area];
+
+                        if (data->t100_aux_ampl)
+                                pressure = message[data->t100_aux_ampl];
+
+                        if (data->t100_aux_vect)
+                                orientation = message[data->t100_aux_vect];
+
+                        break;
+
+                case MXT_T100_TYPE_PASSIVE_STYLUS:
+                        tool = MT_TOOL_PEN;
+
+                        /*
+                         * Passive stylus is reported with size zero so
+                         * hardcode.
+                         */
+                        major = MXT_TOUCH_MAJOR_DEFAULT;
+
+                        if (data->t100_aux_ampl)
+                                pressure = message[data->t100_aux_ampl];
+
+                        break;
+
+                case MXT_T100_TYPE_LARGE_TOUCH:
+                        /* Ignore suppressed touch */
+                        break;
+
+                default:
+                        dev_dbg(dev, "Unexpected T100 type\n");
+                        return;
+                }
+        }
+
+        /*
+         * Values reported should be non-zero if tool is touching the
+         * device
+         */
+        if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER)
+                pressure = MXT_PRESSURE_DEFAULT;
+
+        input_mt_slot(input_dev, id);
+
+        if (status & MXT_T100_DETECT) {
+                dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
+                        id, type, x, y, major, pressure, orientation);
+
+                input_mt_report_slot_state(input_dev, tool, 1);
+                input_report_abs(input_dev, ABS_MT_POSITION_X, x);
+                input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
+                input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
+                input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
+                input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
+                input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
+        } else {
+                dev_dbg(dev, "[%u] release\n", id);
+
+                /* close out slot */
+                input_mt_report_slot_state(input_dev, 0, 0);
+        }
+
+        data->update_input = true;
+}
+
 static int mxt_proc_message(struct mxt_data *data, u8 *message)
 {
         u8 report_id = message[0];
@@ -786,9 +932,12 @@ static int mxt_proc_message(struct mxt_data *data, u8 *message)
                  * is not yet registered.
                  */
                 mxt_dump_message(data, message);
-        } else if (report_id >= data->T9_reportid_min
-            && report_id <= data->T9_reportid_max) {
+        } else if (report_id >= data->T9_reportid_min &&
+                   report_id <= data->T9_reportid_max) {
                 mxt_proc_t9_message(data, message);
+        } else if (report_id >= data->T100_reportid_min &&
+                   report_id <= data->T100_reportid_max) {
+                mxt_proc_t100_message(data, message);
         } else if (report_id == data->T19_reportid) {
                 mxt_input_button(data, message);
                 data->update_input = true;
@@ -1411,6 +1560,8 @@ static void mxt_free_object_table(struct mxt_data *data)
         data->T9_reportid_max = 0;
         data->T19_reportid = 0;
         data->T44_address = 0;
+        data->T100_reportid_min = 0;
+        data->T100_reportid_max = 0;
         data->max_reportid = 0;
 }
 
@@ -1487,6 +1638,7 @@ static int mxt_get_object_table(struct mxt_data *data)
                         data->T7_address = object->start_address;
                         break;
                 case MXT_TOUCH_MULTI_T9:
+                        data->multitouch = MXT_TOUCH_MULTI_T9;
                         data->T9_reportid_min = min_id;
                         data->T9_reportid_max = max_id;
                         data->num_touchids = object->num_report_ids
@@ -1498,6 +1650,13 @@ static int mxt_get_object_table(struct mxt_data *data)
                 case MXT_SPT_GPIOPWM_T19:
                         data->T19_reportid = min_id;
                         break;
+                case MXT_TOUCH_MULTITOUCHSCREEN_T100:
+                        data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
+                        data->T100_reportid_min = min_id;
+                        data->T100_reportid_max = max_id;
+                        /* first two report IDs reserved */
+                        data->num_touchids = object->num_report_ids - 2;
+                        break;
                 }
 
                 end_address = object->start_address
@@ -1582,22 +1741,138 @@ static int mxt_read_t9_resolution(struct mxt_data *data)
         return 0;
 }
 
+static int mxt_read_t100_config(struct mxt_data *data)
+{
+        struct i2c_client *client = data->client;
+        int error;
+        struct mxt_object *object;
+        u16 range_x, range_y;
+        u8 cfg, tchaux;
+        u8 aux;
+
+        object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
+        if (!object)
+                return -EINVAL;
+
+        error = __mxt_read_reg(client,
+                               object->start_address + MXT_T100_XRANGE,
+                               sizeof(range_x), &range_x);
+        if (error)
+                return error;
+
+        le16_to_cpus(&range_x);
+
+        error = __mxt_read_reg(client,
+                               object->start_address + MXT_T100_YRANGE,
+                               sizeof(range_y), &range_y);
+        if (error)
+                return error;
+
+        le16_to_cpus(&range_y);
+
+        error =  __mxt_read_reg(client,
+                                object->start_address + MXT_T100_CFG1,
+                                1, &cfg);
+        if (error)
+                return error;
+
+        error =  __mxt_read_reg(client,
+                                object->start_address + MXT_T100_TCHAUX,
+                                1, &tchaux);
+        if (error)
+                return error;
+
+        /* Handle default values */
+        if (range_x == 0)
+                range_x = 1023;
+
+        if (range_y == 0)
+                range_y = 1023;
+
+        if (cfg & MXT_T100_CFG_SWITCHXY) {
+                data->max_x = range_y;
+                data->max_y = range_x;
+        } else {
+                data->max_x = range_x;
+                data->max_y = range_y;
+        }
+
+        /* allocate aux bytes */
+        aux = 6;
+
+        if (tchaux & MXT_T100_TCHAUX_VECT)
+                data->t100_aux_vect = aux++;
+
+        if (tchaux & MXT_T100_TCHAUX_AMPL)
+                data->t100_aux_ampl = aux++;
+
+        if (tchaux & MXT_T100_TCHAUX_AREA)
+                data->t100_aux_area = aux++;
+
+        dev_dbg(&client->dev,
+                "T100 aux mappings vect:%u ampl:%u area:%u\n",
+                data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
+
+        dev_info(&client->dev,
+                 "T100 Touchscreen size X%uY%u\n", data->max_x, data->max_y);
+
+        return 0;
+}
+
 static int mxt_input_open(struct input_dev *dev);
 static void mxt_input_close(struct input_dev *dev);
 
-static int mxt_initialize_t9_input_device(struct mxt_data *data)
+static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
+                                   struct mxt_data *data)
 {
-        struct device *dev = &data->client->dev;
         const struct mxt_platform_data *pdata = data->pdata;
+        int i;
+
+        input_dev->name = "Atmel maXTouch Touchpad";
+
+        __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
+
+        input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
+        input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
+        input_abs_set_res(input_dev, ABS_MT_POSITION_X,
+                          MXT_PIXELS_PER_MM);
+        input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
+                          MXT_PIXELS_PER_MM);
+
+        for (i = 0; i < pdata->t19_num_keys; i++)
+                if (pdata->t19_keymap[i] != KEY_RESERVED)
+                        input_set_capability(input_dev, EV_KEY,
+                                             pdata->t19_keymap[i]);
+}
+
+static int mxt_initialize_input_device(struct mxt_data *data)
+{
+        const struct mxt_platform_data *pdata = data->pdata;
+        struct device *dev = &data->client->dev;
         struct input_dev *input_dev;
         int error;
         unsigned int num_mt_slots;
         unsigned int mt_flags = 0;
-        int i;
 
-        error = mxt_read_t9_resolution(data);
-        if (error)
-                dev_warn(dev, "Failed to initialize T9 resolution\n");
+        switch (data->multitouch) {
+        case MXT_TOUCH_MULTI_T9:
+                num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
+                error = mxt_read_t9_resolution(data);
+                if (error)
+                        dev_warn(dev, "Failed to initialize T9 resolution\n");
+                break;
+
+        case MXT_TOUCH_MULTITOUCHSCREEN_T100:
+                num_mt_slots = data->num_touchids;
+                error = mxt_read_t100_config(data);
+                if (error)
+                        dev_warn(dev, "Failed to read T100 config\n");
+                break;
+
+        default:
+                dev_err(dev, "Invalid multitouch object\n");
+                return -EINVAL;
+        }
 
         input_dev = input_allocate_device();
         if (!input_dev) {
@@ -1612,54 +1887,76 @@ static int mxt_initialize_t9_input_device(struct mxt_data *data)
         input_dev->open = mxt_input_open;
         input_dev->close = mxt_input_close;
 
-        __set_bit(EV_ABS, input_dev->evbit);
-        __set_bit(EV_KEY, input_dev->evbit);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
+        input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
 
-        if (pdata->t19_num_keys) {
-                __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
+        /* For single touch */
+        input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
 
-                for (i = 0; i < pdata->t19_num_keys; i++)
-                        if (pdata->t19_keymap[i] != KEY_RESERVED)
-                                input_set_capability(input_dev, EV_KEY,
-                                                     pdata->t19_keymap[i]);
+        if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
+            (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+             data->t100_aux_ampl)) {
+                input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
+        }
 
+        /* If device has buttons we assume it is a touchpad */
+        if (pdata->t19_num_keys) {
+                mxt_set_up_as_touchpad(input_dev, data);
                 mt_flags |= INPUT_MT_POINTER;
-
-                input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
-                input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
-                input_abs_set_res(input_dev, ABS_MT_POSITION_X,
-                                  MXT_PIXELS_PER_MM);
-                input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
-                                  MXT_PIXELS_PER_MM);
-
-                input_dev->name = "Atmel maXTouch Touchpad";
         }
 
-        /* For single touch */
-        input_set_abs_params(input_dev, ABS_X,
-                             0, data->max_x, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y,
-                             0, data->max_y, 0, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE,
-                             0, 255, 0, 0);
-
         /* For multi touch */
-        num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
         error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
         if (error) {
                 dev_err(dev, "Error %d initialising slots\n", error);
                 goto err_free_mem;
         }
 
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
-                             0, MXT_MAX_AREA, 0, 0);
+        if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
+                input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
+                                     0, MT_TOOL_MAX, 0, 0);
+                input_set_abs_params(input_dev, ABS_MT_DISTANCE,
+                                     MXT_DISTANCE_ACTIVE_TOUCH,
+                                     MXT_DISTANCE_HOVERING,
+                                     0, 0);
+        }
+
         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
                              0, data->max_x, 0, 0);
         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
                              0, data->max_y, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_PRESSURE,
-                             0, 255, 0, 0);
+
+        if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
+            (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+             data->t100_aux_area)) {
+                input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
+                                     0, MXT_MAX_AREA, 0, 0);
+        }
+
+        if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
+            (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+             data->t100_aux_ampl)) {
+                input_set_abs_params(input_dev, ABS_MT_PRESSURE,
+                                     0, 255, 0, 0);
+        }
+
+        if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+            data->t100_aux_vect) {
+                input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
+                                     0, 255, 0, 0);
+        }
+
+        if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+            data->t100_aux_ampl) {
+                input_set_abs_params(input_dev, ABS_MT_PRESSURE,
+                                     0, 255, 0, 0);
+        }
+
+        if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+            data->t100_aux_vect) {
+                input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
+                                     0, 255, 0, 0);
+        }
 
         input_set_drvdata(input_dev, data);
 
@@ -1765,9 +2062,13 @@ static int mxt_configure_objects(struct mxt_data *data,
                         dev_warn(dev, "Error %d updating config\n", error);
         }
 
-        error = mxt_initialize_t9_input_device(data);
-        if (error)
-                return error;
+        if (data->multitouch) {
+                error = mxt_initialize_input_device(data);
+                if (error)
+                        return error;
+        } else {
+                dev_warn(dev, "No touch object detected\n");
+        }
 
         dev_info(dev,
                  "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
@@ -2044,15 +2345,13 @@ static const struct attribute_group mxt_attr_group = {
 static void mxt_start(struct mxt_data *data)
 {
         /* Touch enable */
-        mxt_write_object(data,
-                        MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
+        mxt_write_object(data, data->multitouch, MXT_TOUCH_CTRL, 0x83);
 }
 
 static void mxt_stop(struct mxt_data *data)
 {
         /* Touch disable */
-        mxt_write_object(data,
-                        MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
+        mxt_write_object(data, data->multitouch, MXT_TOUCH_CTRL, 0);
 }
 
 static int mxt_input_open(struct input_dev *dev)
diff --git a/drivers/input/touchscreen/bcm_iproc_tsc.c b/drivers/input/touchscreen/bcm_iproc_tsc.c
new file mode 100644
index 000000000000..ae460a5c93d5
--- /dev/null
+++ b/drivers/input/touchscreen/bcm_iproc_tsc.c
@@ -0,0 +1,522 @@
+/*
+* Copyright (C) 2015 Broadcom Corporation
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License as
+* published by the Free Software Foundation version 2.
+*
+* This program is distributed "as is" WITHOUT ANY WARRANTY of any
+* kind, whether express or implied; without even the implied warranty
+* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*/
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/keyboard.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+#include <asm/irq.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/serio.h>
+
+#define IPROC_TS_NAME "iproc-ts"
+
+#define PEN_DOWN_STATUS     1
+#define PEN_UP_STATUS       0
+
+#define X_MIN               0
+#define Y_MIN               0
+#define X_MAX               0xFFF
+#define Y_MAX               0xFFF
+
+/* Value given by controller for invalid coordinate. */
+#define INVALID_COORD       0xFFFFFFFF
+
+/* Register offsets */
+#define REGCTL1             0x00
+#define REGCTL2             0x04
+#define INTERRUPT_THRES     0x08
+#define INTERRUPT_MASK      0x0c
+
+#define INTERRUPT_STATUS    0x10
+#define CONTROLLER_STATUS   0x14
+#define FIFO_DATA           0x18
+#define FIFO_DATA_X_Y_MASK  0xFFFF
+#define ANALOG_CONTROL      0x1c
+
+#define AUX_DATA            0x20
+#define DEBOUNCE_CNTR_STAT  0x24
+#define SCAN_CNTR_STAT      0x28
+#define REM_CNTR_STAT       0x2c
+
+#define SETTLING_TIMER_STAT 0x30
+#define SPARE_REG           0x34
+#define SOFT_BYPASS_CONTROL 0x38
+#define SOFT_BYPASS_DATA    0x3c
+
+
+/* Bit values for INTERRUPT_MASK and INTERRUPT_STATUS regs */
+#define TS_PEN_INTR_MASK        BIT(0)
+#define TS_FIFO_INTR_MASK       BIT(2)
+
+/* Bit values for CONTROLLER_STATUS reg1 */
+#define TS_PEN_DOWN             BIT(0)
+
+/* Shift values for control reg1 */
+#define SCANNING_PERIOD_SHIFT   24
+#define DEBOUNCE_TIMEOUT_SHIFT  16
+#define SETTLING_TIMEOUT_SHIFT  8
+#define TOUCH_TIMEOUT_SHIFT     0
+
+/* Shift values for coordinates from fifo */
+#define X_COORD_SHIFT  0
+#define Y_COORD_SHIFT  16
+
+/* Bit values for REGCTL2 */
+#define TS_CONTROLLER_EN_BIT    BIT(16)
+#define TS_CONTROLLER_AVGDATA_SHIFT 8
+#define TS_CONTROLLER_AVGDATA_MASK (0x7 << TS_CONTROLLER_AVGDATA_SHIFT)
+#define TS_CONTROLLER_PWR_LDO   BIT(5)
+#define TS_CONTROLLER_PWR_ADC   BIT(4)
+#define TS_CONTROLLER_PWR_BGP   BIT(3)
+#define TS_CONTROLLER_PWR_TS    BIT(2)
+#define TS_WIRE_MODE_BIT        BIT(1)
+
+#define dbg_reg(dev, priv, reg) \
+        dev_dbg(dev, "%20s= 0x%08x\n", #reg, readl((priv)->regs + reg))
+
+struct tsc_param {
+        /* Each step is 1024 us.  Valid 1-256 */
+        u32 scanning_period;
+
+        /*  Each step is 512 us.  Valid 0-255 */
+        u32 debounce_timeout;
+
+        /*
+         * The settling duration (in ms) is the amount of time the tsc
+         * waits to allow the voltage to settle after turning on the
+         * drivers in detection mode. Valid values: 0-11
+         *   0 =  0.008 ms
+         *   1 =  0.01 ms
+         *   2 =  0.02 ms
+         *   3 =  0.04 ms
+         *   4 =  0.08 ms
+         *   5 =  0.16 ms
+         *   6 =  0.32 ms
+         *   7 =  0.64 ms
+         *   8 =  1.28 ms
+         *   9 =  2.56 ms
+         *   10 = 5.12 ms
+         *   11 = 10.24 ms
+         */
+        u32 settling_timeout;
+
+        /* touch timeout in sample counts */
+        u32 touch_timeout;
+
+        /*
+         * Number of data samples which are averaged before a final data point
+         * is placed into the FIFO
+         */
+        u32 average_data;
+
+        /* FIFO threshold */
+        u32 fifo_threshold;
+
+        /* Optional standard touchscreen properties. */
+        u32 max_x;
+        u32 max_y;
+        u32 fuzz_x;
+        u32 fuzz_y;
+        bool invert_x;
+        bool invert_y;
+};
+
+struct iproc_ts_priv {
+        struct platform_device *pdev;
+        struct input_dev *idev;
+
+        void __iomem *regs;
+        struct clk *tsc_clk;
+
+        int  pen_status;
+        struct tsc_param cfg_params;
+};
+
+/*
+ * Set default values the same as hardware reset values
+ * except for fifo_threshold with is set to 1.
+ */
+static const struct tsc_param iproc_default_config = {
+        .scanning_period  = 0x5,  /* 1 to 256 */
+        .debounce_timeout = 0x28, /* 0 to 255 */
+        .settling_timeout = 0x7,  /* 0 to 11 */
+        .touch_timeout    = 0xa,  /* 0 to 255 */
+        .average_data     = 5,    /* entry 5 = 32 pts */
+        .fifo_threshold   = 1,    /* 0 to 31 */
+        .max_x            = X_MAX,
+        .max_y            = Y_MAX,
+};
+
+static void ts_reg_dump(struct iproc_ts_priv *priv)
+{
+        struct device *dev = &priv->pdev->dev;
+
+        dbg_reg(dev, priv, REGCTL1);
+        dbg_reg(dev, priv, REGCTL2);
+        dbg_reg(dev, priv, INTERRUPT_THRES);
+        dbg_reg(dev, priv, INTERRUPT_MASK);
+        dbg_reg(dev, priv, INTERRUPT_STATUS);
+        dbg_reg(dev, priv, CONTROLLER_STATUS);
+        dbg_reg(dev, priv, FIFO_DATA);
+        dbg_reg(dev, priv, ANALOG_CONTROL);
+        dbg_reg(dev, priv, AUX_DATA);
+        dbg_reg(dev, priv, DEBOUNCE_CNTR_STAT);
+        dbg_reg(dev, priv, SCAN_CNTR_STAT);
+        dbg_reg(dev, priv, REM_CNTR_STAT);
+        dbg_reg(dev, priv, SETTLING_TIMER_STAT);
+        dbg_reg(dev, priv, SPARE_REG);
+        dbg_reg(dev, priv, SOFT_BYPASS_CONTROL);
+        dbg_reg(dev, priv, SOFT_BYPASS_DATA);
+}
+
+static irqreturn_t iproc_touchscreen_interrupt(int irq, void *data)
+{
+        struct platform_device *pdev = data;
+        struct iproc_ts_priv *priv = platform_get_drvdata(pdev);
+        u32 intr_status;
+        u32 raw_coordinate;
+        u16 x;
+        u16 y;
+        int i;
+        bool needs_sync = false;
+
+        intr_status = readl(priv->regs + INTERRUPT_STATUS);
+        intr_status &= TS_PEN_INTR_MASK | TS_FIFO_INTR_MASK;
+        if (intr_status == 0)
+                return IRQ_NONE;
+
+        /* Clear all interrupt status bits, write-1-clear */
+        writel(intr_status, priv->regs + INTERRUPT_STATUS);
+
+        /* Pen up/down */
+        if (intr_status & TS_PEN_INTR_MASK) {
+                if (readl(priv->regs + CONTROLLER_STATUS) & TS_PEN_DOWN)
+                        priv->pen_status = PEN_DOWN_STATUS;
+                else
+                        priv->pen_status = PEN_UP_STATUS;
+
+                input_report_key(priv->idev, BTN_TOUCH, priv->pen_status);
+                needs_sync = true;
+
+                dev_dbg(&priv->pdev->dev,
+                        "pen up-down (%d)\n", priv->pen_status);
+        }
+
+        /* coordinates in FIFO exceed the theshold */
+        if (intr_status & TS_FIFO_INTR_MASK) {
+                for (i = 0; i < priv->cfg_params.fifo_threshold; i++) {
+                        raw_coordinate = readl(priv->regs + FIFO_DATA);
+                        if (raw_coordinate == INVALID_COORD)
+                                continue;
+
+                        /*
+                         * The x and y coordinate are 16 bits each
+                         * with the x in the lower 16 bits and y in the
+                         * upper 16 bits.
+                         */
+                        x = (raw_coordinate >> X_COORD_SHIFT) &
+                                FIFO_DATA_X_Y_MASK;
+                        y = (raw_coordinate >> Y_COORD_SHIFT) &
+                                FIFO_DATA_X_Y_MASK;
+
+                        /* We only want to retain the 12 msb of the 16 */
+                        x = (x >> 4) & 0x0FFF;
+                        y = (y >> 4) & 0x0FFF;
+
+                        /* adjust x y according to lcd tsc mount angle */
+                        if (priv->cfg_params.invert_x)
+                                x = priv->cfg_params.max_x - x;
+
+                        if (priv->cfg_params.invert_y)
+                                y = priv->cfg_params.max_y - y;
+
+                        input_report_abs(priv->idev, ABS_X, x);
+                        input_report_abs(priv->idev, ABS_Y, y);
+                        needs_sync = true;
+
+                        dev_dbg(&priv->pdev->dev, "xy (0x%x 0x%x)\n", x, y);
+                }
+        }
+
+        if (needs_sync)
+                input_sync(priv->idev);
+
+        return IRQ_HANDLED;
+}
+
+static int iproc_ts_start(struct input_dev *idev)
+{
+        struct iproc_ts_priv *priv = input_get_drvdata(idev);
+        u32 val;
+        int error;
+
+        /* Enable clock */
+        error = clk_prepare_enable(priv->tsc_clk);
+        if (error) {
+                dev_err(&priv->pdev->dev, "%s clk_prepare_enable failed %d\n",
+                        __func__, error);
+                return error;
+        }
+
+        /*
+         * Interrupt is generated when:
+         *  FIFO reaches the int_th value, and pen event(up/down)
+         */
+        val = TS_PEN_INTR_MASK | TS_FIFO_INTR_MASK;
+        writel(val, priv->regs + INTERRUPT_MASK);
+
+        writel(priv->cfg_params.fifo_threshold, priv->regs + INTERRUPT_THRES);
+
+        /* Initialize control reg1 */
+        val = 0;
+        val |= priv->cfg_params.scanning_period << SCANNING_PERIOD_SHIFT;
+        val |= priv->cfg_params.debounce_timeout << DEBOUNCE_TIMEOUT_SHIFT;
+        val |= priv->cfg_params.settling_timeout << SETTLING_TIMEOUT_SHIFT;
+        val |= priv->cfg_params.touch_timeout << TOUCH_TIMEOUT_SHIFT;
+        writel(val, priv->regs + REGCTL1);
+
+        /* Try to clear all interrupt status */
+        val = readl(priv->regs + INTERRUPT_STATUS);
+        val |= TS_FIFO_INTR_MASK | TS_PEN_INTR_MASK;
+        writel(val, priv->regs + INTERRUPT_STATUS);
+
+        /* Initialize control reg2 */
+        val = readl(priv->regs + REGCTL2);
+        val |= TS_CONTROLLER_EN_BIT | TS_WIRE_MODE_BIT;
+
+        val &= ~TS_CONTROLLER_AVGDATA_MASK;
+        val |= priv->cfg_params.average_data << TS_CONTROLLER_AVGDATA_SHIFT;
+
+        val &= ~(TS_CONTROLLER_PWR_LDO |        /* PWR up LDO */
+                   TS_CONTROLLER_PWR_ADC |      /* PWR up ADC */
+                   TS_CONTROLLER_PWR_BGP |      /* PWR up BGP */
+                   TS_CONTROLLER_PWR_TS);       /* PWR up TS */
+
+        writel(val, priv->regs + REGCTL2);
+
+        ts_reg_dump(priv);
+
+        return 0;
+}
+
+static void iproc_ts_stop(struct input_dev *dev)
+{
+        u32 val;
+        struct iproc_ts_priv *priv = input_get_drvdata(dev);
+
+        writel(0, priv->regs + INTERRUPT_MASK); /* Disable all interrupts */
+
+        /* Only power down touch screen controller */
+        val = readl(priv->regs + REGCTL2);
+        val |= TS_CONTROLLER_PWR_TS;
+        writel(val, priv->regs + REGCTL2);
+
+        clk_disable(priv->tsc_clk);
+}
+
+static int iproc_get_tsc_config(struct device *dev, struct iproc_ts_priv *priv)
+{
+        struct device_node *np = dev->of_node;
+        u32 val;
+
+        priv->cfg_params = iproc_default_config;
+
+        if (!np)
+                return 0;
+
+        if (of_property_read_u32(np, "scanning_period", &val) >= 0) {
+                if (val < 1 || val > 256) {
+                        dev_err(dev, "scanning_period (%u) must be [1-256]\n",
+                                val);
+                        return -EINVAL;
+                }
+                priv->cfg_params.scanning_period = val;
+        }
+
+        if (of_property_read_u32(np, "debounce_timeout", &val) >= 0) {
+                if (val > 255) {
+                        dev_err(dev, "debounce_timeout (%u) must be [0-255]\n",
+                                val);
+                        return -EINVAL;
+                }
+                priv->cfg_params.debounce_timeout = val;
+        }
+
+        if (of_property_read_u32(np, "settling_timeout", &val) >= 0) {
+                if (val > 11) {
+                        dev_err(dev, "settling_timeout (%u) must be [0-11]\n",
+                                val);
+                        return -EINVAL;
+                }
+                priv->cfg_params.settling_timeout = val;
+        }
+
+        if (of_property_read_u32(np, "touch_timeout", &val) >= 0) {
+                if (val > 255) {
+                        dev_err(dev, "touch_timeout (%u) must be [0-255]\n",
+                                val);
+                        return -EINVAL;
+                }
+                priv->cfg_params.touch_timeout = val;
+        }
+
+        if (of_property_read_u32(np, "average_data", &val) >= 0) {
+                if (val > 8) {
+                        dev_err(dev, "average_data (%u) must be [0-8]\n", val);
+                        return -EINVAL;
+                }
+                priv->cfg_params.average_data = val;
+        }
+
+        if (of_property_read_u32(np, "fifo_threshold", &val) >= 0) {
+                if (val > 31) {
+                        dev_err(dev, "fifo_threshold (%u)) must be [0-31]\n",
+                                val);
+                        return -EINVAL;
+                }
+                priv->cfg_params.fifo_threshold = val;
+        }
+
+        /* Parse optional properties. */
+        of_property_read_u32(np, "touchscreen-size-x", &priv->cfg_params.max_x);
+        of_property_read_u32(np, "touchscreen-size-y", &priv->cfg_params.max_y);
+
+        of_property_read_u32(np, "touchscreen-fuzz-x",
+                             &priv->cfg_params.fuzz_x);
+        of_property_read_u32(np, "touchscreen-fuzz-y",
+                             &priv->cfg_params.fuzz_y);
+
+        priv->cfg_params.invert_x =
+                of_property_read_bool(np, "touchscreen-inverted-x");
+        priv->cfg_params.invert_y =
+                of_property_read_bool(np, "touchscreen-inverted-y");
+
+        return 0;
+}
+
+static int iproc_ts_probe(struct platform_device *pdev)
+{
+        struct iproc_ts_priv *priv;
+        struct input_dev *idev;
+        struct resource *res;
+        int irq;
+        int error;
+
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        /* touchscreen controller memory mapped regs */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        priv->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(priv->regs)) {
+                error = PTR_ERR(priv->regs);
+                dev_err(&pdev->dev, "unable to map I/O memory: %d\n", error);
+                return error;
+        }
+
+        priv->tsc_clk = devm_clk_get(&pdev->dev, "tsc_clk");
+        if (IS_ERR(priv->tsc_clk)) {
+                error = PTR_ERR(priv->tsc_clk);
+                dev_err(&pdev->dev,
+                        "failed getting clock tsc_clk: %d\n", error);
+                return error;
+        }
+
+        priv->pdev = pdev;
+        error = iproc_get_tsc_config(&pdev->dev, priv);
+        if (error) {
+                dev_err(&pdev->dev, "get_tsc_config failed: %d\n", error);
+                return error;
+        }
+
+        idev = devm_input_allocate_device(&pdev->dev);
+        if (!idev) {
+                dev_err(&pdev->dev, "failed to allocate input device\n");
+                return -ENOMEM;
+        }
+
+        priv->idev = idev;
+        priv->pen_status = PEN_UP_STATUS;
+
+        /* Set input device info  */
+        idev->name = IPROC_TS_NAME;
+        idev->dev.parent = &pdev->dev;
+
+        idev->id.bustype = BUS_HOST;
+        idev->id.vendor = SERIO_UNKNOWN;
+        idev->id.product = 0;
+        idev->id.version = 0;
+
+        idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        __set_bit(BTN_TOUCH, idev->keybit);
+
+        input_set_abs_params(idev, ABS_X, X_MIN, priv->cfg_params.max_x,
+                             priv->cfg_params.fuzz_x, 0);
+        input_set_abs_params(idev, ABS_Y, Y_MIN, priv->cfg_params.max_y,
+                             priv->cfg_params.fuzz_y, 0);
+
+        idev->open = iproc_ts_start;
+        idev->close = iproc_ts_stop;
+
+        input_set_drvdata(idev, priv);
+        platform_set_drvdata(pdev, priv);
+
+        /* get interrupt */
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "platform_get_irq failed: %d\n", irq);
+                return irq;
+        }
+
+        error = devm_request_irq(&pdev->dev, irq,
+                                 iproc_touchscreen_interrupt,
+                                 IRQF_SHARED, IPROC_TS_NAME, pdev);
+        if (error)
+                return error;
+
+        error = input_register_device(priv->idev);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "failed to register input device: %d\n", error);
+                return error;
+        }
+
+        return 0;
+}
+
+static const struct of_device_id iproc_ts_of_match[] = {
+        {.compatible = "brcm,iproc-touchscreen", },
+        { },
+};
+MODULE_DEVICE_TABLE(of, iproc_ts_of_match);
+
+static struct platform_driver iproc_ts_driver = {
+        .probe = iproc_ts_probe,
+        .driver = {
+                .name   = IPROC_TS_NAME,
+                .of_match_table = of_match_ptr(iproc_ts_of_match),
+        },
+};
+
+module_platform_driver(iproc_ts_driver);
+
+MODULE_DESCRIPTION("IPROC Touchscreen driver");
+MODULE_AUTHOR("Broadcom");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/chipone_icn8318.c b/drivers/input/touchscreen/chipone_icn8318.c
new file mode 100644
index 000000000000..32e9db0e04bf
--- /dev/null
+++ b/drivers/input/touchscreen/chipone_icn8318.c
@@ -0,0 +1,316 @@
+/*
+ * Driver for ChipOne icn8318 i2c touchscreen controller
+ *
+ * Copyright (c) 2015 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Red Hat authors:
+ * Hans de Goede <hdegoede@redhat.com>
+ */
+
+#include <linux/gpio/consumer.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/module.h>
+#include <linux/of.h>
+
+#define ICN8318_REG_POWER               4
+#define ICN8318_REG_TOUCHDATA           16
+
+#define ICN8318_POWER_ACTIVE            0
+#define ICN8318_POWER_MONITOR           1
+#define ICN8318_POWER_HIBERNATE         2
+
+#define ICN8318_MAX_TOUCHES             5
+
+struct icn8318_touch {
+        __u8 slot;
+        __be16 x;
+        __be16 y;
+        __u8 pressure;  /* Seems more like finger width then pressure really */
+        __u8 event;
+/* The difference between 2 and 3 is unclear */
+#define ICN8318_EVENT_NO_DATA   1 /* No finger seen yet since wakeup */
+#define ICN8318_EVENT_UPDATE1   2 /* New or updated coordinates */
+#define ICN8318_EVENT_UPDATE2   3 /* New or updated coordinates */
+#define ICN8318_EVENT_END       4 /* Finger lifted */
+} __packed;
+
+struct icn8318_touch_data {
+        __u8 softbutton;
+        __u8 touch_count;
+        struct icn8318_touch touches[ICN8318_MAX_TOUCHES];
+} __packed;
+
+struct icn8318_data {
+        struct i2c_client *client;
+        struct input_dev *input;
+        struct gpio_desc *wake_gpio;
+        u32 max_x;
+        u32 max_y;
+        bool invert_x;
+        bool invert_y;
+        bool swap_x_y;
+};
+
+static int icn8318_read_touch_data(struct i2c_client *client,
+                                   struct icn8318_touch_data *touch_data)
+{
+        u8 reg = ICN8318_REG_TOUCHDATA;
+        struct i2c_msg msg[2] = {
+                {
+                        .addr = client->addr,
+                        .len = 1,
+                        .buf = &reg
+                },
+                {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = sizeof(struct icn8318_touch_data),
+                        .buf = (u8 *)touch_data
+                }
+        };
+
+        return i2c_transfer(client->adapter, msg, 2);
+}
+
+static inline bool icn8318_touch_active(u8 event)
+{
+        return (event == ICN8318_EVENT_UPDATE1) ||
+               (event == ICN8318_EVENT_UPDATE2);
+}
+
+static irqreturn_t icn8318_irq(int irq, void *dev_id)
+{
+        struct icn8318_data *data = dev_id;
+        struct device *dev = &data->client->dev;
+        struct icn8318_touch_data touch_data;
+        int i, ret, x, y;
+
+        ret = icn8318_read_touch_data(data->client, &touch_data);
+        if (ret < 0) {
+                dev_err(dev, "Error reading touch data: %d\n", ret);
+                return IRQ_HANDLED;
+        }
+
+        if (touch_data.softbutton) {
+                /*
+                 * Other data is invalid when a softbutton is pressed.
+                 * This needs some extra devicetree bindings to map the icn8318
+                 * softbutton codes to evdev codes. Currently no known devices
+                 * use this.
+                 */
+                return IRQ_HANDLED;
+        }
+
+        if (touch_data.touch_count > ICN8318_MAX_TOUCHES) {
+                dev_warn(dev, "Too much touches %d > %d\n",
+                         touch_data.touch_count, ICN8318_MAX_TOUCHES);
+                touch_data.touch_count = ICN8318_MAX_TOUCHES;
+        }
+
+        for (i = 0; i < touch_data.touch_count; i++) {
+                struct icn8318_touch *touch = &touch_data.touches[i];
+                bool act = icn8318_touch_active(touch->event);
+
+                input_mt_slot(data->input, touch->slot);
+                input_mt_report_slot_state(data->input, MT_TOOL_FINGER, act);
+                if (!act)
+                        continue;
+
+                x = be16_to_cpu(touch->x);
+                y = be16_to_cpu(touch->y);
+
+                if (data->invert_x)
+                        x = data->max_x - x;
+
+                if (data->invert_y)
+                        y = data->max_y - y;
+
+                if (!data->swap_x_y) {
+                        input_event(data->input, EV_ABS, ABS_MT_POSITION_X, x);
+                        input_event(data->input, EV_ABS, ABS_MT_POSITION_Y, y);
+                } else {
+                        input_event(data->input, EV_ABS, ABS_MT_POSITION_X, y);
+                        input_event(data->input, EV_ABS, ABS_MT_POSITION_Y, x);
+                }
+        }
+
+        input_mt_sync_frame(data->input);
+        input_sync(data->input);
+
+        return IRQ_HANDLED;
+}
+
+static int icn8318_start(struct input_dev *dev)
+{
+        struct icn8318_data *data = input_get_drvdata(dev);
+
+        enable_irq(data->client->irq);
+        gpiod_set_value_cansleep(data->wake_gpio, 1);
+
+        return 0;
+}
+
+static void icn8318_stop(struct input_dev *dev)
+{
+        struct icn8318_data *data = input_get_drvdata(dev);
+
+        disable_irq(data->client->irq);
+        i2c_smbus_write_byte_data(data->client, ICN8318_REG_POWER,
+                                  ICN8318_POWER_HIBERNATE);
+        gpiod_set_value_cansleep(data->wake_gpio, 0);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int icn8318_suspend(struct device *dev)
+{
+        struct icn8318_data *data = i2c_get_clientdata(to_i2c_client(dev));
+
+        mutex_lock(&data->input->mutex);
+        if (data->input->users)
+                icn8318_stop(data->input);
+        mutex_unlock(&data->input->mutex);
+
+        return 0;
+}
+
+static int icn8318_resume(struct device *dev)
+{
+        struct icn8318_data *data = i2c_get_clientdata(to_i2c_client(dev));
+
+        mutex_lock(&data->input->mutex);
+        if (data->input->users)
+                icn8318_start(data->input);
+        mutex_unlock(&data->input->mutex);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(icn8318_pm_ops, icn8318_suspend, icn8318_resume);
+
+static int icn8318_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct device_node *np = dev->of_node;
+        struct icn8318_data *data;
+        struct input_dev *input;
+        u32 fuzz_x = 0, fuzz_y = 0;
+        int error;
+
+        if (!client->irq) {
+                dev_err(dev, "Error no irq specified\n");
+                return -EINVAL;
+        }
+
+        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        data->wake_gpio = devm_gpiod_get(dev, "wake", GPIOD_OUT_LOW);
+        if (IS_ERR(data->wake_gpio)) {
+                error = PTR_ERR(data->wake_gpio);
+                if (error != -EPROBE_DEFER)
+                        dev_err(dev, "Error getting wake gpio: %d\n", error);
+                return error;
+        }
+
+        if (of_property_read_u32(np, "touchscreen-size-x", &data->max_x) ||
+            of_property_read_u32(np, "touchscreen-size-y", &data->max_y)) {
+                dev_err(dev, "Error touchscreen-size-x and/or -y missing\n");
+                return -EINVAL;
+        }
+
+        /* Optional */
+        of_property_read_u32(np, "touchscreen-fuzz-x", &fuzz_x);
+        of_property_read_u32(np, "touchscreen-fuzz-y", &fuzz_y);
+        data->invert_x = of_property_read_bool(np, "touchscreen-inverted-x");
+        data->invert_y = of_property_read_bool(np, "touchscreen-inverted-y");
+        data->swap_x_y = of_property_read_bool(np, "touchscreen-swapped-x-y");
+
+        input = devm_input_allocate_device(dev);
+        if (!input)
+                return -ENOMEM;
+
+        input->name = client->name;
+        input->id.bustype = BUS_I2C;
+        input->open = icn8318_start;
+        input->close = icn8318_stop;
+        input->dev.parent = dev;
+
+        if (!data->swap_x_y) {
+                input_set_abs_params(input, ABS_MT_POSITION_X, 0,
+                                     data->max_x, fuzz_x, 0);
+                input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
+                                     data->max_y, fuzz_y, 0);
+        } else {
+                input_set_abs_params(input, ABS_MT_POSITION_X, 0,
+                                     data->max_y, fuzz_y, 0);
+                input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
+                                     data->max_x, fuzz_x, 0);
+        }
+
+        error = input_mt_init_slots(input, ICN8318_MAX_TOUCHES,
+                                    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
+        if (error)
+                return error;
+
+        data->client = client;
+        data->input = input;
+        input_set_drvdata(input, data);
+
+        error = devm_request_threaded_irq(dev, client->irq, NULL, icn8318_irq,
+                                          IRQF_ONESHOT, client->name, data);
+        if (error) {
+                dev_err(dev, "Error requesting irq: %d\n", error);
+                return error;
+        }
+
+        /* Stop device till opened */
+        icn8318_stop(data->input);
+
+        error = input_register_device(input);
+        if (error)
+                return error;
+
+        i2c_set_clientdata(client, data);
+
+        return 0;
+}
+
+static const struct of_device_id icn8318_of_match[] = {
+        { .compatible = "chipone,icn8318" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, icn8318_of_match);
+
+/* This is useless for OF-enabled devices, but it is needed by I2C subsystem */
+static const struct i2c_device_id icn8318_i2c_id[] = {
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, icn8318_i2c_id);
+
+static struct i2c_driver icn8318_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "chipone_icn8318",
+                .pm     = &icn8318_pm_ops,
+                .of_match_table = icn8318_of_match,
+        },
+        .probe = icn8318_probe,
+        .id_table = icn8318_i2c_id,
+};
+
+module_i2c_driver(icn8318_driver);
+
+MODULE_DESCRIPTION("ChipOne icn8318 I2C Touchscreen Driver");
+MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/edt-ft5x06.c b/drivers/input/touchscreen/edt-ft5x06.c
index d4c24fb7704f..e6aef3e48bd9 100644
--- a/drivers/input/touchscreen/edt-ft5x06.c
+++ b/drivers/input/touchscreen/edt-ft5x06.c
@@ -37,6 +37,7 @@
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
 #include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
 #include <linux/input/edt-ft5x06.h>
 
 #define MAX_SUPPORT_POINTS              5
@@ -1034,7 +1035,6 @@ static int edt_ft5x06_ts_probe(struct i2c_client *client,
         input->id.bustype = BUS_I2C;
         input->dev.parent = &client->dev;
 
-        __set_bit(EV_SYN, input->evbit);
         __set_bit(EV_KEY, input->evbit);
         __set_bit(EV_ABS, input->evbit);
         __set_bit(BTN_TOUCH, input->keybit);
@@ -1044,6 +1044,10 @@ static int edt_ft5x06_ts_probe(struct i2c_client *client,
                              0, tsdata->num_x * 64 - 1, 0, 0);
         input_set_abs_params(input, ABS_MT_POSITION_Y,
                              0, tsdata->num_y * 64 - 1, 0, 0);
+
+        if (!pdata)
+                touchscreen_parse_of_params(input);
+
         error = input_mt_init_slots(input, MAX_SUPPORT_POINTS, 0);
         if (error) {
                 dev_err(&client->dev, "Unable to init MT slots.\n");
diff --git a/drivers/input/touchscreen/elants_i2c.c b/drivers/input/touchscreen/elants_i2c.c
index 926c58e540c0..43b3c9c2d788 100644
--- a/drivers/input/touchscreen/elants_i2c.c
+++ b/drivers/input/touchscreen/elants_i2c.c
@@ -98,7 +98,6 @@
 #define MAX_FW_UPDATE_RETRIES   30
 
 #define ELAN_FW_PAGESIZE        132
-#define ELAN_FW_FILENAME        "elants_i2c.bin"
 
 /* calibration timeout definition */
 #define ELAN_CALI_TIMEOUT_MSEC  10000
@@ -697,12 +696,19 @@ static int elants_i2c_fw_update(struct elants_data *ts)
 {
         struct i2c_client *client = ts->client;
         const struct firmware *fw;
+        char *fw_name;
         int error;
 
-        error = request_firmware(&fw, ELAN_FW_FILENAME, &client->dev);
+        fw_name = kasprintf(GFP_KERNEL, "elants_i2c_%4x.bin", ts->hw_version);
+        if (!fw_name)
+                return -ENOMEM;
+
+        dev_info(&client->dev, "requesting fw name = %s\n", fw_name);
+        error = request_firmware(&fw, fw_name, &client->dev);
+        kfree(fw_name);
         if (error) {
-                dev_err(&client->dev, "failed to request firmware %s: %d\n",
-                        ELAN_FW_FILENAME, error);
+                dev_err(&client->dev, "failed to request firmware: %d\n",
+                        error);
                 return error;
         }
 
diff --git a/drivers/input/touchscreen/goodix.c b/drivers/input/touchscreen/goodix.c
index ca196689f025..3af16984d57c 100644
--- a/drivers/input/touchscreen/goodix.c
+++ b/drivers/input/touchscreen/goodix.c
@@ -23,6 +23,8 @@
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/acpi.h>
+#include <linux/of.h>
 #include <asm/unaligned.h>
 
 struct goodix_ts_data {
@@ -48,6 +50,7 @@ struct goodix_ts_data {
 #define GOODIX_REG_VERSION              0x8140
 
 #define RESOLUTION_LOC          1
+#define MAX_CONTACTS_LOC        5
 #define TRIGGER_LOC             6
 
 static const unsigned long goodix_irq_flags[] = {
@@ -99,7 +102,7 @@ static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data)
         }
 
         touch_num = data[0] & 0x0f;
-        if (touch_num > GOODIX_MAX_CONTACTS)
+        if (touch_num > ts->max_touch_num)
                 return -EPROTO;
 
         if (touch_num > 1) {
@@ -141,7 +144,7 @@ static void goodix_ts_report_touch(struct goodix_ts_data *ts, u8 *coor_data)
  */
 static void goodix_process_events(struct goodix_ts_data *ts)
 {
-        u8  point_data[1 + GOODIX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
+        u8  point_data[1 + GOODIX_CONTACT_SIZE * ts->max_touch_num];
         int touch_num;
         int i;
 
@@ -202,21 +205,23 @@ static void goodix_read_config(struct goodix_ts_data *ts)
                 ts->abs_x_max = GOODIX_MAX_WIDTH;
                 ts->abs_y_max = GOODIX_MAX_HEIGHT;
                 ts->int_trigger_type = GOODIX_INT_TRIGGER;
+                ts->max_touch_num = GOODIX_MAX_CONTACTS;
                 return;
         }
 
         ts->abs_x_max = get_unaligned_le16(&config[RESOLUTION_LOC]);
         ts->abs_y_max = get_unaligned_le16(&config[RESOLUTION_LOC + 2]);
-        ts->int_trigger_type = (config[TRIGGER_LOC]) & 0x03;
-        if (!ts->abs_x_max || !ts->abs_y_max) {
+        ts->int_trigger_type = config[TRIGGER_LOC] & 0x03;
+        ts->max_touch_num = config[MAX_CONTACTS_LOC] & 0x0f;
+        if (!ts->abs_x_max || !ts->abs_y_max || !ts->max_touch_num) {
                 dev_err(&ts->client->dev,
                         "Invalid config, using defaults\n");
                 ts->abs_x_max = GOODIX_MAX_WIDTH;
                 ts->abs_y_max = GOODIX_MAX_HEIGHT;
+                ts->max_touch_num = GOODIX_MAX_CONTACTS;
         }
 }
 
-
 /**
  * goodix_read_version - Read goodix touchscreen version
  *
@@ -295,7 +300,7 @@ static int goodix_request_input_dev(struct goodix_ts_data *ts)
         input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 
-        input_mt_init_slots(ts->input_dev, GOODIX_MAX_CONTACTS,
+        input_mt_init_slots(ts->input_dev, ts->max_touch_num,
                             INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 
         ts->input_dev->name = "Goodix Capacitive TouchScreen";
@@ -372,11 +377,27 @@ static const struct i2c_device_id goodix_ts_id[] = {
         { }
 };
 
+#ifdef CONFIG_ACPI
 static const struct acpi_device_id goodix_acpi_match[] = {
         { "GDIX1001", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(acpi, goodix_acpi_match);
+#endif
+
+#ifdef CONFIG_OF
+static const struct of_device_id goodix_of_match[] = {
+        { .compatible = "goodix,gt911" },
+        { .compatible = "goodix,gt9110" },
+        { .compatible = "goodix,gt912" },
+        { .compatible = "goodix,gt927" },
+        { .compatible = "goodix,gt9271" },
+        { .compatible = "goodix,gt928" },
+        { .compatible = "goodix,gt967" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, goodix_of_match);
+#endif
 
 static struct i2c_driver goodix_ts_driver = {
         .probe = goodix_ts_probe,
@@ -384,7 +405,8 @@ static struct i2c_driver goodix_ts_driver = {
         .driver = {
                 .name = "Goodix-TS",
                 .owner = THIS_MODULE,
-                .acpi_match_table = goodix_acpi_match,
+                .acpi_match_table = ACPI_PTR(goodix_acpi_match),
+                .of_match_table = of_match_ptr(goodix_of_match),
         },
 };
 module_i2c_driver(goodix_ts_driver);
diff --git a/drivers/input/touchscreen/of_touchscreen.c b/drivers/input/touchscreen/of_touchscreen.c
index f8f9b84230b1..b82b5207c78b 100644
--- a/drivers/input/touchscreen/of_touchscreen.c
+++ b/drivers/input/touchscreen/of_touchscreen.c
@@ -11,8 +11,41 @@
 
 #include <linux/of.h>
 #include <linux/input.h>
+#include <linux/input/mt.h>
 #include <linux/input/touchscreen.h>
 
+static u32 of_get_optional_u32(struct device_node *np,
+                               const char *property)
+{
+        u32 val = 0;
+
+        of_property_read_u32(np, property, &val);
+
+        return val;
+}
+
+static void touchscreen_set_params(struct input_dev *dev,
+                                   unsigned long axis,
+                                   int max, int fuzz)
+{
+        struct input_absinfo *absinfo;
+
+        if (!test_bit(axis, dev->absbit)) {
+                /*
+                 * Emit a warning only if the axis is not a multitouch
+                 * axis, which might not be set by the driver.
+                 */
+                if (!input_is_mt_axis(axis))
+                        dev_warn(&dev->dev,
+                                 "DT specifies parameters but the axis is not set up\n");
+                return;
+        }
+
+        absinfo = &dev->absinfo[axis];
+        absinfo->maximum = max;
+        absinfo->fuzz = fuzz;
+}
+
 /**
  * touchscreen_parse_of_params - parse common touchscreen DT properties
  * @dev: device that should be parsed
@@ -24,22 +57,31 @@
 void touchscreen_parse_of_params(struct input_dev *dev)
 {
         struct device_node *np = dev->dev.parent->of_node;
-        struct input_absinfo *absinfo;
+        u32 maximum, fuzz;
 
         input_alloc_absinfo(dev);
         if (!dev->absinfo)
                 return;
 
-        absinfo = &dev->absinfo[ABS_X];
-        of_property_read_u32(np, "touchscreen-size-x", &absinfo->maximum);
-        of_property_read_u32(np, "touchscreen-fuzz-x", &absinfo->fuzz);
+        maximum = of_get_optional_u32(np, "touchscreen-size-x");
+        fuzz = of_get_optional_u32(np, "touchscreen-fuzz-x");
+        if (maximum || fuzz) {
+                touchscreen_set_params(dev, ABS_X, maximum, fuzz);
+                touchscreen_set_params(dev, ABS_MT_POSITION_X, maximum, fuzz);
+        }
 
-        absinfo = &dev->absinfo[ABS_Y];
-        of_property_read_u32(np, "touchscreen-size-y", &absinfo->maximum);
-        of_property_read_u32(np, "touchscreen-fuzz-y", &absinfo->fuzz);
+        maximum = of_get_optional_u32(np, "touchscreen-size-y");
+        fuzz = of_get_optional_u32(np, "touchscreen-fuzz-y");
+        if (maximum || fuzz) {
+                touchscreen_set_params(dev, ABS_Y, maximum, fuzz);
+                touchscreen_set_params(dev, ABS_MT_POSITION_Y, maximum, fuzz);
+        }
 
-        absinfo = &dev->absinfo[ABS_PRESSURE];
-        of_property_read_u32(np, "touchscreen-max-pressure", &absinfo->maximum);
-        of_property_read_u32(np, "touchscreen-fuzz-pressure", &absinfo->fuzz);
+        maximum = of_get_optional_u32(np, "touchscreen-max-pressure");
+        fuzz = of_get_optional_u32(np, "touchscreen-fuzz-pressure");
+        if (maximum || fuzz) {
+                touchscreen_set_params(dev, ABS_PRESSURE, maximum, fuzz);
+                touchscreen_set_params(dev, ABS_MT_PRESSURE, maximum, fuzz);
+        }
 }
 EXPORT_SYMBOL(touchscreen_parse_of_params);
diff --git a/drivers/input/touchscreen/sun4i-ts.c b/drivers/input/touchscreen/sun4i-ts.c
index b93a28b955fd..c0116994067d 100644
--- a/drivers/input/touchscreen/sun4i-ts.c
+++ b/drivers/input/touchscreen/sun4i-ts.c
@@ -30,6 +30,10 @@
  * These kinds of heuristics are just asking for trouble (and don't belong
  * in the kernel). So this driver offers straight forward, reliable single
  * touch functionality only.
+ *
+ * s.a. A20 User Manual "1.15 TP" (Documentation/arm/sunxi/README)
+ * (looks like the description in the A20 User Manual v1.3 is better
+ * than the one in the A10 User Manual v.1.5)
  */
 
 #include <linux/err.h>
@@ -193,7 +197,7 @@ static int sun4i_get_temp(const struct sun4i_ts_data *ts, long *temp)
         if (ts->temp_data == -1)
                 return -EAGAIN;
 
-        *temp = (ts->temp_data - ts->temp_offset) * ts->temp_step;
+        *temp = ts->temp_data * ts->temp_step - ts->temp_offset;
 
         return 0;
 }
@@ -246,6 +250,8 @@ static int sun4i_ts_probe(struct platform_device *pdev)
         int error;
         u32 reg;
         bool ts_attached;
+        u32 tp_sensitive_adjust = 15;
+        u32 filter_type = 1;
 
         ts = devm_kzalloc(dev, sizeof(struct sun4i_ts_data), GFP_KERNEL);
         if (!ts)
@@ -255,22 +261,31 @@ static int sun4i_ts_probe(struct platform_device *pdev)
         ts->ignore_fifo_data = true;
         ts->temp_data = -1;
         if (of_device_is_compatible(np, "allwinner,sun6i-a31-ts")) {
-                /* Allwinner SDK has temperature = -271 + (value / 6) (C) */
-                ts->temp_offset = 1626;
+                /* Allwinner SDK has temperature (C) = (value / 6) - 271 */
+                ts->temp_offset = 271000;
                 ts->temp_step = 167;
+        } else if (of_device_is_compatible(np, "allwinner,sun4i-a10-ts")) {
+                /*
+                 * The A10 temperature sensor has quite a wide spread, these
+                 * parameters are based on the averaging of the calibration
+                 * results of 4 completely different boards, with a spread of
+                 * temp_step from 0.096 - 0.170 and temp_offset from 176 - 331.
+                 */
+                ts->temp_offset = 257000;
+                ts->temp_step = 133;
         } else {
                 /*
                  * The user manuals do not contain the formula for calculating
                  * the temperature. The formula used here is from the AXP209,
                  * which is designed by X-Powers, an affiliate of Allwinner:
                  *
-                 *     temperature = -144.7 + (value * 0.1)
+                 *     temperature (C) = (value * 0.1) - 144.7
                  *
                  * Allwinner does not have any documentation whatsoever for
                  * this hardware. Moreover, it is claimed that the sensor
                  * is inaccurate and cannot work properly.
                  */
-                ts->temp_offset = 1447;
+                ts->temp_offset = 144700;
                 ts->temp_step = 100;
         }
 
@@ -313,14 +328,20 @@ static int sun4i_ts_probe(struct platform_device *pdev)
                ts->base + TP_CTRL0);
 
         /*
-         * sensitive_adjust = 15 : max, which is not all that sensitive,
+         * tp_sensitive_adjust is an optional property
          * tp_mode = 0 : only x and y coordinates, as we don't use dual touch
          */
-        writel(TP_SENSITIVE_ADJUST(15) | TP_MODE_SELECT(0),
+        of_property_read_u32(np, "allwinner,tp-sensitive-adjust",
+                             &tp_sensitive_adjust);
+        writel(TP_SENSITIVE_ADJUST(tp_sensitive_adjust) | TP_MODE_SELECT(0),
                ts->base + TP_CTRL2);
 
-        /* Enable median filter, type 1 : 5/3 */
-        writel(FILTER_EN(1) | FILTER_TYPE(1), ts->base + TP_CTRL3);
+        /*
+         * Enable median and averaging filter, optional property for
+         * filter type.
+         */
+        of_property_read_u32(np, "allwinner,filter-type", &filter_type);
+        writel(FILTER_EN(1) | FILTER_TYPE(filter_type), ts->base + TP_CTRL3);
 
         /* Enable temperature measurement, period 1953 (2 seconds) */
         writel(TEMP_ENABLE(1) | TEMP_PERIOD(1953), ts->base + TP_TPR);
@@ -330,10 +351,10 @@ static int sun4i_ts_probe(struct platform_device *pdev)
          * finally enable tp mode.
          */
         reg = STYLUS_UP_DEBOUN(5) | STYLUS_UP_DEBOUN_EN(1);
-        if (of_device_is_compatible(np, "allwinner,sun4i-a10-ts"))
-                reg |= TP_MODE_EN(1);
-        else
+        if (of_device_is_compatible(np, "allwinner,sun6i-a31-ts"))
                 reg |= SUN6I_TP_MODE_EN(1);
+        else
+                reg |= TP_MODE_EN(1);
         writel(reg, ts->base + TP_CTRL1);
 
         /*
@@ -383,6 +404,7 @@ static int sun4i_ts_remove(struct platform_device *pdev)
 
 static const struct of_device_id sun4i_ts_of_match[] = {
         { .compatible = "allwinner,sun4i-a10-ts", },
+        { .compatible = "allwinner,sun5i-a13-ts", },
         { .compatible = "allwinner,sun6i-a31-ts", },
         { /* sentinel */ }
 };
diff --git a/drivers/input/touchscreen/sx8654.c b/drivers/input/touchscreen/sx8654.c
new file mode 100644
index 000000000000..aecb9ad2e701
--- /dev/null
+++ b/drivers/input/touchscreen/sx8654.c
@@ -0,0 +1,286 @@
+/*
+ * Driver for Semtech SX8654 I2C touchscreen controller.
+ *
+ * Copyright (c) 2015 Armadeus Systems
+ *      Sébastien Szymanski <sebastien.szymanski@armadeus.com>
+ *
+ * Using code from:
+ *  - sx865x.c
+ *      Copyright (c) 2013 U-MoBo Srl
+ *      Pierluigi Passaro <p.passaro@u-mobo.com>
+ *  - sx8650.c
+ *      Copyright (c) 2009 Wayne Roberts
+ *  - tsc2007.c
+ *      Copyright (c) 2008 Kwangwoo Lee
+ *  - ads7846.c
+ *      Copyright (c) 2005 David Brownell
+ *      Copyright (c) 2006 Nokia Corporation
+ *  - corgi_ts.c
+ *      Copyright (C) 2004-2005 Richard Purdie
+ *  - omap_ts.[hc], ads7846.h, ts_osk.c
+ *      Copyright (C) 2002 MontaVista Software
+ *      Copyright (C) 2004 Texas Instruments
+ *      Copyright (C) 2005 Dirk Behme
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+
+/* register addresses */
+#define I2C_REG_TOUCH0                  0x00
+#define I2C_REG_TOUCH1                  0x01
+#define I2C_REG_CHANMASK                0x04
+#define I2C_REG_IRQMASK                 0x22
+#define I2C_REG_IRQSRC                  0x23
+#define I2C_REG_SOFTRESET               0x3f
+
+/* commands */
+#define CMD_READ_REGISTER               0x40
+#define CMD_MANUAL                      0xc0
+#define CMD_PENTRG                      0xe0
+
+/* value for I2C_REG_SOFTRESET */
+#define SOFTRESET_VALUE                 0xde
+
+/* bits for I2C_REG_IRQSRC */
+#define IRQ_PENTOUCH_TOUCHCONVDONE      0x08
+#define IRQ_PENRELEASE                  0x04
+
+/* bits for RegTouch1 */
+#define CONDIRQ                         0x20
+#define FILT_7SA                        0x03
+
+/* bits for I2C_REG_CHANMASK */
+#define CONV_X                          0x80
+#define CONV_Y                          0x40
+
+/* coordinates rate: higher nibble of CTRL0 register */
+#define RATE_MANUAL                     0x00
+#define RATE_5000CPS                    0xf0
+
+/* power delay: lower nibble of CTRL0 register */
+#define POWDLY_1_1MS                    0x0b
+
+#define MAX_12BIT                       ((1 << 12) - 1)
+
+struct sx8654 {
+        struct input_dev *input;
+        struct i2c_client *client;
+};
+
+static irqreturn_t sx8654_irq(int irq, void *handle)
+{
+        struct sx8654 *sx8654 = handle;
+        int irqsrc;
+        u8 data[4];
+        unsigned int x, y;
+        int retval;
+
+        irqsrc = i2c_smbus_read_byte_data(sx8654->client,
+                                          CMD_READ_REGISTER | I2C_REG_IRQSRC);
+        dev_dbg(&sx8654->client->dev, "irqsrc = 0x%x", irqsrc);
+
+        if (irqsrc < 0)
+                goto out;
+
+        if (irqsrc & IRQ_PENRELEASE) {
+                dev_dbg(&sx8654->client->dev, "pen release interrupt");
+
+                input_report_key(sx8654->input, BTN_TOUCH, 0);
+                input_sync(sx8654->input);
+        }
+
+        if (irqsrc & IRQ_PENTOUCH_TOUCHCONVDONE) {
+                dev_dbg(&sx8654->client->dev, "pen touch interrupt");
+
+                retval = i2c_master_recv(sx8654->client, data, sizeof(data));
+                if (retval != sizeof(data))
+                        goto out;
+
+                /* invalid data */
+                if (unlikely(data[0] & 0x80 || data[2] & 0x80))
+                        goto out;
+
+                x = ((data[0] & 0xf) << 8) | (data[1]);
+                y = ((data[2] & 0xf) << 8) | (data[3]);
+
+                input_report_abs(sx8654->input, ABS_X, x);
+                input_report_abs(sx8654->input, ABS_Y, y);
+                input_report_key(sx8654->input, BTN_TOUCH, 1);
+                input_sync(sx8654->input);
+
+                dev_dbg(&sx8654->client->dev, "point(%4d,%4d)\n", x, y);
+        }
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int sx8654_open(struct input_dev *dev)
+{
+        struct sx8654 *sx8654 = input_get_drvdata(dev);
+        struct i2c_client *client = sx8654->client;
+        int error;
+
+        /* enable pen trigger mode */
+        error = i2c_smbus_write_byte_data(client, I2C_REG_TOUCH0,
+                                          RATE_5000CPS | POWDLY_1_1MS);
+        if (error) {
+                dev_err(&client->dev, "writing to I2C_REG_TOUCH0 failed");
+                return error;
+        }
+
+        error = i2c_smbus_write_byte(client, CMD_PENTRG);
+        if (error) {
+                dev_err(&client->dev, "writing command CMD_PENTRG failed");
+                return error;
+        }
+
+        enable_irq(client->irq);
+
+        return 0;
+}
+
+static void sx8654_close(struct input_dev *dev)
+{
+        struct sx8654 *sx8654 = input_get_drvdata(dev);
+        struct i2c_client *client = sx8654->client;
+        int error;
+
+        disable_irq(client->irq);
+
+        /* enable manual mode mode */
+        error = i2c_smbus_write_byte(client, CMD_MANUAL);
+        if (error) {
+                dev_err(&client->dev, "writing command CMD_MANUAL failed");
+                return;
+        }
+
+        error = i2c_smbus_write_byte_data(client, I2C_REG_TOUCH0, 0);
+        if (error) {
+                dev_err(&client->dev, "writing to I2C_REG_TOUCH0 failed");
+                return;
+        }
+}
+
+static int sx8654_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct sx8654 *sx8654;
+        struct input_dev *input;
+        int error;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_READ_WORD_DATA))
+                return -ENXIO;
+
+        sx8654 = devm_kzalloc(&client->dev, sizeof(*sx8654), GFP_KERNEL);
+        if (!sx8654)
+                return -ENOMEM;
+
+        input = devm_input_allocate_device(&client->dev);
+        if (!sx8654)
+                return -ENOMEM;
+
+        input->name = "SX8654 I2C Touchscreen";
+        input->id.bustype = BUS_I2C;
+        input->dev.parent = &client->dev;
+        input->open = sx8654_open;
+        input->close = sx8654_close;
+
+        __set_bit(INPUT_PROP_DIRECT, input->propbit);
+        input_set_capability(input, EV_KEY, BTN_TOUCH);
+        input_set_abs_params(input, ABS_X, 0, MAX_12BIT, 0, 0);
+        input_set_abs_params(input, ABS_Y, 0, MAX_12BIT, 0, 0);
+
+        sx8654->client = client;
+        sx8654->input = input;
+
+        input_set_drvdata(sx8654->input, sx8654);
+
+        error = i2c_smbus_write_byte_data(client, I2C_REG_SOFTRESET,
+                                          SOFTRESET_VALUE);
+        if (error) {
+                dev_err(&client->dev, "writing softreset value failed");
+                return error;
+        }
+
+        error = i2c_smbus_write_byte_data(client, I2C_REG_CHANMASK,
+                                          CONV_X | CONV_Y);
+        if (error) {
+                dev_err(&client->dev, "writing to I2C_REG_CHANMASK failed");
+                return error;
+        }
+
+        error = i2c_smbus_write_byte_data(client, I2C_REG_IRQMASK,
+                                          IRQ_PENTOUCH_TOUCHCONVDONE |
+                                                IRQ_PENRELEASE);
+        if (error) {
+                dev_err(&client->dev, "writing to I2C_REG_IRQMASK failed");
+                return error;
+        }
+
+        error = i2c_smbus_write_byte_data(client, I2C_REG_TOUCH1,
+                                          CONDIRQ | FILT_7SA);
+        if (error) {
+                dev_err(&client->dev, "writing to I2C_REG_TOUCH1 failed");
+                return error;
+        }
+
+        error = devm_request_threaded_irq(&client->dev, client->irq,
+                                          NULL, sx8654_irq,
+                                          IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                          client->name, sx8654);
+        if (error) {
+                dev_err(&client->dev,
+                        "Failed to enable IRQ %d, error: %d\n",
+                        client->irq, error);
+                return error;
+        }
+
+        /* Disable the IRQ, we'll enable it in sx8654_open() */
+        disable_irq(client->irq);
+
+        error = input_register_device(sx8654->input);
+        if (error)
+                return error;
+
+        i2c_set_clientdata(client, sx8654);
+        return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id sx8654_of_match[] = {
+        { .compatible = "semtech,sx8654", },
+        { },
+};
+MODULE_DEVICE_TABLE(of, sx8654_of_match);
+#endif
+
+static const struct i2c_device_id sx8654_id_table[] = {
+        { "semtech_sx8654", 0 },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, sx8654_id_table);
+
+static struct i2c_driver sx8654_driver = {
+        .driver = {
+                .name = "sx8654",
+                .of_match_table = of_match_ptr(sx8654_of_match),
+        },
+        .id_table = sx8654_id_table,
+        .probe = sx8654_probe,
+};
+module_i2c_driver(sx8654_driver);
+
+MODULE_AUTHOR("Sébastien Szymanski <sebastien.szymanski@armadeus.com>");
+MODULE_DESCRIPTION("Semtech SX8654 I2C Touchscreen Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/tsc2007.c b/drivers/input/touchscreen/tsc2007.c
index 1bf9906b5a3f..ccc8aa615709 100644
--- a/drivers/input/touchscreen/tsc2007.c
+++ b/drivers/input/touchscreen/tsc2007.c
@@ -75,7 +75,7 @@ struct tsc2007 {
         u16                     model;
         u16                     x_plate_ohms;
         u16                     max_rt;
-        unsigned long           poll_period;
+        unsigned long           poll_period; /* in jiffies */
         int                     fuzzx;
         int                     fuzzy;
         int                     fuzzz;
@@ -214,8 +214,7 @@ static irqreturn_t tsc2007_soft_irq(int irq, void *handle)
                         dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
                 }
 
-                wait_event_timeout(ts->wait, ts->stopped,
-                                   msecs_to_jiffies(ts->poll_period));
+                wait_event_timeout(ts->wait, ts->stopped, ts->poll_period);
         }
 
         dev_dbg(&ts->client->dev, "UP\n");
@@ -314,9 +313,9 @@ static int tsc2007_probe_dt(struct i2c_client *client, struct tsc2007 *ts)
                 ts->fuzzz = val32;
 
         if (!of_property_read_u64(np, "ti,poll-period", &val64))
-                ts->poll_period = val64;
+                ts->poll_period = msecs_to_jiffies(val64);
         else
-                ts->poll_period = 1;
+                ts->poll_period = msecs_to_jiffies(1);
 
         if (!of_property_read_u32(np, "ti,x-plate-ohms", &val32)) {
                 ts->x_plate_ohms = val32;
@@ -350,7 +349,7 @@ static int tsc2007_probe_pdev(struct i2c_client *client, struct tsc2007 *ts,
         ts->model             = pdata->model;
         ts->x_plate_ohms      = pdata->x_plate_ohms;
         ts->max_rt            = pdata->max_rt ? : MAX_12BIT;
-        ts->poll_period       = pdata->poll_period ? : 1;
+        ts->poll_period       = msecs_to_jiffies(pdata->poll_period ? : 1);
         ts->get_pendown_state = pdata->get_pendown_state;
         ts->clear_penirq      = pdata->clear_penirq;
         ts->fuzzx             = pdata->fuzzx;
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index a0966331a89b..f2c6c352c55a 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -132,6 +132,7 @@ enum {
         DEVTYPE_GUNZE,
         DEVTYPE_DMC_TSC10,
         DEVTYPE_IRTOUCH,
+        DEVTYPE_IRTOUCH_HIRES,
         DEVTYPE_IDEALTEK,
         DEVTYPE_GENERAL_TOUCH,
         DEVTYPE_GOTOP,
@@ -198,6 +199,7 @@ static const struct usb_device_id usbtouch_devices[] = {
 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
         {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
         {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
+        {USB_DEVICE(0x6615, 0x0012), .driver_info = DEVTYPE_IRTOUCH_HIRES},
 #endif
 
 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
@@ -1177,6 +1179,15 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
                 .rept_size      = 8,
                 .read_data      = irtouch_read_data,
         },
+
+        [DEVTYPE_IRTOUCH_HIRES] = {
+                .min_xc         = 0x0,
+                .max_xc         = 0x7fff,
+                .min_yc         = 0x0,
+                .max_yc         = 0x7fff,
+                .rept_size      = 8,
+                .read_data      = irtouch_read_data,
+        },
 #endif
 
 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK