Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-28 01:55:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

advanced ps/2 mouse driver that supports intellimouse and mice with mouse wheel and 4th and 5th buttons

Browse source 
svn path=/trunk/; revision=6173
This commit is contained in:
Thomas Bluemel 2003-09-28 00:30:34 +00:00
parent 7871924668
commit 9a74edf2a1
8 changed files with 1313 additions and 440 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

239
reactos/drivers/input/psaux/logips2pp.c Normal file
View file

@ -0,0 +1,239 @@
/*
* Logitech PS/2++ mouse driver
*
* Copyright (c) 1999-2003 Vojtech Pavlik <vojtech@suse.cz>
* Copyright (c) 2003 Eric Wong <eric@yhbt.net>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#include <ddk/ntddk.h>
#include <ddk/ntddmou.h>
#include "mouse.h"
#include "logips2pp.h"
/*
* Process a PS2++ or PS2T++ packet.
*/
void ps2pp_process_packet(PDEVICE_EXTENSION DeviceExtension, PMOUSE_INPUT_DATA Input)
{
unsigned char *packet = DeviceExtension->MouseBuffer;
if ((packet[0] & 0x48) == 0x48 && (packet[1] & 0x02) == 0x02) {
switch ((packet[1] >> 4) | (packet[0] & 0x30)) {
case 0x0d: /* Mouse extra info */
/* FIXME - mouse seems to have 2 wheels
input_report_rel(dev, packet[2] & 0x80 ? REL_HWHEEL : REL_WHEEL,
(int) (packet[2] & 8) - (int) (packet[2] & 7)); */
Input->ButtonData = (UINT)((WHEEL_DELTA) * ((int)(packet[2] & 8) - (int)(packet[2] & 7)));
Input->RawButtons |= ((packet[2] >> 4) & 1) ? GPM_B_FOURTH : 0;
Input->RawButtons |= ((packet[2] >> 5) & 1) ? GPM_B_FIFTH : 0;
break;
case 0x0e: /* buttons 4, 5, 6, 7, 8, 9, 10 info */
Input->RawButtons |= (packet[2] & 1) ? GPM_B_FOURTH : 0;
Input->RawButtons |= ((packet[2] >> 1) & 1) ? GPM_B_FIFTH : 0;
/* FIXME - support those buttons???
input_report_key(dev, BTN_BACK, (packet[2] >> 3) & 1);
input_report_key(dev, BTN_FORWARD, (packet[2] >> 4) & 1);
input_report_key(dev, BTN_TASK, (packet[2] >> 2) & 1);
*/
break;
case 0x0f: /* TouchPad extra info */
/* FIXME - mouse seems to have 2 wheels
input_report_rel(dev, packet[2] & 0x08 ? REL_HWHEEL : REL_WHEEL,
(int) ((packet[2] >> 4) & 8) - (int) ((packet[2] >> 4) & 7)); */
Input->ButtonData = (UINT)((WHEEL_DELTA) *((int) ((packet[2] >> 4) & 8) - (int) ((packet[2] >> 4) & 7)));
packet[0] = packet[2] | 0x08;
break;
default:
DbgPrint("logips2pp.c: Received PS2++ packet 0x%x, but don't know how to handle.\n",
(packet[1] >> 4) | (packet[0] & 0x30));
}
packet[0] &= 0x0f;
packet[1] = 0;
packet[2] = 0;
}
}
/*
* ps2pp_cmd() sends a PS2++ command, sliced into two bit
* pieces through the SETRES command. This is needed to send extended
* commands to mice on notebooks that try to understand the PS/2 protocol
* Ugly.
*/
static int ps2pp_cmd(PDEVICE_EXTENSION DeviceExtension, unsigned char *param, unsigned char command)
{
unsigned char d;
int i;
if (psmouse_command(DeviceExtension, NULL, PSMOUSE_CMD_SETSCALE11))
return -1;
for (i = 6; i >= 0; i -= 2) {
d = (command >> i) & 3;
if(psmouse_command(DeviceExtension, &d, PSMOUSE_CMD_SETRES))
return -1;
}
if (psmouse_command(DeviceExtension, param, PSMOUSE_CMD_POLL))
return -1;
return 0;
}
/*
* SmartScroll / CruiseControl for some newer Logitech mice Defaults to
* enabled if we do nothing to it. Of course I put this in because I want it
* disabled :P
* 1 - enabled (if previously disabled, also default)
* 0/2 - disabled
*/
static void ps2pp_set_smartscroll(PDEVICE_EXTENSION DeviceExtension)
{
unsigned char param[4];
ps2pp_cmd(DeviceExtension, param, 0x32);
param[0] = 0;
psmouse_command(DeviceExtension, param, PSMOUSE_CMD_SETRES);
psmouse_command(DeviceExtension, param, PSMOUSE_CMD_SETRES);
psmouse_command(DeviceExtension, param, PSMOUSE_CMD_SETRES);
if (DeviceExtension->psmouse_smartscroll == 1)
param[0] = 1;
else
if (DeviceExtension->psmouse_smartscroll > 2)
return;
/* else leave param[0] == 0 to disable */
psmouse_command(DeviceExtension, param, PSMOUSE_CMD_SETRES);
}
/*
* Support 800 dpi resolution _only_ if the user wants it (there are good
* reasons to not use it even if the mouse supports it, and of course there are
* also good reasons to use it, let the user decide).
*/
void ps2pp_set_800dpi(PDEVICE_EXTENSION DeviceExtension)
{
unsigned char param = 3;
psmouse_command(DeviceExtension, NULL, PSMOUSE_CMD_SETSCALE11);
psmouse_command(DeviceExtension, NULL, PSMOUSE_CMD_SETSCALE11);
psmouse_command(DeviceExtension, NULL, PSMOUSE_CMD_SETSCALE11);
psmouse_command(DeviceExtension, &param, PSMOUSE_CMD_SETRES);
}
/*
* Detect the exact model and features of a PS2++ or PS2T++ Logitech mouse or
* touchpad.
*/
int ps2pp_detect_model(PDEVICE_EXTENSION DeviceExtension, unsigned char *param)
{
int i;
//char *vendor, *name;
static int logitech_4btn[] = { 12, 40, 41, 42, 43, 52, 73, 80, -1 };
static int logitech_wheel[] = { 52, 53, 75, 76, 80, 81, 83, 88, 112, -1 };
static int logitech_ps2pp[] = { 12, 13, 40, 41, 42, 43, 50, 51, 52, 53, 73, 75,
76, 80, 81, 83, 88, 96, 97, 112, -1 };
static int logitech_mx[] = { 112, -1 };
//vendor = "Logitech";
//DbgPrint("Vendor: %s, name: %s\n", vendor, name);
DeviceExtension->model = ((param[0] >> 4) & 0x07) | ((param[0] << 3) & 0x78);
/*if (param[1] < 3)
clear_bit(BTN_MIDDLE, DeviceExtension->dev.keybit);
if (param[1] < 2)
clear_bit(BTN_RIGHT, DeviceExtension->dev.keybit);*/
DeviceExtension->MouseType = PSMOUSE_PS2;
for (i = 0; logitech_ps2pp[i] != -1; i++)
if (logitech_ps2pp[i] == DeviceExtension->model)
DeviceExtension->MouseType = PSMOUSE_PS2PP;
if (DeviceExtension->MouseType == PSMOUSE_PS2PP) {
/* for (i = 0; logitech_4btn[i] != -1; i++)
if (logitech_4btn[i] == psmouse->model)
set_bit(BTN_SIDE, psmouse->dev.keybit);
*/
for (i = 0; logitech_wheel[i] != -1; i++)
if (logitech_wheel[i] == DeviceExtension->model) {
// set_bit(REL_WHEEL, psmouse->dev.relbit);
//name = "Wheel Mouse";DbgPrint("Vendor: %s, name: %s\n", vendor, name);
}
for (i = 0; logitech_mx[i] != -1; i++)
if (logitech_mx[i] == DeviceExtension->model) {
/* set_bit(BTN_SIDE, psmouse->dev.keybit);
set_bit(BTN_EXTRA, psmouse->dev.keybit);
set_bit(BTN_BACK, psmouse->dev.keybit);
set_bit(BTN_FORWARD, psmouse->dev.keybit);
set_bit(BTN_TASK, psmouse->dev.keybit);
*/ //name = "MX Mouse";DbgPrint("Vendor: %s, name: %s\n", vendor, name);
}
/*
* Do Logitech PS2++ / PS2T++ magic init.
*/
if (DeviceExtension->model == 97) { /* TouchPad 3 */
// set_bit(REL_WHEEL, psmouse->dev.relbit);
// set_bit(REL_HWHEEL, psmouse->dev.relbit);
param[0] = 0x11; param[1] = 0x04; param[2] = 0x68; /* Unprotect RAM */
psmouse_command(DeviceExtension, param, 0x30d1);
param[0] = 0x11; param[1] = 0x05; param[2] = 0x0b; /* Enable features */
psmouse_command(DeviceExtension, param, 0x30d1);
param[0] = 0x11; param[1] = 0x09; param[2] = 0xc3; /* Enable PS2++ */
psmouse_command(DeviceExtension, param, 0x30d1);
param[0] = 0;
if (!psmouse_command(DeviceExtension, param, 0x13d1) &&
param[0] == 0x06 && param[1] == 0x00 && param[2] == 0x14) {
//name = "TouchPad 3";DbgPrint("Vendor: %s, name: %s\n", vendor, name);
return PSMOUSE_PS2TPP;
}
} else {
param[0] = param[1] = param[2] = 0;
ps2pp_cmd(DeviceExtension, param, 0x39); /* Magic knock */
ps2pp_cmd(DeviceExtension, param, 0xDB);
if ((param[0] & 0x78) == 0x48 && (param[1] & 0xf3) == 0xc2 &&
(param[2] & 3) == ((param[1] >> 2) & 3)) {
ps2pp_set_smartscroll(DeviceExtension);
return PSMOUSE_PS2PP;
}
}
}
return 0;
}

