#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"
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
};
#endif
#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"
typedef struct _UR98PrivateRec {
char *input_dev;
int min_x;
int max_x;
int min_y;
int max_y;
int min_z;
int max_z;
int min_t;
int max_t;
int cur_x;
int cur_y;
int cur_z;
int cur_t;
int axes;
int button_5;
int buttons[5];
int screen_no;
int screen_width;
int screen_height;
Bool inited;
char state;
LocalDevicePtr head;
int swap_axes;
int head_button;
int head_lock;
int head_thresh;
} UR98PrivateRec, *UR98PrivatePtr;
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;
xf86XInputSetScreen(local, priv->screen_no, *x, *y);
return TRUE;
}
static void UR98PtrCtrl(DeviceIntPtr device, PtrCtrl *ctrl)
{
}
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)
{
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)
{
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;
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);
}
}
}
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;
if (InitButtonClassDeviceStruct(dev, 4 + priv->button_5, map) == FALSE) {
ErrorF("Unable to allocate ButtonClassDeviceStruct\n");
return !Success;
}
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 ,
65535 );
InitValuatorAxisStruct(dev, 1, priv->min_y, priv->max_y,
65535,
0 ,
65535 );
if(priv->axes > 2)
{
if(priv->head_button)
{
InitValuatorAxisStruct(dev, 2, priv->min_t, priv->max_t,
65535,
0 ,
65535 );
}
else
{
InitValuatorAxisStruct(dev, 2, priv->min_z, priv->max_z,
65535,
0 ,
65535 );
}
}
if(priv->axes > 3)
InitValuatorAxisStruct(dev, 3, priv->min_t, priv->max_t,
65535,
0 ,
65535 );
}
if (InitFocusClassDeviceStruct(dev) == FALSE) {
ErrorF("Unable to allocate FocusClassDeviceStruct\n");
}
if(InitPtrFeedbackClassDeviceStruct(dev, UR98PtrCtrl) == FALSE) {
ErrorF("Unable to allocate PtrFeedBackClassDeviceStruct\n");
}
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;
}
}
static int xf86UR98ControlProc (InputInfoPtr pInfo, xDeviceCtl * control)
{
return (Success);
}
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 ;
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;
}
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;
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) {
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) {
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(priv->button_5)
priv->axes = 3;
else
priv->axes = 4;
if(priv->head_button)
priv->axes--;
xf86ProcessCommonOptions(local, local->options);
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,
"ur98",
NULL,
xf86UR98Init,
xf86UR98Uninit,
NULL,
0
};
#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 }
};
XF86ModuleData ur98ModuleData = { &version_rec, Plug, Unplug };
#endif