Added kernel 2.6.27 supportrelease-0.8.1-6

26 files changed, 924 insertions, 87 deletions

diff --git a/ChangeLog b/ChangeLog
index dd49c19..3cbf51c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2008-10-23  Ping Cheng <pingc@wacom.com>
+	* Fixed a configure.in bug (Bartosz Fabianowski)
+	* Added kernel 2.6.27 support
+	* Use BTN_TOOL_DOUBLETAP for USB Tablet PC touch event
+	* Unified USB BTN_TOUCH event for mousedev before X server starts
+	* Label 0.8.1-6
+
 2008-10-08  Ping Cheng <pingc@wacom.com>
 	* Updated configure.in for Xorg 1.5
 	* USB Tablet PC 0x90, 0x93, 0x9A are supported
diff --git a/configure.in b/configure.in
index af4fd58..54c0cb2 100644
--- a/configure.in
+++ b/configure.in
@@ -177,7 +177,8 @@ else
 						19|20|21) WCM_KERNEL_VER="2.6.19";;
 						22|23) WCM_KERNEL_VER="2.6.22";;
 						24|25) WCM_KERNEL_VER="2.6.24";;
-						*) WCM_KERNEL_VER="2.6.26";;
+						26) WCM_KERNEL_VER="2.6.26";;
+						*) WCM_KERNEL_VER="2.6.27";;
 					esac
 				else
 					AC_MSG_WARN([support for kernels older than 2.6.8 has been dropped after 0.7.4])
@@ -913,7 +914,7 @@ if test "$WCM_OPTION_DLLOADER" = yes; then
 	fi
 fi
 AC_MSG_RESULT($WCM_OPTION_DLLOADER)
-AM_CONDITIONAL(WCM_DLLOADER, test "$WCM_OPTION_DLLOADER" == "yes")
+AM_CONDITIONAL(WCM_DLLOADER, test "$WCM_OPTION_DLLOADER" = "yes")
 
 dnl =======================================================
 dnl Check for wacomdrv build
@@ -929,7 +930,7 @@ if test "$WCM_OPTION_WACOMDRV" != "no"; then
 	else
 		AC_MSG_RESULT(yes)
 		WCM_OPTION_WACOMDRV=yes
-		if test "$WCM_OPTION_DLLOADER" == "yes" ; then
+		if test "$WCM_OPTION_DLLOADER" = "yes" ; then
 			WCM_XF86MODULES="wacom_drv.so"
 		else
 			WCM_XF86MODULES="wacom_drv.o"
@@ -1025,6 +1026,7 @@ AC_OUTPUT(Makefile
 	src/2.6.22/Makefile
 	src/2.6.24/Makefile
 	src/2.6.26/Makefile
+	src/2.6.27/Makefile
 	src/wacomxi/Makefile
 	src/wacomxi/wacomcpl)
 
@@ -1057,7 +1059,7 @@ echo "         usbmouse.o - $WCM_OPTION_USBMOUSE"
 echo "            evdev.o - $WCM_OPTION_EVDEV"
 echo "         mousedev.o - $WCM_OPTION_MOUSEDEV"
 echo "            input.o - $WCM_OPTION_INPUT"
-if test "$WCM_OPTION_DLLOADER" == "yes" ; then
+if test "$WCM_OPTION_DLLOADER" = "yes" ; then
 echo "       wacom_drv.so - $WCM_OPTION_WACOMDRV $WCM_MODDIR $WCM_PATCH_WACOMDRV"
 echo "        wacom_drv.o - no"
 else
diff --git a/src/2.6.11/wacom.h b/src/2.6.11/wacom.h
index 5c2b2cd..8a93d7f 100755
--- a/src/2.6.11/wacom.h
+++ b/src/2.6.11/wacom.h
@@ -85,7 +85,7 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v1.46-pc0.3"
+#define DRIVER_VERSION "v1.46-pc0.4"
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB Wacom Graphire and Wacom Intuos tablet driver"
 #define DRIVER_LICENSE "GPL"
diff --git a/src/2.6.11/wacom_sys.c b/src/2.6.11/wacom_sys.c
index 93b87f7..ff5aa50 100755
--- a/src/2.6.11/wacom_sys.c
+++ b/src/2.6.11/wacom_sys.c
@@ -425,12 +425,12 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	wacom->dev.close = wacom_close;
 
 	wacom->dev.evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
-	wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS);
+	wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS) | BIT(BTN_TOUCH);
 	input_set_abs_params(&wacom->dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(&wacom->dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	input_set_abs_params(&wacom->dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOUCH);
+		wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(&wacom->dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(&wacom->dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.13/wacom.h b/src/2.6.13/wacom.h
index cfb35e0..4fb491b 100755
--- a/src/2.6.13/wacom.h
+++ b/src/2.6.13/wacom.h
@@ -91,7 +91,7 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v1.43-2.6.13.1-pc-0.7"
+#define DRIVER_VERSION "v1.43-2.6.13.1-pc-0.8"
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB Wacom Graphire and Wacom Intuos tablet driver"
 #define DRIVER_LICENSE "GPL"
diff --git a/src/2.6.13/wacom_sys.c b/src/2.6.13/wacom_sys.c
index 591c547..109d733 100755
--- a/src/2.6.13/wacom_sys.c
+++ b/src/2.6.13/wacom_sys.c
@@ -421,12 +421,12 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	wacom->dev.close = wacom_close;
 
 	wacom->dev.evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
-	wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS);
+	wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS) | BIT(BTN_TOUCH);
 	input_set_abs_params(&wacom->dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(&wacom->dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	input_set_abs_params(&wacom->dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOUCH);
+		wacom->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(&wacom->dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(&wacom->dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.15/wacom_sys.c b/src/2.6.15/wacom_sys.c
index 3f90f16..f1b29bc 100755
--- a/src/2.6.15/wacom_sys.c
+++ b/src/2.6.15/wacom_sys.c
@@ -398,11 +398,11 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	}
 
 	input_dev->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
-	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS);
+	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS) | BIT(BTN_TOUCH);
 	input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOUCH);
+		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.16/wacom.h b/src/2.6.16/wacom.h
index 2724d23..4d21e25 100644
--- a/src/2.6.16/wacom.h
+++ b/src/2.6.16/wacom.h
@@ -86,7 +86,7 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v1.46-pc0.3"
+#define DRIVER_VERSION "v1.46-pc0.4"
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB Wacom Graphire and Wacom Intuos tablet driver"
 #define DRIVER_LICENSE "GPL"
diff --git a/src/2.6.16/wacom_sys.c b/src/2.6.16/wacom_sys.c
index 1af065b..aa5c3d4 100644
--- a/src/2.6.16/wacom_sys.c
+++ b/src/2.6.16/wacom_sys.c
@@ -400,11 +400,11 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	}
 
 	input_dev->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
-	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS);
+	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS) | BIT(BTN_TOUCH);
 	input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOUCH);
+		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.16/wacom_wac.c b/src/2.6.16/wacom_wac.c
index 06f2812..4449c89 100644
--- a/src/2.6.16/wacom_wac.c
+++ b/src/2.6.16/wacom_wac.c
@@ -28,7 +28,8 @@ static int wacom_penpartner_irq(struct wacom_wac *wacom, void *wcombo)
 				wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
 				wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
 				wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
