/* $OpenBSD: mouse_protocols.c,v 1.16 2014/05/14 18:28:22 shadchin Exp $ */

/*

 * Copyright (c) 2001 Jean-Baptiste Marchand, Julien Montagne and Jerome Verdon

 *

 * Copyright (c) 1998 by Kazutaka Yokota

 *

 * Copyright (c) 1995 Michael Smith

 *

 * Copyright (c) 1993 by David Dawes <dawes@xfree86.org>

 *

 * Copyright (c) 1990,91 by Thomas Roell, Dinkelscherben, Germany.

 *

 * All rights reserved.

 *

 * Most of this code was taken from the FreeBSD moused daemon, written by

 * Michael Smith. The FreeBSD moused daemon already contained code from the

 * Xfree Project, written by David Dawes and Thomas Roell and Kazutaka Yokota.

 *

 * Adaptation to OpenBSD was done by Jean-Baptiste Marchand, Julien Montagne

 * and Jerome Verdon.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *	This product includes software developed by

 *      David Dawes, Jean-Baptiste Marchand, Julien Montagne, Thomas Roell,

 *      Michael Smith, Jerome Verdon and Kazutaka Yokota.

 * 4. The name authors may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *

 */

/* Support for non-wsmouse (i.e. serial mice) mice */

/*

 * Most of this code comes from the Xfree Project and are derived from two files

 * of Xfree86 3.3.6 with the following CVS tags :

 $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86_Mouse.c,v 3.21.2.24

 1999/12/11 19:00:42 hohndel Exp $

 and

 $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86_PnPMouse.c,v 1.1.2.6

 1999/07/29 09:22:51 hohndel Exp $

 */

#include <sys/ioctl.h>

#include <sys/types.h>

#include <sys/time.h>

#include <sys/tty.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#include <unistd.h>

#include <signal.h>

#include <poll.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <syslog.h>

#include "wsmoused.h"

#include "mouse_protocols.h"

extern int	debug;

extern int	nodaemon;

extern int	background;

extern mouse_t	mouse;

/* Cflags of each mouse protocol, ordered by P_XXX */

static const unsigned short mousecflags[] = {

	(CS7 | CREAD | CLOCAL | HUPCL),	/* Microsoft */

	(CS8 | CSTOPB | CREAD | CLOCAL | HUPCL),	/* MouseSystems */

	(CS8 | CSTOPB | CREAD | CLOCAL | HUPCL),	/* Logitech */

	(CS8 | PARENB | PARODD | CREAD | CLOCAL | HUPCL),	/* MMSeries */

	(CS7 | CREAD | CLOCAL | HUPCL),	/* MouseMan */

	(CS8 | CREAD | CLOCAL | HUPCL),	/* MM HitTablet */

	(CS7 | CREAD | CLOCAL | HUPCL),	/* GlidePoint */

	(CS7 | CREAD | CLOCAL | HUPCL),	/* IntelliMouse */

	(CS7 | CREAD | CLOCAL | HUPCL),	/* Thinking Mouse */

};

/* array ordered by P_XXX giving protocol properties */

static const unsigned char proto[][7] = {

	/* mask hd_id   dp_mask dp_id   bytes b4_mask b4_id */

	{0x40, 0x40, 0x40, 0x00, 3, ~0x23, 0x00},	/* Microsoft */

	{0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff},	/* MouseSystems */

	{0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff},	/* Logitech */

	{0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff},	/* MMSeries */

	{0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00},	/* MouseMan */

	{0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff},	/* MM HitTablet */

	{0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00},	/* GlidePoint */

	{0x40, 0x40, 0x40, 0x00, 3, ~0x3f, 0x00},	/* IntelliMouse */

	{0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00},	/* ThinkingMouse */

};

/*

 * array ordered by P_XXX (mouse protocols) giving the protocol

 * corresponding to the name of a mouse

 */

const char *mouse_names[] = {

	"microsoft",

	"mousesystems",

	"logitech",

	"mmseries",

	"mouseman",

	"mmhitab",

	"glidepoint",

	"intellimouse",

	"thinkingmouse",

	NULL

};

/* protocol currently used */

static unsigned char cur_proto[7];

/* PnP EISA/product IDs */

