← Back to branch summary

~ubuntu-branches/ubuntu/saucy/joystick/saucy

« back to all changes in this revision

Viewing changes to xfree86/tuntitko-common.c

  • Committer: Bazaar Package Importer
  • Author(s): Edward Betts
  • Date: 2001-12-26 13:32:55 UTC
  • Revision ID: james.westby@ubuntu.com-20011226133255-hlp8fay1eq671xwn
Tags: upstream-20010903
Import upstream version 20010903

Show diffs side-by-side

added added

removed removed

Lines of Context:
xfree86/tuntitko-common.c
 
1
#include "tuntitko-common.h"
 
2
 
 
3
#include <linux/input.h>
 
4
 
 
5
#include <fcntl.h>
 
6
#include <unistd.h>
 
7
 
 
8
#include <extnsionst.h>
 
9
#include <extinit.h>
 
10
#include <exevents.h>
 
11
 
 
12
TLOG_VARIABLE;
 
13
 
 
14
static int
 
15
tunProcInit (DeviceIntPtr pTun)
 
16
{
 
17
  LocalDevicePtr        local = (LocalDevicePtr) pTun->public.devicePrivate;
 
18
  TunDevicePtr          tun = (TunDevicePtr) local -> private;
 
19
  TunDeviceIDInfo       device_ID;
 
20
 
 
21
  int                   smin, swidth, sheight, smax;
 
22
  int                   i, fd = -1;
 
23
 
 
24
  if ((fd = open (tun->input_device, O_RDONLY)) < 0)
 
25
    {
 
26
      ErrorF ("Tuntitko: unable to open file %s", tun->input_device);
 
27
      goto error;
 
28
    }
 
29
 
 
30
  tunQueryDeviceID (fd, device_ID);
 
31
  if (device_ID [ID_BUS] != tun->device_ID [ID_BUS] ||
 
32
      device_ID [ID_VENDOR] != tun->device_ID [ID_VENDOR] ||
 
33
      device_ID [ID_PRODUCT] != tun->device_ID [ID_PRODUCT] ||
 
34
      device_ID [ID_VERSION] != tun->device_ID [ID_VERSION])
 
35
    {
 
36
      ErrorF ("Tuntitko: something bad happend - device ID is not the same as configured device ID");
 
37
      goto error;
 
38
    }
 
39
 
 
40
  smin = 0;
 
41
  swidth = screenInfo.screens [0]->width;
 
42
  sheight = screenInfo.screens [0]->height;
 
43
  smax = (swidth < sheight) ? sheight : swidth;
 
44
 
 
45
  TLOG ("xvaluators %d", tun->nof_xvaluators);
 
46
  
 
47
  if (tun->nof_xvaluators)
 
48
    { /* register valuators */
 
49
      TunValuatorPtr            valptr;
 
50
 
 
51
      if (InitValuatorClassDeviceStruct (pTun, tun->nof_xvaluators, xf86GetMotionEvents,
 
52
                                         local->history_size, tun->is_absolute) == FALSE)
 
53
        {
 
54
          ErrorF("unable to allocate Valuator class device\n"); 
 
55
          goto error;
 
56
        }
 
57
 
 
58
      for (i = 0; i < tun->nof_xvaluators; i++)
 
59
        if (tun->xval_to_lval_tbl [i] == NULL) /* register fake valuator */
 
60
          InitValuatorAxisStruct (pTun, i, -1, 1, 1,0,1);
 
61
        else
 
62
          {
 
63
            valptr = tun->xval_to_lval_tbl [i];
 
64
 
 
65
            if (valptr -> is_absolute == FALSE &&
 
66
                valptr->min >= valptr->max)
 
67
              { 
 
68
                valptr->min = smin;
 
69
                if (i == 0) /* X */
 
70
                  valptr->max = swidth;
 
71
                else if (i == 1) /* Y */
 
72
                  valptr->max = sheight;
 
73
                else valptr->max = smax; 
 
74
              }
 
75
 
 
76
            valptr->value = (valptr->max + valptr->min) / 2;
 
77
            InitValuatorAxisStruct (pTun, i, 
 
78
                                    valptr->min,
 
79
                                    valptr->max,
 
80
                                    1,0,1 /* fake resolution */);
 
81
          }
 
82
 
 
83
      /* allocate the motion history buffer if needed */
 
84
      xf86MotionHistoryAllocate (local);
 
85
 
 
86
      valptr = tun->xval_to_lval_tbl [0];
 
87
      if (valptr)
 
88
        tun->factorX = ((double) screenInfo.screens[0]->width)
 
89
          / (double) (valptr->max - valptr->min);
 
90
      else tun->factorX = 1.0;
 
91
 
 
92
      valptr = (tun->nof_xvaluators > 1) 
 
93
        ? tun->xval_to_lval_tbl [1]
 
94
        : NULL;
 
95
 
 
96
      if (valptr)
 
97
        tun->factorY = ((double) screenInfo.screens[0]->height)
 
98
          / (double) (valptr->max - valptr->min);
 
99
 
 
100
      TLOG ("FX: %g, FY: %g", tun->factorX, tun->factorY);
 
101
    }
 
102
 
 
103
  if (tun->has_proximity)
 
104
    if (InitProximityClassDeviceStruct (pTun) == FALSE)
 
105
      {
 
106
        ErrorF ("unable to init proximity class device\n");
 
107
        goto error;
 
108
      }
 
109
  
 
110
  if (tun->max_xbutton)
 
111
    {
 
112
      CARD8             map [BUTTON_MAX];
 
113
 
 
114
      for (i = 0; i <= tun->max_xbutton; i++)
 
115
        map [i] = i;
 
116
 
 
117
      if (InitButtonClassDeviceStruct (pTun, tun->max_xbutton, map) == FALSE)
 
118
        {
 
119
          ErrorF ("unable to init Button class device\n");
 
120
          goto error;
 
121
        }
 
122
    }
 
123
 
 
124
#ifndef XFREE86_V4
 
125
  AssignTypeAndName (pTun, local->atom, local->name);
 
126
#endif
 
127
 
 
128
  close (fd);  /* let's hope that nobody change our device behind our back :*) */
 
129
  TLOG ("[%s] Init OK.", local->name);
 
130
 
 
131
  return Success;
 
132
 
 
133
 error:
 
134
  if (fd > 0)
 
135
    close (fd);
 
136
 
 
137
  return !Success;
 
138
}
 
