// SPDX-License-Identifier: GPL-2.0-only/* * PS/2 mouse driver * * Copyright (c) 1999-2002 Vojtech Pavlik * Copyright (c) 2003-2004 Dmitry Torokhov */  #define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt#define psmouse_fmt(fmt)	fmt #include <linux/bitops.h>#include <linux/delay.h>#include <linux/module.h>#include <linux/slab.h>#include <linux/interrupt.h>#include <linux/input.h>#include <linux/serio.h>#include <linux/init.h>#include <linux/libps2.h>#include <linux/mutex.h>#include <linux/types.h> #include "psmouse.h"#include "synaptics.h"#include "logips2pp.h"#include "alps.h"#include "lifebook.h"#include "trackpoint.h"#include "touchkit_ps2.h"#include "elantech.h"#include "sentelic.h"#include "cypress_ps2.h"#include "focaltech.h"#include "vmmouse.h"#include "byd.h" #define DRIVER_DESC	"PS/2 mouse driver" MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");MODULE_DESCRIPTION(DRIVER_DESC);MODULE_LICENSE("GPL"); static unsigned int psmouse_max_proto = PSMOUSE_AUTO;static int psmouse_set_maxproto(const char *val, const struct kernel_param *);static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp);static const struct kernel_param_ops param_ops_proto_abbrev = {	.set = psmouse_set_maxproto,	.get = psmouse_get_maxproto,};#define param_check_proto_abbrev(name, p)	__param_check(name, p, unsigned int)module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);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);MODULE_PARM_DESC(resolution, "Resolution, in dpi."); static unsigned int psmouse_rate = 100;module_param_named(rate, psmouse_rate, uint, 0644);MODULE_PARM_DESC(rate, "Report rate, in reports per second."); static bool psmouse_smartscroll = true;module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled."); static bool psmouse_a4tech_2wheels;module_param_named(a4tech_workaround, psmouse_a4tech_2wheels, bool, 0644);MODULE_PARM_DESC(a4tech_workaround, "A4Tech second scroll wheel workaround, 1 = enabled, 0 = disabled (default)."); static unsigned int psmouse_resetafter = 5;module_param_named(resetafter, psmouse_resetafter, uint, 0644);MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never)."); static unsigned int psmouse_resync_time;module_param_named(resync_time, psmouse_resync_time, uint, 0644);MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never)."); PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO,			NULL,			psmouse_attr_show_protocol, psmouse_attr_set_protocol);PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO,			(void *) offsetof(struct psmouse, rate),			psmouse_show_int_attr, psmouse_attr_set_rate);PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO,			(void *) offsetof(struct psmouse, resolution),			psmouse_show_int_attr, psmouse_attr_set_resolution);PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO,			(void *) offsetof(struct psmouse, resetafter),			psmouse_show_int_attr, psmouse_set_int_attr);PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO,			(void *) offsetof(struct psmouse, resync_time),			psmouse_show_int_attr, psmouse_set_int_attr); static struct attribute *psmouse_dev_attrs[] = {	&psmouse_attr_protocol.dattr.attr,	&psmouse_attr_rate.dattr.attr,	&psmouse_attr_resolution.dattr.attr,	&psmouse_attr_resetafter.dattr.attr,	&psmouse_attr_resync_time.dattr.attr,	NULL}; ATTRIBUTE_GROUPS(psmouse_dev); /* * psmouse_mutex 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 DEFINE_MUTEX(psmouse_mutex); struct psmouse *psmouse_from_serio(struct serio *serio){	struct ps2dev *ps2dev = serio_get_drvdata(serio); 	return container_of(ps2dev, struct psmouse, ps2dev);} void psmouse_report_standard_buttons(struct input_dev *dev, u8 buttons){	input_report_key(dev, BTN_LEFT,   buttons & BIT(0));	input_report_key(dev, BTN_MIDDLE, buttons & BIT(2));	input_report_key(dev, BTN_RIGHT,  buttons & BIT(1));} void psmouse_report_standard_motion(struct input_dev *dev, u8 *packet){	int x, y; 	x = packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0;	y = packet[2] ? packet[2] - ((packet[0] << 3) & 0x100) : 0; 	input_report_rel(dev, REL_X, x);	input_report_rel(dev, REL_Y, -y);} void psmouse_report_standard_packet(struct input_dev *dev, u8 *packet){	psmouse_report_standard_buttons(dev, packet[0]);	psmouse_report_standard_motion(dev, packet);} /* * psmouse_process_byte() analyzes the PS/2 data stream and reports * relevant events to the input module once full packet has arrived. */psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse){	struct input_dev *dev = psmouse->dev;	u8 *packet = psmouse->packet;	int wheel; 	if (psmouse->pktcnt < psmouse->pktsize)		return PSMOUSE_GOOD_DATA; 	/* Full packet accumulated, process it */ 	switch (psmouse->protocol->type) {	case PSMOUSE_IMPS:		/* IntelliMouse has scroll wheel */		input_report_rel(dev, REL_WHEEL, -(s8) packet[3]);		break; 	case PSMOUSE_IMEX:		/* Scroll wheel and buttons on IntelliMouse Explorer */		switch (packet[3] & 0xC0) {		case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */			input_report_rel(dev, REL_WHEEL,					 -sign_extend32(packet[3], 5));			break;		case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */			input_report_rel(dev, REL_HWHEEL,					 -sign_extend32(packet[3], 5));			break;		case 0x00:		case 0xC0:			wheel = sign_extend32(packet[3], 3); 			/*			 * Some A4Tech mice have two scroll wheels, with first			 * one reporting +/-1 in the lower nibble, and second			 * one reporting +/-2.			 */			if (psmouse_a4tech_2wheels && abs(wheel) > 1)				input_report_rel(dev, REL_HWHEEL, wheel / 2);			else				input_report_rel(dev, REL_WHEEL, -wheel); 			input_report_key(dev, BTN_SIDE,  packet[3] & BIT(4));			input_report_key(dev, BTN_EXTRA, packet[3] & BIT(5));			break;		}		break; 	case PSMOUSE_GENPS:		/* Report scroll buttons on NetMice */		input_report_rel(dev, REL_WHEEL, -(s8) packet[3]); 		/* Extra buttons on Genius NewNet 3D */		input_report_key(dev, BTN_SIDE,  packet[0] & BIT(6));		input_report_key(dev, BTN_EXTRA, packet[0] & BIT(7));		break; 	case PSMOUSE_THINKPS:		/* Extra button on ThinkingMouse */		input_report_key(dev, BTN_EXTRA, packet[0] & BIT(3)); 		/*		 * Without this bit of weirdness moving up gives wildly		 * high Y changes.		 */		packet[1] |= (packet[0] & 0x40) << 1;		break; 	case PSMOUSE_CORTRON:		/*		 * Cortron PS2 Trackball reports SIDE button in the		 * 4th bit of the first byte.		 */		input_report_key(dev, BTN_SIDE, packet[0] & BIT(3));		packet[0] |= BIT(3);		break; 	default:		break;	} 	/* Generic PS/2 Mouse */	packet[0] |= psmouse->extra_buttons;	psmouse_report_standard_packet(dev, packet); 	input_sync(dev); 	return PSMOUSE_FULL_PACKET;} /* * __psmouse_set_state() sets new psmouse state and resets all flags. */static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state){	psmouse->state = new_state;	psmouse->pktcnt = psmouse->out_of_sync_cnt = 0;	psmouse->ps2dev.flags = 0;	psmouse->last = jiffies;} /* * psmouse_set_state() sets new psmouse state and resets all flags and * counters while holding serio lock so fighting with interrupt handler * is not a concern. */void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state){	serio_pause_rx(psmouse->ps2dev.serio);	__psmouse_set_state(psmouse, new_state);	serio_continue_rx(psmouse->ps2dev.serio);} /* * psmouse_handle_byte() processes one byte of the input data stream * by calling corresponding protocol handler. */static int psmouse_handle_byte(struct psmouse *psmouse){	psmouse_ret_t rc = psmouse->protocol_handler(psmouse); 	switch (rc) {	case PSMOUSE_BAD_DATA:		if (psmouse->state == PSMOUSE_ACTIVATED) {			psmouse_warn(psmouse,				     "%s at %s lost sync at byte %d\n",				     psmouse->name, psmouse->phys,				     psmouse->pktcnt);			if (++psmouse->out_of_sync_cnt == psmouse->resetafter) {				__psmouse_set_state(psmouse, PSMOUSE_IGNORE);				psmouse_notice(psmouse,						"issuing reconnect request\n");				serio_reconnect(psmouse->ps2dev.serio);				return -EIO;			}		}		psmouse->pktcnt = 0;		break; 	case PSMOUSE_FULL_PACKET:		psmouse->pktcnt = 0;		if (psmouse->out_of_sync_cnt) {			psmouse->out_of_sync_cnt = 0;			psmouse_notice(psmouse,					"%s at %s - driver resynced.\n",					psmouse->name, psmouse->phys);		}		break; 	case PSMOUSE_GOOD_DATA:		break;	}	return 0;} static void psmouse_handle_oob_data(struct psmouse *psmouse, u8 data){	switch (psmouse->oob_data_type) {	case PSMOUSE_OOB_NONE:		psmouse->oob_data_type = data;		break; 	case PSMOUSE_OOB_EXTRA_BTNS:		psmouse_report_standard_buttons(psmouse->dev, data);		input_sync(psmouse->dev); 		psmouse->extra_buttons = data;		psmouse->oob_data_type = PSMOUSE_OOB_NONE;		break; 	default:		psmouse_warn(psmouse,			     "unknown OOB_DATA type: 0x%02x\n",			     psmouse->oob_data_type);		psmouse->oob_data_type = PSMOUSE_OOB_NONE;		break;	}} static enum ps2_disposition psmouse_pre_receive_byte(struct ps2dev *ps2dev,						     u8 data,						     unsigned int flags){	struct psmouse *psmouse = container_of(ps2dev, struct psmouse, ps2dev); 	if (psmouse->state == PSMOUSE_IGNORE)		return PS2_IGNORE; 	if (unlikely((flags & SERIO_TIMEOUT) ||		     ((flags & SERIO_PARITY) &&		      !psmouse->protocol->ignore_parity))) { 		if (psmouse->state == PSMOUSE_ACTIVATED)			psmouse_warn(psmouse,				     "bad data from KBC -%s%s\n",				     flags & SERIO_TIMEOUT ? " timeout" : "",				     flags & SERIO_PARITY ? " bad parity" : "");		return PS2_ERROR;	} 	if (flags & SERIO_OOB_DATA) {		psmouse_handle_oob_data(psmouse, data);		return PS2_IGNORE;	} 	return PS2_PROCESS;} static void psmouse_receive_byte(struct ps2dev *ps2dev, u8 data){	struct psmouse *psmouse = container_of(ps2dev, struct psmouse, ps2dev); 	pm_wakeup_event(&ps2dev->serio->dev, 0); 	if (psmouse->state <= PSMOUSE_RESYNCING)		return; 	if (psmouse->state == PSMOUSE_ACTIVATED &&	    psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {		psmouse_info(psmouse, "%s at %s lost synchronization, throwing %d bytes away.\n",			     psmouse->name, psmouse->phys, psmouse->pktcnt);		psmouse->badbyte = psmouse->packet[0];		__psmouse_set_state(psmouse, PSMOUSE_RESYNCING);		schedule_work(&psmouse->resync_work);		return;	} 	psmouse->packet[psmouse->pktcnt++] = data; 	/* Check if this is a new device announcement (0xAA 0x00) */	if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {		if (psmouse->pktcnt == 1) {			psmouse->last = jiffies;			return;		} 		if (psmouse->packet[1] == PSMOUSE_RET_ID) {			__psmouse_set_state(psmouse, PSMOUSE_IGNORE);			serio_reconnect(ps2dev->serio);			return;		} 		/* Not a new device, try processing first byte normally */		psmouse->pktcnt = 1;		if (psmouse_handle_byte(psmouse))			return; 		psmouse->packet[psmouse->pktcnt++] = data;	} 	/*	 * See if we need to force resync because mouse was idle for	 * too long.	 */	if (psmouse->state == PSMOUSE_ACTIVATED &&	    psmouse->pktcnt == 1 && psmouse->resync_time &&	    time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {		psmouse->badbyte = psmouse->packet[0];		__psmouse_set_state(psmouse, PSMOUSE_RESYNCING);		schedule_work(&psmouse->resync_work);		return;	} 	psmouse->last = jiffies;	psmouse_handle_byte(psmouse);} /* * psmouse_reset() resets the mouse into power-on state. */int psmouse_reset(struct psmouse *psmouse){	u8 param[2];	int error; 	error = ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT);	if (error)		return error; 	if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)		return -EIO; 	return 0;} /* * Here we set the mouse resolution. */void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution){	static const u8 params[] = { 0, 1, 2, 2, 3 };	u8 p; 	if (resolution == 0 || resolution > 200)		resolution = 200; 	p = params[resolution / 50];	ps2_command(&psmouse->ps2dev, &p, PSMOUSE_CMD_SETRES);	psmouse->resolution = 25 << p;} /* * Here we set the mouse report rate. */static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate){	static const u8 rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };	u8 r;	int i = 0; 	while (rates[i] > rate)		i++;	r = rates[i];	ps2_command(&psmouse->ps2dev, &r, PSMOUSE_CMD_SETRATE);	psmouse->rate = r;} /* * 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. */static int psmouse_poll(struct psmouse *psmouse){	return ps2_command(&psmouse->ps2dev, psmouse->packet,			   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. */

Lines 1–500 of 2035. Load more