static const symtab_t pnpprod[] = {

	{"KML0001", P_THINKING},/* Kensignton ThinkingMouse */

	{"MSH0001", P_IMSERIAL},/* MS IntelliMouse */

	{"MSH0004", P_IMSERIAL},/* MS IntelliMouse TrackBall */

	{"KYEEZ00", P_MS},	/* Genius EZScroll */

	{"KYE0001", P_MS},	/* Genius PnP Mouse */

	{"KYE0003", P_IMSERIAL},/* Genius NetMouse */

	{"LGI800C", P_IMSERIAL},/* Logitech MouseMan (4 button model) */

	{"LGI8050", P_IMSERIAL},/* Logitech MouseMan+ */

	{"LGI8051", P_IMSERIAL},/* Logitech FirstMouse+ */

	{"LGI8001", P_LOGIMAN},	/* Logitech serial */

	{"PNP0F01", P_MS},	/* MS serial */

	/*

	 * XXX EzScroll returns PNP0F04 in the compatible device field; but it

	 * doesn't look compatible...

	 */

	{"PNP0F04", P_MSC},	/* MouseSystems */

	{"PNP0F05", P_MSC},	/* MouseSystems */

	{"PNP0F08", P_LOGIMAN},	/* Logitech serial */

	{"PNP0F09", P_MS},	/* MS BallPoint serial */

	{"PNP0F0A", P_MS},	/* MS PnP serial */

	{"PNP0F0B", P_MS},	/* MS PnP BallPoint serial */

	{"PNP0F0C", P_MS},	/* MS serial comatible */

	{"PNP0F0F", P_MS},	/* MS BallPoint comatible */

	{"PNP0F17", P_LOGIMAN},	/* Logitech serial compat */

	{NULL, -1},

};

static const symtab_t *

gettoken(const symtab_t * tab, char *s, int len)

{

	int	i;

			break;

	}

}

const char *

mouse_name(int type)

{

}

void

SetMouseSpeed(int old, unsigned int cflag)

{

	char	*c;

		    mouse.portname, strerror(errno));

	}

	case 9600:

	case 4800:

	case 2400:

	case 1200:

	default:

	}

	c = "*n";

	}

}

int

FlushInput(int fd)

{

}

/*

 * Try to elicit a PnP ID as described in

 * Microsoft, Hayes: "Plug and Play External COM Device Specification,

 * rev 1.00", 1995.

 *

 * The routine does not fully implement the COM Enumerator as par Section

 * 2.1 of the document.  In particular, we don't have idle state in which

 * the driver software monitors the com port for dynamic connection or

 * removal of a device at the port, because `moused' simply quits if no

 * device is found.

 *

 * In addition, as PnP COM device enumeration procedure slightly has

 * changed since its first publication, devices which follow earlier

 * revisions of the above spec. may fail to respond if the rev 1.0

 * procedure is used. XXX

 */

static int

pnpgets(int mouse_fd, char *buf)

{

#if 0

	/*

	 * This is the procedure described in rev 1.0 of PnP COM device spec.

	 * Unfortunately, some devices which comform to earlier revisions of

	 * the spec gets confused and do not return the ID string...

	 */

	/* port initialization (2.1.2) */

	ioctl(mouse_fd, TIOCMGET, &i);

	i |= TIOCM_DTR;		/* DTR = 1 */

	i &= ~TIOCM_RTS;	/* RTS = 0 */

	ioctl(mouse_fd, TIOCMSET, &i);

	usleep(200000);

	if ((ioctl(mouse_fd, TIOCMGET, &i) == -1) || ((i & TIOCM_DSR) == 0))

		goto disconnect_idle;

	/* port setup, 1st phase (2.1.3) */

	SetMouseSpeed(1200, (CS7 | CREAD | CLOCAL | HUPCL));

	i = TIOCM_DTR | TIOCM_RTS;	/* DTR = 0, RTS = 0 */

	ioctl(mouse_fd, TIOCMBIC, &i);

	usleep(200000);

	i = TIOCM_DTR;		/* DTR = 1, RTS = 0 */

	ioctl(mouse_fd, TIOCMBIS, &i);

	usleep(200000);

	/* wait for response, 1st phase (2.1.4) */

	FlushInput(mouse_fd);

	i = TIOCM_RTS;		/* DTR = 1, RTS = 1 */

	ioctl(mouse_fd, TIOCMBIS, &i);

	/* try to read something */

	if (poll(pfd, 1, 200000 / 1000) <= 0) {

		/* port setup, 2nd phase (2.1.5) */

		i = TIOCM_DTR | TIOCM_RTS;	/* DTR = 0, RTS = 0 */

		ioctl(mouse_fd, TIOCMBIC, &i);

		usleep(200000);

		/* wait for respose, 2nd phase (2.1.6) */

		FlushInput(mouse_fd);

		i = TIOCM_DTR | TIOCM_RTS;	/* DTR = 1, RTS = 1 */

		ioctl(mouse_fd, TIOCMBIS, &i);

		/* try to read something */

		if (poll(pfd, 1, 200000 / 1000) <= 0)

			goto connect_idle;

	}

#else

	/*

	 * This is a simplified procedure; it simply toggles RTS.

	 */

	/* wait for response */

	/* try to read something */

		goto connect_idle;

#endif

	/* collect PnP COM device ID (2.1.7) */

				 * 200msec */

		/* we may see "M", or "M3..." before `Begin ID' */

		}

	}

		/* we haven't seen `Begin ID' in time... */

		goto connect_idle;

	}

			break;

			break;

			break;

	}

		goto connect_idle;

