diff options
| -rw-r--r-- | man/ur98.man | 131 | ||||
| -rw-r--r-- | src/xf86Ur-98.c | 721 |
2 files changed, 852 insertions, 0 deletions
diff --git a/man/ur98.man b/man/ur98.man new file mode 100644 index 0000000..b699a0f --- /dev/null +++ b/man/ur98.man @@ -0,0 +1,131 @@ +.\" $XFree86: xc/programs/Xserver/hw/xfree86/input/ur98/ur98.man,v 1.1 2002/11/22 03:49:15 dawes Exp $ +.\" shorthand for double quote that works everywhere. +.ds q \N'34' +.TH UR98 __drivermansuffix__ __vendorversion__ +.SH NAME +UR-98 \- UR98 (TR88L803) head tracker driver +.SH SYNOPSIS +.B "Section \*qInputDevice\*q" +.br +.BI " Identifier \*q" idevname \*q +.br +.B " Driver \*qUR-98\*q" +.br +.BI " Option \*qDevice\*q \*q" devpath \*q +.br +\ \ ... +.br +.B EndSection +.SH DESCRIPTION +.B UR-98 +is an XFree86 input driver for the Union Reality UR-F98 headtracker. +.PP +The +.B UR-98 +driver functions as a pointer input device, and can be used either as an +additional input device or as the X server's core pointer. The driver +provides support for the three axes, throttle and four buttons of the +controller. If mapped as the core pointer the headtracker provides +headtracking to try and place the mouse cursor where you look. As a +secondary input device the unit can be used for gaming, for example to +provide the look up/down and the turn in quake, and with the Z axis bound +to ack/forward to provide movement control. +.PP +The default mapping maps left-right movement to X, up-down movement to Y and +near/far movement to the Z axis. The throttle is mapped as the fourth axis +by default but can also be mapped as button 5. +.PP +For use in "head only" mode the Z axis can be mapped as a button. This +allows the user to select objects with head/neck movement alone but takes some +practice to use well. +.PP +.SH SUPPORTED HARDWARE +Union Reality UR-98. While this is a joystick driver the behaviour is +absolute so this driver is not useful for true joystick interfaces. +.SH CONFIGURATION DETAILS +Please refer to XF86Config(__filemansuffix__) for general configuration +details and for options that can be used with all input drivers. This +section only covers configuration details specific to this driver. +.PP +The following driver +.B options +are supported +.TP +.BI "Option \*qMinX\*q \*q" integer \*q +Set the left hand X value from the headgear, for calibration. +.TP +.BI "Option \*qMaxX\*q \*q" integer \*q +Set the right hand X value from the headgear, for calibration. +.TP +.BI "Option \*qMinY\*q \*q" integer \*q +Set the top Y value from the headgear, for calibration. +.TP +.BI "Option \*qMaxY\*q \*q" integer \*q +Set the bottom Y value from the headgear, for calibration. +.TP +.BI "Option \*qMinZ\*q \*q" integer \*q +Set the nearest Z value from the headgear, for calibration. +.TP +.BI "Option \*qMaxZ\*q \*q" integer \*q +Set the furthest Z value from the headgear, for calibration. +.TP +.BI "Option \*qMinT\*q \*q" integer \*q +Set the low throttle value from the headgear, for calibration. +.TP +.BI "Option \*qMaxT\*q \*q" integer \*q +Set the high throttle value from the headgear, for calibration. +.TP +.BI "Option \*qScreen\*q \*q" integer \*q +The screen to attach to the headgear when running with multiple screens. +The default is screen 0. +.TP +.BI "Option \*qDevice\*q \*q" string \*q +The joystick port that is attached to the headgear interface. This is +usually /dev/input/js0. The digital port is not supported due to lack of +documentation. +.TP +.BI "Option \*qDeviceName\*q \*q" string \*q +Set the X11 device name for the headgear. This defaults to HEAD. +.TP +.BI "Option \*qPortraitMode\*q \*q" string \*q +Set the display orientation. The default is "landscape" but you can rotate +the screen clockwise ("portrait") or anticlockwise ("portraitCCW"). +.TP +.BI "Option \*qSwapXY\*q \*q" boolean \*q +Swap the X and Y values on the display. The default is false. +.TP +.BI "Option \*qButton5\*q \*q" boolean \*q +Map the throttle as a button instead of axis 4. For some gaming applications +this can be more useful. The default is to map the throttle as axis 4. +.TP +.BI "Option \*qHeadButton\*q \*q" boolean \*q +Map the Z axis as button 1. This defaults to false. +.TP +.BI "Option \*qHeadThresh\*q \*q" boolean \*q +Set the distance that is held to be mouse down. +.TP +.BI "Option \*qHeadLock\*q \*q" boolean \*q +Set the range of depth around the mouse down point where mouse x and y +movement is locked out. Set to zero to disable. +.SH "BUGS" +The "HeadButton" option is currently not implemented. +.PP +The hardware or kernel driver has some idiosyncracies. Notably on +kernel initialization the interface occasionally gets into a state where the +readings rapidly cycle left-right-left-right or top-bottom-top-bottom. +In those cases it seems to be neccessary to unload the driver, unplug, +replug and reload the joystick drivers. Once it initializes sanely it +remains sane. +.PP +If the device refuses to work check the gray/black cables are plugged into +the right ports on the unit. Be careful about this as crossing the cables +can lead to the device failing with a nasty burning electronics smell. The +author writes from direct experience. +.PP +This driver is currently Linux specific. +.PP +.SH "SEE ALSO" +XFree86(1), XF86Config(__filemansuffix__), xf86config(1), Xserver(1), X(__miscmansuffix__). +.SH AUTHORS +Authors include... + Alan Cox diff --git a/src/xf86Ur-98.c b/src/xf86Ur-98.c new file mode 100644 index 0000000..d61632f --- /dev/null +++ b/src/xf86Ur-98.c @@ -0,0 +1,721 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/input/ur98/xf86Ur-98.c,v 1.1 2002/11/22 03:49:15 dawes Exp $ */ + +#include <sys/types.h> +#include <unistd.h> +#include <string.h> +#include <errno.h> +#define inline __inline__ +#include <linux/joystick.h> + +#undef BUS_ISA +#undef BUS_PCI + +#include <fcntl.h> +#include <sys/ioctl.h> +#include "misc.h" +#include "xf86.h" +#include "xf86_OSproc.h" +#include "xf86Xinput.h" +#include "exevents.h" +#include "os.h" + +#ifdef XFree86LOADER +#include "xf86Module.h" +#endif + +static const char *reqSymbols[] = { + "AddEnabledDevice", + "ErrorF", + "InitButtonClassDeviceStruct", + "InitProximityClassDeviceStruct", + "InitValuatorAxisStruct", + "InitValuatorClassDeviceStruct", + "InitPtrFeedbackClassDeviceStruct", + "RemoveEnabledDevice", + "Xcalloc", + "Xfree", + "XisbBlockDuration", + "XisbFree", + "XisbNew", + "XisbRead", + "XisbTrace", + "screenInfo", + "xf86AddInputDriver", + "xf86AllocateInput", + "xf86CloseSerial", + "xf86CollectInputOptions", + "xf86ErrorFVerb", + "xf86FindOptionValue", + "xf86GetMotionEvents", + "xf86GetVerbosity", + "xf86MotionHistoryAllocate", + "xf86NameCmp", + "xf86OpenSerial", + "xf86OptionListCreate", + "xf86OptionListMerge", + "xf86OptionListReport", + "xf86PostButtonEvent", + "xf86PostMotionEvent", + "xf86PostProximityEvent", + "xf86ProcessCommonOptions", + "xf86ScaleAxis", + "xf86SetIntOption", + "xf86SetStrOption", + "xf86XInputSetScreen", + "xf86XInputSetSendCoreEvents", + NULL +}; + + + +/* + *************************************************************************** + * + * Default constants. + * + *************************************************************************** + */ + +#define DEFAULT_MAX_X 32768 +#define DEFAULT_MIN_X 0 +#define DEFAULT_MAX_Y 65535 +#define DEFAULT_MIN_Y 0 +#define DEFAULT_MAX_Z 65535 +#define DEFAULT_MIN_Z 0 +#define DEFAULT_MAX_T 65535 +#define DEFAULT_MIN_T 0 + +#define DEFAULT_HEAD_THRESH 38000 +#define DEFAULT_HEAD_LOCK 450 + +#define XI_STYLUS "HEAD" /* X device name for the head tracking device */ + + +/* + *************************************************************************** + * + * Device private records. + * + *************************************************************************** + */ + +typedef struct _UR98PrivateRec { + char *input_dev; /* The head screen input device */ + 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 min_z; /* Minimum z */ + int max_z; /* Maximum z */ + int min_t; /* Minimum t */ + int max_t; /* Maximum t */ + int cur_x; /* Current x */ + int cur_y; /* Current y */ + int cur_z; /* Current z */ + int cur_t; /* Current t */ + int axes; /* Number of axes */ + int button_5; /* True if axis 4 is remapped as button5 */ + int buttons[5]; /* Button status */ + 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 ? */ + char state; /* Current state of report flags. */ + LocalDevicePtr head; /* Device ptr associated with the hw. */ + int swap_axes; /* Swap X an Y axes if != 0 */ + int head_button; /* Z is button 0, cur_z is holds true cur_t */ + int head_lock; /* Lock for x/y in head_button mode */ + int head_thresh; /* Threshhold for Z as button down */ +} UR98PrivateRec, *UR98PrivatePtr; + + +/* + *************************************************************************** + * + * xf86UR98Convert -- + * 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 xf86UR98Convert(LocalDevicePtr local, int first, int num, + int v0,int v1,int v2,int v3, int v4, int v5, int *x, int *y) +{ + UR98PrivatePtr priv = (UR98PrivatePtr) local->private; + int width = priv->max_x - priv->min_x; + int height = priv->max_y - priv->min_y; + int input_x, input_y; + int tmp; + + input_x = v0; + input_y = v1; + + if (priv->swap_axes) { + tmp = input_x; + input_x = input_y; + input_y = tmp; + } + *x = (priv->screen_width * (input_x - priv->min_x)) / width; + *y = (priv->screen_height * (input_y - priv->min_y)) / height; + /* + * 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); + return TRUE; +} + +static void UR98PtrCtrl(DeviceIntPtr device, PtrCtrl *ctrl) +{ + /* I have no clue what this does, except that registering it stops the + X server segfaulting in ProcGetPointerMapping() + Ho Hum. + */ +} + +static void xf86UR98ReadInput(LocalDevicePtr local) +{ + UR98PrivatePtr priv = (UR98PrivatePtr)(local->private); + struct js_event event; + int one=1; + + ioctl(local->fd, FIONBIO, &one); + + while(read(local->fd, &event, sizeof(event))==sizeof(event)) + { + if(event.type & JS_EVENT_BUTTON) + { + /* Shift the buttons if Z is button 1 */ + event.number += priv->head_button; + if(priv->buttons[event.number] != event.value) + { + priv->buttons[event.number] = event.value; + xf86PostButtonEvent(priv->head->dev, TRUE, event.number + 1, event.value, + 0, priv->axes, priv->cur_x, priv->cur_y, priv->cur_z, priv->cur_t); + } + } + if(event.type & JS_EVENT_AXIS) + { + int lock = 0; + + if(priv->head_lock) + { + lock = priv->cur_t - priv->head_thresh; + ErrorF("Lock %d\n", lock); + if(lock < -priv->head_lock || lock > priv->head_lock) + lock = 0; + else + lock = priv->head_button; + } + + switch(event.number) + { + case 0: + if(!lock) + priv->cur_x = event.value+32768; + break; + case 1: + if(!lock) + priv->cur_y = event.value+32768; + break; + case 2: + if(priv->button_5 == 0) + { + /* We use cur_z to hold cur_t in + head button mode. Hackish but saves + a lot of conditional code elsewhere */ + if(priv->head_button) + priv->cur_z = event.value + 32768; + else + priv->cur_t = event.value +32768; + } + else + { + if(event.value > 0) + event.value = 1; + else + event.value = 0; + if(priv->buttons[4] != event.value) + { + priv->buttons[4] = event.value; + xf86PostButtonEvent(priv->head->dev, TRUE, 4, event.value, + 0, priv->axes, priv->cur_x, priv->cur_y, priv->cur_z, priv->cur_t); + } + } + case 3: + if(priv->head_button == 0) + priv->cur_z = event.value+32768; + else + { + ErrorF("Head at %d\n", event.value + 32768); + priv->cur_t = event.value+32768; + /* Low is near... */ + if(priv->cur_t < priv->head_thresh) + event.value = 1; + else + event.value = 0; + if(priv->buttons[0] != event.value) + { + priv->buttons[0] = event.value; + xf86PostButtonEvent(priv->head->dev, TRUE, 1, event.value, + 0, priv->axes, priv->cur_x, priv->cur_y, priv->cur_z, priv->cur_t); + } + } + break; + } + xf86PostMotionEvent(priv->head->dev, TRUE, 0, priv->axes, priv->cur_x, priv->cur_y, priv->cur_z, priv->cur_t); + } + } +} + + +/* + *************************************************************************** + * + * xf86UR98Control -- + * + *************************************************************************** + */ +static Bool +xf86UR98Control(DeviceIntPtr dev, + int mode) +{ + static unsigned char map[] = { 0, 1, 2, 3, 4, 5}; + LocalDevicePtr local = (LocalDevicePtr) dev->public.devicePrivate; + UR98PrivatePtr priv = (UR98PrivatePtr)(local->private); + + switch(mode) + { + + case DEVICE_INIT: + 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 5 buttons. + */ + if (InitButtonClassDeviceStruct(dev, 4 + priv->button_5, map) == FALSE) { + ErrorF("Unable to allocate ButtonClassDeviceStruct\n"); + return !Success; + } + + /* + * Device reports motions on 3 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, priv->axes, xf86GetMotionEvents, + local->history_size, Absolute) == FALSE) { + ErrorF("Unable to allocate ValuatorClassDeviceStruct\n"); + return !Success; + } + else + { + InitValuatorAxisStruct(dev, 0, priv->min_x, priv->max_x, + 65535, + 0 /* min_res */, + 65535 /* max_res */); + InitValuatorAxisStruct(dev, 1, priv->min_y, priv->max_y, + 65535, /* resolution */ + 0 /* min_res */, + 65535 /* max_res */); + if(priv->axes > 2) + { + if(priv->head_button) + { + /* In head button mode we skip the Z axis */ + InitValuatorAxisStruct(dev, 2, priv->min_t, priv->max_t, + 65535, /* resolution */ + 0 /* min_res */, + 65535 /* max_res */); + } + else + { + InitValuatorAxisStruct(dev, 2, priv->min_z, priv->max_z, + 65535, /* resolution */ + 0 /* min_res */, + 65535 /* max_res */); + } + } + if(priv->axes > 3) + InitValuatorAxisStruct(dev, 3, priv->min_t, priv->max_t, + 65535, /* resolution */ + 0 /* min_res */, + 65535 /* max_res */); + } + + if (InitFocusClassDeviceStruct(dev) == FALSE) { + ErrorF("Unable to allocate FocusClassDeviceStruct\n"); + } + + if(InitPtrFeedbackClassDeviceStruct(dev, UR98PtrCtrl) == FALSE) { + ErrorF("Unable to allocate PtrFeedBackClassDeviceStruct\n"); + } + + /* + * Allocate the motion events buffer. + */ + + xf86MotionHistoryAllocate(local); + + return Success; + + case DEVICE_ON: + if (local->fd < 0) { + char c; + int ver; + + local->fd = open(priv->input_dev, O_RDONLY|O_NDELAY); + if (local->fd < 0) { + ErrorF("Unable to open UR98 headtracker device\n"); + return !Success; + } + if(ioctl(local->fd, JSIOCGVERSION, &ver)==-1) + { + ErrorF("Unable to query headtracker interface version\n"); + return !Success; + } + if(ioctl(local->fd, JSIOCGAXES, &c)==-1) + { + ErrorF("Unable to query headtracker parameters\n"); + return !Success; + } + if(c!=4) + { + ErrorF("Device is not a UR-98\n"); + return !Success; + } + if(ioctl(local->fd, JSIOCGBUTTONS, &c)==-1) + { + ErrorF("Unable to query headtracker parameters\n"); + return !Success; + } + if(c!=4) + { + ErrorF("Device is not a UR-98\n"); + return !Success; + } + AddEnabledDevice(local->fd); + } + dev->public.on = TRUE; + return Success; + + case DEVICE_OFF: + dev->public.on = FALSE; + return Success; + + case DEVICE_CLOSE: + dev->public.on = FALSE; + if (local->fd >= 0) { + xf86RemoveEnabledDevice(local); + close(local->fd); + local->fd = -1; + } + return Success; + default: + ErrorF("unsupported mode=%d\n", mode); + return !Success; + } +} + +/* + *************************************************************************** + * + * xf86UR98ControlProc -- + * + *************************************************************************** + */ + +static int xf86UR98ControlProc (InputInfoPtr pInfo, xDeviceCtl * control) +{ + return (Success); +} + +/* + *************************************************************************** + * + * xf86UR98Allocate -- + * + *************************************************************************** + */ +static LocalDevicePtr xf86UR98Allocate(InputDriverPtr drv, char *name, char *type_name, int flag) +{ + LocalDevicePtr local = xf86AllocateInput(drv, 0); + UR98PrivatePtr priv = (UR98PrivatePtr) xalloc(sizeof(UR98PrivateRec)); + int i; + + if (!local || !priv) + { + if(priv) + xfree(priv); + if(local) + xfree(local); + return NULL; + } + + priv->input_dev = strdup("/dev/js0"); + priv->min_x = 0; + priv->max_x = 0; + priv->min_y = 0; + priv->max_y = 0; + priv->min_z = 0; + priv->max_z = 0; + priv->min_t = 0; + priv->max_t = 0; + priv->button_5 = 0; + priv->axes = 4; + priv->screen_no = 0; + priv->screen_width = -1; + priv->screen_height = -1; + priv->inited = 0; + priv->state = 0; + priv->swap_axes = 0; + for(i = 0; i < 5; i++) + priv->buttons[i] = 0; + priv->head_button = 0; + priv->head_thresh = 0; + priv->head_lock = 0; + + local->name = name; + local->flags = 0 /* XI86_NO_OPEN_ON_INIT */; + local->device_control = xf86UR98Control; + local->read_input = xf86UR98ReadInput; + local->control_proc = xf86UR98ControlProc; + local->close_proc = NULL; + local->switch_mode = NULL; + local->conversion_proc = xf86UR98Convert; + local->reverse_conversion_proc = NULL; + local->fd = -1; + local->atom = 0; + local->dev = NULL; + local->private = priv; + local->private_flags = flag; + local->type_name = type_name; + local->history_size = 0; + + return local; +} + + +/* + *************************************************************************** + * + * xf86UR98AllocateHeadTracker -- + * + *************************************************************************** + */ +static LocalDevicePtr xf86UR98AllocateHeadTracker(InputDriverPtr drv) +{ + LocalDevicePtr local = xf86UR98Allocate(drv, XI_STYLUS, "UR98 HeadTracker", 1); + if (local) + ((UR98PrivatePtr) local->private)->head = local; + return local; +} + + +static void xf86UR98Uninit(InputDriverPtr drv, LocalDevicePtr local, int flags) +{ + UR98PrivatePtr priv = (UR98PrivatePtr) local->private; + + xf86UR98Control(local->dev, DEVICE_OFF); + + if (priv) { + priv->head->private = NULL; + xfree(priv->input_dev); + xfree(priv); + } + xfree(local->name); + xfree(local); + + xf86DeleteInput(local, 0); +} + +static InputInfoPtr xf86UR98Init(InputDriverPtr drv, IDevPtr dev, int flags) +{ + LocalDevicePtr local=NULL; + UR98PrivatePtr priv=NULL; + char *str; + int portrait=0; + + + local = xf86UR98AllocateHeadTracker(drv); + priv = local->private; + local->conf_idev = dev; + + xf86CollectInputOptions(local, NULL, NULL); + + str = xf86FindOptionValue(local->options, "Device"); + if (!str) { + xf86Msg(X_ERROR, "%s: No Device specified in UR98 module config.\n", dev->identifier); + goto init_err; + } + priv->input_dev = strdup(str); + priv->head = local; + + /* Process the common options. */ + xf86ProcessCommonOptions(local, local->options); + + str = xf86FindOptionValue(local->options, "DeviceName"); + if (str) { + local->name = strdup(str); + } + xf86Msg(X_CONFIG, "UR98 X device name: %s\n", local->name); + priv->screen_no = xf86SetIntOption(local->options, "ScreenNo", 0); + xf86Msg(X_CONFIG, "UR98 associated screen: %d\n", priv->screen_no); + priv->max_x = xf86SetIntOption(local->options, "MaxX", DEFAULT_MAX_X); + xf86Msg(X_CONFIG, "UR98 maximum x position: %d\n", priv->max_x); + priv->min_x = xf86SetIntOption(local->options, "MinX", DEFAULT_MIN_X); + xf86Msg(X_CONFIG, "UR98 minimum x position: %d\n", priv->min_x); + priv->max_y = xf86SetIntOption(local->options, "MaxY", DEFAULT_MAX_Y); + xf86Msg(X_CONFIG, "UR98 maximum y position: %d\n", priv->max_y); + priv->min_y = xf86SetIntOption(local->options, "MinY", DEFAULT_MIN_Y); + xf86Msg(X_CONFIG, "UR98 minimum y position: %d\n", priv->min_y); + priv->max_z = xf86SetIntOption(local->options, "MaxZ", DEFAULT_MAX_Z); + xf86Msg(X_CONFIG, "UR98 maximum z position: %d\n", priv->max_z); + priv->min_z = xf86SetIntOption(local->options, "MinZ", DEFAULT_MIN_Z); + xf86Msg(X_CONFIG, "UR98 minimum z position: %d\n", priv->min_z); + priv->max_t = xf86SetIntOption(local->options, "MaxT", DEFAULT_MAX_T); + xf86Msg(X_CONFIG, "UR98 maximum z position: %d\n", priv->max_t); + priv->min_t = xf86SetIntOption(local->options, "MinT", DEFAULT_MIN_T); + xf86Msg(X_CONFIG, "UR98 minimum z position: %d\n", priv->min_t); + priv->head_button = xf86SetBoolOption(local->options, "HeadButton", 0); + if(priv->head_button) + xf86Msg(X_CONFIG, "UR98 head proximity acts as button 1\n"); + priv->head_thresh = xf86SetIntOption(local->options, "HeadButton", DEFAULT_HEAD_THRESH); + if(priv->head_button) + xf86Msg(X_CONFIG, "UR98 proximity threshhold %d\n", priv->head_thresh); + if(priv->head_button) + { + priv->head_lock = xf86SetIntOption(local->options, "HeadLock", DEFAULT_HEAD_LOCK); + xf86Msg(X_CONFIG, "UR98 proximity lock range %d\n", priv->head_thresh); + } + priv->button_5 = xf86SetBoolOption(local->options, "Button5", 0); + if(priv->button_5) + xf86Msg(X_CONFIG, "UR98 throttle mapped as button 5\n"); + priv->swap_axes = xf86SetBoolOption(local->options, "SwapXY", 0); + if (priv->swap_axes) { + xf86Msg(X_CONFIG, "UR98 %s device will work with X and Y axes swapped\n", + local->name); + } + 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, "UR98 portrait mode should be: Portrait, Landscape or PortraitCCW"); + str = "Landscape"; + } + xf86Msg(X_CONFIG, "UR98 device will work in %s mode\n", str); + + if (priv->max_x - priv->min_x <= 0) { + xf86Msg(X_INFO, "UR98: reverse x mode (minimum x position >= maximum x position)\n"); + } + if (priv->max_y - priv->min_y <= 0) { + xf86Msg(X_INFO, "UR98: 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; + } + + /* If we have button_5 set then we lose the 't' axis */ + if(priv->button_5) + priv->axes = 3; + else + priv->axes = 4; + + /* If we have head_button set then we lose the 'z' axis */ + if(priv->head_button) + priv->axes--; + + xf86ProcessCommonOptions(local, local->options); + + /* mark the device configured */ + local->flags |= XI86_CONFIGURED; + return local; + +init_err: + if (priv) { + if (priv->input_dev) + xfree(priv->input_dev); + xfree(priv); + } + if (local) + xfree(local); + return NULL; +} + +#ifdef XFree86LOADER +static +#endif +InputDriverRec UR98 = { + 1, /* driver version */ + "ur98", /* driver name */ + NULL, /* identify */ + xf86UR98Init, /* pre-init */ + xf86UR98Uninit, /* un-init */ + NULL, /* module */ + 0 /* ref count */ +}; + +#ifdef XFree86LOADER +static pointer Plug(pointer module, pointer options, int *errmaj,int *errmin) +{ + xf86LoaderReqSymLists(reqSymbols, NULL); + xf86AddInputDriver(&UR98, module, 0); + return module; +} + +static void Unplug(pointer p) +{ +} + +static XF86ModuleVersionInfo version_rec = { + "ur98", + 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 ur98ModuleData = { &version_rec, Plug, Unplug }; +#endif + |