Commit dbf4ccd6 authored by Dmitry Torokhov's avatar Dmitry Torokhov
Browse files

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


       to allow easy switching at run-time.

Signed-off-by: default avatarDmitry Torokhov <dtor@mail.ru>
parent 905ab9d1

drivers/input/mouse/psmouse-base.c

+243 −48
Original line number Diff line number Diff line
@@ -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 (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);



	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)

drivers/input/mouse/psmouse.h

+1 −0
Original line number Diff line number Diff line
@@ -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);

drivers/input/serio/serio.c

+16 −2
Original line number Diff line number Diff line
@@ -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);
@@ -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

include/linux/serio.h

+6 −0
Original line number Diff line number Diff line
@@ -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);