-				wacom_report_abs(wcombo, ABS_PRESSURE, (signed char)data[6] + 127);
+				wacom_report_abs(wcombo, ABS_PRESSURE, ((signed char)data[6] + 127));
+				wacom_report_key(wcombo, BTN_TOUCH, ((signed char)data[6] + 127));
 				wacom_report_key(wcombo, BTN_STYLUS, (data[5] & 0x40));
 			} else {
 				wacom_report_key(wcombo, wacom->tool[0], 0);
@@ -42,7 +43,8 @@ static int wacom_penpartner_irq(struct wacom_wac *wacom, void *wcombo)
 			wacom_report_abs(wcombo, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
 			wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
 			wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
-			wacom_report_abs(wcombo, ABS_PRESSURE, (signed char)data[6] + 127);
+			wacom_report_abs(wcombo, ABS_PRESSURE, ((signed char)data[6] + 127));
+			wacom_report_abs(wcombo, ABS_PRESSURE, ((signed char)data[6] + 127));
 			wacom_report_key(wcombo, BTN_STYLUS, (data[5] & 0x40));
 			break;
 		default:
@@ -107,7 +109,7 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
 		wacom_report_abs(wcombo, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
 		wacom_report_abs(wcombo, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
 		wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
-
+		wacom_report_key(wcombo, BTN_TOUCH, pressure);
 		wacom_report_key(wcombo, BTN_STYLUS, data[4] & 0x10);
 		/* Only allow the stylus2 button to be reported for the pen tool. */
 		wacom_report_key(wcombo, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
@@ -145,6 +147,7 @@ static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
 	wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
 	wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
 	wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
+	wacom_report_key(wcombo, BTN_TOUCH, wacom_le16_to_cpu(&data[6]));
 	wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
 	wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x10);
 	return 1;
@@ -205,6 +208,7 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
 		wacom_report_abs(wcombo, ABS_Y, y);
 		if (wacom->tool[0] != BTN_TOOL_MOUSE) {
 			wacom_report_abs(wcombo, ABS_PRESSURE, data[6] | ((data[7] & 0x01) << 8));
+			wacom_report_key(wcombo, BTN_TOUCH, data[6] | ((data[7] & 0x01) << 8));
 			wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
 			wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x04);
 		}
@@ -219,6 +223,7 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
 			wacom_report_abs(wcombo, ABS_DISTANCE, 0);
 		} else {
 			wacom_report_abs(wcombo, ABS_PRESSURE, 0);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
 			wacom_report_key(wcombo, BTN_STYLUS, 0);
 			wacom_report_key(wcombo, BTN_STYLUS2, 0);
 		}
@@ -361,6 +366,7 @@ static int wacom_intuos_inout(struct wacom_wac *wacom, void *wcombo)
 			wacom_report_abs(wcombo, ABS_RZ, 0);
  		} else {
 			wacom_report_abs(wcombo, ABS_PRESSURE, 0);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
 			wacom_report_abs(wcombo, ABS_TILT_X, 0);
 			wacom_report_abs(wcombo, ABS_TILT_Y, 0);
 			wacom_report_key(wcombo, BTN_STYLUS, 0);
@@ -384,6 +390,7 @@ static void wacom_intuos_general(struct wacom_wac *wacom, void *wcombo)
 	if ((data[1] & 0xb8) == 0xa0) {
 		t = (data[6] << 2) | ((data[7] >> 6) & 3);
 		wacom_report_abs(wcombo, ABS_PRESSURE, t);
+		wacom_report_key(wcombo, BTN_TOUCH, t);
 		wacom_report_abs(wcombo, ABS_TILT_X,
 				((data[7] << 1) & 0x7e) | (data[8] >> 7));
 		wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
@@ -535,11 +542,13 @@ static int wacom_intuos_irq(struct wacom_wac *wacom, void *wcombo)
 
 int wacom_tpc_irq (struct wacom_wac *wacom, void *wcombo)
 {
-	static int stylusInProx, touchInProx;
+	static int stylusInProx, touchInProx = 1, touchOut;
 	char *data = wacom->data;
 	int prox = 0, pressure;
 	struct urb *urb = ((struct wacom_combo *)wcombo)->urb;
 
+	dbg("wacom_tpc_irq: received report #%d", data[0]);
+
 	if (urb->actual_length == 5 || data[0] == 6) { /* Touch data */	
 		if (urb->actual_length == 5) {  /* with touch */
 			prox = data[0] & 0x03;
@@ -547,42 +556,44 @@ int wacom_tpc_irq (struct wacom_wac *wacom, void *wcombo)
 			prox = data[1] & 0x03;
 		}
 
-		if (stylusInProx) { /* stylus is still in prox */
-			touchInProx = 1;
-		} else {
+		if (!stylusInProx) { /* stylus not in prox */
 			if (prox) {
-				if (!touchInProx) {
-					wacom->tool[1] = BTN_TOUCH;
+				if (touchInProx) {
+					wacom->tool[1] = BTN_TOOL_DOUBLETAP;
 					wacom->id[0] = TOUCH_DEVICE_ID;
 					if (urb->actual_length != 5) {
 						wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
 						wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
 						wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));	
+						wacom_report_key(wcombo, BTN_TOUCH, wacom_le16_to_cpu(&data[6]));
 					} else {
 						wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
 						wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
+						wacom_report_key(wcombo, BTN_TOUCH, 1);
 					}
 					wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 					wacom_report_key(wcombo, wacom->tool[1], prox & 0x01);
+					touchOut = 1;
 					return 1;
 				}
 			} else {
-				wacom_report_abs(wcombo, ABS_MISC, 0);
-				wacom_report_key(wcombo, wacom->tool[1], 0);
-				touchInProx = 0;
+				wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
+				wacom_report_key(wcombo, wacom->tool[1], prox & 0x01);
+				wacom_report_key(wcombo, BTN_TOUCH, 0);
+				touchOut = 0;
+				touchInProx = 1;
 				return 1;
 			}
+		} else if (touchOut || !prox) { /* force touch out-prox */
+			wacom_report_abs(wcombo, ABS_MISC, TOUCH_DEVICE_ID);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
+			touchOut = 0;
+			touchInProx = 1;
+			return 1;
 		}
 	} else if (data[0] == 2) { /* Penabled */
 		prox = data[1] & 0x20;
-		/* touch was in control */
-		if (wacom->id[0] == TOUCH_DEVICE_ID) { 
-			/* let it go */
-			wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
-			wacom_report_key(wcombo, wacom->tool[1], 0);
-			return 1;
-		}
-		
+		touchInProx = 0;		
 		wacom->id[0] = ERASER_DEVICE_ID;
 
 		/*
@@ -602,7 +613,7 @@ int wacom_tpc_irq (struct wacom_wac *wacom, void *wcombo)
 				 * was entered with stylus2 pressed 
 				 * report out proximity for previous tool 
 				*/
-				wacom_report_abs(wcombo, ABS_MISC, 0);
+				wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 				wacom_report_key(wcombo, wacom->tool[1], 0);
 				wacom_input_sync(wcombo);
 
@@ -624,8 +635,10 @@ int wacom_tpc_irq (struct wacom_wac *wacom, void *wcombo)
 			if (pressure < 0) 
 				pressure = wacom->features->pressure_max + pressure + 1;
 			wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
+			wacom_report_key(wcombo, BTN_TOUCH, pressure);
 		} else {
 			wacom_report_abs(wcombo, ABS_PRESSURE, 0);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
 			wacom_report_key(wcombo, BTN_STYLUS, 0);
 			wacom_report_key(wcombo, BTN_STYLUS2, 0);
 		}
diff --git a/src/2.6.18/wacom.h b/src/2.6.18/wacom.h
index db33c23..97967bb 100644
--- a/src/2.6.18/wacom.h
+++ b/src/2.6.18/wacom.h
@@ -84,7 +84,7 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v1.46-pc0.3"
+#define DRIVER_VERSION "v1.46-pc0.4"
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB Wacom Graphire and Wacom Intuos tablet driver"
 #define DRIVER_LICENSE "GPL"
diff --git a/src/2.6.19/wacom.h b/src/2.6.19/wacom.h
index 1376b4a..5c2fe78 100755
--- a/src/2.6.19/wacom.h
+++ b/src/2.6.19/wacom.h
@@ -11,7 +11,7 @@
  *  Copyright (c) 2000 Daniel Egger		<egger@suse.de>
  *  Copyright (c) 2001 Frederic Lepied		<flepied@mandrakesoft.com>
  *  Copyright (c) 2004 Panagiotis Issaris	<panagiotis.issaris@mech.kuleuven.ac.be>
- *  Copyright (c) 2002-2007 Ping Cheng		<pingc@wacom.com>
+ *  Copyright (c) 2002-2008 Ping Cheng		<pingc@wacom.com>
  *
  *  ChangeLog:
  *      v0.1 (vp)  - Initial release
@@ -84,7 +84,7 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v1.46-pc0.2"
+#define DRIVER_VERSION "v1.46-pc0.4"
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB Wacom Graphire and Wacom Intuos tablet driver"
 #define DRIVER_LICENSE "GPL"
diff --git a/src/2.6.19/wacom_sys.c b/src/2.6.19/wacom_sys.c
index 9a01aed..6495810 100755
--- a/src/2.6.19/wacom_sys.c
+++ b/src/2.6.19/wacom_sys.c
@@ -393,12 +393,12 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	}
 
 	input_dev->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
-	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS);
+	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS) | BIT(BTN_TOUCH);
 	input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOUCH);
