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

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input:
  Input: appletouch - improve powersaving for Geyser3 devices
  Input: lifebook - fix an oops on Panasonic CF-18
  Input: document intended meaning of KEY_SWITCHVIDEOMODE
  Input: switch to using seq_list_xxx helpers
  Input: i8042 - give more trust to PNP data on i386
  Input: add driver for Fujitsu serial touchscreens
  Input: ads7846 - re-check pendown status before reporting events
  Input: ads7846 - introduce sample settling delay
  Input: xpad - add support for leds on xbox 360 pad

10 files changed, 545 insertions, 113 deletions

diff --git a/drivers/input/input.c b/drivers/input/input.c
index 75b4d2a83dd9..5fe755586623 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -471,37 +471,16 @@ static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
         return 0;
 }
 
-static struct list_head *list_get_nth_element(struct list_head *list, loff_t *pos)
-{
-        struct list_head *node;
-        loff_t i = 0;
-
-        list_for_each(node, list)
-                if (i++ == *pos)
-                        return node;
-
-        return NULL;
-}
-
-static struct list_head *list_get_next_element(struct list_head *list, struct list_head *element, loff_t *pos)
-{
-        if (element->next == list)
-                return NULL;
-
-        ++(*pos);
-        return element->next;
-}
-
 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
 {
         /* acquire lock here ... Yes, we do need locking, I knowi, I know... */
 
-        return list_get_nth_element(&input_dev_list, pos);
+        return seq_list_start(&input_dev_list, *pos);
 }
 
 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
-        return list_get_next_element(&input_dev_list, v, pos);
+        return seq_list_next(v, &input_dev_list, pos);
 }
 
 static void input_devices_seq_stop(struct seq_file *seq, void *v)
@@ -592,13 +571,13 @@ static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
 {
         /* acquire lock here ... Yes, we do need locking, I knowi, I know... */
         seq->private = (void *)(unsigned long)*pos;
-        return list_get_nth_element(&input_handler_list, pos);
+        return seq_list_start(&input_handler_list, *pos);
 }
 
 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
         seq->private = (void *)(unsigned long)(*pos + 1);
-        return list_get_next_element(&input_handler_list, v, pos);
+        return seq_list_next(v, &input_handler_list, pos);
 }
 
 static void input_handlers_seq_stop(struct seq_file *seq, void *v)
diff --git a/drivers/input/joystick/Kconfig b/drivers/input/joystick/Kconfig
index 12db72d83ea0..e2abe18e575d 100644
--- a/drivers/input/joystick/Kconfig
+++ b/drivers/input/joystick/Kconfig
@@ -275,4 +275,11 @@ config JOYSTICK_XPAD_FF
         ---help---
           Say Y here if you want to take advantage of xbox 360 rumble features.
 
+config JOYSTICK_XPAD_LEDS
+        bool "LED Support for Xbox360 controller 'BigX' LED"
+        depends on LEDS_CLASS && JOYSTICK_XPAD
+        ---help---
+          This option enables support for the LED which surrounds the Big X on
+          XBox 360 controller.
+
 endif
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 244089c52650..28080395899c 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -191,13 +191,18 @@ struct usb_xpad {
         unsigned char *idata;           /* input data */
         dma_addr_t idata_dma;
 
-#ifdef CONFIG_JOYSTICK_XPAD_FF
+#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
         struct urb *irq_out;            /* urb for interrupt out report */
         unsigned char *odata;           /* output data */
         dma_addr_t odata_dma;
+        struct mutex odata_mutex;
+#endif
+
+#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
+        struct xpad_led *led;
 #endif
 
-        char phys[65];                  /* physical device path */
+        char phys[64];                  /* physical device path */
 
         int dpad_mapping;               /* map d-pad to buttons or to axes */
         int xtype;                      /* type of xbox device */
@@ -349,7 +354,7 @@ exit:
                      __FUNCTION__, retval);
 }
 
-#ifdef CONFIG_JOYSTICK_XPAD_FF
+#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
 static void xpad_irq_out(struct urb *urb)
 {
         int retval;
@@ -376,29 +381,7 @@ exit:
                    __FUNCTION__, retval);
 }
 
