Rename xf86Wcm* to wcm*

Rename xf86WcmFilterCoord to WcmFilterCoord

Rename xf86WcmSetPressureCurve to wcmSetPressureCurve

Rename xf86WcmFilterIntuos to wcmFilterIntuos

Rename xf86WcmSerialValidate to wcmSerialValidate

Rename xf86WcmWaitForTablet to wcmWaitForTablet

Rename xf86WcmWriteWait to wcmWriteWait

Rename xf86WcmWait to wcmWait

Rename xf86WcmReadPacket to wcmReadPacket

Rename xf86WcmEvent* to wcmEvent*

Signed-off-by: Przemo Firszt <przemo@firszt.eu>
Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

9 files changed, 69 insertions, 69 deletions

diff --git a/src/wcmCommon.c b/src/wcmCommon.c
index 676e42f..b3393b0 100644
--- a/src/wcmCommon.c
+++ b/src/wcmCommon.c
@@ -1088,11 +1088,11 @@ static void resetSampleCounter(const WacomChannelPtr pChannel)
 }
 
 /*****************************************************************************
- * xf86WcmEvent -
+ * wcmEvent -
  *   Handles suppression, transformation, filtering, and event dispatch.
  ****************************************************************************/
 
-void xf86WcmEvent(WacomCommonPtr common, unsigned int channel,
+void wcmEvent(WacomCommonPtr common, unsigned int channel,
 	const WacomDeviceState* pState)
 {
 	WacomDeviceState* pLast;
@@ -1104,7 +1104,7 @@ void xf86WcmEvent(WacomCommonPtr common, unsigned int channel,
 	pChannel = common->wcmChannel + channel;
 	pLast = &pChannel->valid.state;
 
-	DBG(10, common->debugLevel, xf86Msg(X_INFO, "xf86WcmEvent at channel = %d\n", channel));
+	DBG(10, common->debugLevel, xf86Msg(X_INFO, "wcmEvent at channel = %d\n", channel));
 
 	/* sanity check the channel */
 	if (channel >= MAX_CHANNELS)
@@ -1116,7 +1116,7 @@ void xf86WcmEvent(WacomCommonPtr common, unsigned int channel,
 
 	/* timestamp the state for velocity and acceleration analysis */
 	ds.sample = (int)GetTimeInMillis();
-	DBG(10, common->debugLevel, xf86Msg(X_INFO, "xf86WcmEvent: "
+	DBG(10, common->debugLevel, xf86Msg(X_INFO, "wcmEvent: "
 		"c=%d i=%d t=%d s=%u x=%d y=%d b=%d "
 		"p=%d rz=%d tx=%d ty=%d aw=%d rw=%d "
 		"t=%d df=%d px=%d st=%d cs=%d \n",
@@ -1423,7 +1423,7 @@ static void commonDispatchDevice(WacomCommonPtr common, unsigned int channel,
 	 * access errors to the device */
 	if (pDev && !miPointerGetScreen(pDev->dev))
 	{
-		xf86Msg(X_ERROR, "xf86WcmEvent: Wacom driver can not get Current Screen ID\n");
+		xf86Msg(X_ERROR, "wcmEvent: Wacom driver can not get Current Screen ID\n");
 		xf86Msg(X_ERROR, "Please remove Wacom tool from the tablet and bring it back again.\n");
 		return;
 	}
diff --git a/src/wcmFilter.c b/src/wcmFilter.c
index 04549fc..2c20ae4 100644
--- a/src/wcmFilter.c
+++ b/src/wcmFilter.c
@@ -36,10 +36,10 @@ static void filterLine(int* pCurve, int nMax, int x0, int y0, int x1, int y1);
 static void filterIntuosStylus(WacomCommonPtr common, WacomFilterStatePtr state, WacomDeviceStatePtr ds);
 
 /*****************************************************************************
- * xf86WcmSetPressureCurve -- apply user-defined curve to pressure values
+ * wcmSetPressureCurve -- apply user-defined curve to pressure values
  ****************************************************************************/
 
-void xf86WcmSetPressureCurve(WacomDevicePtr pDev, int x0, int y0,
+void wcmSetPressureCurve(WacomDevicePtr pDev, int x0, int y0,
 	int x1, int y1)
 {
 	int i;
@@ -55,7 +55,7 @@ void xf86WcmSetPressureCurve(WacomDevicePtr pDev, int x0, int y0,
 			(FILTER_PRESSURE_RES + 1));
 		if (!pDev->pPressCurve)
 		{
-			xf86Msg(X_ERROR, "%s: xf86WcmSetPressureCurve: failed to "
+			xf86Msg(X_ERROR, "%s: wcmSetPressureCurve: failed to "
 				"allocate memory for curve\n", pDev->local->name);
 			return;
 		}
@@ -236,10 +236,10 @@ static void filterIntuosStylus(WacomCommonPtr common, WacomFilterStatePtr state,
 }
 
 /*****************************************************************************
- * xf86WcmFilterCoord -- provide noise correction to all transducers
+ * wcmFilterCoord -- provide noise correction to all transducers
  ****************************************************************************/
 
-int xf86WcmFilterCoord(WacomCommonPtr common, WacomChannelPtr pChannel,
+int wcmFilterCoord(WacomCommonPtr common, WacomChannelPtr pChannel,
 	WacomDeviceStatePtr ds)
 {
 	/* Only noise correction should happen here. If there's a problem that
@@ -248,7 +248,7 @@ int xf86WcmFilterCoord(WacomCommonPtr common, WacomChannelPtr pChannel,
 	WacomDeviceState *pLast;
 	int *x, *y, i; 
 
-	DBG(10, common->debugLevel, xf86Msg(X_INFO, "xf86WcmFilterCoord with "
+	DBG(10, common->debugLevel, xf86Msg(X_INFO, "wcmFilterCoord with "
 			"common->wcmRawSample = %d \n", common->wcmRawSample));
 	x = pChannel->rawFilter.x;
 	y = pChannel->rawFilter.y;
@@ -269,10 +269,10 @@ int xf86WcmFilterCoord(WacomCommonPtr common, WacomChannelPtr pChannel,
 }
 
 /*****************************************************************************
- * xf86WcmFilterIntuos -- provide error correction to Intuos and Intuos2
+ * wcmFilterIntuos -- provide error correction to Intuos and Intuos2
  ****************************************************************************/
 
-int xf86WcmFilterIntuos(WacomCommonPtr common, WacomChannelPtr pChannel,
+int wcmFilterIntuos(WacomCommonPtr common, WacomChannelPtr pChannel,
 	WacomDeviceStatePtr ds)
 {
 	/* Only error correction should happen here. If there's a problem that
@@ -281,7 +281,7 @@ int xf86WcmFilterIntuos(WacomCommonPtr common, WacomChannelPtr pChannel,
 	if (ds->device_type != CURSOR_ID)
 		filterIntuosStylus(common, &pChannel->rawFilter, ds);
 	else
-		xf86WcmFilterCoord(common, pChannel, ds);
+		wcmFilterCoord(common, pChannel, ds);
 
 	return 0; /* lookin' good */
 }
diff --git a/src/wcmFilter.h b/src/wcmFilter.h
index d5995e4..ae02a09 100644
--- a/src/wcmFilter.h
+++ b/src/wcmFilter.h
@@ -24,11 +24,11 @@
 
 /****************************************************************************/
 
-void xf86WcmSetPressureCurve(WacomDevicePtr pDev, int x0, int y0,
+void wcmSetPressureCurve(WacomDevicePtr pDev, int x0, int y0,
 	int x1, int y1);
-int xf86WcmFilterIntuos(WacomCommonPtr common, WacomChannelPtr pChannel,
+int wcmFilterIntuos(WacomCommonPtr common, WacomChannelPtr pChannel,
 	WacomDeviceStatePtr ds);
-int xf86WcmFilterCoord(WacomCommonPtr common, WacomChannelPtr pChannel,
+int wcmFilterCoord(WacomCommonPtr common, WacomChannelPtr pChannel,
 	WacomDeviceStatePtr ds);
 
 /****************************************************************************/
diff --git a/src/wcmISDV4.c b/src/wcmISDV4.c
index d34138d..c52299a 100644
--- a/src/wcmISDV4.c
+++ b/src/wcmISDV4.c
@@ -35,16 +35,16 @@ static void isdv4InitISDV4(WacomCommonPtr, const char* id, float version);
 static int isdv4GetRanges(LocalDevicePtr);
 static int isdv4StartTablet(LocalDevicePtr);
 static int isdv4Parse(LocalDevicePtr, const unsigned char* data);
-static int xf86WcmSerialValidate(WacomCommonPtr common, const unsigned char* data);
-static int xf86WcmWaitForTablet(int fd, char * data, int size);
-static int xf86WcmWriteWait(int fd, const char* request);
+static int wcmSerialValidate(WacomCommonPtr common, const unsigned char* data);
+static int wcmWaitForTablet(int fd, char * data, int size);
+static int wcmWriteWait(int fd, const char* request);
 
 
 	WacomDeviceClass gWacomISDV4Device =
 	{
 		isdv4Detect,
 		isdv4Init,
-		xf86WcmReadPacket,
+		wcmReadPacket,
 	};
 
 	static WacomModel isdv4General =
@@ -65,7 +65,7 @@ static int xf86WcmWriteWait(int fd, const char* request);
  * XFree86 V4 Functions
  ****************************************************************************/
 
-static int xf86WcmWait(int t)
+static int wcmWait(int t)
 {
 	int err = xf86WaitForInput(-1, ((t) * 1000));
 	if (err != -1)
@@ -76,11 +76,11 @@ static int xf86WcmWait(int t)
 }
 
 /*****************************************************************************
- * xf86WcmSerialValidate -- validates serial packet; returns 0 on success,
+ * wcmSerialValidate -- validates serial packet; returns 0 on success,
  *   positive number of bytes to skip on error.
  ****************************************************************************/
 
-static int xf86WcmSerialValidate(WacomCommonPtr common, const unsigned char* data)
+static int wcmSerialValidate(WacomCommonPtr common, const unsigned char* data)
 {
 	int i, bad = 0;
 
@@ -92,7 +92,7 @@ static int xf86WcmSerialValidate(WacomCommonPtr common, const unsigned char* dat
 		{
 			bad = 1;
 			if (i!=0 && (data[i] & HEADER_BIT)) {
-				xf86Msg(X_WARNING, "xf86WcmSerialValidate: "
+				xf86Msg(X_WARNING, "wcmSerialValidate: "
 					"bad magic at %d v=%x l=%d\n", i,
 					data[i], common->wcmPktLength);
 				return i;
@@ -162,11 +162,11 @@ static int isdv4Query(LocalDevicePtr local, const char* query, char* data)
 	}
 
 	/* Wait 250 mSecs */
-	if (xf86WcmWait(250))
+	if (wcmWait(250))
 		return !Success;
 		
 	/* Send query command to the tablet */
-	if (!xf86WcmWriteWait(local->fd, query))
+	if (!wcmWriteWait(local->fd, query))
 	{
 		xf86Msg(X_WARNING, "%s: unable to xf86WcmWrite request %s "
 			"ISDV4 query command after %d tries\n", local->name,
@@ -175,7 +175,7 @@ static int isdv4Query(LocalDevicePtr local, const char* query, char* data)
 	}
 
 	/* Read the control data */
-	if (!xf86WcmWaitForTablet(local->fd, data, WACOM_PKGLEN_TPCCTL))
+	if (!wcmWaitForTablet(local->fd, data, WACOM_PKGLEN_TPCCTL))
 	{
 		/* Try 19200 if it is not a touch query */
 		if (common->wcmISDV4Speed != 19200 && strcmp(query, WC_ISDV4_TOUCH_QUERY))
@@ -208,7 +208,7 @@ static int isdv4Query(LocalDevicePtr local, const char* query, char* data)
 		else
 		{
 			/* Reread the control data since it may fail the first time */
-			xf86WcmWaitForTablet(local->fd, data, WACOM_PKGLEN_TPCCTL);
+			wcmWaitForTablet(local->fd, data, WACOM_PKGLEN_TPCCTL);
 			if ( !(data[0] & 0x40) )
 			{
 				xf86Msg(X_WARNING, "%s: ISDV4 control data "
@@ -421,7 +421,7 @@ static int isdv4Parse(LocalDevicePtr local, const unsigned char* data)
 			/* let touch go */
 			WacomDeviceState out = { 0 };
 			out.device_type = TOUCH_ID;
-			xf86WcmEvent(common, channel, &out);
+			wcmEvent(common, channel, &out);
 		}
 	}
 
@@ -434,7 +434,7 @@ static int isdv4Parse(LocalDevicePtr local, const unsigned char* data)
 	/* Coordinate data bit check */
 	if (data[0] & 0x40) /* control data */
 		return common->wcmPktLength;
-	else if ((n = xf86WcmSerialValidate(common,data)) > 0)
+	else if ((n = wcmSerialValidate(common,data)) > 0)
 		return n;
 
 	/* pick up where we left off, minus relative values */
@@ -466,7 +466,7 @@ static int isdv4Parse(LocalDevicePtr local, const unsigned char* data)
 					if ((ds->proximity && !last->proximity) ||
 						    (!ds->proximity && last->proximity))
 						ds->sample = (int)GetTimeInMillis();
-					xf86WcmEvent(common, channel, ds);
+					wcmEvent(common, channel, ds);
 				}
 
 				channel = 1;
@@ -519,7 +519,7 @@ static int isdv4Parse(LocalDevicePtr local, const unsigned char* data)
 			{
 				/* send a prox-out for old device */
 				WacomDeviceState out = { 0 };
-				xf86WcmEvent(common, 0, &out);
+				wcmEvent(common, 0, &out);
 				ds->device_type = cur_type;
 			}
 		}
@@ -540,7 +540,7 @@ static int isdv4Parse(LocalDevicePtr local, const unsigned char* data)
 			ds->device_type == ERASER_ID ? "ERASER " :
 			ds->device_type == STYLUS_ID ? "STYLUS" : "NONE"));
 	}
-	xf86WcmEvent(common, channel, ds);
+	wcmEvent(common, channel, ds);
 	return common->wcmPktLength;
 }
 
@@ -549,7 +549,7 @@ static int isdv4Parse(LocalDevicePtr local, const unsigned char* data)
  *   send a request
  ****************************************************************************/
 
-static int xf86WcmWriteWait(int fd, const char* request)
+static int wcmWriteWait(int fd, const char* request)
 {
 	int len, maxtry = MAXTRY;
 
@@ -559,7 +559,7 @@ static int xf86WcmWriteWait(int fd, const char* request)
 		len = xf86WriteSerial(fd, request, strlen(request));
 		if ((len == -1) && (errno != EAGAIN))
 		{
-			xf86Msg(X_ERROR, "Wacom xf86WcmWriteWait error : %s", strerror(errno));
+			xf86Msg(X_ERROR, "Wacom wcmWriteWait error : %s", strerror(errno));
 			return 0;
 		}
 
@@ -571,11 +571,11 @@ static int xf86WcmWriteWait(int fd, const char* request)
 }
 
 /*****************************************************************************
- * xf86WcmWaitForTablet --
+ * wcmWaitForTablet --
  *   wait for tablet data
  ****************************************************************************/
 
-static int xf86WcmWaitForTablet(int fd, char* answer, int size)
+static int wcmWaitForTablet(int fd, char* answer, int size)
 {
 	int len, maxtry = MAXTRY;
 
diff --git a/src/wcmUSB.c b/src/wcmUSB.c
index 7f59588..03134e1 100644
--- a/src/wcmUSB.c
+++ b/src/wcmUSB.c
@@ -53,7 +53,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 	{
 		usbDetect,
 		usbWcmInit,
-		xf86WcmReadPacket,
+		wcmReadPacket,
 	};
 
 	static WacomModel usbUnknown =
@@ -84,7 +84,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -100,7 +100,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -116,7 +116,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -132,7 +132,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -148,7 +148,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -164,7 +164,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -180,7 +180,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -196,7 +196,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -244,7 +244,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterIntuos,  /* input filtering recommended */
+		wcmFilterIntuos,  /* input filtering recommended */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -260,7 +260,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterIntuos,  /* input filtering recommended */
+		wcmFilterIntuos,  /* input filtering recommended */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -276,7 +276,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterIntuos,  /* input filtering recommended */
+		wcmFilterIntuos,  /* input filtering recommended */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -292,7 +292,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterIntuos,  /* input filtering recommended */
+		wcmFilterIntuos,  /* input filtering recommended */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -308,7 +308,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -324,7 +324,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterCoord,   /* input filtering */
+		wcmFilterCoord,   /* input filtering */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -340,7 +340,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial);
 		NULL,                 /* link speed unsupported */
 		NULL,                 /* start not supported */
 		usbParse,
-		xf86WcmFilterIntuos,  /* input filtering recommended */
+		wcmFilterIntuos,  /* input filtering recommended */
 		usbDetectConfig,      /* detect hardware buttons etc */
 	};
 
@@ -810,7 +810,7 @@ static int usbChooseChannel(WacomCommonPtr common, int serial)
 			{
 				common->wcmChannel[i].work.proximity = 0;
 				/* dispatch event */
-				xf86WcmEvent(common, i, &common->wcmChannel[i].work);
+				wcmEvent(common, i, &common->wcmChannel[i].work);
 			}
 		}
 		DBG(1, common->debugLevel, xf86Msg(X_INFO, "usbParse (device with serial number: %u)"
@@ -1121,6 +1121,6 @@ static void usbParseChannel(LocalDevicePtr local, int channel)
 	}
 
 	/* dispatch event */
-	xf86WcmEvent(common, channel, ds);
+	wcmEvent(common, channel, ds);
 }
 /* vim: set noexpandtab shiftwidth=8: */
diff --git a/src/wcmValidateDevice.c b/src/wcmValidateDevice.c
index 0d5fe14..8a47659 100644
--- a/src/wcmValidateDevice.c
+++ b/src/wcmValidateDevice.c
@@ -495,7 +495,7 @@ int wcmParseOptions(LocalDevicePtr local, unsigned long* keys)
 				local->name);
 		else
 		{
-			xf86WcmSetPressureCurve(priv,a,b,c,d);
+			wcmSetPressureCurve(priv,a,b,c,d);
 		}
 	}
 
@@ -714,7 +714,7 @@ int wcmAutoProbeDevice(LocalDevicePtr local)
 	if ((!common->wcmDevice || !strcmp (common->wcmDevice, "auto-dev")))
 	{
 		common->wcmFlags |= AUTODEV_FLAG;
-		if (! (common->wcmDevice = xf86WcmEventAutoDevProbe (local)))
+		if (! (common->wcmDevice = wcmEventAutoDevProbe (local)))
 		{
 			xf86Msg(X_ERROR, "%s: unable to probe device\n",
 				local->name);
diff --git a/src/wcmXCommand.c b/src/wcmXCommand.c
index 7b40685..33ea0c0 100644
--- a/src/wcmXCommand.c
+++ b/src/wcmXCommand.c
@@ -372,7 +372,7 @@ int xf86WcmSetProperty(DeviceIntPtr dev, Atom property, XIPropertyValuePtr prop,
             return BadValue;
 
         if (!checkonly)
-            xf86WcmSetPressureCurve (priv, pcurve[0], pcurve[1],
+            wcmSetPressureCurve (priv, pcurve[0], pcurve[1],
                                      pcurve[2], pcurve[3]);
     } else if (property == prop_suppress)
     {
diff --git a/src/xf86Wacom.c b/src/xf86Wacom.c
index b073cdb..3e5d33b 100644
--- a/src/xf86Wacom.c
+++ b/src/xf86Wacom.c
@@ -924,11 +924,11 @@ Bool xf86WcmIsWacomDevice (char* fname)
 }
 
 /*****************************************************************************
- * xf86WcmEventAutoDevProbe -- Probe for right input device
+ * wcmEventAutoDevProbe -- Probe for right input device
  ****************************************************************************/
 #define DEV_INPUT_EVENT "/dev/input/event%d"
 #define EVDEV_MINORS    32
-char *xf86WcmEventAutoDevProbe (LocalDevicePtr local)
+char *wcmEventAutoDevProbe (LocalDevicePtr local)
 {
 	/* We are trying to find the right eventX device */
 	int i, wait = 0;
@@ -1046,7 +1046,7 @@ static int xf86WcmDevOpen(DeviceIntPtr pWcm)
 	{
 		/* Autoprobe if necessary */
 		if ((common->wcmFlags & AUTODEV_FLAG) &&
-		    !(common->wcmDevice = xf86WcmEventAutoDevProbe (local)))
+		    !(common->wcmDevice = wcmEventAutoDevProbe (local)))
 			xf86Msg(X_ERROR, "%s: Cannot probe device\n", local->name);
 
 		if ((xf86WcmOpen (local) != Success) || (local->fd < 0) ||
@@ -1135,19 +1135,19 @@ static void xf86WcmDevReadInput(LocalDevicePtr local)
 		DBG(10, priv->debugLevel, xf86Msg(X_INFO, "xf86WcmDevReadInput: Read (%d)\n",loop));
 }					
 
-void xf86WcmReadPacket(LocalDevicePtr local)
+void wcmReadPacket(LocalDevicePtr local)
 {
 	WacomDevicePtr priv = (WacomDevicePtr)local->private;
 	WacomCommonPtr common = priv->common;
 	int len, pos, cnt, remaining;
 	unsigned char * data;
 
-	DBG(10, common->debugLevel, xf86Msg(X_INFO, "xf86WcmReadPacket: device=%s"
+	DBG(10, common->debugLevel, xf86Msg(X_INFO, "wcmReadPacket: device=%s"
 		" fd=%d \n", common->wcmDevice, local->fd));
 
 	remaining = sizeof(common->buffer) - common->bufpos;
 
-	DBG(1, common->debugLevel, xf86Msg(X_INFO, "xf86WcmReadPacket: pos=%d"
+	DBG(1, common->debugLevel, xf86Msg(X_INFO, "wcmReadPacket: pos=%d"
 		" remaining=%d\n", common->bufpos, remaining));
 
 	/* fill buffer with as much data as we can handle */
@@ -1171,7 +1171,7 @@ void xf86WcmReadPacket(LocalDevicePtr local)
 
 	/* account for new data */
 	common->bufpos += len;
-	DBG(10, common->debugLevel, xf86Msg(X_INFO, "xf86WcmReadPacket buffer has %d bytes\n",
+	DBG(10, common->debugLevel, xf86Msg(X_INFO, "wcmReadPacket buffer has %d bytes\n",
 		common->bufpos));
 
 	pos = 0;
diff --git a/src/xf86Wacom.h b/src/xf86Wacom.h
index ee6fcba..66548b5 100644
--- a/src/xf86Wacom.h
+++ b/src/xf86Wacom.h
@@ -146,16 +146,16 @@ struct _WacomModule
 #define RESET_RELATIVE(ds) do { (ds).relwheel = 0; } while (0)
 
 /* device autoprobing */
-char *xf86WcmEventAutoDevProbe (LocalDevicePtr local);
+char *wcmEventAutoDevProbe (LocalDevicePtr local);
 
 /* common tablet initialization regime */
 int xf86WcmInitTablet(LocalDevicePtr local, const char* id, float version);
 
 /* standard packet handler */
-void xf86WcmReadPacket(LocalDevicePtr local);
+void wcmReadPacket(LocalDevicePtr local);
 
 /* handles suppression, filtering, and dispatch. */
-void xf86WcmEvent(WacomCommonPtr common, unsigned int channel, const WacomDeviceState* ds);
+void wcmEvent(WacomCommonPtr common, unsigned int channel, const WacomDeviceState* ds);
 
 /* dispatches data to XInput event system */
 void xf86WcmSendEvents(LocalDevicePtr local, const WacomDeviceState* ds);