139
 
 
140
static int
 
141
tunProc(DeviceIntPtr       pTun,
 
142
        int                what)
 
143
{
 
144
  LocalDevicePtr        local = (LocalDevicePtr) pTun->public.devicePrivate;
 
145
  TunDevicePtr          tun = (TunDevicePtr) local -> private;
 
146
 
 
147
  switch (what)
 
148
    {
 
149
    case DEVICE_INIT: 
 
150
      TLOG ("DEVICE_INIT (%s)", local -> name);
 
151
      return tunProcInit (pTun);
 
152
 
 
153
    case DEVICE_ON:
 
154
      TLOG ("DEVICE_ON (%s)", local -> name);
 
155
 
 
156
      if (local->fd < 0)
 
157
        if ((local->fd = open (tun->input_device, O_RDONLY)) == -1)
 
158
          {
 
159
            TLOG ("Can not open device %s file %s", 
 
160
                  local->name, tun->input_device);
 
161
            return !Success;
 
162
          }
 
163
 
 
164
#ifdef XFREE86_V4           
 
165
      xf86AddEnabledDevice(local);
 
166
#else
 
167
      AddEnabledDevice(local->fd);
 
168
#endif
 
169
      pTun->public.on = TRUE;
 
170
 
 
171
      TLOG ("DEVICE_ON (%s): OK.", local -> name);      
 
172
      break;
 
173
 
 
174
    case DEVICE_OFF:
 
175
    case DEVICE_CLOSE:
 
176
      TLOG ("DEVICE_%s (%s)", 
 
177
            what == DEVICE_OFF ? "OFF" : "CLOSE",
 
178
            local -> name);
 
179
      if (local->fd >= 0)
 
180
        {
 
181
#ifdef XFREE86_V4           
 
182
          xf86RemoveEnabledDevice(local);
 
183
#else
 
184
          RemoveEnabledDevice(local->fd);
 
185
#endif
 
186
        }
 
187
      close (local->fd);
 
188
      local->fd = -1;
 
189
      pTun->public.on = FALSE;
 
190
      break;
 
191
 
 
192
    default:
 
193
      ErrorF("unsupported mode=%d\n", what);
 
194
      return !Success;
 
195
    }
 
196
 
 
197
  return Success;
 
198
}
 
199
 
 
200
/** Read the new events from device and enqueue them.
 
201
 */
 
202
 
 
203
static void
 
204
tunReadInput (LocalDevicePtr    local)
 