-static int xpad_play_effect(struct input_dev *dev, void *data,
-                            struct ff_effect *effect)
-{
-        struct usb_xpad *xpad = input_get_drvdata(dev);
-
-        if (effect->type == FF_RUMBLE) {
-                __u16 strong = effect->u.rumble.strong_magnitude;
-                __u16 weak = effect->u.rumble.weak_magnitude;
-                xpad->odata[0] = 0x00;
-                xpad->odata[1] = 0x08;
-                xpad->odata[2] = 0x00;
-                xpad->odata[3] = strong / 256;
-                xpad->odata[4] = weak / 256;
-                xpad->odata[5] = 0x00;
-                xpad->odata[6] = 0x00;
-                xpad->odata[7] = 0x00;
-                usb_submit_urb(xpad->irq_out, GFP_KERNEL);
-        }
-
-        return 0;
-}
-
-static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad)
+static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 {
         struct usb_endpoint_descriptor *ep_irq_out;
         int error = -ENOMEM;
@@ -411,6 +394,8 @@ static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad)
         if (!xpad->odata)
                 goto fail1;
 
+        mutex_init(&xpad->odata_mutex);
+
         xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
         if (!xpad->irq_out)
                 goto fail2;
@@ -423,25 +408,19 @@ static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad)
         xpad->irq_out->transfer_dma = xpad->odata_dma;
         xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
-        input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
-
-        error = input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
-        if (error)
-                goto fail2;
-
         return 0;
 
  fail2: usb_buffer_free(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
  fail1: return error;
 }
 
-static void xpad_stop_ff(struct usb_xpad *xpad)
+static void xpad_stop_output(struct usb_xpad *xpad)
 {
         if (xpad->xtype == XTYPE_XBOX360)
                 usb_kill_urb(xpad->irq_out);
 }
 
-static void xpad_deinit_ff(struct usb_xpad *xpad)
+static void xpad_deinit_output(struct usb_xpad *xpad)
 {
         if (xpad->xtype == XTYPE_XBOX360) {
                 usb_free_urb(xpad->irq_out);
@@ -449,13 +428,130 @@ static void xpad_deinit_ff(struct usb_xpad *xpad)
                                 xpad->odata, xpad->odata_dma);
         }
 }
+#else
+static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
+static void xpad_deinit_output(struct usb_xpad *xpad) {}
+static void xpad_stop_output(struct usb_xpad *xpad) {}
+#endif
+
+#ifdef CONFIG_JOYSTICK_XPAD_FF
+static int xpad_play_effect(struct input_dev *dev, void *data,
+                            struct ff_effect *effect)
+{
+        struct usb_xpad *xpad = input_get_drvdata(dev);
 
+        if (effect->type == FF_RUMBLE) {
+                __u16 strong = effect->u.rumble.strong_magnitude;
+                __u16 weak = effect->u.rumble.weak_magnitude;
+                xpad->odata[0] = 0x00;
+                xpad->odata[1] = 0x08;
+                xpad->odata[2] = 0x00;
+                xpad->odata[3] = strong / 256;
+                xpad->odata[4] = weak / 256;
+                xpad->odata[5] = 0x00;
+                xpad->odata[6] = 0x00;
+                xpad->odata[7] = 0x00;
+                usb_submit_urb(xpad->irq_out, GFP_KERNEL);
+        }
+
+        return 0;
+}
+
+static int xpad_init_ff(struct usb_xpad *xpad)
+{
+        input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
+
+        return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
+}
+
+#else
+static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
+#endif
+
+#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
+#include <linux/leds.h>
+
+struct xpad_led {
+        char name[16];
+        struct led_classdev led_cdev;
+        struct usb_xpad *xpad;
+};
+
+static void xpad_send_led_command(struct usb_xpad *xpad, int command)
+{
+        if (command >= 0 && command < 14) {
+                mutex_lock(&xpad->odata_mutex);
+                xpad->odata[0] = 0x01;
+                xpad->odata[1] = 0x03;
+                xpad->odata[2] = command;
+                usb_submit_urb(xpad->irq_out, GFP_KERNEL);
+                mutex_unlock(&xpad->odata_mutex);
+        }
+}
+
+static void xpad_led_set(struct led_classdev *led_cdev,
+                         enum led_brightness value)
+{
+        struct xpad_led *xpad_led = container_of(led_cdev,
+                                                 struct xpad_led, led_cdev);
+
+        xpad_send_led_command(xpad_led->xpad, value);
+}
+
+static int xpad_led_probe(struct usb_xpad *xpad)
+{
+        static atomic_t led_seq = ATOMIC_INIT(0);
+        long led_no;
+        struct xpad_led *led;
+        struct led_classdev *led_cdev;
+        int error;
+
+        if (xpad->xtype != XTYPE_XBOX360)
+                return 0;
+
+        xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
+        if (!led)
+                return -ENOMEM;
+
+        led_no = (long)atomic_inc_return(&led_seq) - 1;
+
+        snprintf(led->name, sizeof(led->name), "xpad%ld", led_no);
+        led->xpad = xpad;
+
+        led_cdev = &led->led_cdev;
+        led_cdev->name = led->name;
+        led_cdev->brightness_set = xpad_led_set;
+
+        error = led_classdev_register(&xpad->udev->dev, led_cdev);
+        if (error) {
+                kfree(led);
+                xpad->led = NULL;
+                return error;
+        }
+
+        /*
+         * Light up the segment corresponding to controller number
+         */
+        xpad_send_led_command(xpad, (led_no % 4) + 2);
+
+        return 0;
+}
+
+static void xpad_led_disconnect(struct usb_xpad *xpad)
+{
+        struct xpad_led *xpad_led = xpad->led;
+
+        if (xpad_led) {
+                led_classdev_unregister(&xpad_led->led_cdev);
+                kfree(xpad_led->name);
+        }
+}
 #else
