1 files changed, 297 insertions, 54 deletions

diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 019034b21a0b..19785a6c5abd 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -24,6 +24,7 @@
 #include "synaptics.h"
 #include "logips2pp.h"
 #include "alps.h"
+#include "lifebook.h"
 
 #define DRIVER_DESC     "PS/2 mouse driver"
 
@@ -31,10 +32,9 @@ MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
-static unsigned int psmouse_max_proto = -1U;
+static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp);
 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp);
-static char *psmouse_proto_abbrev[] = { NULL, "bare", NULL, NULL, NULL, "imps", "exps", NULL, NULL, NULL };
 #define param_check_proto_abbrev(name, p)       __param_check(name, p, unsigned int)
 #define param_set_proto_abbrev                  psmouse_set_maxproto
 #define param_get_proto_abbrev                  psmouse_get_maxproto
@@ -57,6 +57,7 @@ static unsigned int psmouse_resetafter;
 module_param_named(resetafter, psmouse_resetafter, uint, 0644);
 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
 
+PSMOUSE_DEFINE_ATTR(protocol);
 PSMOUSE_DEFINE_ATTR(rate);
 PSMOUSE_DEFINE_ATTR(resolution);
 PSMOUSE_DEFINE_ATTR(resetafter);
@@ -67,7 +68,23 @@ __obsolete_setup("psmouse_smartscroll=");
 __obsolete_setup("psmouse_resetafter=");
 __obsolete_setup("psmouse_rate=");
 
-static char *psmouse_protocols[] = { "None", "PS/2", "PS2++", "ThinkPS/2", "GenPS/2", "ImPS/2", "ImExPS/2", "SynPS/2", "AlpsPS/2" };
+/*
+ * psmouse_sem protects all operations changing state of mouse
+ * (connecting, disconnecting, changing rate or resolution via
+ * sysfs). We could use a per-device semaphore but since there
+ * rarely more than one PS/2 mouse connected and since semaphore
+ * is taken in "slow" paths it is not worth it.
+ */
+static DECLARE_MUTEX(psmouse_sem);
+
+struct psmouse_protocol {
+        enum psmouse_type type;
+        char *name;
+        char *alias;
+        int maxproto;
+        int (*detect)(struct psmouse *, int);
+        int (*init)(struct psmouse *);
+};
 
 /*
  * psmouse_process_byte() analyzes the PS/2 data stream and reports
@@ -407,12 +424,15 @@ static int thinking_detect(struct psmouse *psmouse, int set_properties)
  */
 static int ps2bare_detect(struct psmouse *psmouse, int set_properties)
 {
-        if (!psmouse->vendor) psmouse->vendor = "Generic";
-        if (!psmouse->name) psmouse->name = "Mouse";
+        if (set_properties) {
+                if (!psmouse->vendor) psmouse->vendor = "Generic";
+                if (!psmouse->name) psmouse->name = "Mouse";
+        }
 
         return 0;
 }
 
+
 /*
  * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
  * the mouse may have.
@@ -424,6 +444,17 @@ static int psmouse_extensions(struct psmouse *psmouse,
         int synaptics_hardware = 0;
 
 /*
+ * We always check for lifebook because it does not disturb mouse
+ * (it only checks DMI information).
+ */
+        if (lifebook_detect(psmouse, set_properties) == 0) {
+                if (max_proto > PSMOUSE_IMEX) {
+                        if (!set_properties || lifebook_init(psmouse) == 0)
+                                return PSMOUSE_LIFEBOOK;
+                }
+        }
+
+/*
  * Try Kensington ThinkingMouse (we try first, because synaptics probe
  * upsets the thinkingmouse).
  */
@@ -506,6 +537,103 @@ static int psmouse_extensions(struct psmouse *psmouse,
         return PSMOUSE_PS2;
 }
 