205
{
 
206
  TunDevicePtr          tun = (TunDevicePtr) local -> private;
 
207
  TunValuatorPtr        valptr;
 
208
  struct input_event    ebuf [64], *ebufptr;
 
209
  int                   rd, i;
 
210
 
 
211
  rd = read (local->fd, ebuf, sizeof (ebuf));
 
212
  if (rd < sizeof (struct input_event))
 
213
    {
 
214
      TLOG ("[%s] Error reading event device :(", local->name);
 
215
      return;
 
216
    }
 
217
 
 
218
  for (i = 0, ebufptr = ebuf; 
 
219
       i < rd / sizeof (struct input_event); 
 
220
       i++, ebufptr++)
 
221
    {
 
222
      TLOG ("[%s] Event %s ", local -> name, 
 
223
            tunGetEventName (ebufptr->type));
 
224
      
 
225
      if (tun->xval_to_lval_tbl &&
 
226
          (ebufptr->time.tv_sec - tun->last_event_time.tv_sec > 1 ||
 
227
           ((ebufptr->time.tv_sec - tun->last_event_time.tv_sec) * 1000000 +
 
228
            (ebufptr->time.tv_usec - tun->last_event_time.tv_usec)) > tun->delta_time))
 
229
        {
 
230
          TLOG ("Pred postem");
 
231
          tunPostMotionEvent (local->dev);
 
232
          TLOG ("Po postu");
 
233
          tun->last_event_time = ebufptr->time;
 
234
        }
 
235
 
 
236
      switch (ebufptr->type)
 
237
        {
 
238
        case EV_ABS:
 
239
          if (ebufptr->code < tun->first_avaluator ||
 
240
              ebufptr->code > (tun->first_avaluator + tun->nof_avaluators) ||
 
241
              tun->avaluators [ebufptr->code - tun->first_avaluator].lid < 0)
 
242
            {
 
243
              ErrorF ("Unknown evaluator %d", ebufptr->code);
 
244
              break;
 
245
            }
 
246
          valptr = tun->avaluators + (ebufptr->code - tun->first_avaluator);
 
247
          
 
248
          valptr->value = (valptr->upsidedown) 
 
249
            ? (valptr->max - ebufptr->value + valptr->min)
 
250
            : ebufptr->value;
 
251
          break;
 
252
 
 
253
        case EV_KEY:
 
254
          if (IS_BUTTON (ebufptr->code))
 
255
            {
 
256
              int               lbut = ebufptr->code - tun->first_lbutton;
 
257
 
 
258
              if (lbut < 0 || lbut > tun->nof_lbuttons ||
 
259
                  (tun->lbut_to_xbut_tbl [lbut] == -1))
 
260
                {
 
261
                  ErrorF ("[%s] Unknown button %d (%s)", local->name, 
 
262
                          lbut, tunGetKeyName (lbut));
 
263
                  break;
 
264
                }
 
265
 
 
266
              if (tun->lbut_to_xbut_tbl [lbut] == TUN_BUTTON_PROXIMITY)
 
267
                tunPostProximityEvent (local->dev, ebufptr->value);
 
268
              else if (tun->lbut_to_xbut_tbl [lbut] > 0)
 
269
                tunPostButtonEvent (local->dev, tun->lbut_to_xbut_tbl [lbut], ebufptr->value);
 
270
 
 
271
              break;
 
272
            }
 
273
        default:
 
274
          TLOG ("[%s] Unhandled event %d (%s)", 
 
275
                local->name, ebufptr->type, tunGetEventName (ebufptr->type));
 
276
        }
 
277
    }
 
278
 
 
279
#if 0
 
280
  TunDevicePtr          tun = (TunDevicePtr) local -> private;
 
281
  TunAbsValuatorPtr     absptr;
 
282
  struct input_event    ebuf [64], *ebufptr;
 
283
  int                   rd, i, value;
 
284
  int                   xdev;
 
285
 
 
286
  rd = read (local->fd, ebuf, sizeof (struct input_event) * 64);
 
287
  if (rd < sizeof (struct input_event))
 
288
    {
 
289
      TLOG ("[%s] Error reading :(", local->name);
 
290
      return;
 
291
    }
 
292
  
 
293
  for (i = 0; i < rd / sizeof (struct input_event); i++)
 
294
    {
 
295
      TLOG ("[%s] Event %s )", local -> name, 
 
296
            tun_names_events [ebuf[i].type]? tun_names_events [ebuf[i].type] : "?");
 
297
      ebufptr = ebuf + i;
 
298
 
 
299
 
 
300
      switch (ebufptr -> type)
 
301
        {
 
302
        case EV_KEY:
 
303
          if (IS_BUTTON (ebufptr->code))
 
304
            {
 
305
              int               lbutton;
 
306
              int               button = -1;
 
307
 
 
308
              lbutton = KEY_TO_BUTTON (ebufptr->code);
 
309
              
 
310
              if (lbutton < tun->nof_alloc_buttons)
 
311
                button = tun->buttons_trans_tbl [lbutton];
 
312
 
 
313
              if (button < 0)
 
314
                break;
 
315
 
 
316
              tunPostButtonEvent (local->dev, tun, button, ebufptr->value);
 
317
            }
 
318
          break;
 
319
        case EV_ABS:
 
320
          xdev = tun->abs_trans_tbl [ebufptr->code];
 
321
          if (xdev == -1)
 
322
            break; /* ignored... */
 
323
 
 
324
          absptr = tun->abs_valuators + xdev;
 
325
          value = absptr->upsidedown 
 
326
            ?  (absptr->max - ebufptr->value)
 
327
            : ebufptr->value;
 
328
            
 
329
 
 
330
          if (tun->abs_bitmap [xdev] == 1) /* already got it... */
 
331
            {
 
332
              tunPostMotionEvent (local->dev, tun);
 
333
              tun->abs_bitmap [xdev] = 1;
 
334
              tun->nof_ev_abs = 1;
 
335
              tun->abs_valuators [xdev].value = value;
 
336
            }
 
337
          else
 
338
            {
 
339
              tun->abs_valuators [xdev].value = value;
 
340
              if (++(tun->nof_ev_abs) >= tun->nof_abs)
 
341
                tunPostMotionEvent (local->dev,tun);
 
342
            }
 
343
 
 
344
        default:
 
345
          break;
 
346
        }
 
347
    }
 
348
#endif
 
349
}
 