19
reactos/drivers/input/psaux/logips2pp.h Normal file
View file

@ -0,0 +1,19 @@
/*
* Logitech PS/2++ mouse driver header
*
* Copyright (c) 2003 Vojtech Pavlik <vojtech@suse.cz>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#include <ddk/ntddk.h>
#include <ddk/iotypes.h>
#include "psaux.h"
#ifndef _LOGIPS2PP_H
#define _LOGIPS2PP_H
void ps2pp_process_packet(PDEVICE_EXTENSION DeviceExtension, PMOUSE_INPUT_DATA Input);
void ps2pp_set_800dpi(PDEVICE_EXTENSION DeviceExtension);
int ps2pp_detect_model(PDEVICE_EXTENSION DeviceExtension, unsigned char *param);
#endif

4
reactos/drivers/input/psaux/makefile
View file

@ -1,4 +1,4 @@
# $Id: makefile,v 1.7 2001/08/21 20:13:14 chorns Exp $
# $Id: makefile,v 1.8 2003/09/28 00:30:34 weiden Exp $
PATH_TO_TOP = ../../..
@ -6,7 +6,7 @@ TARGET_TYPE = driver
TARGET_NAME = psaux
TARGET_OBJECTS = $(TARGET_NAME).o controller.o mouse.o
TARGET_OBJECTS = $(TARGET_NAME).o controller.o mouse.o logips2pp.o synaptics.o
include $(PATH_TO_TOP)/rules.mak

929
reactos/drivers/input/psaux/mouse.c
View file

File diff suppressed because it is too large Load diff

29
reactos/drivers/input/psaux/mouse.h
View file

@ -43,6 +43,35 @@
#define MOUSE_ISINTELLIMOUSE 0x03
#define MOUSE_ISINTELLIMOUSE5BUTTONS 0x04
// -----------------------------------------------------------------------------
#define WHEEL_DELTA 120
#define PSMOUSE_CMD_SETSCALE11 0x00e6
#define PSMOUSE_CMD_SETRES 0x10e8
#define PSMOUSE_CMD_GETINFO 0x03e9
#define PSMOUSE_CMD_SETSTREAM 0x00ea
#define PSMOUSE_CMD_POLL 0x03eb
#define PSMOUSE_CMD_GETID 0x02f2
#define PSMOUSE_CMD_SETRATE 0x10f3
#define PSMOUSE_CMD_ENABLE 0x00f4
#define PSMOUSE_CMD_RESET_DIS 0x00f6
#define PSMOUSE_CMD_RESET_BAT 0x02ff
#define PSMOUSE_RET_BAT 0xaa
#define PSMOUSE_RET_ACK 0xfa
#define PSMOUSE_RET_NAK 0xfe
#define PSMOUSE_PS2 1
#define PSMOUSE_PS2PP 2
#define PSMOUSE_PS2TPP 3
#define PSMOUSE_GENPS 4
#define PSMOUSE_IMPS 5
#define PSMOUSE_IMEX 6
#define PSMOUSE_SYNAPTICS 7
#define input_regs(a,b) do { (a)->regs = (b); } while (0)
static PIRP CurrentIrp;
static ULONG MouseDataRead;
static ULONG MouseDataRequired;

23
reactos/drivers/input/psaux/psaux.h
View file

@ -1,3 +1,5 @@
#include <ddk/ntddk.h>
#include <ddk/iotypes.h>
typedef struct _DEVICE_EXTENSION {
PDEVICE_OBJECT DeviceObject;
@ -5,10 +7,29 @@ typedef struct _DEVICE_EXTENSION {
ULONG ActiveQueue;
ULONG InputDataCount[2];
MOUSE_INPUT_DATA MouseInputData[2][MOUSE_BUFFER_SIZE];
BOOL HasMouse;
unsigned char MouseType;
unsigned char model;
unsigned char MouseBuffer[8];
UINT MouseBufferPosition;
UINT MouseBufferSize;
UINT Resolution;
unsigned char cmdbuf[8];
unsigned char cmdcnt;
unsigned char pktcnt;
char acking;
volatile char ack;
int psmouse_noext;
int psmouse_smartscroll;
ULONG PreviousButtons;
CLASS_INFORMATION ClassInformation;
PKINTERRUPT MouseInterrupt;
KDPC IsrDpc;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

410
reactos/drivers/input/psaux/synaptics.c Normal file
View file

@ -0,0 +1,410 @@
/*
* Synaptics TouchPad PS/2 mouse driver
*
* 2003 Peter Osterlund <petero2@telia.com>
* Ported to 2.5 input device infrastructure.
*
* Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch>
* start merging tpconfig and gpm code to a xfree-input module
* adding some changes and extensions (ex. 3rd and 4th button)
*
* Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu>
* Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com>
* code for the special synaptics commands (from the tpconfig-source)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*
* Trademarks are the property of their respective owners.
*/
#define NO_SYNAPTICS
#include <ddk/ntddk.h>
#include <ddk/ntddmou.h>
#include <ddk/iotypes.h>
#include "mouse.h"
#include "psaux.h"
#ifndef NO_SYNAPTICS
#include "synaptics.h"
/*****************************************************************************
* Synaptics communications functions
****************************************************************************/
/*
* Use the Synaptics extended ps/2 syntax to write a special command byte.
* special command: 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
* is the command. A 0xF3 or 0xE9 must follow (see synaptics_send_cmd
* and synaptics_set_mode)
*/
static int synaptics_special_cmd(PDEVICE_EXTENSION DeviceExtension, unsigned char command)
{
int i;
if (psmouse_command(DeviceExtension, NULL, PSMOUSE_CMD_SETSCALE11))
return -1;
for (i = 6; i >= 0; i -= 2) {
unsigned char d = (command >> i) & 3;
if (psmouse_command(DeviceExtension, &d, PSMOUSE_CMD_SETRES))
return -1;
}
return 0;
}
/*
* Send a command to the synpatics touchpad by special commands
*/
static int synaptics_send_cmd(PDEVICE_EXTENSION DeviceExtension, unsigned char c, unsigned char *param)
{
if (synaptics_special_cmd(DeviceExtension, c))
return -1;
if (psmouse_command(DeviceExtension, param, PSMOUSE_CMD_GETINFO))
return -1;
return 0;
}
/*
* Set the synaptics touchpad mode byte by special commands
*/
static int synaptics_set_mode(PDEVICE_EXTENSION DeviceExtension, unsigned char mode)
{
unsigned char param[1];
if (synaptics_special_cmd(DeviceExtension, mode))
return -1;
param[0] = 0x14;
if (psmouse_command(DeviceExtension, param, PSMOUSE_CMD_SETRATE))
return -1;
return 0;
}
static int synaptics_reset(PDEVICE_EXTENSION DeviceExtension)
{
unsigned char r[2];
if (psmouse_command(DeviceExtension, r, PSMOUSE_CMD_RESET_BAT))
return -1;
if (r[0] == 0xAA && r[1] == 0x00)
return 0;
return -1;
}
/*
* Read the model-id bytes from the touchpad
* see also SYN_MODEL_* macros
*/
static int synaptics_model_id(struct psmouse *psmouse, unsigned long int *model_id)
{
unsigned char mi[3];
if (synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi))
return -1;
*model_id = (mi[0]<<16) | (mi[1]<<8) | mi[2];
return 0;
}
/*
* Read the capability-bits from the touchpad
* see also the SYN_CAP_* macros
*/
static int synaptics_capability(struct psmouse *psmouse, unsigned long int *capability)
{
unsigned char cap[3];
if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
return -1;
*capability = (cap[0]<<16) | (cap[1]<<8) | cap[2];
if (SYN_CAP_VALID(*capability))
return 0;
return -1;
}
/*
* Identify Touchpad
* See also the SYN_ID_* macros
*/
static int synaptics_identify(struct psmouse *psmouse, unsigned long int *ident)
{
unsigned char id[3];
if (synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id))
return -1;
*ident = (id[0]<<16) | (id[1]<<8) | id[2];
if (SYN_ID_IS_SYNAPTICS(*ident))
return 0;
return -1;
}
static int synaptics_enable_device(struct psmouse *psmouse)
{
if (psmouse_command(psmouse, NULL, PSMOUSE_CMD_ENABLE))
return -1;
return 0;
}
static void print_ident(struct synaptics_data *priv)
{
printk(KERN_INFO "Synaptics Touchpad, model: %ld\n", SYN_ID_MODEL(priv->identity));
printk(KERN_INFO " Firware: %ld.%ld\n", SYN_ID_MAJOR(priv->identity),
SYN_ID_MINOR(priv->identity));
if (SYN_MODEL_ROT180(priv->model_id))
printk(KERN_INFO " 180 degree mounted touchpad\n");
if (SYN_MODEL_PORTRAIT(priv->model_id))
printk(KERN_INFO " portrait touchpad\n");
printk(KERN_INFO " Sensor: %ld\n", SYN_MODEL_SENSOR(priv->model_id));
if (SYN_MODEL_NEWABS(priv->model_id))
printk(KERN_INFO " new absolute packet format\n");
if (SYN_MODEL_PEN(priv->model_id))
printk(KERN_INFO " pen detection\n");
if (SYN_CAP_EXTENDED(priv->capabilities)) {
printk(KERN_INFO " Touchpad has extended capability bits\n");
if (SYN_CAP_FOUR_BUTTON(priv->capabilities))
printk(KERN_INFO " -> four buttons\n");
if (SYN_CAP_MULTIFINGER(priv->capabilities))
printk(KERN_INFO " -> multifinger detection\n");
if (SYN_CAP_PALMDETECT(priv->capabilities))
printk(KERN_INFO " -> palm detection\n");
}
}
static int query_hardware(struct psmouse *psmouse)
{
struct synaptics_data *priv = psmouse->private;
int retries = 0;
while ((retries++ < 3) && synaptics_reset(psmouse))
printk(KERN_ERR "synaptics reset failed\n");
if (synaptics_identify(psmouse, &priv->identity))
return -1;
if (synaptics_model_id(psmouse, &priv->model_id))
return -1;
if (synaptics_capability(psmouse, &priv->capabilities))
return -1;
if (synaptics_set_mode(psmouse, (SYN_BIT_ABSOLUTE_MODE |
SYN_BIT_HIGH_RATE |
SYN_BIT_DISABLE_GESTURE |
SYN_BIT_W_MODE)))
return -1;
synaptics_enable_device(psmouse);
print_ident(priv);
return 0;
}
/*****************************************************************************
* Driver initialization/cleanup functions
****************************************************************************/
static inline void set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
{
dev->absmin[axis] = min;
dev->absmax[axis] = max;
dev->absfuzz[axis] = fuzz;
dev->absflat[axis] = flat;
set_bit(axis, dev->absbit);
}
int synaptics_init(struct psmouse *psmouse)
{
struct synaptics_data *priv;
psmouse->private = priv = kmalloc(sizeof(struct synaptics_data), GFP_KERNEL);
if (!priv)
return -1;
memset(priv, 0, sizeof(struct synaptics_data));
priv->inSync = 1;
if (query_hardware(psmouse)) {
printk(KERN_ERR "Unable to query/initialize Synaptics hardware.\n");
goto init_fail;
}
/*
* The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
* which says that they should be valid regardless of the actual size of
* the senser.
*/
set_bit(EV_ABS, psmouse->dev.evbit);
set_abs_params(&psmouse->dev, ABS_X, 1472, 5472, 0, 0);
set_abs_params(&psmouse->dev, ABS_Y, 1408, 4448, 0, 0);
set_abs_params(&psmouse->dev, ABS_PRESSURE, 0, 255, 0, 0);
set_bit(EV_MSC, psmouse->dev.evbit);
set_bit(MSC_GESTURE, psmouse->dev.mscbit);
set_bit(EV_KEY, psmouse->dev.evbit);
set_bit(BTN_LEFT, psmouse->dev.keybit);
set_bit(BTN_RIGHT, psmouse->dev.keybit);
set_bit(BTN_FORWARD, psmouse->dev.keybit);
set_bit(BTN_BACK, psmouse->dev.keybit);
clear_bit(EV_REL, psmouse->dev.evbit);
clear_bit(REL_X, psmouse->dev.relbit);
clear_bit(REL_Y, psmouse->dev.relbit);
return 0;
init_fail:
kfree(priv);
return -1;
}
void synaptics_disconnect(struct psmouse *psmouse)
{
struct synaptics_data *priv = psmouse->private;
kfree(priv);
}
/*****************************************************************************
* Functions to interpret the absolute mode packets
****************************************************************************/
static void synaptics_parse_hw_state(struct synaptics_data *priv, struct synaptics_hw_state *hw)
{
unsigned char *buf = priv->proto_buf;
hw->x = (((buf[3] & 0x10) << 8) |
((buf[1] & 0x0f) << 8) |
buf[4]);
hw->y = (((buf[3] & 0x20) << 7) |
((buf[1] & 0xf0) << 4) |
buf[5]);
hw->z = buf[2];
hw->w = (((buf[0] & 0x30) >> 2) |
((buf[0] & 0x04) >> 1) |
((buf[3] & 0x04) >> 2));
hw->left = (buf[0] & 0x01) ? 1 : 0;
hw->right = (buf[0] & 0x2) ? 1 : 0;
hw->up = 0;
hw->down = 0;
if (SYN_CAP_EXTENDED(priv->capabilities) &&
(SYN_CAP_FOUR_BUTTON(priv->capabilities))) {
hw->up = ((buf[3] & 0x01)) ? 1 : 0;
if (hw->left)
hw->up = !hw->up;
hw->down = ((buf[3] & 0x02)) ? 1 : 0;
if (hw->right)
hw->down = !hw->down;
}
}
/*
* called for each full received packet from the touchpad
*/
static void synaptics_process_packet(struct psmouse *psmouse)
{
struct input_dev *dev = &psmouse->dev;
struct synaptics_data *priv = psmouse->private;
struct synaptics_hw_state hw;
synaptics_parse_hw_state(priv, &hw);
if (hw.z > 0) {
int w_ok = 0;
/*
* Use capability bits to decide if the w value is valid.
* If not, set it to 5, which corresponds to a finger of
* normal width.
*/
if (SYN_CAP_EXTENDED(priv->capabilities)) {
switch (hw.w) {
case 0 ... 1:
w_ok = SYN_CAP_MULTIFINGER(priv->capabilities);
break;
case 2:
w_ok = SYN_MODEL_PEN(priv->model_id);
break;
case 4 ... 15:
w_ok = SYN_CAP_PALMDETECT(priv->capabilities);
break;
}
}
if (!w_ok)
hw.w = 5;
}
/* Post events */
input_report_abs(dev, ABS_X, hw.x);
input_report_abs(dev, ABS_Y, hw.y);
input_report_abs(dev, ABS_PRESSURE, hw.z);
if (hw.w != priv->old_w) {
input_event(dev, EV_MSC, MSC_GESTURE, hw.w);
priv->old_w = hw.w;
}
input_report_key(dev, BTN_LEFT, hw.left);
input_report_key(dev, BTN_RIGHT, hw.right);
input_report_key(dev, BTN_FORWARD, hw.up);
input_report_key(dev, BTN_BACK, hw.down);
input_sync(dev);
}
void synaptics_process_byte(struct psmouse *psmouse, struct pt_regs *regs)
{
struct input_dev *dev = &psmouse->dev;
struct synaptics_data *priv = psmouse->private;
unsigned char *pBuf = priv->proto_buf;
unsigned char u = psmouse->packet[0];
input_regs(dev, regs);
pBuf[priv->proto_buf_tail++] = u;
/* check first byte */
if ((priv->proto_buf_tail == 1) && ((u & 0xC8) != 0x80)) {
priv->inSync = 0;
priv->proto_buf_tail = 0;
printk(KERN_WARNING "Synaptics driver lost sync at 1st byte\n");
return;
}
/* check 4th byte */
if ((priv->proto_buf_tail == 4) && ((u & 0xc8) != 0xc0)) {
priv->inSync = 0;
priv->proto_buf_tail = 0;
printk(KERN_WARNING "Synaptics driver lost sync at 4th byte\n");
return;
}
if (priv->proto_buf_tail >= 6) { /* Full packet received */
if (!priv->inSync) {
priv->inSync = 1;
printk(KERN_NOTICE "Synaptics driver resynced.\n");
}
synaptics_process_packet(psmouse);
priv->proto_buf_tail = 0;
}
}
#else
int synaptics_init(PDEVICE_EXTENSION DeviceExtension)
{
return -1;
}
#endif