+static struct psmouse_protocol psmouse_protocols[] = {
+        {
+                .type           = PSMOUSE_PS2,
+                .name           = "PS/2",
+                .alias          = "bare",
+                .maxproto       = 1,
+                .detect         = ps2bare_detect,
+        },
+        {
+                .type           = PSMOUSE_PS2PP,
+                .name           = "PS2++",
+                .alias          = "logitech",
+                .detect         = ps2pp_init,
+        },
+        {
+                .type           = PSMOUSE_THINKPS,
+                .name           = "ThinkPS/2",
+                .alias          = "thinkps",
+                .detect         = thinking_detect,
+        },
+        {
+                .type           = PSMOUSE_GENPS,
+                .name           = "GenPS/2",
+                .alias          = "genius",
+                .detect         = genius_detect,
+        },
+        {
+                .type           = PSMOUSE_IMPS,
+                .name           = "ImPS/2",
+                .alias          = "imps",
+                .maxproto       = 1,
+                .detect         = intellimouse_detect,
+        },
+        {
+                .type           = PSMOUSE_IMEX,
+                .name           = "ImExPS/2",
+                .alias          = "exps",
+                .maxproto       = 1,
+                .detect         = im_explorer_detect,
+        },
+        {
+                .type           = PSMOUSE_SYNAPTICS,
+                .name           = "SynPS/2",
+                .alias          = "synaptics",
+                .detect         = synaptics_detect,
+                .init           = synaptics_init,
+        },
+        {
+                .type           = PSMOUSE_ALPS,
+                .name           = "AlpsPS/2",
+                .alias          = "alps",
+                .detect         = alps_detect,
+                .init           = alps_init,
+        },
+        {
+                .type           = PSMOUSE_LIFEBOOK,
+                .name           = "LBPS/2",
+                .alias          = "lifebook",
+                .init           = lifebook_init,
+        },
+        {
+                .type           = PSMOUSE_AUTO,
+                .name           = "auto",
+                .alias          = "any",
+                .maxproto       = 1,
+        },
+};
+
+static struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++)
+                if (psmouse_protocols[i].type == type)
+                        return &psmouse_protocols[i];
+
+        WARN_ON(1);
+        return &psmouse_protocols[0];
+}
+
+static struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len)
+{
+        struct psmouse_protocol *p;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) {
+                p = &psmouse_protocols[i];
+
+                if ((strlen(p->name) == len && !strncmp(p->name, name, len)) ||
+                    (strlen(p->alias) == len && !strncmp(p->alias, name, len)))
+                        return &psmouse_protocols[i];
+        }
+
+        return NULL;
+}
+
+
 /*
  * psmouse_probe() probes for a PS/2 mouse.
  */
@@ -653,30 +781,84 @@ static void psmouse_cleanup(struct serio *serio)
 
 static void psmouse_disconnect(struct serio *serio)
 {
-        struct psmouse *psmouse, *parent;
+        struct psmouse *psmouse, *parent = NULL;
 
+        psmouse = serio_get_drvdata(serio);
+
+        device_remove_file(&serio->dev, &psmouse_attr_protocol);
         device_remove_file(&serio->dev, &psmouse_attr_rate);
         device_remove_file(&serio->dev, &psmouse_attr_resolution);
         device_remove_file(&serio->dev, &psmouse_attr_resetafter);
 
-        psmouse = serio_get_drvdata(serio);
+        down(&psmouse_sem);
+
         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 
         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
                 parent = serio_get_drvdata(serio->parent);
-                if (parent->pt_deactivate)
-                        parent->pt_deactivate(parent);
+                psmouse_deactivate(parent);
         }
 
         if (psmouse->disconnect)
                 psmouse->disconnect(psmouse);
 
+        if (parent && parent->pt_deactivate)
+                parent->pt_deactivate(parent);
+
         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
 
         input_unregister_device(&psmouse->dev);
         serio_close(serio);
         serio_set_drvdata(serio, NULL);
         kfree(psmouse);