+		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.19/wacom_wac.c b/src/2.6.19/wacom_wac.c
index 3fdccb7..fb2d3de 100755
--- a/src/2.6.19/wacom_wac.c
+++ b/src/2.6.19/wacom_wac.c
@@ -27,7 +27,8 @@ static int wacom_penpartner_irq(struct wacom_wac *wacom, void *wcombo)
 				wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
 				wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
 				wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
-				wacom_report_abs(wcombo, ABS_PRESSURE, (signed char)data[6] + 127);
+				wacom_report_abs(wcombo, ABS_PRESSURE, ((signed char)data[6] + 127));
+				wacom_report_key(wcombo, BTN_TOUCH, ((signed char)data[6] + 127));
 				wacom_report_key(wcombo, BTN_STYLUS, (data[5] & 0x40));
 			} else {
 				wacom_report_key(wcombo, wacom->tool[0], 0);
@@ -103,7 +104,7 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
 		wacom_report_abs(wcombo, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
 		wacom_report_abs(wcombo, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
 		wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
-
+		wacom_report_key(wcombo, BTN_TOUCH, pressure);
 		wacom_report_key(wcombo, BTN_STYLUS, data[4] & 0x10);
 		/* Only allow the stylus2 button to be reported for the pen tool. */
 		wacom_report_key(wcombo, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
@@ -140,6 +141,7 @@ static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
 	wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
 	wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
 	wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
+	wacom_report_key(wcombo, BTN_TOUCH, wacom_le16_to_cpu(&data[6]));
 	wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
 	wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x10);
 	return 1;
@@ -198,6 +200,7 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
 		wacom_report_abs(wcombo, ABS_Y, y);
 		if (wacom->tool[0] != BTN_TOOL_MOUSE) {
 			wacom_report_abs(wcombo, ABS_PRESSURE, data[6] | ((data[7] & 0x01) << 8));
+			wacom_report_key(wcombo, BTN_TOUCH, data[6] | ((data[7] & 0x01) << 8));
 			wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
 			wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x04);
 		}
@@ -212,6 +215,7 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
 			wacom_report_abs(wcombo, ABS_DISTANCE, 0);
 		} else {
 			wacom_report_abs(wcombo, ABS_PRESSURE, 0);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
 			wacom_report_key(wcombo, BTN_STYLUS, 0);
 			wacom_report_key(wcombo, BTN_STYLUS2, 0);
 		}
@@ -354,6 +358,7 @@ static int wacom_intuos_inout(struct wacom_wac *wacom, void *wcombo)
 			wacom_report_abs(wcombo, ABS_RZ, 0);
  		} else {
 			wacom_report_abs(wcombo, ABS_PRESSURE, 0);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
 			wacom_report_abs(wcombo, ABS_TILT_X, 0);
 			wacom_report_abs(wcombo, ABS_TILT_Y, 0);
 			wacom_report_key(wcombo, BTN_STYLUS, 0);
@@ -377,6 +382,7 @@ static void wacom_intuos_general(struct wacom_wac *wacom, void *wcombo)
 	if ((data[1] & 0xb8) == 0xa0) {
 		t = (data[6] << 2) | ((data[7] >> 6) & 3);
 		wacom_report_abs(wcombo, ABS_PRESSURE, t);
+		wacom_report_key(wcombo, BTN_TOUCH, t);
 		wacom_report_abs(wcombo, ABS_TILT_X,
 				((data[7] << 1) & 0x7e) | (data[8] >> 7));
 		wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
@@ -529,7 +535,7 @@ int wacom_tpc_irq(struct wacom_wac *wacom, void *wcombo)
 {
 	char *data = wacom->data;
 	int prox = 0, pressure;
-	static int stylusInProx, touchInProx;
+	static int stylusInProx, touchInProx = 1, touchOut;
 	struct urb *urb = ((struct wacom_combo *)wcombo)->urb;
 
 	dbg("wacom_tpc_irq: received report #%d", data[0]);
@@ -541,41 +547,45 @@ int wacom_tpc_irq(struct wacom_wac *wacom, void *wcombo)
 			prox = data[1] & 0x03;
 		}
 
-		if (stylusInProx) { /* stylus still in prox */
-			touchInProx = 1;
-		} else {
+		if (!stylusInProx) { /* stylus not in prox */
 			if (prox) { 
-				if (!touchInProx) {
-					wacom->tool[1] = BTN_TOUCH;
+				if (touchInProx) {
+					wacom->tool[1] = BTN_TOOL_DOUBLETAP;
 					wacom->id[0] = TOUCH_DEVICE_ID;
 					if (urb->actual_length != 5) {
 						wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
 						wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
-						wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));	
+						wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
+						wacom_report_key(wcombo, BTN_TOUCH, wacom_le16_to_cpu(&data[6]));
 					} else {
 						wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
 						wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
+						wacom_report_key(wcombo, BTN_TOUCH, 1);
 					}
 					wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 					wacom_report_key(wcombo, wacom->tool[1], prox & 0x01);
+					touchOut = 1;
 					return 1;
 				}
 			} else {
-				touchInProx = 0;
 				wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 				wacom_report_key(wcombo, wacom->tool[1], prox & 0x01);
+				wacom_report_key(wcombo, BTN_TOUCH, 0);
+				touchOut = 0;
+				touchInProx = 1;
 				return 1;
 			}
+		} else if (touchOut || !prox) { /* force touch out-prox */
+			wacom_report_abs(wcombo, ABS_MISC, TOUCH_DEVICE_ID);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
+			touchOut = 0;
+			touchInProx = 1;
+			return 1;
 		}
 	} else if (data[0] == 2) { /* Penabled */
 		prox = data[1] & 0x20;
-		/* touch was in control */
-		if (wacom->id[0] == TOUCH_DEVICE_ID) { 
-			/* let it go */
-			wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
-			wacom_report_key(wcombo, wacom->tool[1], 0);
-			return 1;
-		}
+
+		touchInProx = 0;
 
 		wacom->id[0] = ERASER_DEVICE_ID;
 
@@ -618,8 +628,10 @@ int wacom_tpc_irq(struct wacom_wac *wacom, void *wcombo)
 			if (pressure < 0) 
 				pressure = wacom->features->pressure_max + pressure + 1;
 			wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
+			wacom_report_key(wcombo, BTN_TOUCH, pressure);
 		} else {
 			wacom_report_abs(wcombo, ABS_PRESSURE, 0);
+			wacom_report_key(wcombo, BTN_TOUCH, 0);
 			wacom_report_key(wcombo, BTN_STYLUS, 0);
 			wacom_report_key(wcombo, BTN_STYLUS2, 0);
 		}
diff --git a/src/2.6.22/wacom_sys.c b/src/2.6.22/wacom_sys.c
index 46cbb7e..9383348 100755
--- a/src/2.6.22/wacom_sys.c
+++ b/src/2.6.22/wacom_sys.c
@@ -395,11 +395,11 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	}
 
 	input_dev->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
