[PATCH 2.6.11-rc3] IBM Trackpoint support

Stephen Evanchik
2005-02-03T22:53:22Z

Vojtech,

Here is a patch that exposes the IBM TrackPoint's extended properties
as well as scroll wheel emulation.

I would appreciate comments and suggestions to make this more acceptable.

Stephen

diff -uNr a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
--- a/drivers/input/mouse/Makefile 2005-02-03 17:30:40.000000000 -0500
+++ b/drivers/input/mouse/Makefile 2005-02-03 17:29:42.000000000 -0500
@@ -14,4 +14,4 @@
obj-$(CONFIG_MOUSE_SERIAL) += sermouse.o
obj-$(CONFIG_MOUSE_VSXXXAA) += vsxxxaa.o

-psmouse-objs := psmouse-base.o alps.o logips2pp.o synaptics.o
+psmouse-objs := psmouse-base.o alps.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 2005-02-03 17:30:40.000000000 -0500
+++ b/drivers/input/mouse/psmouse-base.c 2005-02-03 17:29:42.000000000 -0500
@@ -23,6 +23,7 @@
#include "psmouse.h"
#include "synaptics.h"
#include "logips2pp.h"
+#include "trackpoint.h"
#include "alps.h"

#define DRIVER_DESC "PS/2 mouse driver"
@@ -119,6 +120,13 @@
}

/*
+ * TrackPoint scroll simulation handler if the BTN_MIDDLE is down
+ */
+
+ if(psmouse->model == PSMOUSE_TRACKPOINT)
+ trackpoint_sim_scroll(psmouse);
+
+/*
* Generic PS/2 Mouse
*/

@@ -482,6 +490,16 @@
return PSMOUSE_IMPS;

