Input: psmouse - export protocol as a sysfs per-device attribute

       to allow easy switching at run-time.

Signed-off-by: Dmitry Torokhov <dtor@mail.ru>

diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 259e6b70544bba5dcd77a4a192f2093adb2403c0..19785a6c5abd790fdfba408ef84c6b477d9e64d6 100644 (file)
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -32,15 +32,14 @@ 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, "lifebook" };
 #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
 module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
-MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, lifebook, any). Useful for KVM switches.");
+MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
 
 static unsigned int psmouse_resolution = 200;
 module_param_named(resolution, psmouse_resolution, uint, 0644);
@@ -58,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);
@@ -77,7 +77,14 @@ __obsolete_setup("psmouse_rate=");
  */
 static DECLARE_MUTEX(psmouse_sem);
 
-static char *psmouse_protocols[] = { "None", "PS/2", "PS2++", "ThinkPS/2", "GenPS/2", "ImPS/2", "ImExPS/2", "SynPS/2", "AlpsPS/2", "LBPS/2" };
+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
@@ -417,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.
@@ -437,9 +447,7 @@ static int psmouse_extensions(struct psmouse *psmouse,
  * We always check for lifebook because it does not disturb mouse
  * (it only checks DMI information).
  */
-       if (lifebook_detect(psmouse, set_properties) == 0 ||
-           max_proto == PSMOUSE_LIFEBOOK) {
-
+       if (lifebook_detect(psmouse, set_properties) == 0) {
                if (max_proto > PSMOUSE_IMEX) {
                        if (!set_properties || lifebook_init(psmouse) == 0)
                                return PSMOUSE_LIFEBOOK;
@@ -529,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.
  */
@@ -680,6 +785,7 @@ static void psmouse_disconnect(struct serio *serio)
 
        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);
@@ -712,6 +818,49 @@ static void psmouse_disconnect(struct serio *serio)
        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;
+}
+
 /*
  * psmouse_connect() is a callback from the serio module when
  * an unhandled serio port is found.
@@ -739,11 +888,7 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
 
        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);
@@ -767,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);
@@ -795,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);
@@ -946,11 +1077,14 @@ ssize_t psmouse_attr_set_helper(struct device *dev, const char *buf, size_t coun
                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);
 
@@ -961,6 +1095,75 @@ ssize_t psmouse_attr_set_helper(struct device *dev, const char *buf, size_t coun
        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);
@@ -1017,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)

diff --git a/drivers/input/mouse/psmouse.h b/drivers/input/mouse/psmouse.h
index 4848be627a6fe4224b3329dc67dade9bb3755a12..dc8e9ae07f3267b386233681589c7068f27c6f3f 100644 (file)
--- a/drivers/input/mouse/psmouse.h
+++ b/drivers/input/mouse/psmouse.h
@@ -78,6 +78,7 @@ enum psmouse_type {
        PSMOUSE_SYNAPTICS,
        PSMOUSE_ALPS,
        PSMOUSE_LIFEBOOK,
+       PSMOUSE_AUTO            /* This one should always be last */
 };
 
 int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command);

diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index b82815a0b65b60feb04bb8e7fdb46320f710d1df..615bf62ad468b32967582ba3f904b1b08d4c4912 100644 (file)
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -42,6 +42,7 @@ MODULE_LICENSE("GPL");
 EXPORT_SYMBOL(serio_interrupt);
 EXPORT_SYMBOL(__serio_register_port);
 EXPORT_SYMBOL(serio_unregister_port);
+EXPORT_SYMBOL(serio_unregister_child_port);
 EXPORT_SYMBOL(__serio_unregister_port_delayed);
 EXPORT_SYMBOL(__serio_register_driver);
 EXPORT_SYMBOL(serio_unregister_driver);
@@ -179,12 +180,12 @@ static void serio_queue_event(void *object, struct module *owner,
        spin_lock_irqsave(&serio_event_lock, flags);
 
        /*
-        * Scan event list for the other events for the same serio port,
+        * Scan event list for the other events for the same serio port,
         * starting with the most recent one. If event is the same we
         * do not need add new one. If event is of different type we
         * need to add this event and should not look further because
         * we need to preseve sequence of distinct events.
-        */
+        */
        list_for_each_entry_reverse(event, &serio_event_list, node) {
                if (event->object == object) {
                        if (event->type == event_type)
@@ -653,6 +654,19 @@ void serio_unregister_port(struct serio *serio)
        up(&serio_sem);
 }
 
+/*
+ * Safely unregisters child port if one is present.
+ */
+void serio_unregister_child_port(struct serio *serio)
+{
+       down(&serio_sem);
+       if (serio->child) {
+               serio_disconnect_port(serio->child);
+               serio_destroy_port(serio->child);
+       }
+       up(&serio_sem);
+}
+
 /*
  * Submits register request to kseriod for subsequent execution.
  * Can be used when it is not obvious whether the serio_sem is

diff --git a/include/linux/serio.h b/include/linux/serio.h
index a2d3b9ae06f4976439edd8045e714435849b27aa..aa4d6493a034b605d429bf237fd9a37c36fe9fff 100644 (file)
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -83,6 +83,7 @@ static inline void serio_register_port(struct serio *serio)
 }
 
 void serio_unregister_port(struct serio *serio);
+void serio_unregister_child_port(struct serio *serio);
 void __serio_unregister_port_delayed(struct serio *serio, struct module *owner);
 static inline void serio_unregister_port_delayed(struct serio *serio)
 {
@@ -153,6 +154,11 @@ static inline int serio_pin_driver(struct serio *serio)
        return down_interruptible(&serio->drv_sem);
 }
 
+static inline void serio_pin_driver_uninterruptible(struct serio *serio)
+{
+       down(&serio->drv_sem);
+}
+
 static inline void serio_unpin_driver(struct serio *serio)
 {
        up(&serio->drv_sem);