-	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS);
+	input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) | BIT(BTN_STYLUS) | BIT(BTN_TOUCH);
 	input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOUCH);
+		input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.24/wacom_sys.c b/src/2.6.24/wacom_sys.c
index 0de3041..dd6fc02 100755
--- a/src/2.6.24/wacom_sys.c
+++ b/src/2.6.24/wacom_sys.c
@@ -408,12 +408,13 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	}
 
 	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS);
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS) | 
+			BIT_MASK(BTN_TOUCH);
 	input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOUCH);
+		input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.26/wacom_sys.c b/src/2.6.26/wacom_sys.c
index 9ba72b2..d4bbe4c 100755
--- a/src/2.6.26/wacom_sys.c
+++ b/src/2.6.26/wacom_sys.c
@@ -428,12 +428,13 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	}
 
 	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS);
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS) | 
+			BIT_MASK(BTN_TOUCH);
 	input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
 	input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);
 	if (wacom_wac->features->type == TABLETPC) {
-		input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOUCH);
+		input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_DOUBLETAP);
 		input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
 		input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
 	}
diff --git a/src/2.6.27/Makefile.in b/src/2.6.27/Makefile.in
new file mode 100755
index 0000000..eeb3b81
--- /dev/null
+++ b/src/2.6.27/Makefile.in
@@ -0,0 +1,44 @@
+############################ 2.6 kernel compile ###############################
+ifneq ($(KERNELRELEASE),)
+# We were called by kbuild
+# Do NOT indent stuff in this part! It has to be like this to make the
+# $(error ... ) stuff work
+
+ifeq ($(WCM_OPTION_WACOM),yes)
+ifneq ($(CONFIG_USB_WACOM),y)
+wacom-objs := wacom_wac.o wacom_sys.o
+obj-m += wacom.o
+else
+$(error You requested to build wacom with configure, but wacom is configured as built-in in your kernel config)
+endif # CONFIG_USB_WACOM
+endif # WCM_OPTION_WACOM
+
+else  # We were called from command line
+PWD  := $(shell pwd)
+
+WCM_KERNEL_DIR := @WCM_KERNEL_DIR@
+WCM_OPTION_WACOM := @WCM_OPTION_WACOM@
+
+export WCM_OPTION_WACOM 
+
+all:
+# Copy Wacom specific code which is common to all kernel releases
+ifeq ($(WCM_OPTION_WACOM),yes)
+	cp -f ../2.6.19/wacom_wac.c .
+	cp -f ../2.6.22/wacom_wac.h .
+endif 
+	@echo '    Building linuxwacom drivers for 2.6 kernel.'
+	@echo '***Note: Drivers not enabled as modules in your kernel config but requested through configure are NOT built'
+	$(MAKE) -C $(WCM_KERNEL_DIR) M=$(PWD)
+
+endif  # End kbuild check
+
+######################### Version independent targets ##########################
+
+clean:
+	rm -rf *.o *.ko *.mod.* .[a-z]* core *.i
+
+EMPTY_AUTOMAKE_TARGETS = distdir install install-data install-exec uninstall install-info
+EMPTY_AUTOMAKE_TARGETS += installdirs check dvi pdf ps info html tags ctags mostlyclean distclean maintainer-clean
+.PHONY: $(EMPTY_AUTOMAKE_TARGETS)
+	$(EMPTY_AUTOMAKE_TARGETS):
diff --git a/src/2.6.27/wacom.h b/src/2.6.27/wacom.h
new file mode 100755
index 0000000..9f1dfd9
--- /dev/null
+++ b/src/2.6.27/wacom.h
@@ -0,0 +1,139 @@
+/*
+ * drivers/input/tablet/wacom.h
+ *
+ *  USB Wacom Graphire and Wacom Intuos tablet support
+ *
+ *  Copyright (c) 2000-2004 Vojtech Pavlik	<vojtech@ucw.cz>
+ *  Copyright (c) 2000 Andreas Bach Aaen	<abach@stofanet.dk>
+ *  Copyright (c) 2000 Clifford Wolf		<clifford@clifford.at>
+ *  Copyright (c) 2000 Sam Mosel		<sam.mosel@computer.org>
+ *  Copyright (c) 2000 James E. Blair		<corvus@gnu.org>
+ *  Copyright (c) 2000 Daniel Egger		<egger@suse.de>
+ *  Copyright (c) 2001 Frederic Lepied		<flepied@mandrakesoft.com>
+ *  Copyright (c) 2004 Panagiotis Issaris	<panagiotis.issaris@mech.kuleuven.ac.be>
+ *  Copyright (c) 2002-2008 Ping Cheng		<pingc@wacom.com>
+ *
+ *  ChangeLog:
+ *      v0.1 (vp)  - Initial release
+ *      v0.2 (aba) - Support for all buttons / combinations
+ *      v0.3 (vp)  - Support for Intuos added
+ *	v0.4 (sm)  - Support for more Intuos models, menustrip
+ *			relative mode, proximity.
+ *	v0.5 (vp)  - Big cleanup, nifty features removed,
+ *			they belong in userspace
+ *	v1.8 (vp)  - Submit URB only when operating, moved to CVS,
+ *			use input_report_key instead of report_btn and
+ *			other cleanups
+ *	v1.11 (vp) - Add URB ->dev setting for new kernels
+ *	v1.11 (jb) - Add support for the 4D Mouse & Lens
+ *	v1.12 (de) - Add support for two more inking pen IDs
+ *	v1.14 (vp) - Use new USB device id probing scheme.
+ *		     Fix Wacom Graphire mouse wheel
+ *	v1.18 (vp) - Fix mouse wheel direction
+ *		     Make mouse relative
+ *      v1.20 (fl) - Report tool id for Intuos devices
+ *                 - Multi tools support
+ *                 - Corrected Intuos protocol decoding (airbrush, 4D mouse, lens cursor...)
+ *                 - Add PL models support
+ *		   - Fix Wacom Graphire mouse wheel again
+ *	v1.21 (vp) - Removed protocol descriptions
+ *		   - Added MISC_SERIAL for tool serial numbers
+ *	      (gb) - Identify version on module load.
+ *    v1.21.1 (fl) - added Graphire2 support
+ *    v1.21.2 (fl) - added Intuos2 support
+ *                 - added all the PL ids
+ *    v1.21.3 (fl) - added another eraser id from Neil Okamoto
+ *                 - added smooth filter for Graphire from Peri Hankey
+ *                 - added PenPartner support from Olaf van Es
+ *                 - new tool ids from Ole Martin Bjoerndalen
+ *	v1.29 (pc) - Add support for more tablets
+ *		   - Fix pressure reporting
+ *	v1.30 (vp) - Merge 2.4 and 2.5 drivers
+ *		   - Since 2.5 now has input_sync(), remove MSC_SERIAL abuse
+ *		   - Cleanups here and there
+ *    v1.30.1 (pi) - Added Graphire3 support
+ *	v1.40 (pc) - Add support for several new devices, fix eraser reporting, ...
+ *	v1.43 (pc) - Added support for Cintiq 21UX
+ *		   - Fixed a Graphire bug
+ *		   - Merged wacom_intuos3_irq into wacom_intuos_irq
+ *	v1.44 (pc) - Added support for Graphire4, Cintiq 710, Intuos3 6x11, etc.
+ *		   - Report Device IDs
+ *      v1.45 (pc) - Added support for DTF 521, Intuos3 12x12 and 12x19
+ *                 - Minor data report fix
+ *      v1.46 (pc) - Split wacom.c into wacom_sys.c and wacom_wac.c,
+ *		   - where wacom_sys.c deals with system specific code,
+ *		   - and wacom_wac.c deals with Wacom specific code
+ *		   - Support Intuos3 4x6
+ *      v1.47 (pc) - Added support for Bamboo
+ *      v1.48 (pc) - Added support for Bamboo1, BambooFun, and Cintiq 12WX
+ *      v1.49 (pc) - Added support for USB Tablet PC (0x90, 0x93, and 0x9A)
+ */
+
+/*
+ * 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.
+ */
+#ifndef WACOM_H
+#define WACOM_H
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/usb/input.h>
+#include <asm/unaligned.h>
+
+/*
+ * Version Information
+ */
+#define DRIVER_VERSION "v1.49"
+#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
+#define DRIVER_DESC "USB Wacom Graphire and Wacom Intuos tablet driver"
+#define DRIVER_LICENSE "GPL"
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE(DRIVER_LICENSE);
+
+#define USB_VENDOR_ID_WACOM	0x056a
+
+struct wacom {
+	dma_addr_t data_dma;
+	struct input_dev *dev;
+	struct usb_device *usbdev;
+	struct usb_interface *intf;
+	struct urb *irq;
+	struct wacom_wac * wacom_wac;
+	struct mutex lock;
+	unsigned int open:1;
+	char phys[32];
+};
+
+struct wacom_combo {
+	struct wacom * wacom;
+	struct urb * urb;
+};
+
+extern int wacom_wac_irq(struct wacom_wac * wacom_wac, void * wcombo);
+extern void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data);
+extern void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data);
+extern void wacom_report_key(void *wcombo, unsigned int key_type, int key_data);
+extern void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value);
+extern void wacom_input_sync(void *wcombo);
+extern void wacom_init_input_dev(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_g4(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_g(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_pl(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_pt(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_mo(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern void input_dev_bee(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
+extern __u16 wacom_le16_to_cpu(unsigned char *data);
+extern __u16 wacom_be16_to_cpu(unsigned char *data);
+extern struct wacom_features * get_wacom_feature(const struct usb_device_id *id);
+extern const struct usb_device_id * get_device_table(void);
+
+#endif
diff --git a/src/2.6.27/wacom_sys.c b/src/2.6.27/wacom_sys.c
new file mode 100755
index 0000000..9e534d1
--- /dev/null
+++ b/src/2.6.27/wacom_sys.c
@@ -0,0 +1,552 @@
+/*
+ * drivers/input/tablet/wacom_sys.c
+ *
+ *  USB Wacom Graphire and Wacom Intuos tablet support - system specific code
+ */
+
+/*
+ * 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.
+ */
+
+#include "wacom.h"
+#include "wacom_wac.h"
+
+/* defines to get HID report descriptor */
+#define HID_DEVICET_HID		(USB_TYPE_CLASS | 0x01)
+#define HID_DEVICET_REPORT	(USB_TYPE_CLASS | 0x02)
+#define HID_USAGE_UNDEFINED		0x00
+#define HID_USAGE_PAGE			0x05
+#define HID_USAGE_PAGE_DIGITIZER	0x0d
+#define HID_USAGE_PAGE_DESKTOP		0x01
+#define HID_USAGE			0x09
+#define HID_USAGE_X			0x30
+#define HID_USAGE_Y			0x31
+#define HID_USAGE_X_TILT		0x3d
+#define HID_USAGE_Y_TILT		0x3e
+#define HID_USAGE_FINGER		0x22
+#define HID_USAGE_STYLUS		0x20
+#define HID_COLLECTION			0xc0
+#define HID_USAGE_PAGE_VDEFINED		0xff
+
+enum {
+	WCM_UNDEFINED = 0,
+	WCM_DESKTOP,
+	WCM_DIGITIZER,
+	MAX_USAGE_PAGE
+};
+
+struct hid_descriptor
+{
+	struct usb_descriptor_header header;
+	__le16   bcdHID;
+	u8       bCountryCode;
+	u8       bNumDescriptors;
+	u8       bDescriptorType;
+	__le16   wDescriptorLength;
+} __attribute__ ((packed));
+
+/* defines to get/set USB message */
+#define USB_REQ_GET_REPORT	0x01
+#define USB_REQ_SET_REPORT	0x09
+#define WAC_HID_FEATURE_REPORT	0x03
+
+static int usb_get_report(struct usb_interface *intf, unsigned char type,
+				unsigned char id, void *buf, int size)
+{
+	return usb_control_msg(interface_to_usbdev(intf),
+		usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
+		USB_REQ_GET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+		(type << 8) + id, intf->altsetting[0].desc.bInterfaceNumber,
+		buf, size, 100);
+}
+
+static int usb_set_report(struct usb_interface *intf, unsigned char type,
+				unsigned char id, void *buf, int size)
+{
+	return usb_control_msg(interface_to_usbdev(intf),
+		usb_sndctrlpipe(interface_to_usbdev(intf), 0),
+                USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                (type << 8) + id, intf->altsetting[0].desc.bInterfaceNumber,
+		buf, size, 1000);
+}
+
+static struct input_dev * get_input_dev(struct wacom_combo *wcombo)
+{
+	return wcombo->wacom->dev;
+}
+
+static void wacom_sys_irq(struct urb *urb)
+{
+	struct wacom *wacom = urb->context;
+	struct wacom_combo wcombo;
+	int retval;
+
+	switch (urb->status) {
+	case 0:
+		/* success */
+		break;
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		/* this urb is terminated, clean up */
+		dbg("%s - urb shutting down with status: %d", __func__, urb->status);
+		return;
+	default:
+		dbg("%s - nonzero urb status received: %d", __func__, urb->status);
+		goto exit;
+	}
+
+	wcombo.wacom = wacom;
+	wcombo.urb = urb;
+
+	if (wacom_wac_irq(wacom->wacom_wac, (void *)&wcombo))
+		input_sync(get_input_dev(&wcombo));
+
+ exit:
+	usb_mark_last_busy(wacom->usbdev);
+	retval = usb_submit_urb (urb, GFP_ATOMIC);
+	if (retval)
+		err ("%s - usb_submit_urb failed with result %d",
+		     __func__, retval);
+}
+
+void wacom_report_key(void *wcombo, unsigned int key_type, int key_data)
+{
+	input_report_key(get_input_dev((struct wacom_combo *)wcombo), key_type, key_data);
+	return;
+}
+
+void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data)
+{
+	input_report_abs(get_input_dev((struct wacom_combo *)wcombo), abs_type, abs_data);
+	return;
+}
+
+void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data)
+{
+	input_report_rel(get_input_dev((struct wacom_combo *)wcombo), rel_type, rel_data);
+	return;
+}
+
+void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value)
+{
+	input_event(get_input_dev((struct wacom_combo *)wcombo), type, code, value);
+	return;
+}
+
+__u16 wacom_be16_to_cpu(unsigned char *data)
+{
+	__u16 value;
+	value = be16_to_cpu(*(__be16 *) data);
+	return value;
+}
+
+__u16 wacom_le16_to_cpu(unsigned char *data)
+{
+	__u16 value;
+	value = le16_to_cpu(*(__le16 *) data);
+	return value;
+}
+
+void wacom_input_sync(void *wcombo)
+{
+	input_sync(get_input_dev((struct wacom_combo *)wcombo));
+	return;
+}
+
+static int wacom_open(struct input_dev *dev)
+{
+	struct wacom *wacom = input_get_drvdata(dev);
+
+	mutex_lock(&wacom->lock);
+
+	wacom->irq->dev = wacom->usbdev;
+
+	if (usb_autopm_get_interface(wacom->intf) < 0) {
+		mutex_unlock(&wacom->lock);
+		return -EIO;
+	}
+
+	if (usb_submit_urb(wacom->irq, GFP_KERNEL)) {
+		usb_autopm_put_interface(wacom->intf);
+		mutex_unlock(&wacom->lock);
+		return -EIO;
+	}
+
+	wacom->open = 1;
+	wacom->intf->needs_remote_wakeup = 1;
+
+	mutex_unlock(&wacom->lock);
+	return 0;
+}
+
+static void wacom_close(struct input_dev *dev)
+{
+	struct wacom *wacom = input_get_drvdata(dev);
+
+	mutex_lock(&wacom->lock);
+	usb_kill_urb(wacom->irq);
+	wacom->open = 0;
+	wacom->intf->needs_remote_wakeup = 0;
+	mutex_unlock(&wacom->lock);
+}
+
+void input_dev_mo(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_1) |
+		BIT_MASK(BTN_5);
+	input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
+}
+
+void input_dev_g4(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->evbit[0] |= BIT_MASK(EV_MSC);
+	input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
+	input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
+		BIT_MASK(BTN_4);
+}
+
+void input_dev_g(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->evbit[0] |= BIT_MASK(EV_REL);
+	input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
+	input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_LEFT) |
+		BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
+		BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_STYLUS2);
+	input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);
+}
+
+void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
+	input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
+		BIT_MASK(BTN_1) | BIT_MASK(BTN_2) | BIT_MASK(BTN_3);
+	input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
+	input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
+}
+
+void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_4) |
+		BIT_MASK(BTN_5) | BIT_MASK(BTN_6) | BIT_MASK(BTN_7);
+	input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
+}
+
+void input_dev_bee(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_8) | BIT_MASK(BTN_9);
+}
+
+void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->evbit[0] |= BIT_MASK(EV_MSC) | BIT_MASK(EV_REL);
+	input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
+	input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
+	input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_LEFT) |
+		BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE) |
+		BIT_MASK(BTN_SIDE) | BIT_MASK(BTN_EXTRA);
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
+		BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_TOOL_BRUSH) |
+		BIT_MASK(BTN_TOOL_PENCIL) | BIT_MASK(BTN_TOOL_AIRBRUSH) |
+		BIT_MASK(BTN_TOOL_LENS) | BIT_MASK(BTN_STYLUS2);
+	input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);
+	input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
+	input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
+	input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
+	input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
+	input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
+}
+
+void input_dev_pl(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_STYLUS2);
+}
+
+void input_dev_pt(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+{
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER);
+}
+
+static void wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hid_desc, 
+		struct wacom_wac *wacom_wac, char *report)
+{
+	struct usb_device *dev = interface_to_usbdev(intf);
+	char limit = 0, result = 0;
+	int i = 0, usage = WCM_UNDEFINED, finger = 0, pen = 0;
+
+	/* retrive report descriptors */
+	do {
+		result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+			USB_REQ_GET_DESCRIPTOR,
+			USB_RECIP_INTERFACE | USB_DIR_IN,
+			HID_DEVICET_REPORT << 8,
+			intf->altsetting[0].desc.bInterfaceNumber, /* interface */
+			report,
+			hid_desc->wDescriptorLength,
+			5000); /* 5 secs */
+	} while (limit++ < 5);
+
+	for (i=0; i<hid_desc->wDescriptorLength; i++) {
+		if ((unsigned short)report[i] == HID_USAGE_PAGE) {
+			switch ((unsigned short)report[i+1]) {
+			    case HID_USAGE_PAGE_DIGITIZER:
+				usage = WCM_DIGITIZER;
+				i++;
+				continue;
+			    case HID_USAGE_PAGE_DESKTOP:
+				usage = WCM_DESKTOP;
+				i++;
+				continue;
+			}
+		}
+
+		if ((unsigned short)report[i] == HID_USAGE) {
+			switch ((unsigned short)report[i+1]) {
+			    case HID_USAGE_X:
+				if (usage == WCM_DESKTOP) {
+					if (finger) {
+						wacom_wac->features->touch_x_max = 
+						wacom_wac->features->touch_y_max = (unsigned short)
+							(wacom_le16_to_cpu(&report[i+3]));
+						wacom_wac->features->x_max = (unsigned short)
+							(wacom_le16_to_cpu(&report[i+6]));
+						i += 7;
+					} else if (pen) {
+						wacom_wac->features->x_max = (unsigned short)
+							(wacom_le16_to_cpu(&report[i+3]));
+						i += 4;
+					}
+				} else if (usage == WCM_DIGITIZER) {
+					/* max pressure isn't reported 
+					wacom_wac->features->pressure_max = (unsigned short)
+							(report[i+4] << 8  | report[i+3]);
+					*/
+					wacom_wac->features->pressure_max = 255;
+					i += 4;
+				}
+				break;
+			    case HID_USAGE_Y:
+				if (usage == WCM_DESKTOP) {
+					wacom_wac->features->y_max = (unsigned short)
+						(wacom_le16_to_cpu(&report[i+3]));
+				}
+				i += 4;
+				break;
+			    case HID_USAGE_FINGER:
+				finger = 1;
+				i++;
+				break;
+			    case HID_USAGE_STYLUS:
+				pen = 1;
+				i++;
+				break;
+			    case HID_USAGE_UNDEFINED:
+				if (usage == WCM_DESKTOP && finger) { /* capacity */
+					wacom_wac->features->pressure_max = (unsigned short)
+						(wacom_le16_to_cpu(&report[i+3]));
+				}
+				i += 4;
+				break;
+			}
+		}
+
+		if ((unsigned short)report[i] == HID_COLLECTION) {
+			/* reset UsagePage ans Finger */
+			finger = usage = 0;
+		}
+	}
+}
+
+static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+	struct usb_device *dev = interface_to_usbdev(intf);
+	struct usb_host_interface *interface = intf->cur_altsetting;
+	struct usb_endpoint_descriptor *endpoint;
+	struct wacom *wacom;
+	struct wacom_wac *wacom_wac;
+	struct input_dev *input_dev;
+	int error = -ENOMEM;
+	char rep_data[2], limit = 0, *report = NULL;
+	struct hid_descriptor *hid_desc;
+
+	wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
+	wacom_wac = kzalloc(sizeof(struct wacom_wac), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!wacom || !input_dev || !wacom_wac)
+		goto fail1;
+
+	wacom_wac->data = usb_buffer_alloc(dev, 10, GFP_KERNEL, &wacom->data_dma);
+	if (!wacom_wac->data)
+		goto fail1;
+
+	wacom->irq = usb_alloc_urb(0, GFP_KERNEL);
+	if (!wacom->irq)
+		goto fail2;
+
+	wacom->usbdev = dev;
+	wacom->dev = input_dev;
+	wacom->intf = intf;
+	mutex_init(&wacom->lock);
+	usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
+	strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
+
+	wacom_wac->features = get_wacom_feature(id);
+	BUG_ON(wacom_wac->features->pktlen > 10);
+
+	input_dev->name = wacom_wac->features->name;
+	wacom->wacom_wac = wacom_wac;
+	usb_to_input_id(dev, &input_dev->id);
+
+	input_dev->dev.parent = &intf->dev;
+
+	input_set_drvdata(input_dev, wacom);
+
+	input_dev->open = wacom_open;
+	input_dev->close = wacom_close;
+
+	endpoint = &intf->cur_altsetting->endpoint[0].desc;
+
+	/* TabletPC need to retrieve the physical and logical maximum from report descriptor */
+	if (wacom_wac->features->type == TABLETPC) {
+		if (usb_get_extra_descriptor(interface, HID_DEVICET_HID, &hid_desc)) {
+	    		if (usb_get_extra_descriptor(&interface->endpoint[0], 
+				HID_DEVICET_REPORT, &hid_desc)) {
+				printk("wacom: can not retrive extra class descriptor\n");
+				goto fail2;
+			}
+		}
+		report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
+		if (!report) {
+			goto fail2;
+		}
+		wacom_parse_hid(intf, hid_desc, wacom_wac, report);
+	}
+
+	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+	input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS) | 
+			BIT_MASK(BTN_TOUCH);
+	input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
+	input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
+	input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);
+	if (wacom_wac->features->type == TABLETPC) {
+		input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_DOUBLETAP);
+		input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->touch_x_max, 4, 0);
+		input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->touch_y_max, 4, 0);
+	}
+	input_dev->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
+
+	wacom_init_input_dev(input_dev, wacom_wac);
+
+	usb_fill_int_urb(wacom->irq, dev,
+			 usb_rcvintpipe(dev, endpoint->bEndpointAddress),
+			 wacom_wac->data, wacom_wac->features->pktlen,
+			 wacom_sys_irq, wacom, endpoint->bInterval);
+	wacom->irq->transfer_dma = wacom->data_dma;
+	wacom->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+	error = input_register_device(wacom->dev);
+	if (error)
+		goto fail3;
+
+	/* Ask the tablet to report tablet data.  if it is not a Tablet PC.
+	 * Repeat until it succeeds
+	 */
+	if (wacom_wac->features->type != TABLETPC) {
+	    do {
+		rep_data[0] = 2;
+		rep_data[1] = 2;
+		error = usb_set_report(intf, WAC_HID_FEATURE_REPORT, 2, rep_data, 2);
+		if(error >= 0)
+			error = usb_get_report(intf, WAC_HID_FEATURE_REPORT, 2, rep_data, 2);
+	    } while (((error <= 0) || (rep_data[1] != 2)) && limit++ < 5);
+	}
+
+	usb_set_intfdata(intf, wacom);
+	kfree(report);
+	return 0;
+
+ fail3:	usb_free_urb(wacom->irq);
+ fail2:	usb_buffer_free(dev, 10, wacom_wac->data, wacom->data_dma);
+ fail1:	input_free_device(input_dev);
+	kfree(wacom);
+	kfree(wacom_wac);
+	return error;
+}
+
+static void wacom_disconnect(struct usb_interface *intf)
+{
+	struct wacom *wacom = usb_get_intfdata(intf);
+
+	usb_set_intfdata(intf, NULL);
+
+	usb_kill_urb(wacom->irq);
+	input_unregister_device(wacom->dev);
+	usb_free_urb(wacom->irq);
+	usb_buffer_free(interface_to_usbdev(intf), 10, wacom->wacom_wac->data, wacom->data_dma);
+	kfree(wacom->wacom_wac);
+	kfree(wacom);
+}
+
+static int wacom_suspend(struct usb_interface *intf, pm_message_t message)
+{
+	struct wacom *wacom = usb_get_intfdata(intf);
+
+	mutex_lock(&wacom->lock);
+	usb_kill_urb(wacom->irq);
+	mutex_unlock(&wacom->lock);
+
+	return 0;
+}
+
+static int wacom_resume(struct usb_interface *intf)
+{
+	struct wacom *wacom = usb_get_intfdata(intf);
+	int rv;
+
+	mutex_lock(&wacom->lock);
+	if (wacom->open)
+		rv = usb_submit_urb(wacom->irq, GFP_NOIO);
+	else
+		rv = 0;
+	mutex_unlock(&wacom->lock);
+
+	return rv;
+}
+
+static int wacom_reset_resume(struct usb_interface *intf)
+{
+	return wacom_resume(intf);
+}
+
+static struct usb_driver wacom_driver = {
+	.name =		"wacom",
+	.probe =	wacom_probe,
+	.disconnect =	wacom_disconnect,
+	.suspend =	wacom_suspend,
+	.resume =	wacom_resume,
+	.reset_resume =	wacom_reset_resume,
+	.supports_autosuspend = 1,
+};
+
+static int __init wacom_init(void)
+{
+	int result;
+	wacom_driver.id_table = get_device_table();
+	result = usb_register(&wacom_driver);
+	if (result == 0)
+		info(DRIVER_VERSION ":" DRIVER_DESC);
+	return result;
+}
+
+static void __exit wacom_exit(void)
+{
+	usb_deregister(&wacom_driver);
+}
+
+module_init(wacom_init);
+module_exit(wacom_exit);
diff --git a/src/include/util-config.h.in b/src/include/util-config.h.in
index 9fc0730..ceeae0e 100644
--- a/src/include/util-config.h.in
+++ b/src/include/util-config.h.in
@@ -3,6 +3,12 @@
 #ifndef _UTIL_CONFIG_H_
 #define _UTIL_CONFIG_H_
 