#if 0

	/*

	 * According to PnP spec, we should set DTR = 1 and RTS = 0 while

	 * in idle state.  But, `moused' shall set DTR = RTS = 1 and proceed,

	 * assuming there is something at the port even if it didn't

	 * respond to the PnP enumeration procedure.

	 */

disconnect_idle:

	i = TIOCM_DTR | TIOCM_RTS;	/* DTR = 1, RTS = 1 */

	ioctl(mouse_fd, TIOCMBIS, &i);

#endif

connect_idle:

}

/* pnpparse : parse a PnP string ID */

static int

pnpparse(pnpid_t * id, char *buf, int len)

{

	int	offset, sum = 0, i, j;

	/* calculate checksum */

	}

	/* revision */

	/* EISA vendor and product ID */

	/* option strings */

	i = 10;

		/* device serial # */

				break;

		}

		}

	}

		/* PnP class */

				break;

		}

		}

	}

		/* compatible driver */

				break;

		}

		/*

		 * PnP COM spec prior to v0.96 allowed '*' in this field,

		 * it's not allowed now; just ignore it.

		 */

		}

	}

		/* product description */

				break;

		}

		}

	}

	/* checksum exists if there are any optional fields */

#if 0

		debug("Mouse: PnP checksum: 0x%02X\n", sum);

#endif

#if 0

			/*

			 * Checksum error!!

			 * I found some mice do not comply with the PnP COM device

			 * spec regarding checksum... XXX

			 */

			return FALSE;

#endif

		}

	}

}

/* pnpproto : return the prototype used, based on the PnP ID string */

static const symtab_t *

pnpproto(pnpid_t * id)

{

	const symtab_t *t;

	int i, j;

			/* this is not a mouse! */

	}

	/*

	 * The 'Compatible drivers' field may contain more than one

	 * ID separated by ','.

	 */

				break;

		}

	}

}

/* mouse_init : init the mouse by writing appropriate sequences */

void

mouse_init(void)