-static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
-static void xpad_stop_ff(struct usb_xpad *xpad) { }
-static void xpad_deinit_ff(struct usb_xpad *xpad) { }
+static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
+static void xpad_led_disconnect(struct usb_xpad *xpad) { }
 #endif
 
+
 static int xpad_open(struct input_dev *dev)
 {
         struct usb_xpad *xpad = input_get_drvdata(dev);
@@ -472,7 +568,7 @@ static void xpad_close(struct input_dev *dev)
         struct usb_xpad *xpad = input_get_drvdata(dev);
 
         usb_kill_urb(xpad->irq_in);
-        xpad_stop_ff(xpad);
+        xpad_stop_output(xpad);
 }
 
 static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
@@ -564,10 +660,18 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                 for (i = 0; xpad_abs_pad[i] >= 0; i++)
                     xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
 
-        error = xpad_init_ff(intf, xpad);
+        error = xpad_init_output(intf, xpad);
         if (error)
                 goto fail2;
 
+        error = xpad_init_ff(xpad);
+        if (error)
+                goto fail3;
+
+        error = xpad_led_probe(xpad);
+        if (error)
+                goto fail3;
+
         ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;
         usb_fill_int_urb(xpad->irq_in, udev,
                          usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
@@ -578,12 +682,13 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
 
         error = input_register_device(xpad->dev);
         if (error)
-                goto fail3;
+                goto fail4;
 
         usb_set_intfdata(intf, xpad);
         return 0;
 
- fail3: usb_free_urb(xpad->irq_in);
+ fail4: usb_free_urb(xpad->irq_in);
+ fail3: xpad_deinit_output(xpad);
  fail2: usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
  fail1: input_free_device(input_dev);
         kfree(xpad);
@@ -597,8 +702,9 @@ static void xpad_disconnect(struct usb_interface *intf)
 
         usb_set_intfdata(intf, NULL);
         if (xpad) {
+                xpad_led_disconnect(xpad);
                 input_unregister_device(xpad->dev);
-                xpad_deinit_ff(xpad);
+                xpad_deinit_output(xpad);
                 usb_free_urb(xpad->irq_in);
                 usb_buffer_free(xpad->udev, XPAD_PKT_LEN,
                                 xpad->idata, xpad->idata_dma);
diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
index e3215267db11..2bea1b2c631c 100644
--- a/drivers/input/mouse/appletouch.c
+++ b/drivers/input/mouse/appletouch.c
@@ -155,6 +155,8 @@ struct atp {
         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
         int                     overflowwarn;   /* overflow warning printed? */
         int                     datalen;        /* size of an USB urb transfer */
+        int                     idlecount;      /* number of empty packets */
+        struct work_struct      work;
 };
 
 #define dbg_dump(msg, tab) \
@@ -208,6 +210,55 @@ static inline int atp_is_geyser_3(struct atp *dev)
                 (productId == GEYSER4_JIS_PRODUCT_ID);
 }
 
+/*
+ * By default Geyser 3 device sends standard USB HID mouse
+ * packets (Report ID 2). This code changes device mode, so it
+ * sends raw sensor reports (Report ID 5).
+ */
+static int atp_geyser3_init(struct usb_device *udev)
+{
+        char data[8];
+        int size;
+
+        size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                        ATP_GEYSER3_MODE_READ_REQUEST_ID,
+                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                        ATP_GEYSER3_MODE_REQUEST_VALUE,
+                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
+
+        if (size != 8) {
+                err("Could not do mode read request from device"
+                    " (Geyser 3 mode)");
+                return -EIO;
+        }
+
+        /* Apply the mode switch */
+        data[0] = ATP_GEYSER3_MODE_VENDOR_VALUE;
+
+        size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                        ATP_GEYSER3_MODE_WRITE_REQUEST_ID,
+                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                        ATP_GEYSER3_MODE_REQUEST_VALUE,
+                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
+
+        if (size != 8) {
+                err("Could not do mode write request to device"
+                    " (Geyser 3 mode)");
+                return -EIO;
+        }
+        return 0;
+}
+
+/* Reinitialise the device if it's a geyser 3 */
+static void atp_reinit(struct work_struct *work)
+{
+        struct atp *dev = container_of(work, struct atp, work);
+        struct usb_device *udev = dev->udev;
+
+        dev->idlecount = 0;
+        atp_geyser3_init(udev);
+}
+
 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
                              int *z, int *fingers)
 {
@@ -439,8 +490,8 @@ static void atp_complete(struct urb* urb)
                 }
                 dev->x_old = x;
                 dev->y_old = y;