+
+        if (parent)
+                psmouse_activate(parent);
+
+        up(&psmouse_sem);
+}
+
+static int psmouse_switch_protocol(struct psmouse *psmouse, struct psmouse_protocol *proto)
+{
+        memset(&psmouse->dev, 0, sizeof(struct input_dev));
+
+        init_input_dev(&psmouse->dev);
+
+        psmouse->dev.private = psmouse;
+        psmouse->dev.dev = &psmouse->ps2dev.serio->dev;
+
+        psmouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
+        psmouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
+        psmouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);
+
+        psmouse->set_rate = psmouse_set_rate;
+        psmouse->set_resolution = psmouse_set_resolution;
+        psmouse->protocol_handler = psmouse_process_byte;
+        psmouse->pktsize = 3;
+
+        if (proto && (proto->detect || proto->init)) {
+                if (proto->detect && proto->detect(psmouse, 1) < 0)
+                        return -1;
+
+                if (proto->init && proto->init(psmouse) < 0)
+                        return -1;
+
+                psmouse->type = proto->type;
+        }
+        else
+                psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1);
+
+        sprintf(psmouse->devname, "%s %s %s",
+                psmouse_protocol_by_type(psmouse->type)->name, psmouse->vendor, psmouse->name);
+
+        psmouse->dev.name = psmouse->devname;
+        psmouse->dev.phys = psmouse->phys;
+        psmouse->dev.id.bustype = BUS_I8042;
+        psmouse->dev.id.vendor = 0x0002;
+        psmouse->dev.id.product = psmouse->type;
+        psmouse->dev.id.version = psmouse->model;
+
+        return 0;
 }
 
 /*
@@ -688,6 +870,8 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
         struct psmouse *psmouse, *parent = NULL;
         int retval;
 
+        down(&psmouse_sem);
+
         /*
          * If this is a pass-through port deactivate parent so the device
          * connected to this port can be successfully identified
@@ -697,20 +881,14 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
                 psmouse_deactivate(parent);
         }
 
-        if (!(psmouse = kmalloc(sizeof(struct psmouse), GFP_KERNEL))) {
+        if (!(psmouse = kcalloc(1, sizeof(struct psmouse), GFP_KERNEL))) {
                 retval = -ENOMEM;
                 goto out;
         }
 
-        memset(psmouse, 0, sizeof(struct psmouse));
-
         ps2_init(&psmouse->ps2dev, serio);
         sprintf(psmouse->phys, "%s/input0", serio->phys);
-        psmouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
-        psmouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
-        psmouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);
-        psmouse->dev.private = psmouse;
-        psmouse->dev.dev = &serio->dev;
+
         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
 
         serio_set_drvdata(serio, psmouse);
@@ -734,25 +912,10 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
         psmouse->resolution = psmouse_resolution;
         psmouse->resetafter = psmouse_resetafter;
         psmouse->smartscroll = psmouse_smartscroll;
-        psmouse->set_rate = psmouse_set_rate;
-        psmouse->set_resolution = psmouse_set_resolution;
-        psmouse->protocol_handler = psmouse_process_byte;
-        psmouse->pktsize = 3;
 
-        psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1);
-
-        sprintf(psmouse->devname, "%s %s %s",
-                psmouse_protocols[psmouse->type], psmouse->vendor, psmouse->name);
-
-        psmouse->dev.name = psmouse->devname;
-        psmouse->dev.phys = psmouse->phys;
-        psmouse->dev.id.bustype = BUS_I8042;
-        psmouse->dev.id.vendor = 0x0002;
-        psmouse->dev.id.product = psmouse->type;
-        psmouse->dev.id.version = psmouse->model;
+        psmouse_switch_protocol(psmouse, NULL);
 
         input_register_device(&psmouse->dev);
-
         printk(KERN_INFO "input: %s on %s\n", psmouse->devname, serio->phys);
 
         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
@@ -762,6 +925,7 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
         if (parent && parent->pt_activate)
                 parent->pt_activate(parent);
 
+        device_create_file(&serio->dev, &psmouse_attr_protocol);
         device_create_file(&serio->dev, &psmouse_attr_rate);
         device_create_file(&serio->dev, &psmouse_attr_resolution);
         device_create_file(&serio->dev, &psmouse_attr_resetafter);
@@ -771,10 +935,11 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
         retval = 0;
 
 out:
-        /* If this is a pass-through port the parent awaits to be activated */
+        /* If this is a pass-through port the parent needs to be re-activated */
         if (parent)
                 psmouse_activate(parent);
 
+        up(&psmouse_sem);
         return retval;
 }
 
@@ -791,6 +956,8 @@ static int psmouse_reconnect(struct serio *serio)
                 return -1;
         }
 
+        down(&psmouse_sem);
+
         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
                 parent = serio_get_drvdata(serio->parent);
                 psmouse_deactivate(parent);
@@ -823,6 +990,7 @@ out:
         if (parent)
                 psmouse_activate(parent);
 
+        up(&psmouse_sem);
         return rc;
 }
 
@@ -893,26 +1061,109 @@ ssize_t psmouse_attr_set_helper(struct device *dev, const char *buf, size_t coun
 
         if (serio->drv != &psmouse_drv) {
                 retval = -ENODEV;
-                goto out;
+                goto out_unpin;
+        }
+
+        retval = down_interruptible(&psmouse_sem);
+        if (retval)
+                goto out_unpin;
+
+        if (psmouse->state == PSMOUSE_IGNORE) {
+                retval = -ENODEV;
+                goto out_up;
         }
 
         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
                 parent = serio_get_drvdata(serio->parent);
                 psmouse_deactivate(parent);
         }