100
reactos/drivers/input/psaux/synaptics.h Normal file
View file

@ -0,0 +1,100 @@
/*
* Synaptics TouchPad PS/2 mouse driver
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#ifndef NO_SYNAPTICS
#ifndef _SYNAPTICS_H
#define _SYNAPTICS_H
extern void synaptics_process_byte(DeviceExtension, struct pt_regs *regs);
#endif
extern int synaptics_init(DeviceExtension);
#ifndef NO_SYNAPTICS
extern void synaptics_disconnect(DeviceExtension);
/* synaptics queries */
#define SYN_QUE_IDENTIFY 0x00
#define SYN_QUE_MODES 0x01
#define SYN_QUE_CAPABILITIES 0x02
#define SYN_QUE_MODEL 0x03
#define SYN_QUE_SERIAL_NUMBER_PREFIX 0x06
#define SYN_QUE_SERIAL_NUMBER_SUFFIX 0x07
#define SYN_QUE_RESOLUTION 0x08
/* synatics modes */
#define SYN_BIT_ABSOLUTE_MODE (1 << 7)
#define SYN_BIT_HIGH_RATE (1 << 6)
#define SYN_BIT_SLEEP_MODE (1 << 3)
#define SYN_BIT_DISABLE_GESTURE (1 << 2)
#define SYN_BIT_W_MODE (1 << 0)
/* synaptics model ID bits */
#define SYN_MODEL_ROT180(m) ((m) & (1 << 23))
#define SYN_MODEL_PORTRAIT(m) ((m) & (1 << 22))
#define SYN_MODEL_SENSOR(m) (((m) >> 16) & 0x3f)
#define SYN_MODEL_HARDWARE(m) (((m) >> 9) & 0x7f)
#define SYN_MODEL_NEWABS(m) ((m) & (1 << 7))
#define SYN_MODEL_PEN(m) ((m) & (1 << 6))
#define SYN_MODEL_SIMPLIC(m) ((m) & (1 << 5))
#define SYN_MODEL_GEOMETRY(m) ((m) & 0x0f)
/* synaptics capability bits */
#define SYN_CAP_EXTENDED(c) ((c) & (1 << 23))
#define SYN_CAP_SLEEP(c) ((c) & (1 << 4))
#define SYN_CAP_FOUR_BUTTON(c) ((c) & (1 << 3))
#define SYN_CAP_MULTIFINGER(c) ((c) & (1 << 1))
#define SYN_CAP_PALMDETECT(c) ((c) & (1 << 0))
#define SYN_CAP_VALID(c) ((((c) & 0x00ff00) >> 8) == 0x47)
/* synaptics modes query bits */
#define SYN_MODE_ABSOLUTE(m) ((m) & (1 << 7))
#define SYN_MODE_RATE(m) ((m) & (1 << 6))
#define SYN_MODE_BAUD_SLEEP(m) ((m) & (1 << 3))
#define SYN_MODE_DISABLE_GESTURE(m) ((m) & (1 << 2))
#define SYN_MODE_PACKSIZE(m) ((m) & (1 << 1))
#define SYN_MODE_WMODE(m) ((m) & (1 << 0))
/* synaptics identify query bits */
#define SYN_ID_MODEL(i) (((i) >> 4) & 0x0f)
#define SYN_ID_MAJOR(i) ((i) & 0x0f)
#define SYN_ID_MINOR(i) (((i) >> 16) & 0xff)
#define SYN_ID_IS_SYNAPTICS(i) ((((i) >> 8) & 0xff) == 0x47)
/*
* A structure to describe the state of the touchpad hardware (buttons and pad)
*/
struct synaptics_hw_state {
int x;
int y;
int z;
int w;
int left;
int right;
int up;
int down;
};
struct synaptics_data {
/* Data read from the touchpad */
unsigned long int model_id; /* Model-ID */
unsigned long int capabilities; /* Capabilities */
unsigned long int identity; /* Identification */
/* Data for normal processing */
unsigned char proto_buf[6]; /* Buffer for Packet */
unsigned char last_byte; /* last received byte */
int inSync; /* Packets in sync */
int proto_buf_tail;
int old_w; /* Previous w value */
};
#endif /* _SYNAPTICS_H */
#endif /* NO_SYNAPTICS */