350
 
 
351
static void
 
352
tunClose (LocalDevicePtr        local)
 
353
{
 
354
  TLOG ("Close (%s)", local -> name);
 
355
}
 
356
 
 
357
 
 
358
/** ???.
 
359
 *  \todo tunChangeControl: Figure out what does it mean.
 
360
 */
 
361
static int
 
362
tunChangeControl(LocalDevicePtr local, xDeviceCtl *control)
 
363
{
 
364
  xDeviceResolutionCtl  *res;
 
365
 
 
366
  TLOG ("ChangeControl (%s)", local -> name);
 
367
  res = (xDeviceResolutionCtl *)control;
 
368
        
 
369
  if ((control->control != DEVICE_RESOLUTION) ||
 
370
      (res->num_valuators < 1))
 
371
    return (BadMatch);
 
372
 
 
373
  return(Success);
 
374
}
 
375
 
 
376
/** ???.
 
377
 */
 
378
int 
 
379
tunControlProc(LocalDevicePtr   local,
 
380
               xDeviceCtl       *ctl)
 
381
{
 
382
  TLOG ("ControlProc (%s)", local -> name);
 
383
  return !Success;
 
384
}
 
385
 
 
386
/** ???.
 
387
 */
 
388
static int
 
389
tunSwitchMode(ClientPtr client,
 
390
                  DeviceIntPtr  dev,
 
391
                  int           mode)
 
392
{
 
393
  LocalDevicePtr        local = (LocalDevicePtr)dev->public.devicePrivate;
 
394
  TLOG ("SwitchMode (%s)", local -> name);
 
395
  return !Success;
 
396
}
 
397
 
 
398
 
 
399
/** Convert valuators to X and Y.
 
400
 */
 
401
 
 
402
static Bool
 
403
tunConvert(LocalDevicePtr       local,
 
404
           int          first,
 
405
           int          num,
 
406
           int          v0,
 
407
           int          v1,
 
408
           int          v2,
 
409
           int          v3,
 
410
           int          v4,
 
411
           int          v5,
 
412
           int*         x,
 
413
           int*         y)
 