{

	char           *s;

	/**

	 ** This comment is a little out of context here, but it contains

	 ** some useful information...

	 ********************************************************************

	 **

	 ** The following lines take care of the Logitech MouseMan protocols.

	 **

	 ** NOTE: There are diffrent versions of both MouseMan and TrackMan!

	 **       Hence I add another protocol P_LOGIMAN, which the user can

	 **       specify as MouseMan in his XF86Config file. This entry was

	 **       formerly handled as a special case of P_MS. However, people

	 **       who don't have the middle button problem, can still specify

	 **       Microsoft and use P_MS.

	 **

	 ** By default, these mice should use a 3 byte Microsoft protocol

	 ** plus a 4th byte for the middle button. However, the mouse might

	 ** have switched to a different protocol before we use it, so I send

	 ** the proper sequence just in case.

	 **

	 ** NOTE: - all commands to (at least the European) MouseMan have to

	 **	 be sent at 1200 Baud.

	 **       - each command starts with a '*'.

	 **       - whenever the MouseMan receives a '*', it will switch back

	 **	 to 1200 Baud. Hence I have to select the desired protocol

	 **	 first, then select the baud rate.

	 **

	 ** The protocols supported by the (European) MouseMan are:

	 **   -  5 byte packed binary protocol, as with the Mouse Systems

	 **      mouse. Selected by sequence "*U".

	 **   -  2 button 3 byte Microsoft compatible protocol. Selected

	 **      by sequence "*V".

	 **   -  3 button 3+1 byte Microsoft compatible protocol (default).

	 **      Selected by sequence "*X".

	 **

	 ** The following baud rates are supported:

	 **   -  1200 Baud (default). Selected by sequence "*n".

	 **   -  9600 Baud. Selected by sequence "*q".

	 **

	 ** Selecting a sample rate is no longer supported with the MouseMan!

	 ** Some additional lines in xf86Config.c take care of ill configured

	 ** baud rates and sample rates. (The user will get an error.)

	 */

	case P_LOGI:

		/*

		 * The baud rate selection command must be sent at the current

		 * baud rate; try all likely settings

		 */

#if 0

		SetMouseSpeed(1200, mousecflags[mouse.proto]);

#endif

		/* select MM series data format */

		/* select report rate/frequency */

		else

		break;

	case P_LOGIMAN:

		/* The command must always be sent at 1200 baud */

	case P_MMHIT:

		/*

		 * Initialize Hitachi PUMA Plus - Model 1212E to desired settings.

		 * The tablet must be configured to be in MM mode, NO parity,

		 * Binary Format.  xf86Info.sampleRate controls the sensativity

		 * of the tablet.  We only use this tablet for it's 4-button puck

		 * so we don't run in "Absolute Mode"

		 */

		/* Resolution is in 'lines per inch' on the Hitachi tablet */

		else

	case P_THINKING:

		/* the PnP ID string may be sent again, discard it */

		/* send the command to initialize the beast */

				break;

				break;

		}

		break;

	case P_MSC:

#if 0

		if (mouse.flags & ClearDTR) {

			i = TIOCM_DTR;

			ioctl(mouse.mfd, TIOCMBIC, &i);

		}

		if (mouse.flags & ClearRTS) {

			i = TIOCM_RTS;

			ioctl(mouse.mfd, TIOCMBIC, &i);

		}

#endif

	default:

	}

}

/* mouse_identify : identify the protocol used by the mouse */

int

mouse_identify(void)

{

				 * 256 bytes long */

	const symtab_t *t;

	int len;

	/* protocol has been specified with '-t' */

	else {

		/* maybe this is an PnP mouse... */

		      pnpid.neisaid, pnpid.neisaid,

		      pnpid.eisaid, pnpid.ncompat,

		      pnpid.ncompat, pnpid.compat,

		      pnpid.ndescription, pnpid.ndescription,

		      pnpid.description);

		/* we have a valid PnP serial device ID */

	}

	      cur_proto[0], cur_proto[1], cur_proto[2], cur_proto[3],

	      cur_proto[4], cur_proto[5], cur_proto[6]);

}

/* mouse_protocol : decode bytes with the current mouse protocol */

int

mouse_protocol(u_char rBuf, mousestatus_t * act)