-        }
-        else if (!x && !y) {
+
+        } else if (!x && !y) {
 
                 dev->x_old = dev->y_old = -1;
                 input_report_key(dev->input, BTN_TOUCH, 0);
@@ -449,11 +500,21 @@ static void atp_complete(struct urb* urb)
 
                 /* reset the accumulator on release */
                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
-        }
 
-        input_report_key(dev->input, BTN_LEFT,
-                         !!dev->data[dev->datalen - 1]);
+                /* Geyser 3 will continue to send packets continually after
+                   the first touch unless reinitialised. Do so if it's been
+                   idle for a while in order to avoid waking the kernel up
+                   several hundred times a second */
+                if (atp_is_geyser_3(dev)) {
+                        dev->idlecount++;
+                        if (dev->idlecount == 10) {
+                                dev->valid = 0;
+                                schedule_work(&dev->work);
+                        }
+                }
+        }
 
+        input_report_key(dev->input, BTN_LEFT, dev->data[dev->datalen - 1] & 1);
         input_sync(dev->input);
 
 exit:
@@ -480,6 +541,7 @@ static void atp_close(struct input_dev *input)
         struct atp *dev = input_get_drvdata(input);
 
         usb_kill_urb(dev->urb);
+        cancel_work_sync(&dev->work);
         dev->open = 0;
 }
 
@@ -528,40 +590,10 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
                 dev->datalen = 81;
 
         if (atp_is_geyser_3(dev)) {
-                /*
-                 * By default Geyser 3 device sends standard USB HID mouse
-                 * packets (Report ID 2). This code changes device mode, so it
-                 * sends raw sensor reports (Report ID 5).
-                 */
-                char data[8];
-                int size;
-
-                size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                        ATP_GEYSER3_MODE_READ_REQUEST_ID,
-                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                        ATP_GEYSER3_MODE_REQUEST_VALUE,
-                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
-
-                if (size != 8) {
-                        err("Could not do mode read request from device"
-                                                        " (Geyser 3 mode)");
+                /* switch to raw sensor mode */
+                if (atp_geyser3_init(udev))
                         goto err_free_devs;
-                }
-
-                /* Apply the mode switch */
-                data[0] = ATP_GEYSER3_MODE_VENDOR_VALUE;
-
-                size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                        ATP_GEYSER3_MODE_WRITE_REQUEST_ID,
-                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                        ATP_GEYSER3_MODE_REQUEST_VALUE,
-                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
 
-                if (size != 8) {
-                        err("Could not do mode write request to device"
-                                                        " (Geyser 3 mode)");
-                        goto err_free_devs;
-                }
                 printk("appletouch Geyser 3 inited.\n");
         }
 