414
{
 
415
  TunDevicePtr tun = (TunDevicePtr) local->private;
 
416
 
 
417
  if (tun -> nof_xvaluators < 2)
 
418
    return FALSE;
 
419
 
 
420
#ifdef XFREE86_V4
 
421
  {
 
422
    TunValuatorPtr      valptr;
 
423
 
 
424
    valptr = tun->xval_to_lval_tbl [0];
 
425
    if (valptr)
 
426
      tun->factorX = ((double) screenInfo.screens[0]->width)
 
427
        / (double) (valptr->max - valptr->min);
 
428
    else tun->factorX = 1.0;
 
429
  
 
430
    valptr = (tun->nof_xvaluators > 1) 
 
431
      ? tun->xval_to_lval_tbl [1]
 
432
      : NULL;
 
433
  
 
434
    if (valptr)
 
435
      tun->factorY = ((double) screenInfo.screens[0]->height)
 
436
        / (double) (valptr->max - valptr->min);
 
437
    else
 
438
      tun->factorY = 1.0;
 
439
  }
 
440
#endif
 
441
 
 
442
  *x = v0 * tun->factorX;
 
443
  *y = v1 * tun->factorY;
 
444
 
 
445
  TLOG ("Convert (%s) (%d %d), NEW (%d %d)", local -> name, v0, v1, *x, *y);
 
446
 
 
447
  return TRUE;
 
448
}
 
449
 
 
450
/** Convert X and Y to valuators.
 
451
 */
 
452
 
 
453
static Bool
 
454
tunReverseConvert(LocalDevicePtr        local,
 
455
                  int           x,
 
456
                  int           y,
 
457
                  int           *valuators)
 
458
{
 
459
  TLOG ("ReverseConvert (%s)", local -> name);
 
460
  return FALSE;
 
461
}
 
462
 
 
463
LocalDevicePtr
 
464
tunAllocate (int id, char *name)
 
465
{
 
466
  LocalDevicePtr        local = (LocalDevicePtr) xalloc (sizeof (LocalDeviceRec));
 
467
  TunDevicePtr          priv = (TunDevicePtr) xalloc (sizeof (TunDeviceRec));
 
468
 
 
469
  TLOG ("Allocating linput%d (name %s)",  id, name);
 
470
 
 
471
  local->name = strdup (name);
 
472
  local->flags = XI86_NO_OPEN_ON_INIT;
 
473
 
 
474
  local->device_config = tunConfig; /* parsovatko */
 
475
  local->device_control = tunProc;   /* DEVICE_CLOSE apod */
 
476
  local->read_input = tunReadInput;  /* handluje cteni ze souboru */
 
477
  local->control_proc = tunChangeControl;
 
478
  local->close_proc = tunClose;      /* pozavira soubory */
 
479
  local->control_proc = tunControlProc; /* ??? */
 
480
  local->switch_mode = tunSwitchMode;  /* swica relativni a absolutni flazek... */
 
481
  local->conversion_proc = tunConvert; /* convert valuators to X and Y */
 
482
  local->reverse_conversion_proc = tunReverseConvert; /* convert valuators to X and Y */
 
483
  local->fd = -1;
 
484
  local->atom = 0;
 
485
  local->dev = NULL;
 
486
 
 
487
  local->private = priv; /* FIXME !!! */
 
488
  local->private_flags = 0;
 
489
  
 
490
  local->history_size = 0;
 
491
  local->old_x = -1;
 
492
  local->old_y = -1;
 
493
 
 
494
  priv->input_device = (char*) xalloc (TUN_DEFAULT_INPUT_PATH_LENGTH);
 
495
  sprintf (priv->input_device, TUN_DEFAULT_INPUT_PATH, id);
 
496
 
 
497
  priv->factorX = 1;
 
498
  priv->factorY = 1;
 
499
 
 
500
  priv->last_event_time.tv_sec = 0;
 
501
  priv->last_event_time.tv_usec = 0;
 
502
 
 
503
  priv->delta_time = 50;
 
504
  priv->last_valuator = -1;
 
505
  priv->num_of_recieved_valuators = 0;
 
506
 
 
507
  priv->nof_avaluators = 0;
 
508
  priv->first_avaluator = 0;
 
509
  priv->avaluators = NULL;
 
510
 
 
511
  priv->nof_rvaluators = 0;
 
512
  priv->first_rvaluator = 0;
 
513
  priv->rvaluators = NULL;
 
514
 
 
515
  priv->xval_to_lval_tbl = NULL;
 
516
 
 
517
  priv->nof_lbuttons = 0;
 
518
  priv->first_lbutton = 0;
 
519
  priv->lbut_to_xbut_tbl = NULL;
 
520
 
 
521
  priv->is_absolute = 1;
 
522
  priv->has_proximity = 0;
 
523
  priv->has_mouse_wheel_hack = 0;
 
524
 
 
525
  return local;
 
526
}