summaryrefslogtreecommitdiff
path: root/src/xf86Elo.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/xf86Elo.c')
-rw-r--r--src/xf86Elo.c1791
1 files changed, 1791 insertions, 0 deletions
diff --git a/src/xf86Elo.c b/src/xf86Elo.c
new file mode 100644
index 0000000..8c57432
--- /dev/null
+++ b/src/xf86Elo.c
@@ -0,0 +1,1791 @@
+/* $XConsortium: xf86Elo.c /main/13 1996/10/25 14:11:31 kaleb $ */
+/*
+ * Copyright 1995, 1999 by Patrick Lecoanet, France. <lecoanet@cena.dgac.fr>
+ *
+ * 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 Patrick Lecoanet not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Patrick Lecoanet makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * PATRICK LECOANET DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL PATRICK LECOANET 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 ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+/* $XFree86: xc/programs/Xserver/hw/xfree86/input/elographics/xf86Elo.c,v 1.14 2001/08/17 13:27:56 dawes Exp $ */
+
+/*
+ *******************************************************************************
+ *******************************************************************************
+ *
+ * This driver is able to deal with Elographics SmartSet serial controllers.
+ * It uses only a subset of the functions provided through the protocol.
+ *
+ * SUPPORT FOR E281-2310 and compatible controllers added with help of:
+ * 1996/01/17 Juergen P. Meier (jpm@mailserv.rz.fh-muenchen.de) and
+ * 1998/03/25 G.Felkel@edelmann.de
+ *
+ * The E281-2310 is a somewhat lobotomized 2210.
+ * It does not support the c,g,h,k,l,p,q,s and t commands.
+ * Especially the P command, which is used to check the baud rate.
+ * The E281-2310 however semms to use always 9600bps, 8bit, 1stop
+ * no parity, Hardwarehandshake (RTS-CTS) (which are the drivers
+ * default values)
+ *
+ *******************************************************************************
+ *******************************************************************************
+ */
+
+#include "xf86Version.h"
+#if XF86_VERSION_CURRENT >= XF86_VERSION_NUMERIC(3,9,0,0,0)
+#define XFREE86_V4
+#endif
+
+#ifdef XFREE86_V4
+
+#ifndef XFree86LOADER
+#include <unistd.h>
+#include <errno.h>
+#endif
+
+#include "misc.h"
+#include "xf86.h"
+#if !defined(DGUX)
+#include "xf86_ansic.h"
+#endif
+#include "xf86_OSproc.h"
+#include "xf86Xinput.h"
+#include "exevents.h"
+
+#ifdef XFree86LOADER
+#include "xf86Module.h"
+#endif
+
+#else /* XFREE86_V4 */
+
+#include "Xos.h"
+#include <signal.h>
+#include <stdio.h>
+
+#define NEED_EVENTS
+#include "X.h"
+#include "Xproto.h"
+#include "inputstr.h"
+#include "scrnintstr.h"
+#include "XI.h"
+#include "XIproto.h"
+
+#if defined(sun) && !defined(i386)
+#include <errno.h>
+#include <termio.h>
+#include <fcntl.h>
+#include <ctype.h>
+
+#include "extio.h"
+#else /* defined(sun) && !defined(i386) */
+#include "compiler.h"
+
+#include "xf86.h"
+#include "xf86Procs.h"
+#include "xf86_OSlib.h"
+#include "xf86_Config.h"
+#include "xf86Xinput.h"
+#endif /* defined(sun) && !defined(i386) */
+
+#if !defined(sun) || defined(i386)
+#include "os.h"
+#include "osdep.h"
+#include "exevents.h"
+
+#include "extnsionst.h"
+#include "extinit.h"
+#endif /* !defined(sun) || defined(i386) */
+
+#endif /* XFREE86_V4 */
+
+
+#ifndef XFREE86_V4
+#if !defined(sun) || defined(i386)
+/*
+ ***************************************************************************
+ *
+ * Configuration descriptor.
+ *
+ ***************************************************************************
+ */
+
+#define PORT 1
+#define ELO_DEVICE_NAME 2
+#define SCREEN_NO 3
+#define UNTOUCH_DELAY 4
+#define REPORT_DELAY 5
+#define MAXX 6
+#define MAXY 7
+#define MINX 8
+#define MINY 9
+#define DEBUG_LEVEL 10
+#define HISTORY_SIZE 11
+#define LINK_SPEED 12
+#define ALWAYS_CORE 13
+#define SWAP_AXES 14
+#define PORTRAIT_MODE 15
+
+static SymTabRec EloTab[] = {
+ { ENDSUBSECTION, "endsubsection" },
+ { PORT, "port" },
+ { ELO_DEVICE_NAME, "devicename" },
+ { SCREEN_NO, "screenno" },
+ { UNTOUCH_DELAY, "untouchdelay" },
+ { REPORT_DELAY, "reportdelay"},
+ { MAXX, "maximumxposition" },
+ { MAXY, "maximumyposition" },
+ { MINX, "minimumxposition" },
+ { MINY, "minimumyposition" },
+ { DEBUG_LEVEL, "debuglevel" },
+ { HISTORY_SIZE, "historysize" },
+ { LINK_SPEED, "linkspeed" },
+ { ALWAYS_CORE, "alwayscore" },
+ { SWAP_AXES, "swapxy" },
+ { PORTRAIT_MODE, "portraitmode" },
+ { -1, "" },
+};
+
+#define LS300 1
+#define LS1200 2
+#define LS2400 3
+#define LS9600 4
+#define LS19200 5
+
+static SymTabRec LinkSpeedTab[] = {
+ { LS300, "b300" },
+ { LS1200, "b1200" },
+ { LS2400, "b2400" },
+ { LS9600, "b9600" },
+ { LS19200, "b19200" }
+};
+#endif /* !defined(sun) || defined(i386) */
+
+/*
+ * This struct connects a line speed with
+ * a compatible motion packet delay. The
+ * driver will attempt to enforce a correct
+ * delay (according to this table) in order to
+ * avoid losing data in the touchscreen controller.
+ * LinkSpeedValues should be kept in sync with
+ * LinkSpeedTab.
+ */
+typedef struct {
+ int speed;
+ int delay;
+} LinkParameterStruct;
+
+static LinkParameterStruct LinkSpeedValues[] = {
+ { B300, 32 },
+ { B1200, 8 },
+ { B2400, 4 },
+ { B9600, 1 },
+ { B19200, 0 }
+};
+#endif /* XFREE86_V4 */
+
+
+/*
+ ***************************************************************************
+ *
+ * Default constants.
+ *
+ ***************************************************************************
+ */
+#define ELO_MAX_TRIALS 3 /* Number of timeouts waiting for a */
+ /* pending reply. */
+#define ELO_MAX_WAIT 100000 /* Max wait time for a reply (microsec) */
+#define ELO_UNTOUCH_DELAY 5 /* 100 ms */
+#define ELO_REPORT_DELAY 1 /* 40 ms or 25 motion reports/s */
+#define ELO_LINK_SPEED B9600 /* 9600 Bauds */
+#define ELO_PORT "/dev/ttyS1"
+
+#define DEFAULT_MAX_X 3000
+#define DEFAULT_MIN_X 600
+#define DEFAULT_MAX_Y 3000
+#define DEFAULT_MIN_Y 600
+
+
+/*
+ ***************************************************************************
+ *
+ * Protocol constants.
+ *
+ ***************************************************************************
+ */
+#define ELO_PACKET_SIZE 10
+
+#define ELO_SYNC_BYTE 'U' /* Sync byte. First of a packet. */
+#define ELO_TOUCH 'T' /* Report of touchs and motions. Not *
+ * used by 2310. */
+#define ELO_OWNER 'O' /* Report vendor name. */
+#define ELO_ID 'I' /* Report of type and features. */
+#define ELO_MODE 'M' /* Set current operating mode. */
+#define ELO_PARAMETER 'P' /* Set the serial parameters. */
+#define ELO_REPORT 'B' /* Set touch reports timings. */
+#define ELO_ACK 'A' /* Acknowledge packet */
+
+#define ELO_INIT_CHECKSUM 0xAA /* Initial value of checksum. */
+
+#define ELO_PRESS 0x01 /* Flags in ELO_TOUCH status byte */
+#define ELO_STREAM 0x02
+#define ELO_RELEASE 0x04
+
+#define ELO_TOUCH_MODE 0x01 /* Flags in ELO_MODE command */
+#define ELO_STREAM_MODE 0x02
+#define ELO_UNTOUCH_MODE 0x04
+#define ELO_RANGE_CHECK_MODE 0x40
+#define ELO_TRIM_MODE 0x02
+#define ELO_CALIB_MODE 0x04
+#define ELO_SCALING_MODE 0x08
+#define ELO_TRACKING_MODE 0x40
+
+#define ELO_SERIAL_SPEED 0x06 /* Flags for high speed serial (19200) */
+#define ELO_SERIAL_MASK 0xF8
+
+#define ELO_SERIAL_IO '0' /* Indicator byte for PARAMETER command */
+
+
+/*
+ ***************************************************************************
+ *
+ * Usefull macros.
+ *
+ ***************************************************************************
+ */
+#define WORD_ASSEMBLY(byte1, byte2) (((byte2) << 8) | (byte1))
+#define SYSCALL(call) while(((call) == -1) && (errno == EINTR))
+
+/* This one is handy, thanx Fred ! */
+#ifdef DBG
+#undef DBG
+#endif
+#ifdef DEBUG
+#undef DEBUG
+#endif
+
+static int debug_level = 0;
+#define DEBUG 1
+#if DEBUG
+#define DBG(lvl, f) {if ((lvl) <= debug_level) f;}
+#else
+#define DBG(lvl, f)
+#endif
+
+#ifdef XFREE86_V4
+#undef SYSCALL
+#undef read
+#undef write
+#undef close
+#define SYSCALL(call) call
+#define read(fd, ptr, num) xf86ReadSerial(fd, ptr, num)
+#define write(fd, ptr, num) xf86WriteSerial(fd, ptr, num)
+#define close(fd) xf86CloseSerial(fd)
+#endif
+
+
+/*
+ ***************************************************************************
+ *
+ * Device private records.
+ *
+ ***************************************************************************
+ */
+typedef struct _EloPrivateRec {
+ char *input_dev; /* The touchscreen input tty */
+ int min_x; /* Minimum x reported by calibration */
+ int max_x; /* Maximum x */
+ int min_y; /* Minimum y reported by calibration */
+ int max_y; /* Maximum y */
+ int untouch_delay; /* Delay before reporting an untouch (in ms) */
+ int report_delay; /* Delay between touch report packets */
+#ifndef XFREE86_V4
+ int link_speed; /* Speed of the RS232 link connecting the ts. */
+#endif
+ int screen_no; /* Screen associated with the device */
+ int screen_width; /* Width of the associated X screen */
+ int screen_height; /* Height of the screen */
+ Bool inited; /* The controller has already been configured ? */
+ Bool is_a_2310; /* Set if the smartset is a 2310. */
+ int checksum; /* Current checksum of data in assembly buffer */
+ int packet_buf_p; /* Assembly buffer pointer */
+ int swap_axes; /* Swap X an Y axes if != 0 */
+ unsigned char packet_buf[ELO_PACKET_SIZE]; /* Assembly buffer */
+} EloPrivateRec, *EloPrivatePtr;
+
+
+#ifndef XFREE86_V4
+#if !defined(sun) || defined(i386)
+/*
+ ***************************************************************************
+ *
+ * xf86EloConfig --
+ * Configure the driver from the configuration data.
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloConfig(LocalDevicePtr *array,
+ int inx,
+ int max,
+ LexPtr val)
+{
+ LocalDevicePtr local = array[inx];
+ EloPrivatePtr priv = (EloPrivatePtr)(local->private);
+ int token;
+ int portrait=0;
+
+ while ((token = xf86GetToken(EloTab)) != ENDSUBSECTION) {
+ switch(token) {
+
+ case PORT:
+ if (xf86GetToken(NULL) != STRING) {
+ xf86ConfigError("Elographics input port expected");
+ }
+ priv->input_dev = strdup(val->str);
+ if (xf86Verbose) {
+ ErrorF("%s Elographics input port: %s\n",
+ XCONFIG_GIVEN, priv->input_dev);
+ }
+ break;
+
+ case ELO_DEVICE_NAME:
+ if (xf86GetToken(NULL) != STRING) {
+ xf86ConfigError("Elographics device name expected");
+ }
+ local->name = strdup(val->str);
+ if (xf86Verbose) {
+ ErrorF("%s Elographics X device name: %s\n",
+ XCONFIG_GIVEN, local->name);
+ }
+ break;
+
+ case SCREEN_NO:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics screen number expected");
+ }
+ priv->screen_no = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics associated screen: %d\n",
+ XCONFIG_GIVEN, priv->screen_no);
+ }
+ break;
+
+ case UNTOUCH_DELAY:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics untouch delay expected");
+ }
+ priv->untouch_delay = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics untouch delay: %d ms\n",
+ XCONFIG_GIVEN, priv->untouch_delay*10);
+ }
+ break;
+
+ case REPORT_DELAY:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics report delay expected");
+ }
+ priv->report_delay = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics report delay: %d ms\n",
+ XCONFIG_GIVEN, priv->report_delay*10);
+ }
+ break;
+
+ case LINK_SPEED:
+ {
+ int ltoken = xf86GetToken(LinkSpeedTab);
+ if (ltoken == EOF ||
+ ltoken == STRING ||
+ ltoken == NUMBER) {
+ xf86ConfigError("Elographics link speed expected");
+ }
+ priv->link_speed = LinkSpeedValues[ltoken-1].speed;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics link speed: %s bps\n",
+ XCONFIG_GIVEN, (LinkSpeedTab[ltoken-1].name)+1);
+ }
+ }
+ break;
+
+ case MAXX:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics maximum x position expected");
+ }
+ priv->max_x = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics maximum x position: %d\n",
+ XCONFIG_GIVEN, priv->max_x);
+ }
+ break;
+
+ case MAXY:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics maximum y position expected");
+ }
+ priv->max_y = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics maximum y position: %d\n",
+ XCONFIG_GIVEN, priv->max_y);
+ }
+ break;
+
+ case MINX:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics minimum x position expected");
+ }
+ priv->min_x = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics minimum x position: %d\n",
+ XCONFIG_GIVEN, priv->min_x);
+ }
+ break;
+
+ case MINY:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics minimum y position expected");
+ }
+ priv->min_y = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics minimum y position: %d\n",
+ XCONFIG_GIVEN, priv->min_y);
+ }
+ break;
+
+ case DEBUG_LEVEL:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics driver debug level expected");
+ }
+ debug_level = val->num;
+ if (xf86Verbose) {
+#if DEBUG
+ ErrorF("%s Elographics debug level sets to %d\n", XCONFIG_GIVEN,
+ debug_level);
+#else
+ ErrorF("%s Elographics debug not available\n",
+ XCONFIG_GIVEN, debug_level);
+#endif
+ }
+ break;
+
+ case HISTORY_SIZE:
+ if (xf86GetToken(NULL) != NUMBER) {
+ xf86ConfigError("Elographics motion history size expected");
+ }
+ local->history_size = val->num;
+ if (xf86Verbose) {
+ ErrorF("%s EloGraphics motion history size is %d\n", XCONFIG_GIVEN,
+ local->history_size);
+ }
+ break;
+
+ case ALWAYS_CORE:
+ xf86AlwaysCore(local, TRUE);
+ if (xf86Verbose) {
+ ErrorF("%s Elographics device will always stays core pointer\n",
+ XCONFIG_GIVEN);
+ }
+ break;
+
+ case SWAP_AXES:
+ priv->swap_axes = 1;
+ if (xf86Verbose) {
+ ErrorF("%s Elographics device will work with X and Y axes swapped\n",
+ XCONFIG_GIVEN);
+ }
+ break;
+
+ case PORTRAIT_MODE:
+ if (xf86GetToken(NULL) != STRING) {
+ portrait_mode_err:
+ xf86ConfigError("Elographics portrait mode should be: Portrait, Landscape or PortraitCCW");
+ }
+ if (strcmp(val->str, "portrait") == 0) {
+ portrait = 1;
+ }
+ else if (strcmp(val->str, "portraitccw") == 0) {
+ portrait = -1;
+ }
+ else if (strcmp(val->str, "landscape") != 0) {
+ goto portrait_mode_err;
+ }
+ if (xf86Verbose) {
+ ErrorF("%s Elographics device will work in %s mode\n",
+ XCONFIG_GIVEN, val->str);
+ }
+ break;
+
+ case EOF:
+ FatalError("Unexpected EOF (missing EndSubSection)");
+ break;
+
+ default:
+ xf86ConfigError("Elographics subsection keyword expected");
+ break;
+ }
+ }
+
+ if (priv->max_x - priv->min_x <= 0) {
+ ErrorF("%s Elographics: reverse x mode (minimum x position >= maximum x position)\n",
+ XCONFIG_GIVEN);
+ }
+ if (priv->max_y - priv->min_y <= 0) {
+ ErrorF("%s Elographics: reverse y mode (minimum y position >= maximum y position)\n",
+ XCONFIG_GIVEN);
+ }
+ /*
+ * The portrait adjustments need to be done after axis reversing
+ * and axes swap. This way the driver can cope with deffective
+ * hardware and still do the correct processing depending on the
+ * actual display orientation.
+ */
+ if (portrait == 1) {
+ /*
+ * Portrait Clockwise: reverse Y axis and exchange X and Y.
+ */
+ int tmp;
+ tmp = priv->min_y;
+ priv->min_y = priv->max_y;
+ priv->max_y = tmp;
+ priv->swap_axes = (priv->swap_axes==0) ? 1 : 0;
+ }
+ else if (portrait == -1) {
+ /*
+ * Portrait Counter Clockwise: reverse X axis and exchange X and Y.
+ */
+ int tmp;
+ tmp = priv->min_x;
+ priv->min_x = priv->max_x;
+ priv->max_x = tmp;
+ priv->swap_axes = (priv->swap_axes==0) ? 1 : 0;
+ }
+
+ DBG(2, ErrorF("xf86EloConfig port name=%s\n", priv->input_dev))
+
+ return Success;
+}
+#endif
+#endif
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloGetPacket --
+ * Read a packet from the port. Try to synchronize with start of
+ * packet and compute checksum.
+ * The packet structure read by this function is as follow:
+ * Byte 0 : ELO_SYNC_BYTE
+ * Byte 1
+ * ...
+ * Byte 8 : packet data
+ * Byte 9 : checksum of bytes 0 to 8
+ *
+ * This function returns if a valid packet has been assembled in
+ * buffer or if no more data is available.
+ *
+ * Returns Success if a packet is successfully assembled including
+ * testing checksum. If a packet checksum is incorrect, it is discarded.
+ * Bytes preceding the ELO_SYNC_BYTE are also discarded.
+ * Returns !Success if out of data while reading. The start of the
+ * partially assembled packet is left in buffer, buffer_p and
+ * checksum reflect the current state of assembly.
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloGetPacket(unsigned char *buffer,
+ int *buffer_p,
+ int *checksum,
+ int fd)
+{
+ int num_bytes;
+ Bool ok;
+
+ DBG(4, ErrorF("Entering xf86EloGetPacket with checksum == %d and buffer_p == %d\n",
+ *checksum, *buffer_p));
+
+ /*
+ * Try to read enough bytes to fill up the packet buffer.
+ */
+ DBG(4, ErrorF("buffer_p is %d, Trying to read %d bytes from link\n",
+ *buffer_p, ELO_PACKET_SIZE - *buffer_p));
+ SYSCALL(num_bytes = read(fd,
+ (char *) (buffer + *buffer_p),
+ ELO_PACKET_SIZE - *buffer_p));
+
+ /*
+ * Okay, give up.
+ */
+ if (num_bytes < 0) {
+ Error("System error while reading from Elographics touchscreen.");
+ return !Success;
+ }
+ DBG(4, ErrorF("Read %d bytes\n", num_bytes));
+
+ while (num_bytes) {
+ /*
+ * Sync with the start of a packet.
+ */
+ if ((*buffer_p == 0) && (buffer[0] != ELO_SYNC_BYTE)) {
+ /*
+ * No match, shift data one byte toward the start of the buffer.
+ */
+ ErrorF("Elographics: Dropping one byte in an attempt to synchronize: '%c' 0x%X\n",
+ buffer[0], buffer[0]);
+ memcpy(&buffer[0], &buffer[1], num_bytes-1);
+ }
+ else {
+ /*
+ * Compute checksum in assembly buffer.
+ */
+ if (*buffer_p < ELO_PACKET_SIZE-1) {
+ *checksum = *checksum + buffer[*buffer_p];
+ *checksum = *checksum % 256;
+ DBG(4, ErrorF(" 0x%X-->0x%X ", buffer[*buffer_p], *checksum));
+ }
+ (*buffer_p)++;
+ }
+ num_bytes--;
+ }
+
+ if (*buffer_p == ELO_PACKET_SIZE) {
+ /*
+ * Got a packet, validate checksum and reset state.
+ */
+ ok = (*checksum == buffer[ELO_PACKET_SIZE-1]);
+ DBG(3, ErrorF("Expecting checksum %d, got %d\n", *checksum, buffer[ELO_PACKET_SIZE-1]));
+ *checksum = ELO_INIT_CHECKSUM;
+ *buffer_p = 0;
+
+ if (!ok) {
+ ErrorF("Checksum error on Elographics touchscreen link\n");
+ return !Success;
+ }
+
+ /*
+ * Valid packet received report it.
+ */
+ return Success;
+ }
+ else {
+ return !Success;
+ }
+}
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloConvert --
+ * Convert extended valuators to x and y suitable for core motion
+ * events. Return True if ok and False if the requested conversion
+ * can't be done for the specified valuators.
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloConvert(LocalDevicePtr local,
+ int first,
+ int num,
+ int v0,
+ int v1,
+ int v2,
+ int v3,
+ int v4,
+ int v5,
+ int *x,
+ int *y)
+{
+ EloPrivatePtr priv = (EloPrivatePtr) local->private;
+ int width = priv->max_x - priv->min_x;
+ int height = priv->max_y - priv->min_y;
+ int input_x, input_y;
+
+ if (first != 0 || num != 2) {
+ return FALSE;
+ }
+
+ DBG(3, ErrorF("EloConvert: v0(%d), v1(%d)\n", v0, v1));
+
+ if (priv->swap_axes) {
+ input_x = v1;
+ input_y = v0;
+ }
+ else {
+ input_x = v0;
+ input_y = v1;
+ }
+ *x = (priv->screen_width * (input_x - priv->min_x)) / width;
+ *y = (priv->screen_height -
+ (priv->screen_height * (input_y - priv->min_y)) / height);
+
+#ifdef XFREE86_V4
+ /*
+ * Need to check if still on the correct screen.
+ * This call is here so that this work can be done after
+ * calib and before posting the event.
+ */
+ xf86XInputSetScreen(local, priv->screen_no, *x, *y);
+#endif
+
+ DBG(3, ErrorF("EloConvert: x(%d), y(%d)\n", *x, *y));
+
+ return TRUE;
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloReadInput --
+ * Read all pending report packets from the touchscreen and enqueue
+ * them.
+ * If a packet is not fully received it is deferred until the next
+ * call to the function.
+ * Packets recognized by this function comply with the format:
+ *
+ * Byte 1 : ELO_TOUCH
+ * Byte 2 : Packet type
+ * Bit 2 : Pen Up (Release)
+ * Bit 1 : Position (Stream)
+ * Bit 0 : Pen Down (Press)
+ * Byte 3 : X coordinate (lower bits)
+ * Byte 4 : X coordinate (upper bits)
+ * Byte 5 : Y coordinate (lower bits)
+ * Byte 6 : Y coordinate (upper bits)
+ * Byte 7 : Z coordinate (lower bits)
+ * Byte 8 : Z coordinates (upper bits)
+ *
+ *
+ ***************************************************************************
+ */
+static void
+xf86EloReadInput(LocalDevicePtr local)
+{
+ EloPrivatePtr priv = (EloPrivatePtr)(local->private);
+ int cur_x, cur_y;
+ int state;
+
+ DBG(4, ErrorF("Entering ReadInput\n"));
+ /*
+ * Try to get a packet.
+ */
+ if (xf86EloGetPacket(priv->packet_buf,
+ &priv->packet_buf_p,
+ &priv->checksum,
+ local->fd) != Success) {
+ return;
+ }
+
+ /*
+ * Process only ELO_TOUCHs here.
+ */
+ if (priv->packet_buf[1] == ELO_TOUCH) {
+ /*
+ * First stick together the various pieces.
+ */
+ cur_x = WORD_ASSEMBLY(priv->packet_buf[3], priv->packet_buf[4]);
+ cur_y = WORD_ASSEMBLY(priv->packet_buf[5], priv->packet_buf[6]);
+ state = priv->packet_buf[2] & 0x07;
+
+ /*
+ * Send events.
+ *
+ * We *must* generate a motion before a button change if pointer
+ * location has changed as DIX assumes this. This is why we always
+ * emit a motion, regardless of the kind of packet processed.
+ */
+ xf86PostMotionEvent(local->dev, TRUE, 0, 2, cur_x, cur_y);
+
+ /*
+ * Emit a button press or release.
+ */
+ if (state == ELO_PRESS || state == ELO_RELEASE) {
+ xf86PostButtonEvent(local->dev, TRUE, 1, state == ELO_PRESS, 0, 2, cur_x, cur_y);
+ }
+
+ DBG(3, ErrorF("TouchScreen: x(%d), y(%d), %s\n",
+ cur_x, cur_y,
+ (state == ELO_PRESS) ? "Press" : ((state == ELO_RELEASE) ? "Release" : "Stream")));
+ }
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloSendPacket --
+ * Emit an height bytes packet to the controller.
+ * The function expects a valid buffer containing the
+ * command to be sent to the controller. It fills it with the
+ * leading sync character an the trailing checksum byte.
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloSendPacket(unsigned char *packet,
+ int fd)
+{
+ int i, result;
+ int sum = ELO_INIT_CHECKSUM;
+
+ packet[0] = ELO_SYNC_BYTE;
+ for (i = 0; i < ELO_PACKET_SIZE-1; i++) {
+ sum += packet[i];
+ sum &= 0xFF;
+ }
+ packet[ELO_PACKET_SIZE-1] = sum;
+
+ DBG(4, ErrorF("Sending packet : 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X \n",
+ packet[0], packet[1], packet[2], packet[3], packet[4],
+ packet[5], packet[6], packet[7], packet[8], packet[9]));
+ SYSCALL(result = write(fd, packet, ELO_PACKET_SIZE));
+ if (result != ELO_PACKET_SIZE) {
+ DBG(5, ErrorF("System error while sending to Elographics touchscreen.\n"));
+ return !Success;
+ }
+ else {
+ return Success;
+ }
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloWaitReply --
+ * It is assumed that the reply will be in the few next bytes
+ * read and will be available very soon after the query post. if
+ * these two asumptions are not met, there are chances that the server
+ * will be stuck for a while.
+ * The reply type need to match parameter 'type'.
+ * The reply is left in reply. The function returns Success if the
+ * reply is valid and !Success otherwise.
+ *
+ ***************************************************************************
+ */
+#ifndef XFREE86_V4
+static int
+xf86WaitForInput(int fd,
+ int timeout)
+{
+ fd_set readfds;
+ struct timeval to;
+ int r;
+
+ FD_ZERO(&readfds);
+ FD_SET(fd, &readfds);
+ to.tv_sec = 0;
+ to.tv_usec = timeout;
+
+ SYSCALL(r = select(FD_SETSIZE, &readfds, NULL, NULL, &to));
+ return r;
+}
+#endif
+
+static Bool
+xf86EloWaitReply(unsigned char type,
+ unsigned char *reply,
+ int fd)
+{
+ Bool ok;
+ int i, result;
+ int reply_p = 0;
+ int sum = ELO_INIT_CHECKSUM;
+
+ DBG(4, ErrorF("Waiting a '%c' reply\n", type));
+ i = ELO_MAX_TRIALS;
+ do {
+ ok = !Success;
+
+ /*
+ * Wait half a second for the reply. The fuse counts down each
+ * timeout and each wrong packet.
+ */
+ DBG(4, ErrorF("Waiting %d ms for data from port\n", ELO_MAX_WAIT / 1000));
+ result = xf86WaitForInput(fd, ELO_MAX_WAIT);
+ if (result > 0) {
+ ok = xf86EloGetPacket(reply, &reply_p, &sum, fd);
+ /*
+ * Do not report an error on a 'P' query as the controller
+ * might be a 2310.
+ */
+ if (ok == Success && reply[1] != type && type != ELO_PARAMETER) {
+ DBG(3, ErrorF("Wrong reply received\n"));
+ ok = !Success;
+ }
+ }
+ else {
+ DBG(3, ErrorF("No answer from link : %d\n", result));
+ }
+
+ if (result == 0) {
+ i--;
+ }
+ } while(ok != Success && i);
+
+ return ok;
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloWaitAck --
+ * Wait for an acknowledge from the controller. Returns Success if
+ * acknowledge received and reported no errors.
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloWaitAck(int fd)
+{
+ unsigned char packet[ELO_PACKET_SIZE];
+ int i, nb_errors;
+
+ if (xf86EloWaitReply(ELO_ACK, packet, fd) == Success) {
+ for (i = 0, nb_errors = 0; i < 4; i++) {
+ if (packet[2 + i] != '0') {
+ nb_errors++;
+ }
+ }
+ if (nb_errors != 0) {
+ DBG(2, ErrorF("Elographics acknowledge packet reports %d errors\n",
+ nb_errors));
+ }
+ return Success;
+ /* return (nb_errors < 4) ? Success : !Success;*/
+ }
+ else {
+ return !Success;
+ }
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloSendQuery --
+ * Emit a query to the controller and blocks until the reply and
+ * the acknowledge are read.
+ *
+ * The reply is left in reply. The function returns Success if the
+ * reply is valid and !Success otherwise.
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloSendQuery(unsigned char *request,
+ unsigned char *reply,
+ int fd)
+{
+ Bool ok;
+
+ if (xf86EloSendPacket(request, fd) == Success) {
+ ok = xf86EloWaitReply(toupper(request[1]), reply, fd);
+ if (ok == Success) {
+ ok = xf86EloWaitAck(fd);
+ }
+ return ok;
+ }
+ else {
+ return !Success;
+ }
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloSendControl --
+ * Emit a control command to the controller and wait for acknowledge.
+ *
+ * Returns Success if acknowledge received and reported no error.
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloSendControl(unsigned char *control,
+ int fd)
+{
+ if (xf86EloSendPacket(control, fd) == Success) {
+ return xf86EloWaitAck(fd);
+ }
+ else {
+ return !Success;
+ }
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloPrintIdent --
+ * Print type of touchscreen and features on controller board.
+ *
+ ***************************************************************************
+ */
+static void
+xf86EloPrintIdent(unsigned char *packet,
+ EloPrivatePtr priv)
+{
+#ifdef XFREE86_V4
+ xf86Msg(X_PROBED, "Elographics touchscreen is a ");
+ switch(packet[2]) {
+ case '0':
+ xf86Msg(X_NONE, "AccuTouch");
+ break;
+ case '1':
+ xf86Msg(X_NONE, "DuraTouch");
+ break;
+ case '2':
+ xf86Msg(X_NONE, "Intellitouch");
+ break;
+ }
+ xf86Msg(X_NONE, ", connected through a ");
+ switch(packet[3]) {
+ case '0':
+ xf86Msg(X_NONE, "serial link.\n");
+ break;
+ case '1':
+ xf86Msg(X_NONE, "PC-Bus port.\n");
+ break;
+ case '2':
+ xf86Msg(X_NONE, "Micro Channel port.\n");
+ break;
+ }
+ xf86Msg(X_PROBED, "The controller is a model ");
+ if (packet[8] & 1) {
+ if (priv->is_a_2310) {
+ xf86Msg(X_NONE, "E281-2310");
+ }
+ else {
+ xf86Msg(X_NONE, "E271-2210");
+ }
+ }
+ else {
+ xf86Msg(X_NONE, "E271-2200");
+ }
+ xf86Msg(X_NONE, ", firmware revision %d.%d.\n", packet[6], packet[5]);
+
+ if (packet[4]) {
+ xf86Msg(X_PROBED, " Additional features:\n");
+ if (packet[4] & 0x10) {
+ xf86Msg(X_PROBED, " External A/D converter\n");
+ }
+ if (packet[4] & 0x20) {
+ xf86Msg(X_PROBED, " 32Ko RAM\n");
+ }
+ if (packet[4] & 0x40) {
+ xf86Msg(X_PROBED, " RAM onboard\n");
+ }
+ if (packet[4] & 0x80) {
+ xf86Msg(X_PROBED, " Z axis active\n");
+ }
+ xf86Msg(X_NONE, "\n");
+ }
+#else
+ ErrorF("%s Elographics touchscreen is a ", XCONFIG_PROBED);
+ switch(packet[2]) {
+ case '0':
+ ErrorF("AccuTouch");
+ break;
+ case '1':
+ ErrorF("DuraTouch");
+ break;
+ case '2':
+ ErrorF("Intellitouch");
+ break;
+ }
+ ErrorF(", connected through a ");
+ switch(packet[3]) {
+ case '0':
+ ErrorF("serial link.\n");
+ break;
+ case '1':
+ ErrorF("PC-Bus port.\n");
+ break;
+ case '2':
+ ErrorF("Micro Channel port.\n");
+ break;
+ }
+ ErrorF("%s The controller is a model ", XCONFIG_PROBED);
+ if (packet[8] & 1) {
+ if (priv->is_a_2310) {
+ ErrorF("E281-2310");
+ }
+ else {
+ ErrorF("E271-2210");
+ }
+ }
+ else {
+ ErrorF("E271-2200");
+ }
+ ErrorF(", firmware revision %d.%d.\n", packet[6], packet[5]);
+
+ if (packet[4]) {
+ ErrorF("%s Additional features:\n", XCONFIG_PROBED);
+ if (packet[4] & 0x10) {
+ ErrorF("%s External A/D converter\n", XCONFIG_PROBED);
+ }
+ if (packet[4] & 0x20) {
+ ErrorF("%s 32Ko RAM\n", XCONFIG_PROBED);
+ }
+ if (packet[4] & 0x40) {
+ ErrorF("%s RAM onboard\n", XCONFIG_PROBED);
+ }
+ if (packet[4] & 0x80) {
+ ErrorF("%s Z axis active\n", XCONFIG_PROBED);
+ }
+ ErrorF("\n");
+ }
+#endif
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloPtrControl --
+ *
+ ***************************************************************************
+ */
+#if 0
+static void
+xf86EloPtrControl(DeviceIntPtr dev,
+ PtrCtrl *ctrl)
+{
+}
+#endif
+
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloControl --
+ *
+ ***************************************************************************
+ */
+static Bool
+xf86EloControl(DeviceIntPtr dev,
+ int mode)
+{
+ LocalDevicePtr local = (LocalDevicePtr) dev->public.devicePrivate;
+ EloPrivatePtr priv = (EloPrivatePtr)(local->private);
+ unsigned char map[] = { 0, 1 };
+ unsigned char req[ELO_PACKET_SIZE];
+ unsigned char reply[ELO_PACKET_SIZE];
+
+ switch(mode) {
+
+ case DEVICE_INIT:
+ {
+#if defined(sun) && !defined(i386) && !defined(XFREE86_V4)
+ char *name = (char *) getenv("ELO_DEV");
+ char *calib = (char *) getenv("ELO_CALIB");
+ char *speed = (char *) getenv("ELO_SPEED");
+ char *delays = (char *) getenv("ELO_DELAYS");
+#endif
+
+ DBG(2, ErrorF("Elographics touchscreen init...\n"));
+
+#if defined(sun) && !defined(i386) && !defined(XFREE86_V4)
+ if (name) {
+ priv->input_dev = strdup(name);
+ ErrorF("Elographics touchscreen port changed to '%s'\n",
+ priv->input_dev);
+ }
+ if (calib) {
+ if (sscanf(calib, "%d %d %d %d",
+ &priv->min_x, &priv->max_x,
+ &priv->min_y, &priv->max_y) != 4) {
+ ErrorF("Incorrect syntax in ELO_CALIB\n");
+ return !Success;
+ }
+ else if (priv->max_x <= priv->min_x ||
+ priv->max_y <= priv->min_y) {
+ ErrorF("Bogus calibration data in ELO_CALIB\n");
+ return !Success;
+ }
+ else {
+ ErrorF("Calibration will be done with:\n");
+ ErrorF("x_min=%d, x_max=%d, y_min=%d, y_max=%d\n",
+ priv->min_x, priv->max_x, priv->min_y, priv->max_y);
+ }
+ }
+ if (speed) {
+ /* These tests should be kept in sync with the LinkSpeedValues
+ * array. */
+ if (strcmp(speed, "B9600") == 0) {
+ priv->link_speed = B9600;
+ }
+ else if (strcmp(speed, "B19200") == 0) {
+ priv->link_speed = B19200;
+ }
+ else if (strcmp(speed, "B2400") == 0) {
+ priv->link_speed = B2400;
+ }
+ else if (strcmp(speed, "B1200") == 0) {
+ priv->link_speed = B1200;
+ }
+ else if (strcmp(speed, "B300") == 0) {
+ priv->link_speed = B300;
+ }
+ else {
+ ErrorF("Bogus speed value in ELO_SPEED\n");
+ return !Success;
+ }
+ }
+ if (delays) {
+ if (sscanf(delays, "%d %d",
+ &priv->untouch_delay,
+ &priv->report_delay) != 2) {
+ ErrorF("Bogus delays data in ELO_DELAYS\n");
+ }
+ else {
+ ErrorF("Untouch delay will be: %d\n", priv->untouch_delay);
+ ErrorF("Report delay will be: %d\n", priv->report_delay);
+ }
+ }
+#endif
+
+ if (priv->screen_no >= screenInfo.numScreens ||
+ priv->screen_no < 0) {
+ priv->screen_no = 0;
+ }
+ priv->screen_width = screenInfo.screens[priv->screen_no]->width;
+ priv->screen_height = screenInfo.screens[priv->screen_no]->height;
+
+ /*
+ * Device reports button press for up to 1 button.
+ */
+ if (InitButtonClassDeviceStruct(dev, 1, map) == FALSE) {
+ ErrorF("Unable to allocate Elographics touchscreen ButtonClassDeviceStruct\n");
+ return !Success;
+ }
+
+ if (InitFocusClassDeviceStruct(dev) == FALSE) {
+ ErrorF("Unable to allocate Elographics touchscreen FocusClassDeviceStruct\n");
+ return !Success;
+ }
+
+ /*
+ * Device reports motions on 2 axes in absolute coordinates.
+ * Axes min and max values are reported in raw coordinates.
+ * Resolution is computed roughly by the difference between
+ * max and min values scaled from the approximate size of the
+ * screen to fit one meter.
+ */
+ if (InitValuatorClassDeviceStruct(dev, 2, xf86GetMotionEvents,
+ local->history_size, Absolute) == FALSE) {
+ ErrorF("Unable to allocate Elographics touchscreen ValuatorClassDeviceStruct\n");
+ return !Success;
+ }
+ else {
+ InitValuatorAxisStruct(dev, 0, priv->min_x, priv->max_x,
+ 9500,
+ 0 /* min_res */,
+ 9500 /* max_res */);
+ InitValuatorAxisStruct(dev, 1, priv->min_y, priv->max_y,
+ 10500,
+ 0 /* min_res */,
+ 10500 /* max_res */);
+ }
+
+ if (InitFocusClassDeviceStruct(dev) == FALSE) {
+ ErrorF("Unable to allocate Elographics touchscreen FocusClassDeviceStruct\n");
+ }
+
+ /*
+ * Allocate the motion events buffer.
+ */
+ xf86MotionHistoryAllocate(local);
+
+ /*
+ * This once has caused the server to crash after doing an xalloc & strcpy ??
+ */
+#ifndef XFREE86_V4
+ AssignTypeAndName(dev, local->atom, local->name);
+#endif
+
+ DBG(2, ErrorF("Done.\n"));
+ return Success;
+ }
+
+ case DEVICE_ON:
+ DBG(2, ErrorF("Elographics touchscreen on...\n"));
+
+ if (local->fd < 0) {
+#ifndef XFREE86_V4
+ struct termios termios_tty;
+ int i, result;
+#endif
+
+ DBG(2, ErrorF("Elographics touchscreen opening : %s\n", priv->input_dev));
+#ifdef XFREE86_V4
+ local->fd = xf86OpenSerial(local->options);
+ if (local->fd < 0) {
+ Error("Unable to open Elographics touchscreen device");
+ return !Success;
+ }
+#else
+ SYSCALL(local->fd = open(priv->input_dev, O_RDWR|O_NDELAY, 0));
+ if (local->fd < 0) {
+ Error("Unable to open Elographics touchscreen device");
+ return !Success;
+ }
+
+ DBG(3, ErrorF("Try to see if the link is at the specified rate\n"));
+ memset(&termios_tty, 0, sizeof(termios_tty));
+ termios_tty.c_cflag = priv->link_speed | CS8 | CREAD | CLOCAL;
+ termios_tty.c_cc[VMIN] = 1;
+ SYSCALL(result = tcsetattr(local->fd, TCSANOW, &termios_tty));
+ if (result < 0) {
+ Error("Unable to configure Elographics touchscreen port");
+ goto not_success;
+ }
+#endif
+ /*
+ * Try to see if the link is at the specified rate and
+ * ask the controller to report various infos.
+ */
+ memset(req, 0, ELO_PACKET_SIZE);
+ req[1] = tolower(ELO_PARAMETER);
+ if (xf86EloSendQuery(req, reply, local->fd) != Success) {
+ priv->is_a_2310 = 1;
+ ErrorF("Not at the specified rate or model 2310, will continue\n");
+ }
+
+ /*
+ * Ask the controller to report various infos.
+ */
+ memset(req, 0, ELO_PACKET_SIZE);
+ req[1] = tolower(ELO_ID);
+ if (xf86EloSendQuery(req, reply, local->fd) == Success) {
+ xf86EloPrintIdent(reply, priv);
+ }
+ else {
+ ErrorF("Unable to ask Elographics touchscreen identification\n");
+ goto not_success;
+ }
+
+ /*
+ * Set the operating mode: Stream, no scaling, no calibration,
+ * no range checking, no trim, tracking enabled.
+ */
+ memset(req, 0, ELO_PACKET_SIZE);
+ req[1] = ELO_MODE;
+ req[3] = ELO_TOUCH_MODE | ELO_STREAM_MODE | ELO_UNTOUCH_MODE;
+ req[4] = ELO_TRACKING_MODE;
+ if (xf86EloSendControl(req, local->fd) != Success) {
+ ErrorF("Unable to change Elographics touchscreen operating mode\n");
+ goto not_success;
+ }
+
+#ifndef XFREE86_V4
+ /*
+ * Check if the report delay is compatible with the selected
+ * link speed and reset it otherwise.
+ */
+ for (i = 0; i < sizeof(LinkSpeedValues)/sizeof(LinkParameterStruct); i++) {
+ if (LinkSpeedValues[i].speed == priv->link_speed) {
+ if (LinkSpeedValues[i].delay > priv->report_delay) {
+ ErrorF("Changing report delay from %d ms to %d ms to comply with link speed\n",
+ priv->report_delay*10, LinkSpeedValues[i].delay*10);
+ priv->report_delay = LinkSpeedValues[i].delay;
+ }
+ }
+ }
+#endif
+ /*
+ * Set the touch reports timings from configuration data.
+ */
+ memset(req, 0, ELO_PACKET_SIZE);
+ req[1] = ELO_REPORT;
+ req[2] = priv->untouch_delay;
+ req[3] = priv->report_delay;
+ if (xf86EloSendControl(req, local->fd) != Success) {
+ ErrorF("Unable to change Elographics touchscreen reports timings\n");
+
+ not_success:
+ SYSCALL(close(local->fd));
+ local->fd = -1;
+ return !Success;
+ }
+#ifdef XFREE86_V4
+ xf86AddEnabledDevice(local);
+#else
+ AddEnabledDevice(local->fd);
+#endif
+ dev->public.on = TRUE;
+ }
+
+ DBG(2, ErrorF("Done\n"));
+ return Success;
+
+ /*
+ * Deactivate the device. After this, the device will not emit
+ * events until a subsequent DEVICE_ON. Thus, we can momentarily
+ * close the port.
+ */
+ case DEVICE_OFF:
+ DBG(2, ErrorF("Elographics touchscreen off...\n"));
+ dev->public.on = FALSE;
+ if (local->fd >= 0) {
+#ifdef XFREE86_V4
+ xf86RemoveEnabledDevice(local);
+#else
+ RemoveEnabledDevice(local->fd);
+#endif
+ }
+ SYSCALL(close(local->fd));
+ local->fd = -1;
+ DBG(2, ErrorF("Done\n"));
+ return Success;
+
+ /*
+ * Final close before server exit. This is used during server shutdown.
+ * Close the port and free all the resources.
+ */
+ case DEVICE_CLOSE:
+ DBG(2, ErrorF("Elographics touchscreen close...\n"));
+ dev->public.on = FALSE;
+ if (local->fd >= 0) {
+ RemoveEnabledDevice(local->fd);
+ }
+ SYSCALL(close(local->fd));
+ local->fd = -1;
+ DBG(2, ErrorF("Done\n"));
+ return Success;
+
+ default:
+ ErrorF("unsupported mode=%d\n", mode);
+ return !Success;
+ }
+}
+
+/*
+ ***************************************************************************
+ *
+ * xf86EloAllocate --
+ *
+ ***************************************************************************
+ */
+static LocalDevicePtr
+#ifndef XFREE86_V4
+xf86EloAllocate(void)
+#else
+xf86EloAllocate(InputDriverPtr drv)
+#endif
+{
+ LocalDevicePtr local;
+ EloPrivatePtr priv;
+
+ priv = xalloc(sizeof(EloPrivateRec));
+ if (!priv)
+ return NULL;
+
+#ifndef XFREE86_V4
+ local = (LocalDevicePtr) xalloc(sizeof(LocalDeviceRec));
+#else
+ local = xf86AllocateInput(drv, 0);
+#endif
+
+ if (!local) {
+ xfree(priv);
+ return NULL;
+ }
+
+#ifdef XFREE86_V4
+ priv->input_dev = strdup(ELO_PORT);
+#else
+ priv->input_dev = ELO_PORT;
+ priv->link_speed = ELO_LINK_SPEED;
+#endif
+ priv->min_x = 0;
+ priv->max_x = 3000;
+ priv->min_y = 0;
+ priv->max_y = 3000;
+ priv->untouch_delay = ELO_UNTOUCH_DELAY;
+ priv->report_delay = ELO_REPORT_DELAY;
+ priv->screen_no = 0;
+ priv->screen_width = -1;
+ priv->screen_height = -1;
+ priv->inited = 0;
+ priv->is_a_2310 = 0;
+ priv->checksum = ELO_INIT_CHECKSUM;
+ priv->packet_buf_p = 0;
+ priv->swap_axes = 0;
+
+ local->name = XI_TOUCHSCREEN;
+ local->flags = 0 /* XI86_NO_OPEN_ON_INIT */;
+#ifndef XFREE86_V4
+#if !defined(sun) || defined(i386)
+ local->device_config = xf86EloConfig;
+#endif
+#endif
+ local->device_control = xf86EloControl;
+ local->read_input = xf86EloReadInput;
+ local->control_proc = NULL;
+ local->close_proc = NULL;
+ local->switch_mode = NULL;
+ local->conversion_proc = xf86EloConvert;
+ local->reverse_conversion_proc = NULL;
+ local->fd = -1;
+ local->atom = 0;
+ local->dev = NULL;
+ local->private = priv;
+ local->type_name = "Elographics TouchScreen";
+ local->history_size = 0;
+
+ return local;
+}
+
+#ifndef XFREE86_V4
+/*
+ ***************************************************************************
+ *
+ * Elographics device association --
+ *
+ ***************************************************************************
+ */
+DeviceAssocRec elographics_assoc =
+{
+ "elographics", /* config_section_name */
+ xf86EloAllocate /* device_allocate */
+};
+
+#ifdef DYNAMIC_MODULE
+/*
+ ***************************************************************************
+ *
+ * entry point of dynamic loading
+ *
+ ***************************************************************************
+ */
+int
+#ifndef DLSYM_BUG
+init_module(unsigned long server_version)
+#else
+init_xf86Elo(unsigned long server_version)
+#endif
+{
+ xf86AddDeviceAssoc(&elographics_assoc);
+
+ if (server_version != XF86_VERSION_CURRENT) {
+ ErrorF("Warning: Elographics module compiled for version%s\n", XF86_VERSION);
+ return 0;
+ }
+ else {
+ return 1;
+ }
+}
+#endif
+
+#else /* XFREE86_V4 */
+
+static void
+xf86EloUninit(InputDriverPtr drv,
+ LocalDevicePtr local,
+ int flags)
+{
+ EloPrivatePtr priv = (EloPrivatePtr) local->private;
+
+ xf86EloControl(local->dev, DEVICE_OFF);
+
+ xfree(priv->input_dev);
+ xfree(priv);
+ xfree(local->name);
+ xfree(local);
+
+ xf86DeleteInput(local, 0);
+}
+
+static const char *default_options[] = {
+ "BaudRate", "9600",
+ "StopBits", "1",
+ "DataBits", "8",
+ "Parity", "None",
+ "Vmin", "10",
+ "Vtime", "1",
+ "FlowControl", "None",
+ NULL
+};
+
+static InputInfoPtr
+xf86EloInit(InputDriverPtr drv,
+ IDevPtr dev,
+ int flags)
+{
+ LocalDevicePtr local=NULL;
+ EloPrivatePtr priv=NULL;
+ char *str;
+ int portrait = 0;
+
+ local = xf86EloAllocate(drv);
+ if (!local) {
+ return NULL;
+ }
+ priv = local->private;
+ local->conf_idev = dev;
+
+ xf86CollectInputOptions(local, default_options, NULL);
+ /* Process the common options. */
+ xf86ProcessCommonOptions(local, local->options);
+
+ str = xf86FindOptionValue(local->options, "Device");
+ if (!str) {
+ xf86Msg(X_ERROR, "%s: No Device specified in Elographics module config.\n",
+ dev->identifier);
+ if (priv) {
+ if (priv->input_dev) {
+ xfree(priv->input_dev);
+ }
+ xfree(priv);
+ }
+ return local;
+ }
+ priv->input_dev = strdup(str);
+
+ local->name = xf86SetStrOption(local->options, "DeviceName", XI_TOUCHSCREEN);
+ xf86Msg(X_CONFIG, "Elographics X device name: %s\n", local->name);
+ priv->screen_no = xf86SetIntOption(local->options, "ScreenNo", 0);
+ xf86Msg(X_CONFIG, "Elographics associated screen: %d\n", priv->screen_no);
+ priv->untouch_delay = xf86SetIntOption(local->options, "UntouchDelay", ELO_UNTOUCH_DELAY);
+ xf86Msg(X_CONFIG, "Elographics untouch delay: %d ms\n", priv->untouch_delay*10);
+ priv->report_delay = xf86SetIntOption(local->options, "ReportDelay", ELO_REPORT_DELAY);
+ xf86Msg(X_CONFIG, "Elographics report delay: %d ms\n", priv->report_delay*10);
+ priv->max_x = xf86SetIntOption(local->options, "MaxX", 3000);
+ xf86Msg(X_CONFIG, "Elographics maximum x position: %d\n", priv->max_x);
+ priv->min_x = xf86SetIntOption(local->options, "MinX", 0);
+ xf86Msg(X_CONFIG, "Elographics minimum x position: %d\n", priv->min_x);
+ priv->max_y = xf86SetIntOption(local->options, "MaxY", 3000);
+ xf86Msg(X_CONFIG, "Elographics maximum y position: %d\n", priv->max_y);
+ priv->min_y = xf86SetIntOption(local->options, "MinY", 0);
+ xf86Msg(X_CONFIG, "Elographics minimum y position: %d\n", priv->min_y);
+ priv->swap_axes = xf86SetBoolOption(local->options, "SwapXY", 0);
+ if (priv->swap_axes) {
+ xf86Msg(X_CONFIG, "Elographics device will work with X and Y axes swapped\n");
+ }
+ debug_level = xf86SetIntOption(local->options, "DebugLevel", 0);
+ if (debug_level) {
+#if DEBUG
+ xf86Msg(X_CONFIG, "Elographics debug level sets to %d\n", debug_level);
+#else
+ xf86Msg(X_INFO, "Elographics debug not available\n");
+#endif
+ }
+ str = xf86SetStrOption(local->options, "PortraitMode", "Landscape");
+ if (strcmp(str, "Portrait") == 0) {
+ portrait = 1;
+ }
+ else if (strcmp(str, "PortraitCCW") == 0) {
+ portrait = -1;
+ }
+ else if (strcmp(str, "Landscape") != 0) {
+ xf86Msg(X_ERROR, "Elographics portrait mode should be: Portrait, Landscape or PortraitCCW");
+ str = "Landscape";
+ }
+ xf86Msg(X_CONFIG, "Elographics device will work in %s mode\n", str);
+
+ if (priv->max_x - priv->min_x <= 0) {
+ xf86Msg(X_INFO, "Elographics: reverse x mode (minimum x position >= maximum x position)\n");
+ }
+ if (priv->max_y - priv->min_y <= 0) {
+ xf86Msg(X_INFO, "Elographics: reverse y mode (minimum y position >= maximum y position)\n");
+ }
+
+ if (portrait == 1) {
+ /*
+ * Portrait Clockwise: reverse Y axis and exchange X and Y.
+ */
+ int tmp;
+ tmp = priv->min_y;
+ priv->min_y = priv->max_y;
+ priv->max_y = tmp;
+ priv->swap_axes = (priv->swap_axes==0) ? 1 : 0;
+ }
+ else if (portrait == -1) {
+ /*
+ * Portrait Counter Clockwise: reverse X axis and exchange X and Y.
+ */
+ int tmp;
+ tmp = priv->min_x;
+ priv->min_x = priv->max_x;
+ priv->max_x = tmp;
+ priv->swap_axes = (priv->swap_axes==0) ? 1 : 0;
+ }
+
+ /* mark the device configured */
+ local->flags |= XI86_CONFIGURED;
+ return local;
+}
+
+#ifdef XFree86LOADER
+static
+#endif
+InputDriverRec ELOGRAPHICS = {
+ 1, /* driver version */
+ "elographics", /* driver name */
+ NULL, /* identify */
+ xf86EloInit, /* pre-init */
+ xf86EloUninit, /* un-init */
+ NULL, /* module */
+ 0 /* ref count */
+};
+
+#ifdef XFree86LOADER
+static pointer
+Plug(pointer module,
+ pointer options,
+ int *errmaj,
+ int *errmin)
+{
+ xf86AddInputDriver(&ELOGRAPHICS, module, 0);
+
+ return module;
+}
+
+static void
+Unplug(pointer p)
+{
+ DBG(1, ErrorF("EloUnplug\n"));
+}
+
+static XF86ModuleVersionInfo version_rec = {
+ "elographics",
+ MODULEVENDORSTRING,
+ MODINFOSTRING1,
+ MODINFOSTRING2,
+ XF86_VERSION_CURRENT,
+ 1, 0, 0,
+ ABI_CLASS_XINPUT,
+ ABI_XINPUT_VERSION,
+ MOD_CLASS_XINPUT,
+ { 0, 0, 0, 0 }
+};
+
+/*
+ * This is the entry point in the module. The name
+ * is setup after the pattern <module_name>ModuleData.
+ * Do not change it.
+ */
+XF86ModuleData elographicsModuleData = { &version_rec, Plug, Unplug };
+
+#endif
+#endif /* XFREE86_V4 */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 23:54:39 +0000