@@ -636,6 +668,8 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
         /* save our data pointer in this interface device */
         usb_set_intfdata(iface, dev);
 
+        INIT_WORK(&dev->work, atp_reinit);
+
         return 0;
 
  err_free_buffer:
@@ -669,14 +703,17 @@ static void atp_disconnect(struct usb_interface *iface)
 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
 {
         struct atp *dev = usb_get_intfdata(iface);
+
         usb_kill_urb(dev->urb);
         dev->valid = 0;
+
         return 0;
 }
 
 static int atp_resume(struct usb_interface *iface)
 {
         struct atp *dev = usb_get_intfdata(iface);
+
         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
                 return -EIO;
 
diff --git a/drivers/input/mouse/lifebook.c b/drivers/input/mouse/lifebook.c
index 1740cadd9594..91109b49fde1 100644
--- a/drivers/input/mouse/lifebook.c
+++ b/drivers/input/mouse/lifebook.c
@@ -109,7 +109,7 @@ static psmouse_ret_t lifebook_process_byte(struct psmouse *psmouse)
 {
         struct lifebook_data *priv = psmouse->private;
         struct input_dev *dev1 = psmouse->dev;
-        struct input_dev *dev2 = priv->dev2;
+        struct input_dev *dev2 = priv ? priv->dev2 : NULL;
         unsigned char *packet = psmouse->packet;
         int relative_packet = packet[0] & 0x08;
 
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 4fca1e7f2678..702a526cf45b 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -366,6 +366,7 @@ static void i8042_pnp_exit(void)
 static int __init i8042_pnp_init(void)
 {
         char kbd_irq_str[4] = { 0 }, aux_irq_str[4] = { 0 };
+        int pnp_data_busted = 0;
         int err;
 
         if (i8042_nopnp) {
@@ -413,27 +414,48 @@ static int __init i8042_pnp_init(void)
 #endif
 
         if (((i8042_pnp_data_reg & ~0xf) == (i8042_data_reg & ~0xf) &&
-              i8042_pnp_data_reg != i8042_data_reg) || !i8042_pnp_data_reg) {
-                printk(KERN_WARNING "PNP: PS/2 controller has invalid data port %#x; using default %#x\n",
+              i8042_pnp_data_reg != i8042_data_reg) ||
+            !i8042_pnp_data_reg) {
+                printk(KERN_WARNING
+                        "PNP: PS/2 controller has invalid data port %#x; "
+                        "using default %#x\n",
                         i8042_pnp_data_reg, i8042_data_reg);
                 i8042_pnp_data_reg = i8042_data_reg;
+                pnp_data_busted = 1;
         }
 
         if (((i8042_pnp_command_reg & ~0xf) == (i8042_command_reg & ~0xf) &&
-              i8042_pnp_command_reg != i8042_command_reg) || !i8042_pnp_command_reg) {
-                printk(KERN_WARNING "PNP: PS/2 controller has invalid command port %#x; using default %#x\n",
+              i8042_pnp_command_reg != i8042_command_reg) ||
+            !i8042_pnp_command_reg) {
+                printk(KERN_WARNING
+                        "PNP: PS/2 controller has invalid command port %#x; "
+                        "using default %#x\n",
                         i8042_pnp_command_reg, i8042_command_reg);
                 i8042_pnp_command_reg = i8042_command_reg;
+                pnp_data_busted = 1;
         }
 
         if (!i8042_nokbd && !i8042_pnp_kbd_irq) {
-                printk(KERN_WARNING "PNP: PS/2 controller doesn't have KBD irq; using default %d\n", i8042_kbd_irq);
+                printk(KERN_WARNING
+                        "PNP: PS/2 controller doesn't have KBD irq; "
+                        "using default %d\n", i8042_kbd_irq);
                 i8042_pnp_kbd_irq = i8042_kbd_irq;
+                pnp_data_busted = 1;
         }
 
         if (!i8042_noaux && !i8042_pnp_aux_irq) {
-                printk(KERN_WARNING "PNP: PS/2 controller doesn't have AUX irq; using default %d\n", i8042_aux_irq);
-                i8042_pnp_aux_irq = i8042_aux_irq;
+                if (!pnp_data_busted && i8042_pnp_kbd_irq) {
+                        printk(KERN_WARNING
+                                "PNP: PS/2 appears to have AUX port disabled, "
+                                "if this is incorrect please boot with "
+                                "i8042.nopnp\n");
+                        i8042_noaux = 1;
+                } else {
+                        printk(KERN_WARNING
+                                "PNP: PS/2 controller doesn't have AUX irq; "
+                                "using default %d\n", i8042_aux_irq);
+                        i8042_pnp_aux_irq = i8042_aux_irq;
+                }
         }
 
         i8042_data_reg = i8042_pnp_data_reg;
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 69371779806a..f929fcdbae2e 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -54,6 +54,19 @@ config TOUCHSCREEN_CORGI
           To compile this driver as a module, choose M here: the
           module will be called corgi_ts.
 
+config TOUCHSCREEN_FUJITSU
+        tristate "Fujitsu serial touchscreen"
+        select SERIO
+        help
+          Say Y here if you have the Fujitsu touchscreen (such as one
+          installed in Lifebook P series laptop) connected to your
+          system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called fujitsu-ts.
+
 config TOUCHSCREEN_GUNZE
         tristate "Gunze AHL-51S touchscreen"
         select SERIO
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 2f86d6ad06d3..5de8933c4993 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_TOUCHSCREEN_BITSY)		+= h3600_ts_input.o
 obj-$(CONFIG_TOUCHSCREEN_CORGI)         += corgi_ts.o
 obj-$(CONFIG_TOUCHSCREEN_GUNZE)         += gunze.o
 obj-$(CONFIG_TOUCHSCREEN_ELO)           += elo.o
+obj-$(CONFIG_TOUCHSCREEN_FUJITSU)       += fujitsu_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MTOUCH)        += mtouch.o
 obj-$(CONFIG_TOUCHSCREEN_MK712)         += mk712.o
 obj-$(CONFIG_TOUCHSCREEN_HP600)         += hp680_ts_input.o
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 1c9069cd3bae..96581d08774f 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -95,7 +95,7 @@ struct ads7846 {
         u16                     dummy;          /* for the pwrdown read */
         struct ts_event         tc;
 
-        struct spi_transfer     xfer[10];
+        struct spi_transfer     xfer[18];
         struct spi_message      msg[5];
         struct spi_message      *last_msg;
         int                     msg_idx;
@@ -107,6 +107,8 @@ struct ads7846 {
         u16                     debounce_tol;
         u16                     debounce_rep;
 
+        u16                     penirq_recheck_delay_usecs;
+
         spinlock_t              lock;
         struct hrtimer          timer;
         unsigned                pendown:1;      /* P: lock */
@@ -553,6 +555,15 @@ static void ads7846_rx(void *ads)
                 return;
         }
 
+        /* Maybe check the pendown state before reporting. This discards
+         * false readings when the pen is lifted.
+         */
+        if (ts->penirq_recheck_delay_usecs) {
+                udelay(ts->penirq_recheck_delay_usecs);
+                if (!ts->get_pendown_state())
+                        Rt = 0;
+        }
+
         /* NOTE: We can't rely on the pressure to determine the pen down
          * state, even this controller has a pressure sensor.  The pressure
          * value can fluctuate for quite a while after lifting the pen and
@@ -896,6 +907,10 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 ts->filter = ads7846_no_filter;
         ts->get_pendown_state = pdata->get_pendown_state;
 
+        if (pdata->penirq_recheck_delay_usecs)
+                ts->penirq_recheck_delay_usecs =
+                                pdata->penirq_recheck_delay_usecs;
+
         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", spi->dev.bus_id);
 
         input_dev->name = "ADS784x Touchscreen";
@@ -936,6 +951,24 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         x->len = 2;
         spi_message_add_tail(x, m);
 
+        /* the first sample after switching drivers can be low quality;
+         * optionally discard it, using a second one after the signals
+         * have had enough time to stabilize.
+         */
+        if (pdata->settle_delay_usecs) {
+                x->delay_usecs = pdata->settle_delay_usecs;
+
+                x++;
+                x->tx_buf = &ts->read_y;
+                x->len = 1;
+                spi_message_add_tail(x, m);
+
+                x++;
+                x->rx_buf = &ts->tc.y;
+                x->len = 2;
+                spi_message_add_tail(x, m);
+        }
+
         m->complete = ads7846_rx_val;
         m->context = ts;
 
@@ -954,6 +987,21 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         x->len = 2;
         spi_message_add_tail(x, m);
 
+        /* ... maybe discard first sample ... */
+        if (pdata->settle_delay_usecs) {
+                x->delay_usecs = pdata->settle_delay_usecs;
+
+                x++;
+                x->tx_buf = &ts->read_x;
+                x->len = 1;
+                spi_message_add_tail(x, m);
+
+                x++;
+                x->rx_buf = &ts->tc.x;
+                x->len = 2;
+                spi_message_add_tail(x, m);
+        }
+
         m->complete = ads7846_rx_val;
         m->context = ts;
 
@@ -973,6 +1021,21 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 x->len = 2;
                 spi_message_add_tail(x, m);
 
+                /* ... maybe discard first sample ... */
+                if (pdata->settle_delay_usecs) {
+                        x->delay_usecs = pdata->settle_delay_usecs;
+
+                        x++;
+                        x->tx_buf = &ts->read_z1;
+                        x->len = 1;
+                        spi_message_add_tail(x, m);
+
+                        x++;
+                        x->rx_buf = &ts->tc.z1;
+                        x->len = 2;
+                        spi_message_add_tail(x, m);
+                }
+
                 m->complete = ads7846_rx_val;
                 m->context = ts;
 
@@ -990,6 +1053,21 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 x->len = 2;
                 spi_message_add_tail(x, m);
 
+                /* ... maybe discard first sample ... */
+                if (pdata->settle_delay_usecs) {
+                        x->delay_usecs = pdata->settle_delay_usecs;
+
+                        x++;
+                        x->tx_buf = &ts->read_z2;
+                        x->len = 1;
+                        spi_message_add_tail(x, m);
+
+                        x++;
+                        x->rx_buf = &ts->tc.z2;
+                        x->len = 2;
+                        spi_message_add_tail(x, m);
+                }
+
                 m->complete = ads7846_rx_val;
                 m->context = ts;
         }
diff --git a/drivers/input/touchscreen/fujitsu_ts.c b/drivers/input/touchscreen/fujitsu_ts.c
new file mode 100644
index 000000000000..daf7a4afc935
--- /dev/null
+++ b/drivers/input/touchscreen/fujitsu_ts.c
@@ -0,0 +1,189 @@
+/*
+ * Fujitsu serial touchscreen driver
+ *
+ * Copyright (c) Dmitry Torokhov <dtor@mail.ru>
+ */
+
+/*
+ * 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/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/serio.h>
+#include <linux/init.h>
+
+#define DRIVER_DESC     "Fujitsu serial touchscreen driver"
+
+MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+#define FUJITSU_LENGTH 5
+
+/*
+ * Per-touchscreen data.
+ */
+struct fujitsu {
+        struct input_dev *dev;
+        struct serio *serio;
+        int idx;
+        unsigned char data[FUJITSU_LENGTH];
+        char phys[32];
+};
+
+/*
+ * Decode serial data (5 bytes per packet)
+ * First byte
+ * 1 C 0 0 R S S S
+ * Where C is 1 while in calibration mode (which we don't use)
+ * R is 1 when no coordinate corection was done.
+ * S are button state
+ */
+static irqreturn_t fujitsu_interrupt(struct serio *serio,
+                                     unsigned char data, unsigned int flags)
+{
+        struct fujitsu *fujitsu = serio_get_drvdata(serio);
+        struct input_dev *dev = fujitsu->dev;
+
+        if (fujitsu->idx == 0) {
+                /* resync skip until start of frame */
+                if ((data & 0xf0) != 0x80)
+                        return IRQ_HANDLED;
+        } else {
+                /* resync skip garbage */
+                if (data & 0x80) {
+                        fujitsu->idx = 0;
+                        return IRQ_HANDLED;
+                }
+        }
+
+        fujitsu->data[fujitsu->idx++] = data;
+        if (fujitsu->idx == FUJITSU_LENGTH) {
+                input_report_abs(dev, ABS_X,
+                                 (fujitsu->data[2] << 7) | fujitsu->data[1]);
+                input_report_abs(dev, ABS_Y,
+                                 (fujitsu->data[4] << 7) | fujitsu->data[3]);
+                input_report_key(dev, BTN_TOUCH,
+                                 (fujitsu->data[0] & 0x03) != 2);
+                input_sync(dev);
+                fujitsu->idx = 0;
+        }
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * fujitsu_disconnect() is the opposite of fujitsu_connect()
+ */
+static void fujitsu_disconnect(struct serio *serio)
+{
+        struct fujitsu *fujitsu = serio_get_drvdata(serio);
+
+        input_get_device(fujitsu->dev);
+        input_unregister_device(fujitsu->dev);
+        serio_close(serio);
+        serio_set_drvdata(serio, NULL);
+        input_put_device(fujitsu->dev);
+        kfree(fujitsu);
+}
+
+/*
+ * fujitsu_connect() is the routine that is called when someone adds a
+ * new serio device that supports the Fujitsu protocol and registers it
+ * as input device.
+ */
+static int fujitsu_connect(struct serio *serio, struct serio_driver *drv)
+{
+        struct fujitsu *fujitsu;
+        struct input_dev *input_dev;
+        int err;
+
+        fujitsu = kzalloc(sizeof(struct fujitsu), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!fujitsu || !input_dev) {
+                err = -ENOMEM;
+                goto fail1;
+        }
+
+        fujitsu->serio = serio;
+        fujitsu->dev = input_dev;
+        snprintf(fujitsu->phys, sizeof(fujitsu->phys),
+                 "%s/input0", serio->phys);
+
+        input_dev->name = "Fujitsu Serial Touchscreen";
+        input_dev->phys = fujitsu->phys;
+        input_dev->id.bustype = BUS_RS232;
+        input_dev->id.vendor = SERIO_FUJITSU;
+        input_dev->id.product = 0;
+        input_dev->id.version = 0x0100;
+        input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
+        input_dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
+
+        input_set_abs_params(input_dev, ABS_X, 0, 4096, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, 4096, 0, 0);
+        serio_set_drvdata(serio, fujitsu);
+
+        err = serio_open(serio, drv);
+        if (err)
+                goto fail2;
+
+        err = input_register_device(fujitsu->dev);
+        if (err)
+                goto fail3;
+
+        return 0;
+
+ fail3:
+        serio_close(serio);
+ fail2:
+        serio_set_drvdata(serio, NULL);
+ fail1:
+        input_free_device(input_dev);
+        kfree(fujitsu);
+        return err;
+}
+
+/*
+ * The serio driver structure.
+ */
+static struct serio_device_id fujitsu_serio_ids[] = {
+        {
+                .type   = SERIO_RS232,
+                .proto  = SERIO_FUJITSU,
+                .id     = SERIO_ANY,
+                .extra  = SERIO_ANY,
+        },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(serio, fujitsu_serio_ids);
+
+static struct serio_driver fujitsu_drv = {
+        .driver         = {
+                .name   = "fujitsu_ts",
+        },
+        .description    = DRIVER_DESC,
+        .id_table       = fujitsu_serio_ids,
+        .interrupt      = fujitsu_interrupt,
+        .connect        = fujitsu_connect,
+        .disconnect     = fujitsu_disconnect,
+};
+
+static int __init fujitsu_init(void)
+{
+        return serio_register_driver(&fujitsu_drv);
+}
+
+static void __exit fujitsu_exit(void)
+{
+        serio_unregister_driver(&fujitsu_drv);
+}
+
+module_init(fujitsu_init);
+module_exit(fujitsu_exit);