+
         psmouse_deactivate(psmouse);
 
         retval = handler(psmouse, buf, count);
 
-        psmouse_activate(psmouse);
+        if (retval != -ENODEV)
+                psmouse_activate(psmouse);
+
         if (parent)
                 psmouse_activate(parent);
 
-out:
+ out_up:
+        up(&psmouse_sem);
+ out_unpin:
         serio_unpin_driver(serio);
         return retval;
 }
 
+static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, char *buf)
+{
+        return sprintf(buf, "%s\n", psmouse_protocol_by_type(psmouse->type)->name);
+}
+
+static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, const char *buf, size_t count)
+{
+        struct serio *serio = psmouse->ps2dev.serio;
+        struct psmouse *parent = NULL;
+        struct psmouse_protocol *proto;
+        int retry = 0;
+
+        if (!(proto = psmouse_protocol_by_name(buf, count)))
+                return -EINVAL;
+
+        if (psmouse->type == proto->type)
+                return count;
+
+        while (serio->child) {
+                if (++retry > 3) {
+                        printk(KERN_WARNING "psmouse: failed to destroy child port, protocol change aborted.\n");
+                        return -EIO;
+                }
+
+                up(&psmouse_sem);
+                serio_unpin_driver(serio);
+                serio_unregister_child_port(serio);
+                serio_pin_driver_uninterruptible(serio);
+                down(&psmouse_sem);
+
+                if (serio->drv != &psmouse_drv)
+                        return -ENODEV;
+
+                if (psmouse->type == proto->type)
+                        return count; /* switched by other thread */
+        }
+
+        if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
+                parent = serio_get_drvdata(serio->parent);
+                if (parent->pt_deactivate)
+                        parent->pt_deactivate(parent);
+        }
+
+        if (psmouse->disconnect)
+                psmouse->disconnect(psmouse);
+
+        psmouse_set_state(psmouse, PSMOUSE_IGNORE);
+        input_unregister_device(&psmouse->dev);
+
+        psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
+
+        if (psmouse_switch_protocol(psmouse, proto) < 0) {
+                psmouse_reset(psmouse);
+                /* default to PSMOUSE_PS2 */
+                psmouse_switch_protocol(psmouse, &psmouse_protocols[0]);
+        }
+
+        psmouse_initialize(psmouse);
+        psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
+
+        input_register_device(&psmouse->dev);
+        printk(KERN_INFO "input: %s on %s\n", psmouse->devname, serio->phys);
+
+        if (parent && parent->pt_activate)
+                parent->pt_activate(parent);
+
+        return count;
+}
+
 static ssize_t psmouse_attr_show_rate(struct psmouse *psmouse, char *buf)
 {
         return sprintf(buf, "%d\n", psmouse->rate);
@@ -969,34 +1220,26 @@ static ssize_t psmouse_attr_set_resetafter(struct psmouse *psmouse, const char *
 
 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp)
 {
-        int i;
+        struct psmouse_protocol *proto;
 
         if (!val)
                 return -EINVAL;
 
-        if (!strncmp(val, "any", 3)) {
-                *((unsigned int *)kp->arg) = -1U;
-                return 0;
-        }
+        proto = psmouse_protocol_by_name(val, strlen(val));
 
-        for (i = 0; i < ARRAY_SIZE(psmouse_proto_abbrev); i++) {
-                if (!psmouse_proto_abbrev[i])
-                        continue;
+        if (!proto || !proto->maxproto)
+                return -EINVAL;
 
-                if (!strncmp(val, psmouse_proto_abbrev[i], strlen(psmouse_proto_abbrev[i]))) {
-                        *((unsigned int *)kp->arg) = i;
-                        return 0;
-                }
-        }
+        *((unsigned int *)kp->arg) = proto->type;
 
-        return -EINVAL;                                 \
+        return 0;                                       \
 }
 
 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp)
 {
-        return sprintf(buffer, "%s\n",
-                        psmouse_max_proto < ARRAY_SIZE(psmouse_proto_abbrev) ?
-                                psmouse_proto_abbrev[psmouse_max_proto] : "any");
+        int type = *((unsigned int *)kp->arg);
+
+        return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name);
 }
 
 static int __init psmouse_init(void)