+/* Compiling for X.org */
+#undef WCM_XORG
+ 
+/* Compiling for XFree86 */
+#undef WCM_XFREE86
+
 /* ncurses header files available */
 #undef WCM_ENABLE_NCURSES
 
diff --git a/src/util/wacomcfg.c b/src/util/wacomcfg.c
index 39e1de2..9a53c85 100755
--- a/src/util/wacomcfg.c
+++ b/src/util/wacomcfg.c
@@ -146,8 +146,12 @@ int WacomConfigListDevices(WACOMCONFIG *hConfig, WACOMDEVICEINFO** ppInfo,
 		return -1;
 
 #if WCM_XF86CONFIG
-	/* read the config in for wacom devices which don'T use the commnon identifier */
+	/* read the config in for wacom devices which don't use the commnon identifier */
+    #if WCM_XORG
 	conf = readConfig ("/etc/X11/xorg.conf");
+    #else
+	conf = readConfig ("/etc/X11/XF86Config");
+    #endif
 #endif
 
 	/* estimate size of memory needed to hold structures */
diff --git a/src/xdrv/wcmCommon.c b/src/xdrv/wcmCommon.c
index 4fe24ae..812a789 100755
--- a/src/xdrv/wcmCommon.c
+++ b/src/xdrv/wcmCommon.c
@@ -222,7 +222,7 @@ static void xf86WcmSetScreen(LocalDevicePtr local, int *value0, int *value1)
 		if (screenToSet != -1)
 		{
 			letfPadding = priv->screenTopX[screenToSet];
-			topPadding = priv->screenBottomX[screenToSet];
+			topPadding = priv->screenTopY[screenToSet];
 		}
 		else
 		{
@@ -784,7 +784,7 @@ static void sendCommonEvents(LocalDevicePtr local, const WacomDeviceState* ds, i
 	WacomDevicePtr priv = (WacomDevicePtr) local->private;
 	int buttons = ds->buttons;
 
-	if (priv->oldButtons != buttons)
+	if (priv->oldButtons != buttons || (!priv->oldProximity && !buttons))
 		xf86WcmSendButtons(local,buttons,x,y,z,v3,v4,v5);
 
 	/* emulate wheel/strip events when defined */
@@ -820,7 +820,6 @@ void xf86WcmSendEvents(LocalDevicePtr local, const WacomDeviceState* ds)
 	WacomCommonPtr common = priv->common;
 	int naxes = priv->naxes;
 	int is_absolute = priv->flags & ABSOLUTE_FLAG;
-
 	int v3, v4, v5;
 	int no_jitter; 
 	double relacc, param;
@@ -907,6 +906,7 @@ void xf86WcmSendEvents(LocalDevicePtr local, const WacomDeviceState* ds)
 		priv->oldStripY = ds->stripy;
 		priv->oldRot = rot;
 		priv->oldThrottle = throttle;
+		priv->oldButtons = 0;
 	}
 	if (!is_absolute)
 	{
@@ -991,7 +991,10 @@ void xf86WcmSendEvents(LocalDevicePtr local, const WacomDeviceState* ds)
 				xf86PostMotionEvent(local->dev, is_absolute,
 					0, naxes, x, y, z, v3, v4, v5);
 
-			sendCommonEvents(local, ds, x, y, z, v3, v4, v5);
+			if (priv->oldProximity || !IsTouch(priv))
+				sendCommonEvents(local, ds, x, y, z, v3, v4, v5);
+			else
+				buttons = 0;
 		}
 
 		/* not in proximity */
@@ -1234,7 +1237,7 @@ void xf86WcmEvent(WacomCommonPtr common, unsigned int channel,
 #ifdef WCM_ENABLE_LINUXINPUT
 	/* Discard the first 2 USB packages due to events delay */
 	if ( (pChannel->nSamples < 2) && (common->wcmDevCls == &gWacomUSBDevice) && 
-		ds.device_type != PAD_ID && ds.device_type != TOUCH_ID )
+		ds.device_type != PAD_ID )
 	{
 		DBG(11, common->debugLevel, 
 			ErrorF("discarded %dth USB data.\n", 
@@ -1497,6 +1500,50 @@ static void commonDispatchDevice(WacomCommonPtr common, unsigned int channel,
 		/* button 1 Threshold test */
 		int button = 1;
 		priv = pDev->private;
+
+#ifdef WCM_ENABLE_LINUXINPUT
+		if (common->wcmDevCls == &gWacomUSBDevice && IsTouch(priv) && !ds->proximity)
+		{
+			priv->hardProx = 0;
+		}		
+
+		if (common->wcmDevCls == &gWacomUSBDevice && (IsStylus(priv) || IsEraser(priv)))
+		{
+			priv->hardProx = 1;
+		}
+		
+		/* send a touch out for USB Tablet PCs */
+		if (common->wcmDevCls == &gWacomUSBDevice && !IsTouch(priv) 
+			&& common->wcmTouchDefault && !priv->oldProximity)
+		{ 
+			LocalDevicePtr localDevices = xf86FirstLocalDevice();
+			WacomCommonPtr tempcommon = NULL;
+			WacomDevicePtr temppriv = NULL;
+
+			/* Lookup to see if associated touch was enabled */
+			for (; localDevices != NULL; localDevices = localDevices->next)
+			{
+				if (strstr(localDevices->drv->driverName, "wacom"))
+				{
+					temppriv = (WacomDevicePtr) localDevices->private;
+					tempcommon = temppriv->common;
+
+					if ((tempcommon->tablet_id == common->tablet_id) && 
+						IsTouch(temppriv) && temppriv->oldProximity)
+					{
+						/* Send soft prox-out for touch first */
+						WacomDeviceState out = { 0 };
+						out.device_type = DEVICE_ID(temppriv->flags);
+						DBG(2, common->debugLevel, ErrorF(
+							"Send soft prox-out for %s first\n",
+							localDevices->name));
+						xf86WcmSendEvents(localDevices, &out);
+					}
+				}
+			}
+		}
+#endif /* WCM_ENABLE_LINUXINPUT */
+
 		if (IsStylus(priv) || IsEraser(priv))
 		{
 			if (filtered.pressure < common->wcmThreshold )
@@ -1508,13 +1555,14 @@ static void commonDispatchDevice(WacomCommonPtr common, unsigned int channel,
 		}
 
 		/* touch capacity is supported */
-		if (IsTouch(priv) && common->wcmCapacityDefault >= 0)
+		if (IsTouch(priv) && (common->wcmCapacityDefault >= 0) && !priv->hardProx)
 		{
-			if (((double)(filtered.capacity * 5) / (double)common->wcmMaxZ) > (5 - common->wcmCapacity))
+			if (((double)(filtered.capacity * 5) / 
+					(double)common->wcmMaxZ) > 
+					(5 - common->wcmCapacity))
 				filtered.buttons |= button;
 		}
-
-		if (!(priv->flags & ABSOLUTE_FLAG) && !priv->hardProx)
+		else if (!(priv->flags & ABSOLUTE_FLAG) && !priv->hardProx)
 		{
 			/* initial current max distance */
 			if (strstr(common->wcmModel->name, "Intuos"))
@@ -1522,8 +1570,10 @@ static void commonDispatchDevice(WacomCommonPtr common, unsigned int channel,
 			else
 				common->wcmMaxCursorDist = 0;
 		}
+
 		/* Store current hard prox for next use */
-		priv->hardProx = ds->proximity;		
+		if (!IsTouch(priv))
+			priv->hardProx = ds->proximity;		
 
 		/* User-requested filtering comes next */
 
diff --git a/src/xdrv/wcmISDV4.c b/src/xdrv/wcmISDV4.c
index b55025a..67a001b 100755
--- a/src/xdrv/wcmISDV4.c
+++ b/src/xdrv/wcmISDV4.c
@@ -189,7 +189,6 @@ static void isdv4InitISDV4(WacomCommonPtr common, const char* id, float version)
 	common->wcmFlags &= ~TILT_ENABLED_FLAG;
 }
 
-
 /*****************************************************************************
  * isdv4GetRanges -- get ranges of the device
  ****************************************************************************/
@@ -230,16 +229,11 @@ static int isdv4GetRanges(LocalDevicePtr local)
 		common->wcmPktLength = 5;
 		common->tablet_id = 0x93;
 
-		s = xf86FindOptionValue(local->options, "Touch");
-		if ( !s || (strstr(s, "on")) )  /* touch option is on */
-		{
-			common->wcmTouch = 1;
-		}
-
 		/* Touch might be supported. Send a touch query command */
 		if (isdv4Query(local, WC_ISDV4_TOUCH_QUERY, data) == Success)
 		{
-			if (data[0] & 0x41)
+			/* (data[2] & 0x07) == 0 is for resistive touch */
+			if ((data[0] & 0x41) && (data[2] & 0x07))
 			{
 				/* tablet model */
 				switch (data[2] & 0x07)
@@ -269,9 +263,9 @@ static int isdv4GetRanges(LocalDevicePtr local)
 					common->wcmCapacityDefault = 3;
 					common->wcmCapacity = 3;
 					common->wcmTouchResolX = common->wcmMaxTouchX / ( 2540 * 
-						((data[3] << 9) | (data[4] << 2) | ((data[2] & 0x60) >> 5))); 
+						((data[3] << 9) | (data[4] << 2) | ((data[2] & 0x60) >> 5)));
 					common->wcmTouchResolX = common->wcmMaxTouchX / ( 2540 * 
-						((data[5] << 9) | (data[6] << 2) | ((data[2] & 0x18) >> 3))); 
+						((data[5] << 9) | (data[6] << 2) | ((data[2] & 0x18) >> 3)));
 				}
 				else
 				{
@@ -281,6 +275,12 @@ static int isdv4GetRanges(LocalDevicePtr local)
 			}
 		}
 
+		s = xf86FindOptionValue(local->options, "Touch");
+		if ( !s || (strstr(s, "on")) )  /* touch option is on */
+		{
+			common->wcmTouch = 1;
+		}
+
 		/* TouchDefault was off for all devices
 		 * defaults to enable when touch is supported 
 		 */
diff --git a/src/xdrv/wcmUSB.c b/src/xdrv/wcmUSB.c
index 1a6b656..f09d7e5 100755
--- a/src/xdrv/wcmUSB.c
+++ b/src/xdrv/wcmUSB.c
@@ -1016,7 +1016,7 @@ static void usbParseChannel(LocalDevicePtr local, int channel, int serial)
 				ds->device_id = PAD_DEVICE_ID;
 				ds->proximity = (event->value != 0);
 			}
-			else if (event->code == BTN_TOUCH)
+			else if (event->code == BTN_TOOL_DOUBLETAP)
 			{
 				DBG(6, common->debugLevel, ErrorF(
 					"USB Touch detected %x (value=%d)\n",
diff --git a/src/xdrv/xf86Wacom.c b/src/xdrv/xf86Wacom.c
index 6424c0b..9bdbef8 100755
--- a/src/xdrv/xf86Wacom.c
+++ b/src/xdrv/xf86Wacom.c
@@ -75,7 +75,7 @@
  * 2008-08-27 47-pc0.8.1-4 - Support Bamboo1 Meadium and Monarch
  */
 
-static const char identification[] = "$Identification: 47-0.8.1-4 $";
+static const char identification[] = "$Identification: 47-0.8.1-6 $";
 
 /****************************************************************************/
 
@@ -700,6 +700,12 @@ static int xf86WcmRegisterX11Devices (LocalDevicePtr local)
 		InitValuatorAxisStruct(local->dev, 5, 0, 1023, 1, 1, 1);
 	}
 
+	if (IsTouch(priv))
+	{
+		/* hard prox out */
+		priv->hardProx = 0;
+	}
+
 	return TRUE;
 }