/*
+ * Try to initialize the IBM TrackPoint
+ */
+ if (max_proto > PSMOUSE_PS2 && trackpoint_init(psmouse) == 0) {
+ psmouse->vendor = "IBM";
+ psmouse->name = "TrackPoint";
+
+ return PSMOUSE_PS2;
+ }
+
+/*
* Okay, all failed, we have a standard mouse here. The number of the buttons
* is still a question, though. We assume 3.
*/
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 2005-02-03 17:29:42.000000000 -0500
@@ -0,0 +1,649 @@
+/*
+ * 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.
+ *
+ * 29/01/2005 - Fixed UltraNav support
+ * Moved to libps2 interface
+ * Renamed internal property variables to be consistent with reference docs
+ * Fixed negative inertia not being set properly
+ * Added middle button scroll module parameter
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/serio.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/input.h>
+#include <linux/libps2.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_reach = TP_DEF_REACH;
+module_param_named(reach, tp_reach, uint, 0);
+MODULE_PARM_DESC(reach, "Backup Range");
+
+int tp_draghys = TP_DEF_DRAGHYS;
+module_param_named(draghys, tp_draghys, uint, 0);
+MODULE_PARM_DESC(draghys, "Resistance to dragging");
+
+int tp_mindrag = TP_DEF_MINDRAG;
+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_ptson = TP_DEF_PTSON;
+module_param_named(ptson, tp_ptson, uint, 0);
+MODULE_PARM_DESC(ptson, "Press to Select");
+
+int tp_mb = TP_DEF_MB;
+module_param_named(mb, tp_mb, uint, 0);
+MODULE_PARM_DESC(mb, "Middle button is disabled");
+
+int tp_mb_scroll = TP_DEF_MB_SCROLL;
+module_param_named(mb_scroll, tp_mb_scroll, uint, 0);
+MODULE_PARM_DESC(mb_scroll, "Scroll with middle button");
+
+
+__obsolete_setup("pts=");
+__obsolete_setup("backup=");
+__obsolete_setup("draghyst=");
+
+/*
+ * Device IO: read, write and toggle bit
+ */
+static void trackpoint_command(struct ps2dev *ps2dev, unsigned char cmd)
+{
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_COMMAND));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, cmd));
+}
+
+static void trackpoint_read(struct ps2dev *ps2dev, unsigned char loc,
unsigned char *results)
+{
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_COMMAND));
+ ps2_command(ps2dev, results, MAKE_PS2_CMD(0, 1, loc));
+}
+
+static void trackpoint_write(struct ps2dev *ps2dev, unsigned char
loc, unsigned char val)
+{
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_COMMAND));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_WRITE_MEM));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, loc));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, val));
+}
+
+static int trackpoint_toggle_bit(struct ps2dev *ps2dev, 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;
+
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_COMMAND));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_TOGGLE));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, loc));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, mask));
+
+ 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, "%lu\n", (unsigned long)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(&psmouse->ps2dev, 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->ps2dev, 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_INERTIA);
+MAKE_PROC_READ(PROC_READ_NAME(neg_inertia), inertia);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(backup), reach, TP_REACH);
+MAKE_PROC_READ(PROC_READ_NAME(backup), reach);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(drag_hyst), draghys, TP_DRAGHYS);
+MAKE_PROC_READ(PROC_READ_NAME(drag_hyst), draghys);
+
+MAKE_PROC_WRITE(PROC_WRITE_NAME(min_drag), mindrag, TP_MINDRAG);
+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_PTSON,
TP_MASK_PTSON);
+MAKE_PROC_READ(PROC_READ_NAME(ptson), ptson);
+
+MAKE_PROC_TOGGLE(PROC_TOGGLE_NAME(skip_back), skipback,
TP_TOGGLE_SKIPBACK, TP_MASK_SKIPBACK);
+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);
+
+MAKE_PROC_TOGGLE(PROC_TOGGLE_NAME(ext_dev), ext_dev,
TP_TOGGLE_EXT_DEV, TP_MASK_EXT_DEV);
+MAKE_PROC_READ(PROC_READ_NAME(ext_dev), ext_dev);
+
+/* MAKE_PROC_WRITE( ) for Soft Transparent mode */
+static int transparent_write_func(struct file *file, const char
__user *buffer, unsigned long count, void *data)
+{
+ int len = count;
+ unsigned char command;
+ 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->transparent = simple_strtoul(tmp, 0, 10);
+ command = (tp->transparent) ? TP_SET_SOFT_TRANS : TP_CANCEL_SOFT_TRANS;
+
+ trackpoint_command(&psmouse->ps2dev, command);
+ return len;
+}
+
+MAKE_PROC_READ(PROC_READ_NAME(transparent), transparent);
+
+/* MAKE_PROC_WRITE( ) for Middle Button Scroll mode */
+static int scroll_write_func(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->mb_scroll = simple_strtoul(tmp, 0, 10);
+
+ return len;
+}
+
+MAKE_PROC_READ(PROC_READ_NAME(scroll), mb_scroll);
+
+/* MAKE_PROC_WRITE( ) for delay before scroll */
+static int scroll_delay_write_func(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->scroll_delay = simple_strtoul(tmp, 0, 10);
+
+ return len;
+}
+
+MAKE_PROC_READ(PROC_READ_NAME(scroll_delay), scroll_delay);
+
+
+
+#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);
+ NEW_PROC_TOGGLE_ENTRY(ext_dev);
+
+ /* Soft Transparent mode isn't a toggle or a single
+ * command used to read/write the value
+ */
+ entry = create_proc_entry("transparent", 0644, tp_dir);
+ if(!entry)
+ goto no_transparent;
+ entry->owner = THIS_MODULE;
+ entry->data = psmouse;
+ entry->read_proc = transparent_read_func;
+ entry->write_proc = transparent_write_func;
+
+ entry = create_proc_entry("scroll", 0644, tp_dir);
+ if(!entry)
+ goto no_scroll;
+ entry->owner = THIS_MODULE;
+ entry->data = psmouse;
+ entry->read_proc = scroll_read_func;
+ entry->write_proc = scroll_write_func;
+
+ entry = create_proc_entry("scroll_delay", 0644, tp_dir);
+ if(!entry)
+ goto no_scroll_delay;
+ entry->owner = THIS_MODULE;
+ entry->data = psmouse;
+ entry->read_proc = scroll_delay_read_func;
+ entry->write_proc = scroll_delay_write_func;
+
+ return 0;
+
+no_scroll_delay:
+ remove_proc_entry("scroll_delay", tp_dir);
+
+no_scroll:
+ remove_proc_entry("transparent", tp_dir);
+
+no_transparent:
+ remove_proc_entry("ext_dev", tp_dir);
+
+no_ext_dev:
+ remove_proc_entry("mb", tp_dir);
+
+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("scroll_delay", tp_dir);
+ remove_proc_entry("scroll", tp_dir);
+ remove_proc_entry("transparent", tp_dir);
+ remove_proc_entry("ext_dev", tp_dir);
+ 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) { }
+#endif
+
+
+/* This is much cleaner now, it probably could be better.
+ * The only thing left here is to make the scroll feature more gradual.
+ */
+
+void trackpoint_sim_scroll(struct psmouse *psmouse)
+{
+ int diff;
+ struct trackpoint_data *tp = psmouse->private;
+ unsigned char *packet = psmouse->packet;
+
+ if(!tp->mb_scroll)
+ return;
+
+ if( ((packet[0] >> 2) & 1) == 0 ) {
+
+ if(tp->mb_was_down &&
+ time_after(tp->last_mb_press +
msecs_to_jiffies(tp->scroll_delay), jiffies)) {
+
+ /* This doesn't seem to get processed until the next
+ * mouse move.
+ */
+ input_report_key(&psmouse->dev, BTN_MIDDLE, 1);
+
+ input_sync(&psmouse->dev);
+ }
+
+ tp->scrolling = 0;
+ tp->mb_was_down = 0;
+ }
+ else if(tp->scrolling) {
+
+ /* Vertical scrolling */
+ diff = (int) ((packet[0] << 3) & 0x100) - (int) packet[2];
+ if( diff < -2 ) {
+ input_report_rel(&psmouse->dev, REL_WHEEL, 1);
+ }
+ else if(diff > 2) {
+ input_report_rel(&psmouse->dev, REL_WHEEL, -1);
+ }
+
+ /* Horizontal scrolling */
+ diff = (int) packet[1] - (int) ((packet[0] << 4) & 0x100);
+ if( diff < -2) {
+ input_report_rel(&psmouse->dev, REL_HWHEEL, 1);
+ }
+ else if( diff > 2) {
+ input_report_rel(&psmouse->dev, REL_HWHEEL, -1);
+ }
+
+ packet[1] &= 0x00;
+ packet[2] &= 0x00;
+ }
+ else {
+ /* Middle button is down, but we aren't scrolling */
+ if( time_after_eq(jiffies, tp->last_mb_press +
msecs_to_jiffies(tp->scroll_delay)) )
+ tp->scrolling = 1;
+
+ tp->last_mb_press = jiffies;
+ tp->mb_was_down = 1;
+ }
+
+ /* Suppress the key event from entering the queue */
+ packet[0] &= 0xFB;
+}
+
+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->ps2dev, TP_SENS, tp->sens);
+ trackpoint_write(&psmouse->ps2dev, TP_INERTIA, tp->inertia);
+ trackpoint_write(&psmouse->ps2dev, TP_SPEED, tp->speed);
+
+ trackpoint_write(&psmouse->ps2dev, TP_REACH, tp->reach);
+ trackpoint_write(&psmouse->ps2dev, TP_DRAGHYS, tp->draghys);
+ trackpoint_write(&psmouse->ps2dev, TP_MINDRAG, tp->mindrag);
+
+ trackpoint_write(&psmouse->ps2dev, TP_THRESH, tp->thresh);
+ trackpoint_write(&psmouse->ps2dev, TP_UP_THRESH, tp->up_thresh);
+
+ trackpoint_write(&psmouse->ps2dev, TP_Z_TIME, tp->z_time);
+ trackpoint_write(&psmouse->ps2dev, TP_JENKS_CURV, tp->jenks_curv);
+
+
+ trackpoint_read(&psmouse->ps2dev, TP_TOGGLE_PTSON, &toggle);
+ if(((toggle & TP_MASK_PTSON) == TP_MASK_PTSON)!= tp->ptson)
+ trackpoint_toggle_bit(&psmouse->ps2dev, TP_TOGGLE_PTSON, TP_MASK_PTSON);
+
+ trackpoint_read(&psmouse->ps2dev, TP_TOGGLE_MB, &toggle);
+ if(((toggle & TP_MASK_MB) == TP_MASK_MB) != tp->mb)
+ trackpoint_toggle_bit(&psmouse->ps2dev, TP_TOGGLE_MB, TP_MASK_MB);
+
+ trackpoint_read(&psmouse->ps2dev, TP_TOGGLE_TWOHAND, &toggle);
+ if(((toggle & TP_MASK_TWOHAND) == TP_MASK_TWOHAND) != tp->twohand)
+ trackpoint_toggle_bit(&psmouse->ps2dev, TP_TOGGLE_TWOHAND, TP_MASK_TWOHAND);
+
+ trackpoint_read(&psmouse->ps2dev, TP_TOGGLE_SKIPBACK, &toggle);
+ if(((toggle & TP_MASK_SKIPBACK) == TP_MASK_SKIPBACK) != tp->skipback)
+ trackpoint_toggle_bit(&psmouse->ps2dev, TP_TOGGLE_SKIPBACK,
TP_MASK_SKIPBACK);
+
+ trackpoint_read(&psmouse->ps2dev, TP_TOGGLE_MB, &toggle);
+ if(((toggle & TP_MASK_MB) == TP_MASK_MB) != tp->mb)
+ trackpoint_toggle_bit(&psmouse->ps2dev, TP_TOGGLE_MB, TP_MASK_MB);
+
+ trackpoint_read(&psmouse->ps2dev, TP_TOGGLE_SOURCE_TAG, &toggle);
+ if(((toggle & TP_MASK_SOURCE_TAG) == TP_MASK_SOURCE_TAG) != tp->source_tag)
+ trackpoint_toggle_bit(&psmouse->ps2dev, TP_TOGGLE_SOURCE_TAG,
TP_MASK_SOURCE_TAG);
+
+ trackpoint_read(&psmouse->ps2dev, TP_TOGGLE_EXT_DEV, &toggle);
+ if(((toggle & TP_MASK_EXT_DEV) == TP_MASK_EXT_DEV) != tp->skipback)
+ trackpoint_toggle_bit(&psmouse->ps2dev, TP_TOGGLE_EXT_DEV, TP_MASK_EXT_DEV);
+
+ return 0;
+}
+
+static void trackpoint_defaults(struct trackpoint_data *tp)
+{
+ tp->ptson = tp_ptson;
+ tp->sens = tp_sens;
+ tp->speed = tp_speed;
+ tp->reach = tp_reach;
+
+ tp->draghys = tp_draghys;
+ tp->mindrag = tp_mindrag;
+
+ tp->thresh = tp_thresh;
+ tp->up_thresh = tp_upthresh;
+
+ tp->z_time = tp_ztime;
+ tp->jenks_curv = tp_jenks;
+
+ tp->mb = tp_mb;
+ tp->mb_scroll = tp_mb_scroll;
+
+ /* The following can't be set via module parameters */
+ tp->inertia = TP_DEF_INERTIA;
+ tp->skipback = TP_DEF_SKIPBACK;
+ tp->ext_dev = TP_DEF_EXT_DEV;
+ tp->scroll_delay = TP_DEF_SCROLL_DELAY;
+
+ tp->scrolling = tp->mb_was_down = 0;
+ tp->xacc = tp->yacc = 0;
+}
+
+
+
+int trackpoint_init(struct psmouse *psmouse)
+{
+ unsigned char param[2];
+ struct trackpoint_data *priv;
+ struct ps2dev *ps2dev = &psmouse->ps2dev;
+
+ param[0] = param[1] = 0;
+
+ /* The real driver disables, queries and
+ then enables so we'll do that too
+ */
+ ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
+
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_DISABLE));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_DISABLE_EXT));
+
+ ps2_command(ps2dev, param, MAKE_PS2_CMD(0, 2, TP_READ_ID));
+
+ if(param[0] != TP_MAGIC_IDENT)
+ return -1;
+
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, TP_ENABLE_EXT));
+ ps2_command(ps2dev, NULL, MAKE_PS2_CMD(0, 0, 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];
+ trackpoint_defaults(priv);
+
+ trackpoint_reconnect(psmouse);
+ trackpoint_proc_init(psmouse);
+
+
+ /* Used to simulate wheel scrolling */
+ set_bit(REL_HWHEEL, psmouse->dev.relbit);
+ set_bit(REL_WHEEL, psmouse->dev.relbit);
+
+ psmouse->model = PSMOUSE_TRACKPOINT;
+
+ psmouse->reconnect = trackpoint_reconnect;
+ psmouse->disconnect = trackpoint_disconnect;
+
+ 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 2005-02-03 17:29:42.000000000 -0500
@@ -0,0 +1,170 @@
+/*
+ * 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 */
+#define TP_DISABLE_EXT (0x40) /* Disable external pointing device */
+#define TP_ENABLE_EXT (0x41) /* Enable external pointing device */
+
+/*
+ * Mode manipulation
+ */
+#define TP_SET_SOFT_TRANS (0x4E) /* Set mode */
+#define TP_CANCEL_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_INERTIA (0x4D) /* Negative Inertia */
+#define TP_SPEED (0x60) /* Speed of TP Cursor */
+#define TP_REACH (0x57) /* Backup for Z-axis press */
+#define TP_DRAGHYS (0x58) /* Drag Hysteresis */
+ /* (how hard it is to drag */
+ /* with Z-axis pressed) */
+
+#define TP_MINDRAG (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_PTSON (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_SKIPBACK (0x2D) /* Suppress movement */
+ /* after drag release */
+#define TP_TOGGLE_EXT_DEV (0x23) /* Toggle external device */
+#define TP_TOGGLE_SOURCE_TAG (0x20) /* Bit 3 of the first packet
will be set to
+ to the origin of the packet (external or TP) */
+
+/*
+ * Various makses for registers
+ * XOR'd to current contents for new value
+ */
+#define TP_MASK_PTSON (0x01)
+#define TP_MASK_SKIPBACK (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)
+#define TP_MASK_EXT_DEV (0x02)
+#define TP_MASK_SOURCE_TAG (0x80)
+
+/* Power on Self Test Results */
+#define TP_POR_SUCCESS (0x3B)
+
+/*
+ * Default power on values
+ */
+#define TP_DEF_SENS (0x80)
+#define TP_DEF_INERTIA (0x06)
+#define TP_DEF_SPEED (0x61)
+#define TP_DEF_REACH (0x0A)
+
+#define TP_DEF_DRAGHYS (0xFF)
+#define TP_DEF_MINDRAG (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_PTSON (0x00)
+#define TP_DEF_SKIPBACK (0x00)
+#define TP_DEF_EXT_DEV (0x01)
+#define TP_DEF_MB_SCROLL (0x00)
+#define TP_DEF_SCROLL_DELAY (200)
+
+#define MAKE_PS2_CMD(params, results, cmd) ((params<<12) |
(results<<8) | (cmd))
+
+#define PSMOUSE_TRACKPOINT 42
+#define Z_ACCEL_EXP 1.2
+#define Z_ACCEL_MULT 0.02
+
+
+struct trackpoint_data
+{
+ unsigned char firmware_id;
+
+ 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;
+
+ unsigned char ext_dev;
+ unsigned char transparent;
+ unsigned char source_tag;
+
+ unsigned char mb_scroll, mb_was_down, scrolling;
+ unsigned long scroll_delay, last_mb_press;
+
+ int xacc, yacc;
+};
+
+extern int trackpoint_init (struct psmouse *psmouse);
+extern void trackpoint_sim_scroll(struct psmouse *psmouse);
+
+#endif /* _TRACKPOINT_H */