- obsolete

[packages/kernel.git] / trackpoint-2.6.9.patch

diff -uNr a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
--- a/drivers/input/mouse/Makefile	2004-10-18 17:53:43.000000000 -0400
+++ b/drivers/input/mouse/Makefile	2004-10-31 12:27:45.000000000 -0500
@@ -14,4 +14,4 @@
 obj-$(CONFIG_MOUSE_SERIAL)	+= sermouse.o
 obj-$(CONFIG_MOUSE_VSXXXAA)	+= vsxxxaa.o
 
-psmouse-objs  := psmouse-base.o logips2pp.o synaptics.o
+psmouse-objs  := psmouse-base.o logips2pp.o synaptics.o trackpoint.o
diff -uNr a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
--- a/drivers/input/mouse/psmouse-base.c	2004-10-18 17:53:43.000000000 -0400
+++ b/drivers/input/mouse/psmouse-base.c	2004-11-07 00:28:29.000000000 -0500
@@ -21,6 +21,7 @@
 #include "psmouse.h"
 #include "synaptics.h"
 #include "logips2pp.h"
+#include "trackpoint.h"
 
 #define DRIVER_DESC	"PS/2 mouse driver"
 
@@ -468,6 +469,16 @@
 	int synaptics_hardware = 0;
 
 /*
+ * Try to initialize the IBM TrackPoint
+ */
+	if (max_proto > PSMOUSE_PS2 && trackpoint_init(psmouse) == 0) {
+		psmouse->vendor = "IBM";
+		psmouse->name = "TrackPoint";
+ 
+		return PSMOUSE_PS2;
+	}
+
+/*
  * Try Synaptics TouchPad
  */
 	if (max_proto > PSMOUSE_PS2 && synaptics_detect(psmouse)) {
diff -uNr a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c
--- a/drivers/input/mouse/trackpoint.c	1969-12-31 19:00:00.000000000 -0500
+++ b/drivers/input/mouse/trackpoint.c	2004-12-01 18:52:16.000000000 -0500
@@ -0,0 +1,424 @@
+/*
+ * Stephen Evanchik <evanchsa@gmail.com>
+ *
+ * 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.
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/serio.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/input.h>
+#include <linux/proc_fs.h>
+#include <asm/uaccess.h>
+#include "psmouse.h"
+#include "trackpoint.h"
+
+
+int tp_sens = TP_DEF_SENS;
+module_param_named(sens, tp_sens, uint, 0);
+MODULE_PARM_DESC(sens, "Sensitivity");
+
+int tp_speed = TP_DEF_SPEED;
+module_param_named(speed, tp_speed, uint, 0);
+MODULE_PARM_DESC(speed, "Speed of pointer");
+
+int tp_backup = TP_DEF_BACKUP;
+module_param_named(backup, tp_backup, uint, 0);
+MODULE_PARM_DESC(backup, "Backup Range");
+
+int tp_draghyst = TP_DEF_DRAG_HYST;
+module_param_named(draghyst, tp_draghyst, uint, 0);
+MODULE_PARM_DESC(draghyst, "Resistance to dragging");
+
+int tp_mindrag = TP_DEF_MIN_DRAG;
+module_param_named(mindrag, tp_mindrag, uint, 0);
+MODULE_PARM_DESC(mindrag, "Drag threshold");
+
+int tp_thresh = TP_DEF_THRESH;
+module_param_named(thresh, tp_thresh, uint, 0);
+MODULE_PARM_DESC(thresh, "Force necessary to trigger a press or release");
+
+int tp_upthresh = TP_UP_THRESH;
+module_param_named(upthresh, tp_upthresh, uint, 0);
+MODULE_PARM_DESC(upthresh, "Force necessary to trigger a click");
+
+int tp_ztime = TP_DEF_Z_TIME;
+module_param_named(ztime, tp_ztime, uint, 0);
+MODULE_PARM_DESC(ztime, "Determines how sharp a press is");
+
+int tp_jenks = TP_DEF_JENKS_CURV;
+module_param_named(jenks, tp_jenks, uint, 0);
+MODULE_PARM_DESC(jenks, "Double click sensitivity");
+
+
+/* Toggles */
+int tp_pts = TP_DEF_PTS;
+module_param_named(pts, tp_pts, uint, 0);
+MODULE_PARM_DESC(pts, "Press to Select");
+
+int tp_mb = TP_DEF_MB;
+module_param_named(mb, tp_mb, uint, 0);
+MODULE_PARM_DESC(pts, "Middle button is disabled");
+
+/*
+ * Device IO: read, write and toggle bit
+ */
+static void trackpoint_read(struct psmouse *psmouse, unsigned char loc, unsigned char *results)
+{
+	psmouse_command(psmouse, NULL, MAKE_PS2_CMD(0, 0, TP_COMMAND));
+	psmouse_command(psmouse, results, MAKE_PS2_CMD(0, 1, loc));
+}
+
+static void trackpoint_write(struct psmouse *psmouse, unsigned char loc, unsigned char val)
+{	
+	psmouse_command(psmouse, NULL, MAKE_PS2_CMD(0, 0, TP_COMMAND));
+	psmouse_command(psmouse, NULL, MAKE_PS2_CMD(0,0, TP_WRITE_MEM));
+	psmouse_command(psmouse, &val, MAKE_PS2_CMD(1,0, loc));
+}
+
+static int trackpoint_toggle_bit(struct psmouse *psmouse, unsigned char loc, unsigned char mask)
+{
+	/* Bad things will happen if the loc param isn't in this range */
+	if(loc < 0x20 || loc >= 0x2F)
+		return -1;
+	
+	psmouse_command(psmouse, NULL, MAKE_PS2_CMD(0, 0, TP_COMMAND));
+	psmouse_command(psmouse, NULL, MAKE_PS2_CMD(0, 0, TP_TOGGLE));
+	psmouse_command(psmouse, &mask, MAKE_PS2_CMD(1, 0, loc));
+	
+	return 0;
+}
+
+
+#ifdef CONFIG_PROC_FS
+
+#define PROC_READ_NAME(name) name##_read_func
+#define PROC_WRITE_NAME(name) name##_write_func
+#define PROC_TOGGLE_NAME(name) name##_toggle_func
+
+#define MAKE_PROC_READ(name, item) \
+	static int name(char* page, char** start, off_t off, int count, int* eof, void* data) \
+	{ \
+		int len; \
+		struct psmouse *psmouse = (struct psmouse *)data; \
+		struct trackpoint_data *tp = (struct trackpoint_data*)psmouse->private; \
+		len = sprintf(page, "%d\n", tp->item); \
+		*eof = 1; \
+		return len; \
+	}
+
+#define MAKE_PROC_WRITE(name, item, command) \
+	static int name(struct file *file, const char __user *buffer, unsigned long count, void *data) \
+	{ \
+		int len = count; \
+		unsigned char tmp[5]; \
+		struct psmouse *psmouse = (struct psmouse *)data; \
+		struct trackpoint_data *tp = (struct trackpoint_data*)psmouse->private; \
+		if(count > sizeof(tmp) - 1) \
+			len = sizeof(tmp) - 1; \
+		if(copy_from_user(tmp, buffer, len)) \
+			return -EFAULT; \
+		tmp[len] = '\0'; \
+		tp->item = simple_strtoul(tmp, 0, 10); \
+		trackpoint_write((struct psmouse *)data, command, tp->item); \
+		return len; \
+	}
+
+#define MAKE_PROC_TOGGLE(name, item, command, mask) \
+	static int name(struct file *file, const char __user *buffer, unsigned long count, void *data) \
+	{ \
+		int len = count; \
+		unsigned char toggle, tmp[5]; \
+		struct psmouse *psmouse = (struct psmouse *)data; \
+		struct trackpoint_data *tp = (struct trackpoint_data*)psmouse->private; \
+		if(count > sizeof(tmp) - 1) \
+			len = sizeof(tmp) - 1; \
+		if(copy_from_user(tmp, buffer, len)) \
+			return -EFAULT; \
+		tmp[len] = '\0'; \
+		toggle = (tmp[0] == '1') ? 1 : 0; \
+		if( toggle != tp->item) { \
+			tp->item = toggle; \
+			trackpoint_toggle_bit(psmouse, command, mask); \
+		} \
+		return len; \
+	}
+
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(sensitivity), sens, TP_SENS);
+MAKE_PROC_READ(PROC_READ_NAME(sensitivity), sens);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(speed), speed, TP_SPEED);
+MAKE_PROC_READ(PROC_READ_NAME(speed), speed);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(neg_inertia), inertia, TP_NEG_INERT);
+MAKE_PROC_READ(PROC_READ_NAME(neg_inertia), inertia);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(backup), reach, TP_BACKUP);
+MAKE_PROC_READ(PROC_READ_NAME(backup), reach);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(drag_hyst), draghys, TP_DRAG_HYST);
+MAKE_PROC_READ(PROC_READ_NAME(drag_hyst), draghys);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(min_drag), mindrag, TP_MIN_DRAG);
+MAKE_PROC_READ(PROC_READ_NAME(min_drag), mindrag);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(thresh), thresh, TP_THRESH);
+MAKE_PROC_READ(PROC_READ_NAME(thresh), thresh);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(up_thresh), up_thresh, TP_UP_THRESH);
+MAKE_PROC_READ(PROC_READ_NAME(up_thresh), up_thresh);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(z_time), z_time, TP_Z_TIME);
+MAKE_PROC_READ(PROC_READ_NAME(z_time), z_time);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(jenks_curv), jenks_curv, TP_JENKS_CURV);
+MAKE_PROC_READ(PROC_READ_NAME(jenks_curv), jenks_curv);
+
+MAKE_PROC_TOGGLE(PROC_TOGGLE_NAME(ptson), ptson, TP_TOGGLE_PTS, TP_MASK_PTS);
+MAKE_PROC_READ(PROC_READ_NAME(ptson), ptson);
+
+MAKE_PROC_TOGGLE(PROC_TOGGLE_NAME(skip_back), skipback, TP_TOGGLE_SKIP_BACK, TP_MASK_SKIP_BACK);
+MAKE_PROC_READ(PROC_READ_NAME(skip_back), skipback);
+
+MAKE_PROC_TOGGLE(PROC_TOGGLE_NAME(mb), mb, TP_TOGGLE_MB, TP_MASK_MB);
+MAKE_PROC_READ(PROC_READ_NAME(mb), mb);
+
+
+
+#define NEW_PROC_ENTRY(name) \
+        entry = create_proc_entry(#name, 0644, tp_dir); \
+        if(!entry) \
+                goto no_##name; \
+        entry->owner = THIS_MODULE; \
+        entry->data = psmouse; \
+        entry->read_proc = PROC_READ_NAME(name); \
+        entry->write_proc = PROC_WRITE_NAME(name);
+
+
+#define NEW_PROC_TOGGLE_ENTRY(name) \
+        entry = create_proc_entry(#name, 0644, tp_dir); \
+        if(!entry) \
+                goto no_##name; \
+        entry->owner = THIS_MODULE; \
+        entry->data = psmouse; \
+        entry->read_proc = PROC_READ_NAME(name); \
+        entry->write_proc = PROC_TOGGLE_NAME(name);
+	
+
+
+static struct proc_dir_entry *tp_dir = NULL;
+
+
+static int trackpoint_proc_init(struct psmouse *psmouse) 
+{ 
+	struct proc_dir_entry *entry = NULL;
+
+	tp_dir = proc_mkdir("trackpoint", NULL);
+	if(!tp_dir) 
+		return -ENOMEM;
+
+	tp_dir->owner = THIS_MODULE;
+
+	NEW_PROC_ENTRY(sensitivity);
+	NEW_PROC_ENTRY(speed);
+	NEW_PROC_ENTRY(neg_inertia);
+	NEW_PROC_ENTRY(backup);
+	NEW_PROC_ENTRY(drag_hyst);
+	NEW_PROC_ENTRY(min_drag);
+	NEW_PROC_ENTRY(thresh);
+	NEW_PROC_ENTRY(up_thresh);
+	NEW_PROC_ENTRY(z_time);
+	NEW_PROC_ENTRY(jenks_curv);
+
+	NEW_PROC_TOGGLE_ENTRY(ptson);
+	NEW_PROC_TOGGLE_ENTRY(skip_back);
+	NEW_PROC_TOGGLE_ENTRY(mb);
+
+	return 0;
+
+no_mb:
+	remove_proc_entry("skip_back", tp_dir);
+
+no_skip_back:
+	remove_proc_entry("ptson", tp_dir);
+
+no_ptson:
+	remove_proc_entry("jenks_curv", tp_dir);
+
+no_jenks_curv:
+	remove_proc_entry("z_time", tp_dir);
+
+no_z_time:
+	remove_proc_entry("up_thresh", tp_dir);
+
+no_up_thresh:
+	remove_proc_entry("thresh", tp_dir);
+
+no_thresh:
+	remove_proc_entry("min_drag", tp_dir);
+
+no_min_drag:
+	remove_proc_entry("drag_hyst", tp_dir);
+
+no_drag_hyst:
+	remove_proc_entry("backup", tp_dir);
+
+no_backup:
+	remove_proc_entry("neg_inertia", tp_dir);
+
+no_neg_inertia:
+	remove_proc_entry("speed", tp_dir);
+
+no_speed:
+	remove_proc_entry("sensitivity", tp_dir);
+
+no_sensitivity:
+	remove_proc_entry("trackpoint", NULL);
+
+	return -ENOMEM;
+}
+
+static void trackpoint_proc_remove(void)
+{
+        remove_proc_entry("mb", tp_dir);
+        remove_proc_entry("skip_back", tp_dir);
+        remove_proc_entry("ptson", tp_dir);
+        remove_proc_entry("jenks_curv", tp_dir);
+        remove_proc_entry("z_time", tp_dir);
+        remove_proc_entry("up_thresh", tp_dir);
+        remove_proc_entry("thresh", tp_dir);
+        remove_proc_entry("min_drag", tp_dir);
+        remove_proc_entry("drag_hyst", tp_dir);
+        remove_proc_entry("backup", tp_dir);
+        remove_proc_entry("neg_inertia", tp_dir);
+        remove_proc_entry("speed", tp_dir);
+        remove_proc_entry("sensitivity", tp_dir);
+        remove_proc_entry("trackpoint", NULL);
+}
+
+#else
+static int trackpoint_proc_init(struct psmouse *psmouse) { return 0; }
+static void trackpoint_proc_remove(void) { do {} while(0); }
+#endif
+
+
+void trackpoint_disconnect(struct psmouse *psmouse)
+{
+	trackpoint_proc_remove();
+
+	kfree(psmouse->private);
+}
+
+int trackpoint_reconnect(struct psmouse *psmouse)
+{
+	unsigned char toggle;
+	struct trackpoint_data *tp = psmouse->private;
+
+	/* Push the config to the device */
+	
+	trackpoint_write(psmouse, TP_SENS, tp->sens);
+	trackpoint_write(psmouse, TP_NEG_INERT, tp->inertia);
+	trackpoint_write(psmouse, TP_SPEED, tp->speed);
+
+	trackpoint_write(psmouse, TP_BACKUP, tp->reach);
+	trackpoint_write(psmouse, TP_DRAG_HYST, tp->draghys);
+	trackpoint_write(psmouse, TP_MIN_DRAG, tp->mindrag);
+
+	trackpoint_write(psmouse, TP_THRESH, tp->thresh);
+	trackpoint_write(psmouse, TP_UP_THRESH, tp->up_thresh);
+
+	trackpoint_write(psmouse, TP_Z_TIME, tp->z_time);
+	trackpoint_write(psmouse, TP_JENKS_CURV, tp->jenks_curv);
+
+
+	trackpoint_read(psmouse, TP_TOGGLE_PTS, &toggle);
+	if(((toggle & TP_MASK_PTS) == TP_MASK_PTS)!= tp->ptson)
+		 trackpoint_toggle_bit(psmouse, TP_TOGGLE_PTS, TP_MASK_PTS);
+
+	trackpoint_read(psmouse, TP_TOGGLE_MB, &toggle);
+	if(((toggle & TP_MASK_MB) == TP_MASK_MB) != tp->mb)
+		 trackpoint_toggle_bit(psmouse, TP_TOGGLE_MB, TP_MASK_MB);
+
+	trackpoint_read(psmouse, TP_TOGGLE_SKIP_BACK, &toggle);
+	if(((toggle & TP_MASK_SKIP_BACK) == TP_MASK_SKIP_BACK) != tp->skipback)
+		trackpoint_toggle_bit(psmouse, TP_TOGGLE_SKIP_BACK, TP_MASK_SKIP_BACK);
+
+	/* TODO: Add external device pass through */
+
+	return 0;
+}
+
+static void trackpoint_defaults(struct trackpoint_data *tp)
+{
+	tp->sens = tp_sens;
+	tp->speed = tp_speed;
+	tp->reach = tp_backup;
+
+	tp->draghys = tp_draghyst;
+	tp->mindrag = tp_mindrag;
+
+	tp->thresh = tp_thresh;
+	tp->up_thresh = tp_upthresh;
+
+	tp->z_time = tp_ztime;
+	tp->jenks_curv = tp_jenks;
+
+	tp->ptson = tp_pts;
+	tp->mb = tp_mb;
+	tp->skipback = TP_DEF_SKIP_BACK;
+}
+
+
+
+int trackpoint_init(struct psmouse *psmouse)
+{
+	unsigned char param[2];
+	struct trackpoint_data *priv;
+
+	param[0] = param[1] = 0;
+
+	/* The real driver disables, queries and 
+	   then enables so we'll do that too
+	*/
+	psmouse_command(psmouse, param, MAKE_PS2_CMD(0, 2, TP_DISABLE));
+
+	psmouse_command(psmouse, param, MAKE_PS2_CMD(0, 2, TP_READ_ID));
+	if(param[0] != TP_MAGIC_IDENT) 
+		return -1;
+
+	psmouse_command(psmouse, param, MAKE_PS2_CMD(0, 2, TP_ENABLE));
+
+	psmouse->private = priv = kmalloc(sizeof(struct trackpoint_data), GFP_KERNEL);
+
+	if(!priv) 
+		return -1;
+
+	memset(priv, 0, sizeof(struct trackpoint_data));
+
+	priv->firmware_id = param[1];
+
+
+	psmouse->reconnect = trackpoint_reconnect;
+	psmouse->disconnect = trackpoint_disconnect;
+
+	/*
+	 * Initialize the device's default settings
+	 */
+	trackpoint_defaults(priv);
+	trackpoint_reconnect(psmouse);
+
+	trackpoint_proc_init(psmouse);
+
+	printk("IBM TrackPoint firmware: 0x%02X\n", param[1]);
+
+	return 0;
+}
+
+
diff -uNr a/drivers/input/mouse/trackpoint.h b/drivers/input/mouse/trackpoint.h
--- a/drivers/input/mouse/trackpoint.h	1969-12-31 19:00:00.000000000 -0500
+++ b/drivers/input/mouse/trackpoint.h	2004-12-01 18:59:01.000000000 -0500
@@ -0,0 +1,151 @@
+/*
+ * IBM TrackPoint PS/2 mouse driver
+ *
+ * Stephen Evanchik <evanchsa@clarkson.edu>
+ *
+ * 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 _TRACKPOINT_H
+#define _TRACKPOINT_H
+
+/*
+ * These constants are from the TrackPoint System
+ * Engineering documentation Version 4 from IBM Watson
+ * research:
+ * 	http://wwwcssrv.almaden.ibm.com/trackpoint/download.html
+ */
+
+#define TP_DISABLE	(0xF5)
+#define TP_ENABLE	(0xF4)
+
+#define TP_READ_ID	(0xE1)	/* Sent for device identification */
+#define TP_MAGIC_IDENT	(0x01)	/* Sent after a TP_READ_ID followed */
+				/* by the firmware ID */
+													
+#define TP_COMMAND	(0xE2)	/* Commands start with this */
+
+
+/*
+ * Commands
+ */
+#define TP_RECALIB	(0x51)	/* Recalibrate */
+#define TP_POWER_DOWN	(0x44)	/* Can only be undone through HW reset */
+#define TP_EXT_DEV	(0x21)	/* Determines if external device is connected (RO) */
+#define TP_EXT_BTN	(0x4B)	/* Read extended button status */
+#define TP_POR		(0x7F)	/* Execute Power on Reset */
+#define TP_POR_RESULTS	(0x25)	/* Read Power on Self test results */
+
+/*
+ * Mode manipulation
+ */
+#define TP_SET_SOFT_TRANS (0x4E) /* Set mode */
+#define TP_CAN_SOFT_TRANS (0xB9) /* Cancel mode */
+#define TP_SET_HARD_TRANS (0x45) /* Mode can only be set */
+
+
+/*
+ * Register oriented commands/properties
+ */
+#define TP_WRITE_MEM	(0x81)
+#define TP_READ_MEM	(0x80)	/* Not used in this implementation */
+
+/*
+* RAM Locations for properties
+ */
+#define TP_SENS		(0x4A)	/* Sensitivity */
+#define TP_MB 		(0x4C)	/* Read Middle Button Status (RO) */
+#define TP_NEG_INERT	(0x4D)	/* Negative Inertia */
+#define TP_SPEED	(0x60)	/* Speed of TP Cursor */
+#define TP_BACKUP	(0x57)	/* Backup for Z-axis press */
+#define TP_DRAG_HYST	(0x58)	/* Drag Hysteresis */
+				/* (how hard it is to drag */
+				/* with Z-axis pressed) */
+
+#define TP_MIN_DRAG	(0x59)	/* Minimum amount of force needed */
+				/* to trigger dragging */
+
+#define TP_THRESH	(0x5C)	/* Minimum value for a Z-axis press */
+#define TP_UP_THRESH	(0x5A)	/* Used to generate a 'click' on Z-axis */
+#define TP_Z_TIME	(0x5E)	/* How sharp of a press */
+#define TP_JENKS_CURV	(0x5D)	/* Minimum curvature for double click */
+
+/*
+ * Toggling Flag bits
+ */
+#define TP_TOGGLE (0x47) /* Toggle command */
+
+#define TP_TOGGLE_MB		(0x23)	/* Disable/Enable Middle Button */
+#define TP_TOGGLE_DRIFT		(0x23)	/* Drift Correction */
+#define TP_TOGGLE_BURST		(0x28)	/* Burst Mode */
+#define TP_TOGGLE_PTS		(0x2C)	/* Press to Select */
+#define TP_TOGGLE_HARD_TRANS	(0x2C)	/* Alternate method to set Hard Transparency */
+#define TP_TOGGLE_TWOHAND	(0x2D)	/* Two handed */
+#define TP_TOGGLE_STICKY_TWO	(0x2D)	/* Sticky two handed */
+#define TP_TOGGLE_SKIP_BACK	(0x2D)	/* Suppress movement */
+					/* after drag release */
+
+/*
+ * Various makses for registers 
+ * XOR'd to current contents for new value
+ */
+#define TP_MASK_PTS		(0x01)
+#define TP_MASK_SKIP_BACK	(0x08)
+#define TP_MASK_TWOHAND		(0x01)
+#define TP_MASK_STICKY_TWO	(0x04)
+#define TP_MASK_HARD_TRANS	(0x80)
+#define TP_MASK_BURST		(0x80)
+#define TP_MASK_MB		(0x01)
+#define TP_MASK_DRIFT		(0x80)
+
+/* Power on Self Test Results */
+#define TP_POR_SUCCESS		(0x3B)
+
+/*
+ * Default power on values
+ */
+#define TP_DEF_SENS	(0x80)
+#define TP_DEF_NEG_INT	(0x06)
+#define TP_DEF_SPEED	(0x61)
+#define TP_DEF_BACKUP	(0x0A)
+
+#define TP_DEF_DRAG_HYST (0xFF)
+#define TP_DEF_MIN_DRAG	 (0x14)
+
+#define TP_DEF_THRESH     (0x08)
+#define TP_DEF_UP_THRESH  (0xFF)
+#define TP_DEF_Z_TIME     (0x26)
+#define TP_DEF_JENKS_CURV (0x87)
+
+/* Toggles */
+#define TP_DEF_MB	 (0x00)
+#define TP_DEF_PTS	 (0x00)
+#define TP_DEF_SKIP_BACK (0x00)
+
+#define MAKE_PS2_CMD(params, results, cmd) ((params<<12) | (results<<8) | (cmd))
+
+enum
+{ TP_SOFT_TRANS, TP_HARD_TRANS };
+
+struct trackpoint_data
+{
+	unsigned char firmware_id;
+
+	unsigned char mode;	/* Transparency mode */
+
+	unsigned char sens, speed, inertia, reach;
+	unsigned char draghys, mindrag;
+	unsigned char thresh, up_thresh;
+	unsigned char z_time, jenks_curv;
+
+	unsigned char ptson; /* Press to Select */
+	unsigned char twohand, skipback;
+	unsigned char mb;
+};
+
+extern int trackpoint_init (struct psmouse *psmouse);
+
+
+#endif /* _TRACKPOINT_H */