diff -Nur -X dontdiff linux-2.6.0.vanilla/drivers/input/touchscreen/Kconfig linux-2.6.0.lbtouch/drivers/input/touchscreen/Kconfig --- linux-2.6.0.vanilla/drivers/input/touchscreen/Kconfig 2003-12-18 03:58:49.000000000 +0100 +++ linux-2.6.0.lbtouch/drivers/input/touchscreen/Kconfig 2003-12-18 17:35:17.000000000 +0100 @@ -19,8 +19,10 @@ If unsure, say N. - To compile this driver as a module, choose M here: the - module will be called h3600_ts_input. + This driver is also available as a module ( = code which can be + inserted in and removed from the running kernel whenever you want). + The module will be called gunze. If you want to compile it as a + module, say M here and read . config TOUCHSCREEN_GUNZE tristate "Gunze AHL-51S touchscreen" @@ -35,3 +37,6 @@ To compile this driver as a module, choose M here: the module will be called gunze. +config TOUCHSCREEN_LBTOUCH + tristate "Lifebook touchscreen" + depends on INPUT && INPUT_TOUCHSCREEN && SERIO diff -Nur -X dontdiff linux-2.6.0.vanilla/drivers/input/touchscreen/Makefile linux-2.6.0.lbtouch/drivers/input/touchscreen/Makefile --- linux-2.6.0.vanilla/drivers/input/touchscreen/Makefile 2003-12-18 03:59:36.000000000 +0100 +++ linux-2.6.0.lbtouch/drivers/input/touchscreen/Makefile 2003-09-06 20:27:49.000000000 +0200 @@ -6,3 +6,4 @@ obj-$(CONFIG_TOUCHSCREEN_BITSY) += h3600_ts_input.o obj-$(CONFIG_TOUCHSCREEN_GUNZE) += gunze.o +obj-$(CONFIG_TOUCHSCREEN_LBTOUCH)+= lbtouch.o diff -Nur -X dontdiff linux-2.6.0.vanilla/drivers/input/touchscreen/lbtouch.c linux-2.6.0.lbtouch/drivers/input/touchscreen/lbtouch.c --- linux-2.6.0.vanilla/drivers/input/touchscreen/lbtouch.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.0.lbtouch/drivers/input/touchscreen/lbtouch.c 2004-01-03 21:20:57.000000000 +0100 @@ -0,0 +1,651 @@ +/* + * $Id: lbtouch.c,v 1.1.1.1 2003/09/06 18:27:49 conan Exp $ + * + * Copyright (c) 2000-2003 Kenan Esau + */ + +/* + * Lifebook touchscreen driver for Linux + */ + +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Should you need to contact me, the author, you can do so either by + * e-mail - mail your message to , or by paper mail: + * Kenan Esau, Friedrich-Greinerstr. 8, 73666 Baltmannsweiler 2, + * Germany + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "lbtouch.h" + +MODULE_AUTHOR("Kenan Esau "); +MODULE_DESCRIPTION("Lifebook touchscreen driver"); +MODULE_LICENSE("GPL"); + +static int min_x = 86; +static int max_x = 955; +static int min_y = 37; +static int max_y = 937; + +MODULE_PARM(min_x, "i"); +MODULE_PARM(min_y, "i"); +MODULE_PARM(max_x, "i"); +MODULE_PARM(max_y, "i"); + +#define DEBUG +#ifdef DEBUG +#define DBG(msg, args...) printk(msg, ##args) +#else +#define DBG(msg, args...) +#endif + +/* + * Definitions & global arrays. + */ + +static char *lbtouch_name = "Lifebook TouchScreen"; + +/* + * Per-touchscreen data. + */ +#define BUF_SIZE (1 * LBTOUCH_PACKET_SIZE) + + +struct lbtouch { + struct input_dev dev; + struct serio *serio; + + spinlock_t data_lock; + int idx_wr; + int idx_rd; + unsigned char data[BUF_SIZE]; + unsigned char *pkt; + + char phys[32]; + + uint8_t touched; + uint8_t lb_down; + uint8_t rb_down; + + /*! current coordinates */ + uint32_t cur_x; + uint32_t cur_y; + + struct semaphore sem; + + /* determine whether we are currently in command mode (send + command to the devices/ only during init) or if we are running + in normal mode */ + atomic_t cmd_mode; + wait_queue_head_t sleepq; +}; + + +static int lbtouch_snd_byte(struct lbtouch *lb, unsigned char c); +static int lbtouch_snd_byte(struct lbtouch *lb, unsigned char c); +static int lbtouch_snd_cmd(struct lbtouch *lb, unsigned char cmd[]); +static int lbtouch_get_x(struct lbtouch *lb); +static int lbtouch_get_y(struct lbtouch *lb); +static int lbtouch_first_touch(struct lbtouch *lb); +static int lbtouch_untouch(struct lbtouch *lb); +static int lbtouch_currently_touched(struct lbtouch *lb); +static int lbtouch_lb_down(struct lbtouch *lb); +static int lbtouch_rb_down(struct lbtouch *lb); +static int lbtouch_lb_up(struct lbtouch *lb); +static int lbtouch_rb_up(struct lbtouch *lb); +static int lbtouch_quickpoint_move(struct lbtouch *lb); +static void lbtouch_save_state(struct lbtouch *lb); +static void lbtouch_process_packet(struct lbtouch *lb, struct pt_regs *regs); +static irqreturn_t lbtouch_interrupt(struct serio *serio, + unsigned char data, + unsigned int flags, + struct pt_regs *regs); +static void lbtouch_init_hw(struct lbtouch *lb); + + + + +static int lbtouch_snd_byte(struct lbtouch *lb, unsigned char c) +{ + int res; + + res = serio_write(lb->serio, c); + interruptible_sleep_on_timeout(&lb->sleepq, HZ/40); + + return res; +} + + + + +static unsigned char lbtouch_read(struct lbtouch *lb) +{ + unsigned char ch; + + down_interruptible(&lb->sem); + spin_lock(&lb->data_lock); + ch = lb->data[lb->idx_rd]; + lb->idx_rd = (lb->idx_rd + 1) % BUF_SIZE; + spin_unlock(&lb->data_lock); + + return ch; +} + + + + +static int lbtouch_snd_cmd(struct lbtouch *lb, unsigned char cmd[]) +{ + unsigned char c; + int retry = 0; + int ret = -1; + + atomic_set(&lb->cmd_mode, 1); + + do { + lbtouch_snd_byte(lb, cmd[0]); + c = lbtouch_read(lb); + switch (c) { + case ACK: + break; + + case ERROR: + default: + DBG("ERROR: %02x \n", c); + case RESEND: + DBG(" RESENDING\n"); + retry++; + break; + } + } while ( (c != ACK) && (retry < 3) ); + + if (c != ACK) + goto out; + retry = 0; + + + DBG("DEVICE GOT CMD: %02x \n", cmd[0]); + switch (cmd[0]) { + case RESET_DISPLAY: + interruptible_sleep_on_timeout(&lb->sleepq, HZ/2); + c = lbtouch_read(lb); + if (c != RESET_COMPLETE) + goto out; + c = lbtouch_read(lb); + if (c != DEVICE_ID) + goto out; + c = ACK; + DBG("RESET_DISPLAY\n"); + break; + + case DISABLE_DISPLAY: + DBG("DISABLE_DISPLAY\n"); + break; + case ENABLE_DISPLAY: + DBG("ENABLE_DISPLAY\n"); + break; + + case SET_RESOLUTION: + do { + lbtouch_snd_byte(lb, cmd[1]); + retry++; + c = lbtouch_read(lb); + } while ( (c != ACK) && + (retry < 3) ); + DBG("SET_RESOLUTION\n"); + break; + + case SET_SAMPLE_RATE: + do { + lbtouch_snd_byte(lb, cmd[1]); + retry++; + c = lbtouch_read(lb); + } while ( (c != ACK) && + (retry < 3) ); + DBG("SET_SAMPLE_RATE\n"); + break; + } + + if (c == ACK) { + DBG("CMD OK\n"); + ret = 0; + } + out: + lb->idx_wr = 0; + lb->idx_rd = 0; + atomic_set(&lb->cmd_mode, 0); + return ret; +} + + + + +static int lbtouch_get_x(struct lbtouch *lb) +{ + int x = 0; + + if (lbtouch_currently_touched(lb)) { + x = ( (unsigned short)lb->pkt[1] | + ((unsigned short)(lb->pkt[0] & LBTOUCH_X_HIGH) << 4 ) ); + } else { + x = ((lb->pkt[0] & 0x10) ? lb->pkt[1]-256 : lb->pkt[1]); + } + return x; +} + + + + +static int lbtouch_get_y(struct lbtouch *lb) +{ + int y = 0; + if (lbtouch_currently_touched(lb)) { + y = ( (unsigned short)lb->pkt[2] | + ((unsigned short)(lb->pkt[0] & LBTOUCH_Y_HIGH) << 2 ) ); + } else { + y = ((lb->pkt[0] & 0x20) ? lb->pkt[2]-256 : lb->pkt[2]); + } + return y; +} + + + + +static int lbtouch_first_touch(struct lbtouch *lb) +{ + int i; + i =( (lb->pkt[0] & LBTOUCH_TOUCHED) && !(lb->touched) ) ? 1 : 0; + return i; +} + + + + +static int lbtouch_untouch(struct lbtouch *lb) +{ + int i; + i =( !(lb->pkt[0] & LBTOUCH_TOUCHED) && (lb->touched) ) ? 1 : 0; + return i; +} + + + + +static int lbtouch_currently_touched(struct lbtouch *lb) +{ + int i; + i = (lb->pkt[0] & LBTOUCH_TOUCHED) ? 1 : 0; + return i; +} + + + + +static int lbtouch_quickpoint_move(struct lbtouch *lb) +{ + if ( !(lb->pkt[0] & LBTOUCH_TOUCHED) && !(lb->touched) && + (lbtouch_get_x(lb) != 0) && (lbtouch_get_y(lb)) !=0) + return 1; + else + return 0; +} + + + + +static int lbtouch_lb_down(struct lbtouch *lb) +{ + if ( (lb->pkt[0] & LBTOUCH_LB) && (lb->lb_down == 0) ) + return 1; + else + return 0; +} + + + + +static int lbtouch_rb_down(struct lbtouch *lb) +{ + if ( (lb->pkt[0] & LBTOUCH_RB) && (lb->rb_down == 0) ) + return 1; + else + return 0; +} + + + + +static int lbtouch_lb_up(struct lbtouch *lb) +{ + if ( (!(lb->pkt[0] & LBTOUCH_LB)) && (lb->lb_down == 1) ) + return 1; + else + return 0; +} + + + + +static int lbtouch_rb_up(struct lbtouch *lb) +{ + if ( (!(lb->pkt[0] & LBTOUCH_RB)) && (lb->rb_down == 1) ) + return 1; + else + return 0; +} + + + + +static void lbtouch_save_state(struct lbtouch *lb) +{ + lb->touched = lbtouch_currently_touched(lb); +} + + + + +static void lbtouch_process_packet(struct lbtouch *lb, struct pt_regs *regs) +{ + struct input_dev *dev = &lb->dev; + unsigned long x = 0; + unsigned long y = 0; + + x = lbtouch_get_x(lb); + y = lbtouch_get_y(lb); + input_regs(dev, regs); + + if (lbtouch_first_touch(lb)) { + DBG("first touch\n"); + input_report_key(dev, BTN_TOUCH, 1); + lb->touched = 1; + } + + if (lbtouch_untouch(lb)) { + DBG("untouch\n"); + input_report_key(dev, BTN_TOUCH, 0); + } + + if (lbtouch_currently_touched(lb)) { + DBG("penmove: X = %ld Y = %ld\n", x, y); + input_report_abs(dev, ABS_X, x); + input_report_abs(dev, ABS_Y, y); + } + + if (lbtouch_quickpoint_move(lb)) { + DBG("quickpointmove: X = %ld Y = %ld\n", x, y); + input_report_rel(dev, REL_X, x); + input_report_rel(dev, REL_Y, y); + } + + if (lbtouch_lb_down(lb)) { + DBG("left button down\n"); + input_report_key(dev, BTN_LEFT, 1); + lb->lb_down = 1; + } + + if (lbtouch_rb_down(lb)) { + DBG("right button down\n"); + input_report_key(dev, BTN_RIGHT, 1); + lb->rb_down = 1; + } + + if (lbtouch_lb_up(lb)) { + DBG("left button up\n"); + input_report_key(dev, BTN_LEFT, 0); + lb->lb_down = 0; + } + + if (lbtouch_rb_up(lb)) { + DBG("right button up\n"); + input_report_key(dev, BTN_RIGHT, 0); + lb->rb_down = 0; + } + + input_sync(dev); + + /* save the state for the currently received packet */ + lbtouch_save_state(lb); +} + + + + +static irqreturn_t lbtouch_interrupt(struct serio *serio, + unsigned char data, + unsigned int flags, + struct pt_regs *regs) +{ + struct lbtouch* lbtouch = serio->private; + static int packet_complete = 0; + + spin_lock(&lbtouch->data_lock); + lbtouch->data[lbtouch->idx_wr] = data; + lbtouch->idx_wr = (lbtouch->idx_wr + 1) % BUF_SIZE; + if ( (lbtouch->idx_wr % LBTOUCH_PACKET_SIZE) == 0 ) { + packet_complete = 1; + lbtouch->pkt = &lbtouch->data[lbtouch->idx_rd]; + DBG("Packet complete \n"); + } + + spin_unlock(&lbtouch->data_lock); + + if (atomic_read(&lbtouch->cmd_mode) == 1) { + up(&lbtouch->sem); + + return IRQ_HANDLED; + } + + if (packet_complete) { + lbtouch_process_packet(lbtouch, regs); + packet_complete = 0; + lbtouch->idx_rd = 0; + } + + return IRQ_HANDLED; +} + + + + +static void lbtouch_init_hw(struct lbtouch *lb) +{ + unsigned char c[3]; + + c[0]=DISABLE_DISPLAY; + lbtouch_snd_cmd(lb, c); + + c[0]=RESET_DISPLAY; + lbtouch_snd_cmd(lb, c); + + c[0]=RESET_SCALING; + lbtouch_snd_cmd(lb, c); + + c[0]=SET_SAMPLE_RATE; + c[1]=_40HZ; + lbtouch_snd_cmd(lb, c); + + c[0]=SET_RESOLUTION; /*set display to normal mode*/ + c[1]=NORMAL_MODE; /*uses set_res.-command too */ + lbtouch_snd_cmd(lb, c); + + c[0]=SET_RESOLUTION; + c[1]=_400CPI; + lbtouch_snd_cmd(lb, c); + + c[0]=ENABLE_DISPLAY; + lbtouch_snd_cmd(lb, c); +} + + + + +/* + * Reinitialize mouse hardware after software suspend. + */ +static int lbtouch_pm_callback(struct pm_dev *dev, pm_request_t request, + void *data) +{ + struct lbtouch *lbtouch = dev->data; + struct serio_dev *ser_dev = lbtouch->serio->dev; + + if (request != PM_RESUME) + return 0; + + /* reinitialize the i8042 controller */ + serio_close(lbtouch->serio); + serio_open(lbtouch->serio, ser_dev); + + lbtouch_init_hw(lbtouch); + + return 0; +} + + + + +/* + * lbtouch_disconnect() is the opposite of lbtouch_connect() + */ +static void lbtouch_disconnect(struct serio *serio) +{ + struct lbtouch* lbtouch = serio->private; + input_unregister_device(&lbtouch->dev); + serio_close(serio); + kfree(lbtouch); +} + + + + +/* + * lbtouch_connect() is the routine that is called when someone adds a + * new serio device. It looks whether it was registered as a Lbtouch touchscreen + * and if yes, registers it as an input device. + */ +static void lbtouch_connect(struct serio *serio, struct serio_dev *dev) +{ + struct lbtouch *lbtouch; + struct pm_dev *pmdev; + + printk("type = 0x%lx\n", serio->type); + if ((serio->type & SERIO_TYPE) != (SERIO_8042)) { + printk(KERN_ERR "not a lbtouchscreen \n"); + return; + } + + if (!(lbtouch = kmalloc(sizeof(struct lbtouch), GFP_KERNEL))) + return; + + memset(lbtouch, 0, sizeof(struct lbtouch)); + + lbtouch->cur_x = (max_x - min_x) / 2; + lbtouch->cur_y = (max_y - min_y) / 2; + + init_input_dev(&lbtouch->dev); + lbtouch->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL); + lbtouch->dev.absbit[0] = BIT(ABS_X) | BIT(ABS_Y); + lbtouch->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y); + lbtouch->dev.absfuzz[ABS_X] = 0; + lbtouch->dev.absfuzz[ABS_Y] = 0; + lbtouch->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT); + lbtouch->dev.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH); + + lbtouch->dev.absmin[ABS_X] = min_x; + lbtouch->dev.absmax[ABS_X] = max_x; + + lbtouch->dev.absmin[ABS_Y] = min_y; + lbtouch->dev.absmax[ABS_Y] = max_y; + + lbtouch->serio = serio; + serio->private = lbtouch; + + sprintf(lbtouch->phys, "%s/input0", serio->phys); + printk("%s\n", lbtouch->phys); + + pmdev = pm_register(PM_SYS_DEV, PM_SYS_UNKNOWN, lbtouch_pm_callback); + if (pmdev) { + lbtouch->dev.pm_dev = pmdev; + pmdev->data = lbtouch; + } + + + lbtouch->dev.private = lbtouch; + lbtouch->dev.name = lbtouch_name; + lbtouch->dev.phys = lbtouch->phys; + lbtouch->dev.id.bustype = BUS_I8042; + lbtouch->dev.id.vendor = 1; /* SERIO_LBTOUCH; */ + lbtouch->dev.id.product = 0x0001; + lbtouch->dev.id.version = 0x0001; + + spin_lock_init(&lbtouch->data_lock); + init_waitqueue_head(&lbtouch->sleepq); + sema_init(&lbtouch->sem, 0); + lbtouch->pkt = &lbtouch->data[0]; + + if (serio_open(serio, dev)) { + kfree(lbtouch); + return; + } + + input_register_device(&lbtouch->dev); + + lbtouch_init_hw(lbtouch); + printk(KERN_INFO "input: %s on %s\n", lbtouch_name, serio->phys); +} + + + + +/* + * The serio device structure. + */ + +static struct serio_dev lbtouch_dev = { + .interrupt = lbtouch_interrupt, + .connect = lbtouch_connect, + .disconnect = lbtouch_disconnect, +}; + +/* + * The functions for inserting/removing us as a module. + */ + +int __init lbtouch_init(void) +{ + printk(KERN_INFO "Registering device \n"); + serio_register_device(&lbtouch_dev); + return 0; +} + +void __exit lbtouch_exit(void) +{ + printk(KERN_INFO "Unegistering device \n"); + serio_unregister_device(&lbtouch_dev); +} + +module_init(lbtouch_init); +module_exit(lbtouch_exit); diff -Nur -X dontdiff linux-2.6.0.vanilla/drivers/input/touchscreen/lbtouch.h linux-2.6.0.lbtouch/drivers/input/touchscreen/lbtouch.h --- linux-2.6.0.vanilla/drivers/input/touchscreen/lbtouch.h 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.0.lbtouch/drivers/input/touchscreen/lbtouch.h 2003-09-20 20:31:30.000000000 +0200 @@ -0,0 +1,99 @@ +#define LBTOUCH_PACKET_SIZE 3 +#define LBTOUCH_BUFFER_SIZE (LBTOUCH_PACKET_SIZE * 500) +#define LBTOUCH_TOUCHED 0x04 +#define LBTOUCH_X_HIGH 0x30 +#define LBTOUCH_Y_HIGH 0xC0 +#define LBTOUCH_LB 0x01 +#define LBTOUCH_RB 0x02 +#define LBTOUCH_ACK 0xF4 +#define LBTOUCH_TIMEOUT 500 + +/* + d0 ?????????????? + e1 ?? + e2 ?? + e6 Reset Scaling + e7 Set scaling + e8 Set resolution + e9 Determine status + ea Set stream modus + eb read data + ec reset wrap mode + ee set wrap mode + f0 set remote mode + f2 identify unit + f3 set sample rate + f4 enable + f5 disable + f5 set standard + fe resend + ff reset +*/ + + +/* + COMMANDS +*/ +#define RESET_SCALING 0xE6 +#define SET_SCALING 0xE7 +#define SET_RESOLUTION 0xE8 +#define GET_STATUS 0xE9 +#define SET_STREAM_MODE 0xEA +#define READ_DATA 0xEB +#define RESET_WRAP_MODE 0xEC +#define SET_WRAP_MODE 0xEE +#define SET_REMOTE_MODE 0xF0 +#define IDENTIFY_UNIT 0xF2 +#define SET_SAMPLE_RATE 0xF3 +#define ENABLE_DISPLAY 0xF4 +#define DISABLE_DISPLAY 0xF5 +#define SET_DEFAULTS 0xF6 +/* + The Device can send RESEND as a reply to a command + it did not understand but RESEND can also be send + TO the display to repeat an erroneous received packet +*/ +#define RESET_DISPLAY 0xFF /* Wait until 0xAA 0x00 arrives to indicate that the reset is complete */ + + +/* + TRANSMISSION RATES +*/ +#define _10HZ 0x0A +#define _20HZ 0x14 +#define _40HZ 0x28 +#define _60HZ 0x3C +#define _80HZ 0x50 +#define _100HZ 0x64 +#define _200HZ 0xC8 + + +/* + RESOLUTIONS +*/ +#define _50CPI 0x00 +#define _100CPI 0x01 +#define _200CPI 0x02 +#define _400CPI 0x03 + + +/* + REPLIES +*/ +#define RESEND 0xFE +#define ACK 0xFA +#define ERROR 0xFC +#define RESET_COMPLETE 0xAA +#define DEVICE_ID 0x00 + +/* + MODES +*/ +#define STOPPED_MODE 0x06 +#define NORMAL_MODE 0x07 +#define ENHANCED_MODE 0x08 + +/* + States +*/ +#define STATE_TOUCHED 0x1L