{

	/* MOUSE_MSS_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */

	static int      butmapmss[4] = {	/* Microsoft, MouseMan,

						 * GlidePoint, IntelliMouse,

						 * Thinking Mouse */

		0,

		MOUSE_BUTTON3DOWN,

		MOUSE_BUTTON1DOWN,

		MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,

	};

	static int      butmapmss2[4] = {	/* Microsoft, MouseMan,

						 * GlidePoint, Thinking Mouse */

		0,

		MOUSE_BUTTON4DOWN,

		MOUSE_BUTTON2DOWN,

		MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN,

	};

	/* MOUSE_INTELLI_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */

	static int      butmapintelli[4] = {	/* IntelliMouse, NetMouse,

						 * Mie Mouse, MouseMan+ */

		0,

		MOUSE_BUTTON2DOWN,

		MOUSE_BUTTON4DOWN,

		MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN,

	};

	/* MOUSE_MSC_BUTTON?UP -> MOUSE_BUTTON?DOWN */

	static int      butmapmsc[8] = {	/* MouseSystems, MMSeries,

						 * Logitech, Bus, sysmouse */

		0,

		MOUSE_BUTTON3DOWN,

		MOUSE_BUTTON2DOWN,

		MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN,

		MOUSE_BUTTON1DOWN,

		MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,

		MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN,

		MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN

	};

	/* for Hitachi tablet */

	static int      butmaphit[8] = {	/* MM HitTablet */

		0,

		MOUSE_BUTTON3DOWN,

		MOUSE_BUTTON2DOWN,

		MOUSE_BUTTON1DOWN,

		MOUSE_BUTTON4DOWN,

		MOUSE_BUTTON5DOWN,

		MOUSE_BUTTON6DOWN,

		MOUSE_BUTTON7DOWN,

	};

	static int      pBufP = 0;

	static unsigned char pBuf[8];

	/*

         * Hack for resyncing: We check here for a package that is:

         *  a) illegal (detected by wrong data-package header)

         *  b) invalid (0x80 == -128 and that might be wrong for MouseSystems)

         *  c) bad header-package

         *

         * NOTE: b) is a violation of the MouseSystems-Protocol, since values of

         *       -128 are allowed, but since they are very seldom we can easily

         *       use them as package-header with no button pressed.

         * NOTE/2: On a PS/2 mouse any byte is valid as a data byte. Furthermore,

         *         0x80 is not valid as a header byte. For a PS/2 mouse we skip

         *         checking data bytes.

         *         For resyncing a PS/2 mouse we require the two most significant

         *         bits in the header byte to be 0. These are the overflow bits,

         *         and in case of an overflow we actually lose sync. Overflows

         *         are very rare, however, and we quickly gain sync again after

         *         an overflow condition. This is the best we can do. (Actually,

         *         we could use bit 0x08 in the header byte for resyncing, since

         *         that bit is supposed to be always on, but nobody told

         *         Microsoft...)

         */

	}

	/* is there an extra data byte? */

		/*

		 * Hack for Logitech MouseMan Mouse - Middle button

		 *

		 * Unfortunately this mouse has variable length packets: the standard

		 * Microsoft 3 byte packet plus an optional 4th byte whenever the

		 * middle button status changes.

		 *

		 * We have already processed the standard packet with the movement

		 * and button info.  Now post an event message with the old status

		 * of the left and right buttons and the updated middle button.

		 */

		/*

		 * Even worse, different MouseMen and TrackMen differ in the 4th

		 * byte: some will send 0x00/0x20, others 0x01/0x21, or even

		 * 0x02/0x22, so I have to strip off the lower bits.

	         *

	         * [JCH-96/01/21]

	         * HACK for ALPS "fourth button". (It's bit 0x10 of the "fourth byte"

	         * and it is activated by tapping the glidepad with the finger! 8^)

	         * We map it to bit bit3, and the reverse map in xf86Events just has

	         * to be extended so that it is identified as Button 4. The lower

	         * half of the reverse-map may remain unchanged.

		 */

		/*

		 * [KY-97/08/03]

		 * Receive the fourth byte only when preceding three bytes have

		 * been detected (pBufP >= cur_proto[4]).  In the previous

		 * versions, the test was pBufP == 0; thus, we may have mistakingly

		 * received a byte even if we didn't see anything preceding

		 * the byte.

		 */

		}

			/*

			 * IntelliMouse, NetMouse (including NetMouse Pro) and Mie Mouse

			 * always send the fourth byte, whereas the fourth byte is

			 * optional for GlidePoint and ThinkingMouse. The fourth byte

			 * is also optional for MouseMan+ and FirstMouse+ in their

			 * native mode. It is always sent if they are in the IntelliMouse

			 * compatible mode.

			 */

		case P_IMSERIAL:	/* IntelliMouse, NetMouse, Mie Mouse,

					 * MouseMan+ */

		default:

		}

	}

	/*

         * assembly full package

         */

	    cur_proto[4],

	    pBuf[0], pBuf[1], pBuf[2], pBuf[3],

	    pBuf[4], pBuf[5], pBuf[6], pBuf[7]);

	case P_MS:		/* Microsoft */

	case P_LOGIMAN:	/* MouseMan/TrackMan */

	case P_GLIDEPOINT:	/* GlidePoint */

	case P_THINKING:	/* ThinkingMouse */

	case P_IMSERIAL:	/* IntelliMouse, NetMouse, Mie Mouse,

				 * MouseMan+ */

	case P_MSC:		/* MouseSystems Corp */

	case P_MMHIT:		/* MM HitTablet */

	case P_MM:		/* MM Series */

	case P_LOGI:		/* Logitech Mice */

		/*