diff options
| -rw-r--r-- | src/xf86HyperPen.c | 1789 |
1 files changed, 1789 insertions, 0 deletions
diff --git a/src/xf86HyperPen.c b/src/xf86HyperPen.c new file mode 100644 index 0000000..7c2ddc8 --- /dev/null +++ b/src/xf86HyperPen.c @@ -0,0 +1,1789 @@ +/* + * xf86HyperPen + * + * Based on the xf86Summa driver. + * + * Modified for the Aiptek HyperPen 6000 / Tevion MD 9310 + * (c) 2000 Roland Jansen <roland@lut.rwth-aachen.de> + * + * + * + * added button and 19200 bps stuff from the DigitalEdge driver on sourceforge + * (c) 2000 Christian Herzog <daduke@dataway.ch> + * + * + */ + +/* xf86Summa + * Copyright 1996 by Steven Lang <tiger@tyger.org> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Steven Lang not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. Steven Lang makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * STEVEN LANG DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL STEVEN LANG BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ +/* $XFree86: xc/programs/Xserver/hw/xfree86/input/hyperpen/xf86HyperPen.c,v 1.6 2002/02/25 20:17:23 dawes Exp $ */ + +#include <xf86Version.h> + +#if XF86_VERSION_CURRENT >= XF86_VERSION_NUMERIC(3,9,0,0,0) +#define XFREE86_V4 1 +#endif + +#ifdef XFREE86_V4 +/* post 3.9 headers */ + +#ifndef XFree86LOADER +#include <unistd.h> +#include <errno.h> +#endif + +#include <misc.h> +#include <xf86.h> +#define NEED_XF86_TYPES +#if !defined(DGUX) +#include <xf86_ansic.h> +#include <xisb.h> +#endif +#include <xf86_OSproc.h> +#include <xf86Xinput.h> +#include <exevents.h> /* Needed for InitValuator/Proximity stuff */ +#include <keysym.h> +#include <mipointer.h> + +#ifdef XFree86LOADER +#include <xf86Module.h> +#endif + +#define wait_for_fd(fd) xf86WaitForInput((fd), 1000) +#define tcflush(fd, n) xf86FlushInput((fd)) +#undef read +#define read(a,b,c) xf86ReadSerial((a),(b),(c)) +#undef write +#define write(a,b,c) xf86WriteSerial((a),(char*)(b),(c)) +#undef close +#define close(a) xf86CloseSerial((a)) +#define XCONFIG_PROBED "(==)" +#define XCONFIG_GIVEN "(**)" +#define xf86Verbose 1 +#undef PRIVATE +#define PRIVATE(x) XI_PRIVATE(x) + +/* + * Be sure to set vmin appropriately for your device's protocol. You want to + * read a full packet before returning + */ + +static const char *default_options[] = +{ + "BaudRate", "9600", + "DataBits", "8", + "StopBits", "1", + "Parity", "Odd", + "FlowControl", "Xoff", + "VTime", "10", + "VMin", "7", + NULL +}; + +static InputDriverPtr hypDrv; + + +#else /* pre 3.9 headers */ + +#include "Xos.h" +#include <signal.h> +#include <stdio.h> + +#define NEED_EVENTS +#include "X.h" +#include "Xproto.h" +#include "misc.h" +#include "inputstr.h" +#include "scrnintstr.h" +#include "XI.h" +#include "XIproto.h" + +#if defined(sun) && !defined(i386) +#define POSIX_TTY +#include <errno.h> +#include <termio.h> +#include <fcntl.h> +#include <ctype.h> + +#include "extio.h" +#else +#include "compiler.h" + +#ifdef XFree86LOADER +#include "xf86_libc.h" +#endif +#include "xf86.h" +#include "xf86Procs.h" +#include "xf86_OSlib.h" +#include "xf86_Config.h" +#include "xf86Xinput.h" +#include "atKeynames.h" +#include "xf86Version.h" +#endif + +#if !defined(sun) || defined(i386) +#include "osdep.h" +#include "exevents.h" + +#include "extnsionst.h" +#include "extinit.h" +#endif + +#if defined(__QNX__) || defined(__QNXNTO__) +#define POSIX_TTY +#endif +#endif /* pre 3.9 headers */ + +/* +** Debugging macros +*/ +#ifdef DBG +#undef DBG +#endif +#ifdef DEBUG +#undef DEBUG +#endif + +#ifndef INI_DEBUG_LEVEL +#define INI_DEBUG_LEVEL 0 +#endif + +static int debug_level = INI_DEBUG_LEVEL; +#define DEBUG 1 +#if DEBUG +#define DBG(lvl, f) {if ((lvl) <= debug_level) f;} +#else +#define DBG(lvl, f) +#endif + +/* +** Device records +*/ +#define ABSOLUTE_FLAG 1 +#define STYLUS_FLAG 2 +#define INVX_FLAG 4 +#define INVY_FLAG 8 +#define BAUD_19200_FLAG 16 + +int stylus; + +typedef struct +{ + char *hypDevice; /* device file name */ + int hypButTrans; /* button translation flags */ + int hypOldX; /* previous X position */ + int hypOldY; /* previous Y position */ + int hypOldZ; /* previous Z position */ + int hypOldProximity; /* previous proximity */ + int hypOldPush; /* previous buttons state */ + int hypOldButtons; /* previous buttons state */ + int hypOldBarrel; /* previous buttons state */ + int hypOldBarrel1; /* previous buttons state */ + int hypOldPressure; /* previous pen pressure */ + int hypMaxX; /* max X value */ + int hypMaxY; /* max Y value */ + int hypMaxZ; /* max Z value */ + int hypXSize; /* active area X size */ + int hypXOffset; /* active area X offset */ + int hypYSize; /* active area Y size */ + int hypYOffset; /* active area Y offset */ + int hypRes; /* resolution in lines per inch */ + int flags; /* various flags */ + int hypIndex; /* number of bytes read */ + int modelid; /* model id */ + int PT; /* pressure threshold */ + int AutoPT; /* automatically set PT*/ + int PMax; /* maximum pressure read from tablet */ + unsigned char hypData[7]; /* data read on the device */ +} HyperPenDeviceRec, *HyperPenDevicePtr; + +/* +** List of model IDs +*/ +static struct MODEL_ID { + unsigned id; + char* name; +} models[] = { + {0x32, "HyperPen 3000"}, + {0x43, "HyperPen 4000"}, + {0x54, "HyperPen 5000"}, + {0x64, "HyperPen 6000"}, + {0, NULL} +}; + +/* +** Configuration data +*/ +#define HYPERPEN_SECTION_NAME "HyperPen" + +#ifndef XFREE86_V4 + +#define PORT 1 +#define DEVICENAME 2 +#define THE_MODE 3 +#define CURSOR 4 +#define BORDER 5 +#define DEBUG_LEVEL 6 +#define HISTORY_SIZE 7 +#define ALWAYS_CORE 8 +#define ACTIVE_AREA 9 +#define ACTIVE_OFFSET 10 +#define INVX 11 +#define INVY 12 +#define BAUD_RATE 13 +#define PMIN 14 +#define PMAX 15 + +#if !defined(sun) || defined(i386) +static SymTabRec HypTab[] = { + {ENDSUBSECTION, "endsubsection"}, + {PORT, "port"}, + {DEVICENAME, "devicename"}, + {THE_MODE, "mode"}, + {CURSOR, "cursor"}, + {BORDER, "border"}, + {DEBUG_LEVEL, "debuglevel"}, + {HISTORY_SIZE, "historysize"}, + {ALWAYS_CORE, "alwayscore"}, + {ACTIVE_AREA, "activearea"}, + {ACTIVE_OFFSET, "activeoffset"}, + {INVX, "invx"}, + {INVY, "invy"}, + {BAUD_RATE, "baudrate"}, + {PMIN, "pmin"}, + {PMAX, "pmax"}, + {-1, ""} +}; + +#define RELATIVE 1 +#define ABSOLUTE 2 + +static SymTabRec HypModeTabRec[] = { + {RELATIVE, "relative"}, + {ABSOLUTE, "absolute"}, + {-1, ""} +}; + +#define PUCK 1 +#define STYLUS 2 + +static SymTabRec HypPointTabRec[] = { + {PUCK, "puck"}, + {STYLUS, "stylus"}, + {-1, ""} +}; + +#endif +#endif /* Pre 3.9 headers */ + +/* +** Contants and macro +*/ +#define BUFFER_SIZE 256 /* size of reception buffer */ +#define XI_NAME "HYPERPEN" /* X device name for the stylus */ + +#define SYSCALL(call) while(((call) == -1) && (errno == EINTR)) + + +#define SS_RESET "\0" /* Reset */ +#define SS_GETID "\5" /* Get Model ID */ +#define SS_CONFIG "a" /* Send configuration (max coords) */ +#define SS_PROMPT_MODE "D" /* Prompt mode */ +#define SS_STREAM_MODE "@" /* Stream mode */ +#define SS_RATE "µ" /* 19200 bps */ +#define SS_ABSOLUTE "F" /* absolute mode */ +#define SS_RELATIVE "E" /* relative mode */ +#define SS_MACROKEY "U" /* enable F-keys */ +#define SS_MACRO_4K "\2" /* start F-keys for Hyperpen 4000 */ +#define SS_MACRO_56K "\1" /* start F-keys for Hyperpen 5000/6000 */ +static const char * ss_initstr = SS_STREAM_MODE; + +#define PHASING_BIT 0x80 +#define PROXIMITY_BIT 0x40 +#define XSIGN_BIT 0x10 +#define YSIGN_BIT 0x08 +#define BUTTON_BITS 0x07 +#define COORD_BITS 0x7f +#define XAXIS_BITS 0x03 +#define YAXIS_BITS 0x0C +#define ZMASK_BIT 0x70 +#define TIP_BITS 0x01 +#define F_BIT 0x20 + + +/* macro from counts/inch to counts/meter */ +#define LPI2CPM(res) (res * 1000 / 25.4) + +/* +** External declarations +*/ + +#ifndef XFREE86_V4 + +#if defined(sun) && !defined(i386) +#define ENQUEUE suneqEnqueue +#else +#define ENQUEUE xf86eqEnqueue + +extern void xf86eqEnqueue( +#if NeedFunctionPrototypes + xEventPtr /*e */ +#endif + ); +#endif + +extern void miPointerDeltaCursor( +#if NeedFunctionPrototypes + int /*dx */ , + int /*dy */ , + unsigned long /*time */ +#endif + ); + + +#ifndef XFREE86_V4 +/* + *************************************************************************** + * + * set_serial_speed -- + * + * Set speed of the serial port. + * + *************************************************************************** + */ +static int +set_serial_speed(int fd, int speed_code) +{ + struct termios termios_tty; + int err; +#ifdef POSIX_TTY + SYSCALL(err = tcgetattr(fd, &termios_tty)); + if (err == -1) { + ErrorF("HyperPen tcgetattr error : %s\n", strerror(errno)); + return !Success; + } + termios_tty.c_iflag = IXOFF; + termios_tty.c_oflag = 0; + termios_tty.c_cflag = speed_code|CS8|CREAD|CLOCAL|HUPCL|PARENB|PARODD; + termios_tty.c_lflag = 0; + termios_tty.c_cc[VINTR] = 0; + termios_tty.c_cc[VQUIT] = 0; + termios_tty.c_cc[VERASE] = 0; + termios_tty.c_cc[VEOF] = 0; +#ifdef VWERASE + termios_tty.c_cc[VWERASE] = 0; +#endif +#ifdef VREPRINT + termios_tty.c_cc[VREPRINT] = 0; +#endif + termios_tty.c_cc[VKILL] = 0; + termios_tty.c_cc[VEOF] = 0; + termios_tty.c_cc[VEOL] = 0; +#ifdef VEOL2 + termios_tty.c_cc[VEOL2] = 0; +#endif + termios_tty.c_cc[VSUSP] = 0; +#ifdef VDSUSP + termios_tty.c_cc[VDSUSP] = 0; +#endif +#ifdef VDISCARD + termios_tty.c_cc[VDISCARD] = 0; +#endif +#ifdef VLNEXT + termios_tty.c_cc[VLNEXT] = 0; +#endif + /* minimum 1 character in one read call and timeout to 100 ms */ + termios_tty.c_cc[VMIN] = 1; + termios_tty.c_cc[VTIME] = 10; + SYSCALL(err = tcsetattr(fd, TCSANOW, &termios_tty)); + if (err == -1) { + ErrorF("HyperPen tcsetattr TCSANOW error : %s\n", strerror(errno)); + return !Success; + } +#else + Code for OSs without POSIX tty functions +#endif + return Success; +} +#endif /* Pre 3.9 stuff */ + +#if !defined(sun) || defined(i386) +/* +** xf86HypConfig +** Reads the HyperPen section from the XF86Config file +*/ +static Bool +xf86HypConfig(LocalDevicePtr *array, int inx, int max, LexPtr val) +{ + LocalDevicePtr dev = array[inx]; + HyperPenDevicePtr priv = (HyperPenDevicePtr)(dev->private); + int token; + int mtoken; + + DBG(1, ErrorF("xf86HypConfig\n")); + + priv->AutoPT=1; + priv->PMax=1000; + + while ((token = xf86GetToken(HypTab)) != ENDSUBSECTION) { + switch(token) { + case DEVICENAME: + if (xf86GetToken(NULL) != STRING) + xf86ConfigError("Option string expected"); + else { + dev->name = strdup(val->str); + if (xf86Verbose) + ErrorF("%s HyperPen X device name is %s\n", XCONFIG_GIVEN, + dev->name); + } + break; + + case PORT: + if (xf86GetToken(NULL) != STRING) + xf86ConfigError("Option string expected"); + else { + priv->hypDevice = strdup(val->str); + if (xf86Verbose) + ErrorF("%s HyperPen port is %s\n", XCONFIG_GIVEN, + priv->hypDevice); + } + break; + + case THE_MODE: + mtoken = xf86GetToken(HypModeTabRec); + if ((mtoken == EOF) || (mtoken == STRING) || (mtoken == NUMBER)) + xf86ConfigError("Mode type token expected"); + else { + switch (mtoken) { + case ABSOLUTE: + priv->flags |= ABSOLUTE_FLAG; + break; + case RELATIVE: + priv->flags &= ~ABSOLUTE_FLAG; + break; + default: + xf86ConfigError("Illegal Mode type"); + break; + } + } + break; + + case CURSOR: + mtoken = xf86GetToken(HypPointTabRec); + if ((mtoken == EOF) || (mtoken == STRING) || (mtoken == NUMBER)) + xf86ConfigError("Cursor token expected"); + else { + switch (mtoken) { + case STYLUS: + priv->flags |= STYLUS_FLAG; + break; + case PUCK: + priv->flags &= ~STYLUS_FLAG; + break; + default: + xf86ConfigError("Illegal cursor type"); + break; + } + } + break; + + case DEBUG_LEVEL: + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + debug_level = val->num; + if (xf86Verbose) { +#if DEBUG + ErrorF("%s HyperPen debug level set to %d\n", XCONFIG_GIVEN, + debug_level); +#else + ErrorF("%s HyperPen debug level not set to %d because" + " debugging is not compiled with the xf86HyperPen driver\n", XCONFIG_GIVEN, + debug_level); +#endif + } + break; + + case HISTORY_SIZE: + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + dev->history_size = val->num; + if (xf86Verbose) + ErrorF("%s HyperPen Motion history size is %d\n", XCONFIG_GIVEN, + dev->history_size); + break; + + case ALWAYS_CORE: + xf86AlwaysCore(dev, TRUE); + if (xf86Verbose) + ErrorF("%s HyperPen device always stays core pointer\n", + XCONFIG_GIVEN); + break; + + case ACTIVE_AREA: + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + priv->hypXSize = val->realnum * 100; + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + priv->hypYSize = val->realnum * 100; + if (xf86Verbose) + ErrorF("%s HyperPen active area: %d.%02dx%d.%02d" + " inches\n", XCONFIG_GIVEN, priv->hypXSize / 100, + priv->hypXSize % 100, priv->hypYSize / 100, + priv->hypYSize % 100); + break; + + case ACTIVE_OFFSET: + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + priv->hypXOffset = val->realnum * 100; + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + priv->hypYOffset = val->realnum * 100; + if (xf86Verbose) + ErrorF("%s HyperPen active area offsets: %d.%02d %d.%02d" + " inches\n", XCONFIG_GIVEN, priv->hypXOffset / 100, + priv->hypXOffset % 100, priv->hypYOffset / 100, + priv->hypYOffset % 100); + break; + case INVX: + priv->flags |= INVX_FLAG; + break; + case INVY: + priv->flags |= INVY_FLAG; + break; + case BAUD_RATE: + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + switch (val->num) { + case 19200: + priv->flags |= BAUD_19200_FLAG; + break; + case 9600: + priv->flags &= ~BAUD_19200_FLAG; + break; + default: + xf86ConfigError("Illegal speed value"); + break; + } + break; + case PMIN: + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + if (val->num < 2) + xf86ConfigError("Illegal minimum pressure"); + else + { + priv->AutoPT = 0; /* desactivate auto threshold adjustment*/ + priv->PT = val->num; + }; + break; + case PMAX: + if (xf86GetToken(NULL) != NUMBER) + xf86ConfigError("Option number expected"); + if (val->num < 3) + xf86ConfigError("Illegal maximum pressure"); + else + priv->PMax = val->num; + break; + case EOF: + FatalError("Unexpected EOF (missing EndSubSection)"); + break; + + default: + xf86ConfigError("HyperPen subsection keyword expected"); + break; + } + } + + DBG(1, ErrorF("xf86HypConfig name=%s\n", priv->hypDevice)); + + return Success; +} +#endif +#endif /* pre 3.9 headers */ + +/* +** xf86HypConvert +** Convert valuators to X and Y. +*/ +static Bool +xf86HypConvert(LocalDevicePtr local, + int first, + int num, + int v0, + int v1, + int v2, + int v3, + int v4, + int v5, + int* x, + int* y) +{ + HyperPenDevicePtr priv = (HyperPenDevicePtr) local->private; + + if (first != 0 || num == 1) + return FALSE; + *x = (v0 * screenInfo.screens[0]->width) / priv->hypXSize; + *y = (v1 * screenInfo.screens[0]->height) / priv->hypYSize; + if (priv->flags & INVX_FLAG) + *x = screenInfo.screens[0]->width - *x; + if (*x < 0) + *x = 0; + if (priv->flags & INVY_FLAG) + *y = screenInfo.screens[0]->height - *y; + if (*y < 0) + *y = 0; + if (*x > screenInfo.screens[0]->width) + *x = screenInfo.screens[0]->width; + if (*y > screenInfo.screens[0]->height) + *y = screenInfo.screens[0]->height; + + + + return TRUE; +} + +/* +** xf86HypReverseConvert +** Convert X and Y to valuators. +*/ +static Bool +xf86HypReverseConvert(LocalDevicePtr local, + int x, + int y, + int *valuators) +{ + HyperPenDevicePtr priv = (HyperPenDevicePtr) local->private; + valuators[0] = ((x * priv->hypXSize) / screenInfo.screens[0]->width); + valuators[1] = ((y * priv->hypYSize) / screenInfo.screens[0]->height); + + + + return TRUE; +} + +/* +** xf86HypReadInput +** Reads from the HyperPen and posts any new events to the server. +*/ +static void +xf86HypReadInput(LocalDevicePtr local) +{ + HyperPenDevicePtr priv = (HyperPenDevicePtr) local->private; + int len, loop; + int is_core_pointer, is_absolute; + int f_keys, f_key, tip; + int x, y, bx, by, barrel, barrel1, prox, pressure, button, push; + int hw_pressure; + + DeviceIntPtr device; + unsigned char buffer[BUFFER_SIZE]; + + + + + SYSCALL(len = read(local->fd, buffer, sizeof(buffer))); + + if (len <= 0) { + Error("error reading HyperPen device"); + return; + } else { + + } + + for(loop=0; loop<len; loop++) { + + if ((priv->hypIndex == 0) && !(buffer[loop] & PHASING_BIT)) { /* magic bit is not OK */ + DBG(6, ErrorF("xf86HypReadInput bad magic number 0x%x\n", buffer[loop]));; + continue; + } + + priv->hypData[priv->hypIndex++] = buffer[loop]; + + if (priv->hypIndex == (priv->flags & ABSOLUTE_FLAG? 7 : 5)) { +/* the packet is OK */ +/* reset char count for next read */ + priv->hypIndex = 0; + + prox = (priv->hypData[0] & PROXIMITY_BIT)? 0: 1; + tip = (priv->hypData[0] & TIP_BITS)? 1:0; + button = (priv->hypData[0] & BUTTON_BITS); + + f_keys = (priv->hypData[0] & F_BIT); + pressure = (int) priv->hypData[6] + (((int) priv->hypData[5] & ZMASK_BIT) << 3); + + if ((tip==0) && (button==0) && (pressure>2) && (pressure != 1022)) {priv->flags |= STYLUS_FLAG; stylus=1;} else + if ((tip==0) && (button==0) && (pressure==0)) {priv->flags &= ~STYLUS_FLAG; stylus=0; pressure = 1019;} + +is_absolute = stylus; + + x = priv->hypData[1] + (priv->hypData[2] << 7) + ((priv->hypData[5] & XAXIS_BITS) << 14); + y = priv->hypData[3] + (priv->hypData[4] << 7) + ((priv->hypData[5] & YAXIS_BITS) << 12); + + if ((f_keys) && (tip)) (f_key = ((x >> 7) + 1) >> 1); else f_key =0; + + x -= priv->hypXOffset; + y = priv->hypYSize - y + priv->hypYOffset; + if (x < 0) x = 0; + if (y < 0) y = 0; + if (x > priv->hypXSize) x = priv->hypXSize; + if (y > priv->hypYSize) y = priv->hypYSize; + bx=x; + by=y; + + if (!is_absolute) { + x -= priv->hypOldX; + y -= priv->hypOldY; + } + + + + + + + hw_pressure=pressure; + + + if (!priv->PMax) priv->PMax=1000; + if (pressure>1020) pressure=priv->PT; + if (priv->AutoPT) + { + if ((pressure>1) && !(tip)) priv->PT = pressure; + pressure = 511 * (pressure - priv->PT - 10) / (priv->PMax - priv->PT); + } + else + { + pressure = 511 * (pressure - priv->PT) / (priv->PMax - priv->PT); + button &= ~1; + if (pressure>0) button |=1; + + }; + + + if (pressure > 511) pressure = 511; + if (pressure < 0) pressure = 0; + + + + push = button & 1; + barrel = button & 2; + barrel1 = button & 4; + + DBG(6, ErrorF("hw-press=%d\ttip=%d\tbarrel=%d\tbarrel1=%d\tpush=%d\tpressure=%d\tPT=%d\tbuttons=%d\tf-key=%d\n",hw_pressure, priv->hypData[0] & TIP_BITS, barrel, barrel1, push, pressure, priv->PT, priv->hypData[0] & BUTTON_BITS,f_key)); + + device = local->dev; + + + + + is_core_pointer = xf86IsCorePointer(device); + +/* coordonates are ready we can send events */ + + if ((prox) && !(f_keys)) { + if (!(priv->hypOldProximity)) + if (!is_core_pointer) + xf86PostProximityEvent(device, 1, 0, 3, x, y, pressure); + + if ((is_absolute && ((priv->hypOldX != x) || + (priv->hypOldY != y) || + (priv->hypOldZ != pressure))) + || (!is_absolute && (x || y))) { + if (is_absolute || priv->hypOldProximity) { + xf86PostMotionEvent(device, is_absolute, 0, 3, x, y, pressure); + } + } + + + + if (priv->hypOldBarrel1 != barrel1) { + int delta; + delta = barrel1 - priv->hypOldBarrel1; + if (priv->hypOldBarrel1 != barrel1) { + + + + xf86PostButtonEvent(device, is_absolute, 2, (delta > 0), 0, 3, x, y, pressure); + } + } + + if (priv->hypOldBarrel != barrel) { + int delta; + delta = barrel - priv->hypOldBarrel; + if (priv->hypOldBarrel != barrel) { + + xf86PostButtonEvent(device, is_absolute, 3, (delta > 0), 0, 3, x, y, pressure); + } + } + + if ((priv->hypOldPush != push) && !barrel && !barrel1) { + int delta; + delta = push - priv->hypOldPush; + if (priv->hypOldPush != push) { + + xf86PostButtonEvent(device, is_absolute, 1, (delta > 0), 0, 3, x, y, pressure); + } + } + + + priv->hypOldX = bx; + priv->hypOldY = by; + priv->hypOldPush = push; + priv->hypOldBarrel = barrel; + priv->hypOldBarrel1 = barrel1; + priv->hypOldProximity = prox; + + + } else { /* !PROXIMITY */ +/* Any changes in buttons are ignored when !proximity */ + if (!is_core_pointer) + if (priv->hypOldProximity) + xf86PostProximityEvent(device, 0, 0, 3, x, y, pressure); + priv->hypOldProximity = 0; + } + } + } + + +} + +/* +** xf86HypControlProc +** It really does do something. Honest! +*/ +static void +xf86HypControlProc(DeviceIntPtr device, PtrCtrl *ctrl) +{ + DBG(2, ErrorF("xf86HypControlProc\n")); +} + +/* +** xf86HypWriteAndRead +** Write data, and get the response. +*/ +static char * +xf86HypWriteAndRead(int fd, char *data, char *buffer, int len, int cr_term) +{ + int err, numread = 0; +#ifndef XFREE86_V4 + fd_set readfds; + struct timeval timeout; +#endif + + SYSCALL(err = write(fd, data, strlen(data))); + if (err == -1) { + Error("HyperPen write"); + return NULL; + } + +#ifndef XFREE86_V4 + FD_ZERO(&readfds); + FD_SET(fd, &readfds); +#endif + while (numread < len) { +#ifndef XFREE86_V4 + timeout.tv_sec = 0; + timeout.tv_usec = 100000; + + SYSCALL(err = select(FD_SETSIZE, &readfds, NULL, NULL, &timeout)); +#else + err = xf86WaitForInput(fd, 100000); +#endif + if (err == -1) { + Error("HyperPen select"); + return NULL; + } + if (!err) { + ErrorF("Timeout while reading HyperPen tablet. No tablet connected ???\n"); + return NULL; + } + + SYSCALL(err = read(fd, buffer + numread++, 1)); + if (err == -1) { + Error("HyperPen read"); + return NULL; + } + if (!err) { + --numread; + break; + } + if (cr_term && buffer[numread - 1] == '\r') { + buffer[numread - 1] = 0; + break; + } + } + buffer[numread] = 0; + return buffer; +} + +/* +** xf86HypOpen +** Open and initialize the tablet, as well as probe for any needed data. +*/ + +#ifdef XFREE86_V4 +#define WAIT(t) \ + err = xf86WaitForInput(-1, ((t) * 1000)); \ + if (err == -1) { \ + ErrorF("HyperPen select error : %s\n", strerror(errno)); \ + return !Success; \ + } +#else +#define WAIT(t) \ + timeout.tv_sec = 0; \ + timeout.tv_usec = (t) * 1000; \ + SYSCALL(err = select(0, NULL, NULL, NULL, &timeout)); \ + if (err == -1) { \ + ErrorF("HyperPen select error : %s\n", strerror(errno)); \ + return !Success; \ + } +#endif + +static Bool +xf86HypOpen(LocalDevicePtr local) +{ +#ifndef XFREE86_V4 + struct termios termios_tty; + struct timeval timeout; +#endif + char buffer[256]; + int err, idx; + int i, n; + double res100; + double sratio, tratio; + HyperPenDevicePtr priv = (HyperPenDevicePtr)local->private; + + DBG(1, ErrorF("opening %s\n", priv->hypDevice)); + +#ifdef XFREE86_V4 + local->fd = xf86OpenSerial(local->options); +#else + SYSCALL(local->fd = open(priv->hypDevice, O_RDWR | O_NDELAY, 0)); +#endif + if (local->fd == -1) { + Error(priv->hypDevice); + return !Success; + } + DBG(2, ErrorF("%s opened as fd %d\n", priv->hypDevice, local->fd)); + +#ifdef XFREE86_V4 + if (xf86SetSerialSpeed(local->fd, 9600) < 0) + return !Success; +#else + if (set_serial_speed(local->fd, B9600) == !Success) + return !Success; +#endif + + DBG(1, ErrorF("initializing HyperPen tablet\n")); + +/* Send reset to the tablet */ + + write(local->fd, SS_RESET, strlen(SS_RESET)); + WAIT(1000); + +/* Put it in prompt mode so it doesn't say anything before we're ready */ + SYSCALL(err = write(local->fd, SS_PROMPT_MODE, strlen(SS_PROMPT_MODE))); + if (err == -1) { + Error("HyperPen write"); + return !Success; + } +/* Clear any pending input */ + tcflush(local->fd, TCIFLUSH); + + DBG(2, ErrorF("reading model\n")); + + if (!xf86HypWriteAndRead(local->fd, SS_GETID, buffer, 1, 0)) + return !Success; + + priv->modelid=buffer[0]; + + for (n = -1, i = 0; models[i].id != 0; i++) + if (models[i].id == priv->modelid) + n = i; + + if (xf86Verbose) + ErrorF("%s HyperPen Model: 0x%x (%s)\n", + XCONFIG_PROBED, priv->modelid, n==-1? "UNKNOWN":models[n].name); + + + /* enable F-Keys */ + SYSCALL(err = write(local->fd, SS_MACROKEY, strlen(SS_MACROKEY))); + if (err == -1) { + ErrorF("HyperPen write error : %s\n", strerror(errno)); + return !Success; + } + + DBG(6, ErrorF("prepared F-keys\n")); + + /* start sequence depends on model ID */ + if (priv->modelid == 0x43) SYSCALL(err = write(local->fd, SS_MACRO_4K, strlen(SS_MACRO_4K))); else SYSCALL(err = write(local->fd, SS_MACRO_56K, strlen(SS_MACRO_56K))); + + if (err == -1) { + ErrorF("HyperPen write error : %s\n", strerror(errno)); + return !Success; + } + + DBG(6, ErrorF("started F-keys\n")); + + + + priv->hypRes = 500; + res100 = priv->hypRes / 100; + + DBG(2, ErrorF("reading max coordinates\n")); + + if (!xf86HypWriteAndRead(local->fd, SS_CONFIG, buffer, 5, 0)) + return !Success; + + priv->hypMaxX = (buffer[1] & 0x7f) | (buffer[2] << 7); + priv->hypMaxY = (buffer[3] & 0x7f) | (buffer[4] << 7); + priv->hypMaxZ = 512; + +if (xf86Verbose) + ErrorF("%s HyperPen max tablet size %d.%02dinx%d.%02din, %dx%d " + "lines of resolution\n", XCONFIG_PROBED, + priv->hypMaxX / priv->hypRes, + (priv->hypMaxX * 100 / priv->hypRes) % 100, + priv->hypMaxY / priv->hypRes, + (priv->hypMaxY * 100 / priv->hypRes) % 100, + priv->hypMaxX, priv->hypMaxY); + + if (priv->hypXOffset >= 0 && priv->hypYOffset >= 0) { + priv->hypXOffset *= res100; + priv->hypYOffset *= res100; + priv->hypMaxX -= priv->hypXOffset; + priv->hypMaxY -= priv->hypYOffset; + } + + if (priv->hypXSize > 0 && priv->hypYSize > 0) { + if ((priv->hypXSize * res100) <= priv->hypMaxX && + (priv->hypYSize * res100) <= priv->hypMaxY) { + priv->hypXSize *= res100; + priv->hypYSize *= res100; + } else { + ErrorF("%s HyperPen active area bigger than tablet, " + "assuming maximum\n", XCONFIG_PROBED); + priv->hypXSize = priv->hypMaxX; + priv->hypYSize = priv->hypMaxY; + } + } else { + priv->hypXSize = priv->hypMaxX; + priv->hypYSize = priv->hypMaxY; + } + + /* map tablet area by screen aspect ratio */ + sratio = (double)screenInfo.screens[0]->height / + (double)screenInfo.screens[0]->width; + tratio = (double)priv->hypMaxY / (double)priv->hypMaxX; + + if (tratio <= 1.0) { /* tablet horizontal > vertical */ + priv->hypXSize = (double)priv->hypYSize / sratio; + if (priv->hypXSize > priv->hypMaxX) priv->hypXSize = priv->hypMaxX; + } + else { + priv->hypYSize = (double)priv->hypXSize / sratio; + if (priv->hypYSize > priv->hypMaxY) priv->hypYSize = priv->hypMaxY; + } + ErrorF("%s HyperPen using tablet area %d by %d, at res %d lpi\n", + XCONFIG_PROBED, priv->hypXSize, priv->hypYSize, priv->hypRes); + + if (priv->flags & BAUD_19200_FLAG) { +/* Send 19200 baud to the tablet */ + SYSCALL(err = write(local->fd, SS_RATE, strlen(SS_RATE))); + if (err == -1) { + ErrorF("HyperPen write error : %s\n", strerror(errno)); + return !Success; + } + + DBG(6, ErrorF("tablet set to 19200 bps\n")); + + + /* Wait 10 mSecs */ + WAIT(10); + + /* Set the speed of the serial link to 19200 */ +#ifdef XFREE86_V4 + if (xf86SetSerialSpeed(local->fd, 19200) < 0) { + return !Success; + } +#else + if (set_serial_speed(local->fd, B19200) == !Success) + return !Success; +#endif + + DBG(6, ErrorF("set serial speed to 19200\n")); + } + + + +/* Sets up the tablet mode to increment, stream, and such */ + for (idx = 0; ss_initstr[idx]; idx++) { + buffer[idx] = ss_initstr[idx]; + } + + buffer[idx] = 0; + + SYSCALL(err = write(local->fd, buffer, idx)); + + + + if (err == -1) { + Error("HyperPen write"); + return !Success; + } + + if (err <= 0) { + SYSCALL(close(local->fd)); + return !Success; + } + return Success; +} + +/* +** xf86HypOpenDevice +** Opens and initializes the device driver stuff or something. +*/ +static int +xf86HypOpenDevice(DeviceIntPtr pHyp) +{ + LocalDevicePtr local = (LocalDevicePtr)pHyp->public.devicePrivate; + HyperPenDevicePtr priv = (HyperPenDevicePtr)PRIVATE(pHyp); + + if (xf86HypOpen(local) != Success) { + if (local->fd >= 0) { + SYSCALL(close(local->fd)); + } + local->fd = -1; + } + +/* Set the real values */ + InitValuatorAxisStruct(pHyp, + 0, + 0, /* min val */ + priv->hypXSize, /* max val */ + LPI2CPM(priv->hypRes), /* resolution */ + 0, /* min_res */ + LPI2CPM(priv->hypRes)); /* max_res */ + InitValuatorAxisStruct(pHyp, + 1, + 0, /* min val */ + priv->hypYSize, /* max val */ + LPI2CPM(priv->hypRes), /* resolution */ + 0, /* min_res */ + LPI2CPM(priv->hypRes)); /* max_res */ + InitValuatorAxisStruct(pHyp, + 2, + 0, /* min val */ + 511, /* max val */ + 512, /* resolution */ + 0, /* min_res */ + 512); /* max_res */ + return (local->fd != -1); +} + +/* +** xf86HypProc +** Handle requests to do stuff to the driver. +*/ +static int +xf86HypProc(DeviceIntPtr pHyp, int what) +{ + CARD8 map[25]; + int nbaxes; + int nbbuttons; + int loop; + LocalDevicePtr local = (LocalDevicePtr)pHyp->public.devicePrivate; + HyperPenDevicePtr priv = (HyperPenDevicePtr)PRIVATE(pHyp); + + + + switch (what) { + case DEVICE_INIT: + DBG(1, ErrorF("xf86HypProc pHyp=0x%x what=INIT\n", pHyp)); + + nbaxes = 3; /* X, Y, Z */ + nbbuttons = (priv->flags & STYLUS_FLAG)? 3 : 4; + + for(loop=1; loop<=nbbuttons; loop++) map[loop] = loop; + + if (InitButtonClassDeviceStruct(pHyp, + nbbuttons, + map) == FALSE) { + ErrorF("unable to allocate Button class device\n"); + return !Success; + } + + if (InitFocusClassDeviceStruct(pHyp) == FALSE) { + ErrorF("unable to init Focus class device\n"); + return !Success; + } + + if (InitPtrFeedbackClassDeviceStruct(pHyp, + xf86HypControlProc) == FALSE) { + ErrorF("unable to init ptr feedback\n"); + return !Success; + } + + if (InitProximityClassDeviceStruct(pHyp) == FALSE) { + ErrorF("unable to init proximity class device\n"); + return !Success; + } + + if (InitValuatorClassDeviceStruct(pHyp, + nbaxes, + xf86GetMotionEvents, + local->history_size, + (priv->flags & ABSOLUTE_FLAG)? Absolute: Relative) + == FALSE) { + ErrorF("unable to allocate Valuator class device\n"); + return !Success; + } +/* allocate the motion history buffer if needed */ + xf86MotionHistoryAllocate(local); +#ifndef XFREE86_V4 + AssignTypeAndName(pHyp, local->atom, local->name); +#endif +/* open the device to gather informations */ + xf86HypOpenDevice(pHyp); + break; + + case DEVICE_ON: + DBG(1, ErrorF("xf86HypProc pHyp=0x%x what=ON\n", pHyp)); + + if ((local->fd < 0) && (!xf86HypOpenDevice(pHyp))) { + return !Success; + } +#ifdef XFREE86_V4 + xf86AddEnabledDevice(local); +#else + AddEnabledDevice(local->fd); +#endif + pHyp->public.on = TRUE; + break; + + case DEVICE_OFF: + DBG(1, ErrorF("xf86HypProc pHyp=0x%x what=%s\n", pHyp, + (what == DEVICE_CLOSE) ? "CLOSE" : "OFF")); + if (local->fd >= 0) +#ifdef XFREE86_V4 + xf86RemoveEnabledDevice(local); +#else + RemoveEnabledDevice(local->fd); +#endif + pHyp->public.on = FALSE; + break; + + case DEVICE_CLOSE: + DBG(1, ErrorF("xf86HypProc pHyp=0x%x what=%s\n", pHyp, + (what == DEVICE_CLOSE) ? "CLOSE" : "OFF")); + SYSCALL(close(local->fd)); + local->fd = -1; + break; + + default: + ErrorF("unsupported mode=%d\n", what); + return !Success; + break; + } + DBG(2, ErrorF("END xf86HypProc Success what=%d dev=0x%x priv=0x%x\n", + what, pHyp, priv)); + return Success; +} + +/* +** xf86HypClose +** It... Uh... Closes the physical device? +*/ +static void +xf86HypClose(LocalDevicePtr local) +{ + if (local->fd >= 0) { + SYSCALL(close(local->fd)); + } + local->fd = -1; +} + +/* +** xf86HypChangeControl +** When I figure out what it does, it will do it. +*/ +static int +xf86HypChangeControl(LocalDevicePtr local, xDeviceCtl *control) +{ + xDeviceResolutionCtl *res; + + res = (xDeviceResolutionCtl *)control; + + if ((control->control != DEVICE_RESOLUTION) || + (res->num_valuators < 1)) + return (BadMatch); + + return(Success); +} + +/* +** xf86HypSwitchMode +** Switches the mode. For now just absolute or relative, hopefully +** more on the way. +*/ +static int +xf86HypSwitchMode(ClientPtr client, DeviceIntPtr dev, int mode) +{ + LocalDevicePtr local = (LocalDevicePtr)dev->public.devicePrivate; + HyperPenDevicePtr priv = (HyperPenDevicePtr)(local->private); + char newmode; + + DBG(3, ErrorF("xf86HypSwitchMode dev=0x%x mode=%d\n", dev, mode)); + + switch(mode) { + case Absolute: + priv->flags |= ABSOLUTE_FLAG; + + break; + + case Relative: + priv->flags &= ~ABSOLUTE_FLAG; + + break; + + default: + DBG(1, ErrorF("xf86HypSwitchMode dev=0x%x invalid mode=%d\n", + dev, mode)); + return BadMatch; + } + SYSCALL(write(local->fd, &newmode, 1)); + return Success; +} + +/* +** xf86HypAllocate +** Allocates the device structures for the HyperPen. +*/ +static LocalDevicePtr +xf86HypAllocate(void) +{ +#ifdef XFREE86_V4 + LocalDevicePtr local = xf86AllocateInput(hypDrv, 0); +#else + LocalDevicePtr local = (LocalDevicePtr)xalloc(sizeof(LocalDeviceRec)); +#endif + HyperPenDevicePtr priv = (HyperPenDevicePtr)xalloc(sizeof(HyperPenDeviceRec)); +#if defined (sun) && !defined(i386) + char *dev_name = getenv("HYPERPEN_DEV"); +#endif + + local->name = XI_NAME; + local->type_name = "HyperPen Tablet"; + local->flags = 0; /*XI86_NO_OPEN_ON_INIT;*/ +#ifndef XFREE86_V4 +#if !defined(sun) || defined(i386) + local->device_config = xf86HypConfig; +#endif +#endif + local->device_control = xf86HypProc; + local->read_input = xf86HypReadInput; + local->control_proc = xf86HypChangeControl; + local->close_proc = xf86HypClose; + local->switch_mode = xf86HypSwitchMode; + local->conversion_proc = xf86HypConvert; + local->reverse_conversion_proc = xf86HypReverseConvert; + local->fd = -1; + local->atom = 0; + local->dev = NULL; + local->private = priv; + local->private_flags = 0; + local->history_size = 0; + +#if defined(sun) && !defined(i386) + if (dev_name) { + priv->hypDevice = (char *)xalloc(strlen(dev_name) + 1); + strcpy(priv->hypDevice, dev_name); + ErrorF("xf86HypOpen port changed to '%s'\n", priv->hypDevice); + } else { + priv->hypDevice = ""; + } +#else + priv->hypDevice = ""; /* device file name */ +#endif + priv->hypOldX = -1; /* previous X position */ + priv->hypOldY = -1; /* previous Y position */ + priv->hypOldProximity = 0; /* previous proximity */ + priv->hypOldButtons = 0; /* previous buttons state */ + priv->hypMaxX = -1; /* max X value */ + priv->hypMaxY = -1; /* max Y value */ + priv->hypXSize = -1; /* active area X */ + priv->hypXOffset = 0; /* active area X offset */ + priv->hypYSize = -1; /* active area Y */ + priv->hypYOffset = 0; /* active area Y offset */ + priv->flags = ABSOLUTE_FLAG; /* various flags -- default abs format */ + priv->hypIndex = 0; /* number of bytes read */ + priv->hypRes = 0; /* resolution */ + stylus=0; + + return local; +} + +#ifndef XFREE86_V4 + +/* +** HyperPen device association +** Device section name and allocation function. +*/ +DeviceAssocRec hypmasketch_assoc = +{ + HYPERPEN_SECTION_NAME, /* config_section_name */ + xf86HypAllocate /* device_allocate */ +}; + +#ifdef DYNAMIC_MODULE +/* +** init_module +** Entry point for dynamic module. +*/ +int +#ifndef DLSYM_BUG +init_module(unsigned long server_version) +#else +init_xf86HyperPen(unsigned long server_version) +#endif +{ + xf86AddDeviceAssoc(&hypmasketch_assoc); + + if (server_version != XF86_VERSION_CURRENT) { + ErrorF("Warning: HyperPen module compiled for version %s\n", + XF86_VERSION); + return 0; + } else { + return 1; + } +} +#endif + +#ifdef XFree86LOADER +/* + * Entry point for the loader code + */ +XF86ModuleVersionInfo xf86HyperPenVersion = { + "hyperpen", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XF86_VERSION_CURRENT, + 0x00010000, + {0,0,0,0} +}; + +void +xf86HyperPenModuleInit(data, magic) + pointer *data; + INT32 *magic; +{ + static int cnt = 0; + + switch (cnt) { + case 0: + *magic = MAGIC_VERSION; + *data = &xf86HyperPenVersion; + cnt++; + break; + + case 1: + *magic = MAGIC_ADD_XINPUT_DEVICE; + *data = &hypmasketch_assoc; + cnt++; + break; + + default: + *magic = MAGIC_DONE; + *data = NULL; + break; + } +} +#endif + +#else + +/* + * xf86HypUninit -- + * + * called when the driver is unloaded. + */ +static void +xf86HypUninit(InputDriverPtr drv, + LocalDevicePtr local, + int flags) +{ + HyperPenDevicePtr priv = (HyperPenDevicePtr) local->private; + + DBG(1, ErrorF("xf86HypUninit\n")); + + xf86HypProc(local->dev, DEVICE_OFF); + + xfree (priv); + xf86DeleteInput(local, 0); +} + + +/* + * xf86HypInit -- + * + * called when the module subsection is found in XF86Config + */ +static InputInfoPtr +xf86HypInit(InputDriverPtr drv, + IDevPtr dev, + int flags) +{ + LocalDevicePtr local = NULL; + HyperPenDevicePtr priv = NULL; + char *s; + + hypDrv = drv; + + local = xf86HypAllocate(); + local->conf_idev = dev; + + xf86CollectInputOptions(local, default_options, NULL); + xf86OptionListReport( local->options ); + + if (local) + priv = (HyperPenDevicePtr) local->private; + + if (!local || !priv) { + goto SetupProc_fail; + } + + local->name = dev->identifier; + + /* Serial Device is mandatory */ + priv->hypDevice = xf86FindOptionValue(local->options, "Device"); + + if (!priv->hypDevice) { + xf86Msg (X_ERROR, "%s: No Device specified.\n", dev->identifier); + goto SetupProc_fail; + } + + /* Process the common options. */ + xf86ProcessCommonOptions(local, local->options); + + /* Optional configuration */ + + xf86Msg(X_CONFIG, "%s serial device is %s\n", dev->identifier, + priv->hypDevice); + + debug_level = xf86SetIntOption(local->options, "DebugLevel", 0); + if (debug_level > 0) { + xf86Msg(X_CONFIG, "%s: debug level set to %d\n", dev->identifier, debug_level); + } + + + + s = xf86FindOptionValue(local->options, "Mode"); + + if (s && (xf86NameCmp(s, "absolute") == 0)) { + priv->flags = priv->flags | ABSOLUTE_FLAG; + } + else if (s && (xf86NameCmp(s, "relative") == 0)) { + priv->flags = priv->flags & ~ABSOLUTE_FLAG; + } + else if (s) { + xf86Msg(X_ERROR, "%s: invalid Mode (should be absolute or relative). " + "Using default.\n", dev->identifier); + } + xf86Msg(X_CONFIG, "%s is in %s mode\n", local->name, + (priv->flags & ABSOLUTE_FLAG) ? "absolute" : "relative"); + + + s = xf86FindOptionValue(local->options, "Cursor"); + + if (s && (xf86NameCmp(s, "stylus") == 0)) { + priv->flags = priv->flags | STYLUS_FLAG; + } + else if (s && (xf86NameCmp(s, "puck") == 0)) { + priv->flags = priv->flags & ~STYLUS_FLAG; + } + else if (s) { + xf86Msg(X_ERROR, "%s: invalid Cursor (should be stylus or puck). " + "Using default.\n", dev->identifier); + } + xf86Msg(X_CONFIG, "%s is in cursor-mode %s\n", local->name, + (priv->flags & STYLUS_FLAG) ? "cursor" : "puck"); + + priv->hypXSize = xf86SetIntOption(local->options, "XSize", 0); + if (priv->hypXSize != 0) { + xf86Msg(X_CONFIG, "%s: XSize = %d\n", + dev->identifier, priv->hypXSize); + } + + priv->hypYSize = xf86SetIntOption(local->options, "YSize", 0); + if (priv->hypYSize != 0) { + xf86Msg(X_CONFIG, "%s: YSize = %d\n", + dev->identifier, priv->hypYSize); + } + + priv->PT = xf86SetIntOption(local->options, "PMin", 0); + if (priv->PT > 2) { + xf86Msg(X_CONFIG, "%s: PMin = %d\n", + dev->identifier, priv->PT); + } + else + xf86Msg(X_ERROR, "%s: invalid PMin value (should be > 2)." + "Using default.\n", dev->identifier); + + + priv->PMax = xf86SetIntOption(local->options, "PMax", 0); + if (priv->PMax > 3) { + xf86Msg(X_CONFIG, "%s: PMax = %d\n", + dev->identifier, priv->PMax); + } + else + xf86Msg(X_ERROR, "%s: invalid PMax value (should be > 3)." + "Using default.\n", dev->identifier); + + + priv->hypXOffset = xf86SetIntOption(local->options, "XOffset", 0); + if (priv->hypXOffset != 0) { + xf86Msg(X_CONFIG, "%s: XOffset = %d\n", + dev->identifier, priv->hypXOffset); + } + + priv->hypYOffset = xf86SetIntOption(local->options, "YOffset", 0); + if (priv->hypYOffset != 0) { + xf86Msg(X_CONFIG, "%s: YOffset = %d\n", + dev->identifier, priv->hypYOffset); + } + + if (xf86SetBoolOption(local->options, "InvX", FALSE)) { + priv->flags |= INVX_FLAG; + xf86Msg(X_CONFIG, "%s: InvX\n", dev->identifier); + } + + if (xf86SetBoolOption(local->options, "InvY", FALSE)) { + priv->flags |= INVY_FLAG; + xf86Msg(X_CONFIG, "%s: InvY\n", dev->identifier); + } + + { + int val; + val = xf86SetIntOption(local->options, "BaudRate", 0); + switch (val) { + case 19200: + priv->flags |= BAUD_19200_FLAG; + break; + case 9600: + priv->flags &= ~BAUD_19200_FLAG; + break; + default: + xf86Msg(X_CONFIG, "%s: Illegal speed value (must be 9600 or 19200)\n", dev->identifier); + break; + } + } + + /* mark the device configured */ + local->flags |= XI86_POINTER_CAPABLE | XI86_CONFIGURED; + + /* return the LocalDevice */ + return (local); + + SetupProc_fail: + if (priv) + xfree(priv); + if (local) + xfree(local); + return NULL; +} + +#ifdef XFree86LOADER +static +#endif +InputDriverRec HYPERPEN = { + 1, /* driver version */ + "hyperpen", /* driver name */ + NULL, /* identify */ + xf86HypInit, /* pre-init */ + xf86HypUninit, /* un-init */ + NULL, /* module */ + 0 /* ref count */ +}; + + +/* + *************************************************************************** + * + * Dynamic loading functions + * + *************************************************************************** + */ +#ifdef XFree86LOADER +/* + * xf86HypUnplug -- + * + * called when the module subsection is found in XF86Config + */ +static void +xf86HypUnplug(pointer p) +{ + DBG(1, ErrorF("xf86HypUnplug\n")); +} + +/* + * xf86HypPlug -- + * + * called when the module subsection is found in XF86Config + */ +static pointer +xf86HypPlug(pointer module, + pointer options, + int *errmaj, + int *errmin) +{ + DBG(1, ErrorF("xf86HypPlug\n")); + + xf86AddInputDriver(&HYPERPEN, module, 0); + + return module; +} + +static XF86ModuleVersionInfo xf86HypVersionRec = +{ + "hyperpen", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XF86_VERSION_CURRENT, + 1, 0, 0, + ABI_CLASS_XINPUT, + ABI_XINPUT_VERSION, + MOD_CLASS_XINPUT, + {0, 0, 0, 0} /* signature, to be patched into the file by */ + /* a tool */ +}; + +XF86ModuleData hyperpenModuleData = {&xf86HypVersionRec, + xf86HypPlug, + xf86HypUnplug}; + +#endif /* XFree86LOADER */ +#endif /* XFREE86_V4 */ + +/* end of xf86HyperPen.c */ |