Merging XORG-CURRENT into trunk
[xorg/acecad] / src / acecad.c
1 /* 
2  * Copyright (c) 2001 Edouard TISSERANT <tissered@esstin.u-nancy.fr>
3  * Parts inspired from Shane Watts <shane@bofh.asn.au> XFree86 3 Acecad Driver
4  * Thanks to Emily, from AceCad, For giving me documents.
5  * 
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19  * THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
21  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  *
24  *
25  */
26 /* $XFree86: xc/programs/Xserver/hw/xfree86/input/acecad/acecad.c,v 1.4 2003/10/30 00:40:45 dawes Exp $ */
27
28 #define _ACECAD_C_
29 /*****************************************************************************
30  *      Standard Headers
31  ****************************************************************************/
32
33 #ifdef LINUX_INPUT
34 #include <asm/types.h>
35 #include <linux/input.h>
36 #ifdef BUS_PCI
37 #undef BUS_PCI
38 #endif
39 #ifdef BUS_ISA
40 #undef BUS_ISA
41 #endif
42 #endif
43
44 #include <misc.h>
45 #include <xf86.h>
46 #define NEED_XF86_TYPES
47 #include <xf86_ansic.h>
48 #include <xf86_OSproc.h>
49 #include <xisb.h>
50 #include <xf86Xinput.h>
51 #include <exevents.h>
52 #include <xf86Module.h>
53
54 /*****************************************************************************
55  *      Local Headers
56  ****************************************************************************/
57 #include "acecad.h"
58
59 /*****************************************************************************
60  *      Variables without includable headers
61  ****************************************************************************/
62
63 /*****************************************************************************
64  *      Local Variables
65  ****************************************************************************/
66
67 #define SYSCALL(call) while(((call) == -1) && (errno == EINTR))
68 #undef read
69 #define read(a,b,c) xf86ReadSerial((a),(b),(c))
70
71 /* max number of input events to read in one read call */
72 #define MAX_EVENTS 50
73
74
75 InputDriverRec ACECAD = 
76 {
77         1,
78         "acecad",
79         NULL,
80         AceCadPreInit,
81         NULL,
82         NULL,
83         0
84 };
85
86 #ifdef XFree86LOADER
87 static XF86ModuleVersionInfo VersionRec =
88 {
89         "acecad",
90         MODULEVENDORSTRING,
91         MODINFOSTRING1,
92         MODINFOSTRING2,
93         XORG_VERSION_CURRENT,
94         1, 0, 0,
95         ABI_CLASS_XINPUT,
96         ABI_XINPUT_VERSION,
97         MOD_CLASS_XINPUT,
98         {0, 0, 0, 0}
99 };
100
101
102 XF86ModuleData acecadModuleData = { &VersionRec, SetupProc, TearDownProc};
103
104 /*****************************************************************************
105  *      Function Definitions
106  ****************************************************************************/
107
108 static pointer
109 SetupProc(      pointer module,
110                 pointer options,
111                 int *errmaj,
112                 int *errmin )
113 {
114         xf86AddInputDriver(&ACECAD, module, 0);
115         return module;
116 }
117
118 static void
119 TearDownProc( pointer p )
120 {
121 #if 0
122         LocalDevicePtr local = (LocalDevicePtr) p;
123         AceCadPrivatePtr priv = (AceCadPrivatePtr) local->private;
124
125         DeviceOff (local->dev);
126
127         xf86CloseSerial (local->fd);
128         XisbFree (priv->buffer);
129         xfree (priv);
130         xfree (local->name);
131         xfree (local);
132 #endif
133 }
134 #endif
135
136 static const char *default_options[] =
137 {
138         "BaudRate", "9600",
139         "StopBits", "1",
140         "DataBits", "8",
141         "Parity", "Odd",
142         "Vmin", "1",
143         "Vtime", "10",
144         "FlowControl", "Xoff",
145         NULL
146 };
147
148 #ifdef LINUX_INPUT
149 static int
150 IsUSBLine(int fd)
151 {
152     int version;
153     int err;
154
155     SYSCALL(err = ioctl(fd, EVIOCGVERSION, &version));
156     
157     if (!err) {
158         xf86Msg(X_CONFIG,"Kernel Input driver version is %d.%d.%d\n",
159                version >> 16, (version >> 8) & 0xff, version & 0xff);
160         return 1;
161     } else {
162         return 0;
163     }
164 }
165 #endif
166
167 static InputInfoPtr
168 AceCadPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
169 {
170         LocalDevicePtr local = xf86AllocateInput(drv, 0);
171         AceCadPrivatePtr priv = xcalloc (1, sizeof (AceCadPrivateRec));
172         int speed;
173         char *s;
174
175         if ((!local) || (!priv))
176                 goto SetupProc_fail;
177
178         memset(priv,0,sizeof (AceCadPrivateRec));
179
180         local->name = dev->identifier;
181         local->type_name = "AceCad Tablet";
182         local->flags = XI86_POINTER_CAPABLE | XI86_SEND_DRAG_EVENTS;
183         local->motion_history_proc = xf86GetMotionEvents;
184         local->control_proc = NULL;
185         local->close_proc = CloseProc;
186         local->switch_mode = NULL;
187         local->conversion_proc = ConvertProc;
188         local->reverse_conversion_proc = ReverseConvertProc;
189         local->dev = NULL;
190         local->private = priv;
191         local->private_flags = 0;
192         local->conf_idev = dev;
193         local->device_control = DeviceControl;
194         /*local->always_core_feedback = 0;*/
195         
196         xf86CollectInputOptions(local, default_options, NULL);
197
198         xf86OptionListReport(local->options);
199
200         priv->acecadInc = xf86SetIntOption(local->options, "Increment", 0 );
201
202         local->fd = xf86OpenSerial (local->options);
203         if (local->fd == -1)
204         {
205                 xf86Msg(X_ERROR,"AceCad driver unable to open device\n");
206                 goto SetupProc_fail;
207         }
208         xf86ErrorFVerb( 6, "tty port opened successfully\n" );
209
210 #ifdef LINUX_INPUT
211         if(IsUSBLine(local->fd)){
212                 priv->acecadUSB=1;
213
214                 local->read_input = USBReadInput;
215
216                 if (USBQueryHardware(local) != Success)
217                 {
218                         ErrorF ("Unable to query/initialize AceCad hardware.\n");
219                         goto SetupProc_fail;
220                 }
221         } else
222 #endif
223         {
224                 priv->acecadUSB=0;
225
226                 local->read_input = ReadInput;
227                 
228                 speed = xf86SetIntOption(local->options, "ReportSpeed", 85 );
229
230                 switch (speed)
231                 {
232                 case 120:
233                         priv->acecadReportSpeed = 'Q';
234                         break;
235                 case 85:
236                         priv->acecadReportSpeed = 'R';
237                         break;
238                 case 10:
239                         priv->acecadReportSpeed = 'S';
240                         break;
241                 case 2:
242                         priv->acecadReportSpeed = 'T';
243                         break;
244                 default:
245                         priv->acecadReportSpeed = 'R';
246                         speed = 85;
247                         xf86Msg(X_CONFIG, "Acecad Tablet: ReportSpeed possible values:\n 120, 85, 10, 2 \n");         
248                 }
249
250                 xf86Msg(X_CONFIG, "Acecad Tablet report %d points/s\n", speed);         
251
252                 priv->buffer = XisbNew (local->fd, 200);
253
254                 /* 
255                  * Verify that hardware is attached and fuctional
256                  */
257                 if (QueryHardware(priv) != Success)
258                 {
259                         xf86Msg(X_ERROR,"Unable to query/initialize AceCad hardware.\n");
260                         goto SetupProc_fail;
261                 }
262         }
263
264         s = xf86FindOptionValue(local->options, "Mode");
265         if (s && (xf86NameCmp(s, "Relative") == 0))
266         {
267                 priv->flags = priv->flags & ~ABSOLUTE_FLAG;
268         }
269         else 
270         {
271                 priv->flags = priv->flags | ABSOLUTE_FLAG;
272         }
273
274         xf86Msg(X_CONFIG, "Acecad Tablet is in %s mode\n",(priv->flags & ABSOLUTE_FLAG) ? "absolute" : "relative");         
275         DBG (9, XisbTrace (priv->buffer, 1));
276
277         local->history_size = xf86SetIntOption(local->options , "HistorySize", 0);
278
279         xf86ProcessCommonOptions(local, local->options);
280
281         local->flags |= XI86_CONFIGURED;
282         
283         if (local->fd != -1)
284         { 
285                 RemoveEnabledDevice (local->fd);
286                 if (priv->buffer)
287                 {
288                         XisbFree(priv->buffer);
289                         priv->buffer = NULL;
290                 }
291                 xf86CloseSerial(local->fd);
292         }
293         RemoveEnabledDevice (local->fd);
294         local->fd = -1;
295         return (local);
296
297         /* 
298          * If something went wrong, cleanup and return NULL
299          */
300   SetupProc_fail:
301         if ((local) && (local->fd))
302                 xf86CloseSerial (local->fd);
303         if (local)
304                 xf86DeleteInput (local, 0);
305
306         if ((priv) && (priv->buffer))
307                 XisbFree (priv->buffer);
308         if (priv)
309                 xfree (priv);
310         return (NULL);
311 }
312
313 static Bool
314 DeviceControl (DeviceIntPtr dev, int mode)
315 {
316         Bool    RetValue;
317
318         switch (mode)
319         {
320         case DEVICE_INIT:
321                 DeviceInit (dev);
322                 RetValue = Success;
323                 break;
324         case DEVICE_ON:
325                 RetValue = DeviceOn( dev );
326                 break;
327         case DEVICE_OFF:
328                 RetValue = DeviceOff( dev );
329                 break;
330         case DEVICE_CLOSE:
331                 RetValue = DeviceClose( dev );
332                 break;
333         default:
334                 RetValue = BadValue;
335         }
336
337         return( RetValue );
338 }
339
340 static Bool
341 DeviceOn (DeviceIntPtr dev)
342 {
343         char buffer[256];
344         LocalDevicePtr local = (LocalDevicePtr) dev->public.devicePrivate;
345         AceCadPrivatePtr priv = (AceCadPrivatePtr) (local->private);
346
347         xf86Msg(X_CONFIG, "Acecad Tablet Device On\n");
348
349         local->fd = xf86OpenSerial(local->options);
350         if (local->fd == -1)
351         {
352                 xf86Msg(X_WARNING, "%s: cannot open input device\n", local->name);
353                 return (!Success);
354         }
355
356         
357         if (priv->acecadUSB==0){
358                 priv->buffer = XisbNew(local->fd, 200);
359                 if (!priv->buffer) 
360                         {
361                                 xf86CloseSerial(local->fd);
362                                 local->fd = -1;
363                                 return (!Success);
364                         }
365
366                 /*Rets qu'a l'envoyer a la tablette */
367                 sprintf(buffer, "%s%c%c%c%c", acecad_initstr, priv->acecadReportSpeed ,ACECAD_INCREMENT, 32 + priv->acecadInc, (priv->flags & ABSOLUTE_FLAG)? ACECAD_ABSOLUTE: ACECAD_RELATIVE);
368                 XisbWrite (priv->buffer, (unsigned char *)buffer, strlen(buffer));
369         }
370         
371         xf86FlushInput(local->fd);
372         xf86AddEnabledDevice (local);
373         dev->public.on = TRUE;
374         return (Success);
375 }
376
377 static Bool
378 DeviceOff (DeviceIntPtr dev)
379 {
380         LocalDevicePtr local = (LocalDevicePtr) dev->public.devicePrivate;
381         AceCadPrivatePtr priv = (AceCadPrivatePtr) (local->private);
382
383
384         if (local->fd != -1)
385         { 
386         RemoveEnabledDevice (local->fd);
387                 if (priv->buffer)
388                 {
389                         XisbFree(priv->buffer);
390                         priv->buffer = NULL;
391                 }
392                 xf86CloseSerial(local->fd);
393         }
394
395
396         xf86RemoveEnabledDevice (local);
397         dev->public.on = FALSE;
398         return (Success);
399 }
400
401 static Bool
402 DeviceClose (DeviceIntPtr dev)
403 {
404         xf86Msg(X_CONFIG, "Acecad Tablet Device Close\n");
405         return (Success);
406 }
407
408 static void 
409 ControlProc(DeviceIntPtr        device,
410                    PtrCtrl      *ctrl)
411 {
412         xf86Msg(X_CONFIG, "Acecad Tablet Control Proc\n");
413 }
414
415 static Bool
416 DeviceInit (DeviceIntPtr dev)
417 {
418         int rx, ry;
419         LocalDevicePtr local = (LocalDevicePtr) dev->public.devicePrivate;
420         AceCadPrivatePtr priv = (AceCadPrivatePtr) (local->private);
421         unsigned char map[] =
422         {0, 1, 2, 3};
423
424         xf86Msg(X_CONFIG, "Acecad Tablet Device Init\n");
425
426         /* 3 boutons */
427         if (InitButtonClassDeviceStruct (dev, 3, map) == FALSE)
428         {
429                 ErrorF ("Unable to allocate AceCad ButtonClassDeviceStruct\n");
430                 return !Success;
431         }
432
433         if (InitFocusClassDeviceStruct (dev) == FALSE)
434         {
435                 ErrorF("Unable to allocate AceCad FocusClassDeviceStruct\n");
436                 return !Success;
437         }
438
439         if (InitPtrFeedbackClassDeviceStruct(dev,
440                                              ControlProc) == FALSE) {
441                 ErrorF("unable to init ptr feedback\n");
442                 return !Success;
443         }
444
445
446         /* 3 axes */
447         if (InitValuatorClassDeviceStruct (dev, 3, xf86GetMotionEvents,
448                         local->history_size,
449                         ((priv->flags & ABSOLUTE_FLAG)? Absolute: Relative)|OutOfProximity)
450                          == FALSE)
451         {
452                 ErrorF ("Unable to allocate AceCad ValuatorClassDeviceStruct\n");
453                 return !Success;
454         }
455         else
456         {
457
458                 InitValuatorAxisStruct(dev,
459                            0,
460                            0,                   /* min val */
461                            priv->acecadMaxX,    /* max val */
462                            1000,                /* resolution */
463                            0,                   /* min_res */
464                            1000);               /* max_res */
465                 InitValuatorAxisStruct(dev,
466                            1,
467                            0,                   /* min val */
468                            priv->acecadMaxY,    /* max val */
469                            1000,                /* resolution */
470                            0,                   /* min_res */
471                            1000);               /* max_res */
472                 InitValuatorAxisStruct(dev,
473                            2,
474                            0,                   /* min val */
475                            priv->acecadMaxZ,    /* max val */
476                            1000,                /* resolution */
477                            0,                   /* min_res */
478                            1000);               /* max_res */
479
480         }
481
482         if (InitProximityClassDeviceStruct (dev) == FALSE)
483         {
484                 ErrorF ("Unable to allocate ProximityClassDeviceStruct\n");
485                 return !Success;
486         }
487
488         xf86MotionHistoryAllocate (local);
489
490
491         /* On ne peut pas calculer l'increment avant, faute d'ecran pour
492         connaitre la taille... */
493
494         if (priv->acecadInc > 95)
495                 priv->acecadInc = 95;
496         if (priv->acecadInc < 1)
497         {
498                 /* guess the best increment value given video mode */
499                 rx=priv->acecadMaxX / screenInfo.screens[0]->width;
500                 ry=priv->acecadMaxY / screenInfo.screens[0]->height;
501                 if (rx < ry)
502                         priv->acecadInc = rx;
503                 else
504                         priv->acecadInc = ry;
505                 if (priv->acecadInc < 1)
506                         priv->acecadInc = 1;
507         }
508
509         xf86Msg(X_CONFIG, "Acecad Tablet Increment: %d\n",priv->acecadInc);
510
511         return (Success);
512 }
513
514 static void
515 ReadInput (LocalDevicePtr local)
516 {
517         int x, y, z;
518         int prox, buttons;
519         int is_core_pointer, is_absolute;
520         AceCadPrivatePtr priv = (AceCadPrivatePtr) (local->private);
521
522         /*xf86Msg(X_CONFIG, "Acecad Tablet Read Input\n");*/
523
524         is_absolute = (priv->flags & ABSOLUTE_FLAG);
525         is_core_pointer = xf86IsCorePointer(local->dev);
526
527         /* 
528          * set blocking to -1 on the first call because we know there is data to
529          * read. Xisb automatically clears it after one successful read so that
530          * succeeding reads are preceeded buy a select with a 0 timeout to prevent
531          * read from blocking indefinately.
532          */
533         XisbBlockDuration (priv->buffer, -1);
534         
535         while (AceCadGetPacket (priv) == Success)
536         {
537                 x = (int)priv->packet[1] | ((int)priv->packet[2] << 7);
538                 y = (int)priv->packet[3] | ((int)priv->packet[4] << 7);
539
540             if (!(priv->flags & ABSOLUTE_FLAG))
541                 {
542                         x = priv->packet[0] & XSIGN_BIT? x:-x;
543                         y = priv->packet[0] & YSIGN_BIT? y:-y;
544                 }
545                 else
546                 {
547                 y = priv->acecadMaxY - y ;
548                 }
549                 
550
551                 z = ((int)priv->packet[5] << 2) |
552                         (((int)priv->packet[6] & 0x01) << 1) |
553                         (((int)priv->packet[6] & 0x10) >> 4);
554
555                 buttons = ((int)priv->packet[0] & 0x07) |
556                         ((int)priv->packet[6] & 0x02 << 2);
557
558                 prox = (priv->packet[0] & PROXIMITY_BIT)? 0: 1;
559
560                 if (prox)
561                 {
562                         if (!(priv->acecadOldProximity))
563                                 if (!is_core_pointer)
564                                 {
565                                         /*xf86Msg(X_CONFIG, "Acecad Tablet ProxIN %d %d %d\n",x, y, z);*/
566                                         xf86PostProximityEvent(local->dev, 1, 0, 3 , x, y, z);
567                                 }
568
569                         if ((is_absolute && ((priv->acecadOldX != x) || (priv->acecadOldY != y) || (priv->acecadOldZ != z)))
570                                 || (!is_absolute && (x || y)))
571                         {
572                                 if (is_absolute || priv->acecadOldProximity)
573                                 {
574                                         /*xf86Msg(X_CONFIG, "Acecad Tablet Motion %d %d %d\n", x, y, z);*/
575                                         xf86PostMotionEvent(local->dev, is_absolute, 0, 3, x, y, z);
576                                 }
577                         }
578
579                         if (priv->acecadOldButtons != buttons)
580                         {
581                                 int     delta;
582
583                                 delta = buttons ^ priv->acecadOldButtons;
584                                 while(delta)
585                                 {
586                                         int id;
587
588                                         id=ffs(delta);
589                                         delta &= ~(1 << (id-1));
590
591                                         /*xf86Msg(X_CONFIG, "Acecad Tablet Button %d 0x%x\n",id,(buttons&(1<<(id-1))));*/
592                                         xf86PostButtonEvent(local->dev, is_absolute, id, (buttons&(1<<(id-1))), 0, 3, x, y,z);
593                                 }
594                         }
595
596                         priv->acecadOldButtons = buttons;
597                         priv->acecadOldX = x;
598                         priv->acecadOldY = y;
599                         priv->acecadOldZ = z;
600                         priv->acecadOldProximity = prox;
601                 }
602                 else
603                 {
604                         if (!is_core_pointer)
605                                 if (priv->acecadOldProximity)
606                                 {
607                                         /*xf86Msg(X_CONFIG, "Acecad Tablet ProxOUT %d %d %d\n",x, y, z);*/
608                                         xf86PostProximityEvent(local->dev, 0, 0, 3, x,y,z);
609                                 }
610                         priv->acecadOldProximity = 0;
611                 }
612         }
613         /*xf86Msg(X_CONFIG, "Acecad Tablet Sortie Read Input\n");*/
614 }
615
616 #ifdef LINUX_INPUT
617 #define set_bit(byte,nb,bit)    (bit ? byte | (1<<nb) : byte & (~(1<<nb)))
618 static void
619 USBReadInput (LocalDevicePtr local)
620 {
621         int len;
622         struct input_event * event;
623         char eventbuf[sizeof(struct input_event) * MAX_EVENTS];
624         AceCadPrivatePtr priv = (AceCadPrivatePtr) (local->private);
625         int x = priv->acecadOldX;
626         int y = priv->acecadOldY;
627         int z = priv->acecadOldZ;
628         int prox = priv->acecadOldProximity;
629         int buttons = priv->acecadOldButtons;
630         int is_core_pointer;
631
632         is_core_pointer = xf86IsCorePointer(local->dev);
633
634         SYSCALL(len = read(local->fd, eventbuf, sizeof(eventbuf)));
635
636         if (len <= 0) {
637                 ErrorF("Error reading wacom device : %s\n", strerror(errno));
638                 return;
639         }
640
641         for (event=(struct input_event *)eventbuf;
642          event<(struct input_event *)(eventbuf+len); event++) {
643          
644                 switch (event->type) {
645                 case EV_ABS:
646                     switch (event->code) {
647                     case ABS_X:
648                         x = event->value;
649                         break;
650
651                     case ABS_Y:
652                         y = event->value;
653                         break;
654
655                     case ABS_PRESSURE:
656                         z = event->value;
657                         break;
658
659                     case ABS_MISC:
660                         break;
661
662                     }
663                     break; /* EV_ABS */
664
665                 case EV_KEY:
666                     switch (event->code) {
667                     case BTN_TOOL_PEN:
668                         prox = event->value;
669                         break;
670
671                     case BTN_TOUCH:
672                         buttons=set_bit(buttons,0,event->value);
673                         break;
674
675                     case BTN_STYLUS:
676                         buttons=set_bit(buttons,1,event->value);
677                         break;
678
679                     case BTN_STYLUS2:
680                         buttons=set_bit(buttons,2,event->value);
681                         break;
682                     }
683                     break; /* EV_KEY */
684                 default:
685                     xf86Msg(X_ERROR, "UNKNOWN event->code=%d\n", event->code);
686                 } /* switch event->type */
687
688                 /* ABS_MISC is the event terminator */
689                 if (event->type != EV_ABS || event->code != ABS_MISC) {
690                     continue;
691                 }
692
693                 if (prox)
694                 {
695                         if (!(priv->acecadOldProximity))
696                                 if (!is_core_pointer)
697                                 {
698                                         xf86PostProximityEvent(local->dev, 1, 0, 3 , x, y, z);
699                                 }
700
701
702                         xf86PostMotionEvent(local->dev, 1, 0, 3, x, y, z);
703
704                         if (priv->acecadOldButtons != buttons)
705                         {
706                                 int     delta;
707
708                                 delta = buttons ^ priv->acecadOldButtons;
709                                 while(delta)
710                                 {
711                                         int id;
712
713                                         id=ffs(delta);
714                                         delta &= ~(1 << (id-1));
715
716                                         xf86PostButtonEvent(local->dev, 1, id, (buttons&(1<<(id-1))), 0, 3, x, y,z);
717                                 }
718                         }
719                 }
720                 else
721                 {
722                         if (!is_core_pointer)
723                                 if (priv->acecadOldProximity)
724                                 {
725                                         xf86PostProximityEvent(local->dev, 0, 0, 3, x,y,z);
726                                 }
727                         priv->acecadOldProximity = 0;
728                 }
729
730                 priv->acecadOldButtons = buttons;
731                 priv->acecadOldX = x;
732                 priv->acecadOldY = y;
733                 priv->acecadOldZ = z;
734                 priv->acecadOldProximity = prox;
735         }
736         /*xf86Msg(X_CONFIG, "Acecad Tablet Sortie Read Input\n");*/
737 }
738 #endif
739
740 static void
741 CloseProc (LocalDevicePtr local)
742 {
743 }
744
745 /* 
746  * The ConvertProc function may need to be tailored for your device.
747  * This function converts the device's valuator outputs to x and y coordinates
748  * to simulate mouse events.
749  */
750 static Bool
751 ConvertProc (LocalDevicePtr local,
752                          int first,
753                          int num,
754                          int v0,
755                          int v1,
756                          int v2,
757                          int v3,
758                          int v4,
759                          int v5,
760                          int *x,
761                          int *y)
762 {
763     AceCadPrivatePtr    priv = (AceCadPrivatePtr)(local->private);
764
765     *x = v0 * screenInfo.screens[0]->width / priv->acecadMaxX;
766     *y = v1 * screenInfo.screens[0]->height / priv->acecadMaxY;
767     return TRUE;
768 }
769
770
771 static Bool
772 ReverseConvertProc(             LocalDevicePtr  local,
773                         int               x,
774                         int               y,
775                         int               *valuators)
776 {
777     AceCadPrivatePtr    priv = (AceCadPrivatePtr)(local->private);
778
779     valuators[0] = x * priv->acecadMaxX / screenInfo.screens[0]->width;
780     valuators[1] = y * priv->acecadMaxY / screenInfo.screens[0]->height;
781
782     return TRUE;
783 }
784
785
786 #define WriteString(str)\
787 XisbWrite (priv->buffer, (unsigned char *)(str), strlen(str))
788
789
790 static Bool
791 QueryHardware (AceCadPrivatePtr priv)
792 {       
793         
794         /* Reset */
795         WriteString("z0");
796         
797         /* Wait */
798         milisleep (250);
799         
800         /* Prompt Mode in order to not be disturbed */
801         WriteString(ACECAD_PROMPT_MODE);
802         
803         /* Flush */
804         while(XisbRead(priv->buffer)>=0);
805         
806         /* Ask for Config packet*/
807         WriteString(ACECAD_CONFIG);
808         
809         /* Read the packet */
810         XisbBlockDuration (priv->buffer, 1000000);
811         NewPacket (priv);
812
813         /*xf86Msg(X_CONFIG, "Acecad Tablet init envoy√© \n");*/
814
815         if ((AceCadGetPacket (priv) == Success))
816         {
817                 priv->acecadMaxX = (int)priv->packet[1] + ((int)priv->packet[2] << 7);
818                 priv->acecadMaxY = (int)priv->packet[3] + ((int)priv->packet[4] << 7);
819                 priv->acecadMaxZ = 512;
820                 xf86Msg(X_CONFIG, "Acecad Tablet MaxX:%d MaxY:%d\n",priv->acecadMaxX,priv->acecadMaxY);
821         }
822         else
823                 return (!Success);
824                 
825         /*xf86Msg(X_CONFIG, "Acecad Tablet query hardware fini \n");*/
826         return (Success);
827 }
828
829 #define BITS_PER_LONG (sizeof(long) * 8)
830 #define NBITS(x) ((((x)-1)/BITS_PER_LONG)+1)
831 #define test_bit(bit, array)    ((array[LONG(bit)] >> OFF(bit)) & 1)
832 #define OFF(x)  ((x)%BITS_PER_LONG)
833 #define LONG(x) ((x)/BITS_PER_LONG)
834
835 #ifdef LINUX_INPUT
836 static Bool
837 USBQueryHardware (LocalDevicePtr local)
838 {       
839         AceCadPrivatePtr priv = (AceCadPrivatePtr) local->private;
840         unsigned long   bit[EV_MAX][NBITS(KEY_MAX)];
841         int                     i, j;
842         int                     abs[5];
843         char            name[256] = "Unknown";
844
845         ioctl(local->fd, EVIOCGNAME(sizeof(name)), name);
846         xf86Msg(X_CONFIG, "Kernel Input device name: \"%s\"\n", name);
847
848         memset(bit, 0, sizeof(bit));
849         ioctl(local->fd, EVIOCGBIT(0, EV_MAX), bit[0]);
850
851     for (i = 0; i < EV_MAX; i++)
852         if (test_bit(i, bit[0])) {
853             ioctl(local->fd, EVIOCGBIT(i, KEY_MAX), bit[i]);
854             for (j = 0; j < KEY_MAX; j++) 
855                 if (test_bit(j, bit[i])) {
856                     if (i == EV_ABS) {
857                         ioctl(local->fd, EVIOCGABS(j), abs);
858                         switch (j) {
859                         case ABS_X:
860                                 priv->acecadMaxX = abs[2];
861                         break;
862                             
863                         case ABS_Y:
864                                 priv->acecadMaxY = abs[2];
865                         break;
866                             
867                         case ABS_PRESSURE:
868                                 priv->acecadMaxZ = abs[2];
869                         break;
870                         }
871                     }
872                 }
873         }
874     
875         xf86Msg(X_CONFIG, "Acecad Tablet MaxX:%d MaxY:%d MaxZ:%d\n",priv->acecadMaxX,priv->acecadMaxY,priv->acecadMaxZ);
876         return (Success);
877 }
878 #endif
879
880 static void
881 NewPacket (AceCadPrivatePtr priv)
882 {
883     priv->packeti = 0;
884 }
885
886 static Bool
887 AceCadGetPacket (AceCadPrivatePtr priv)
888 {
889         int count = 0;
890         int c = 0;
891
892         while((c = XisbRead(priv->buffer))>=0 )
893         {
894         
895                 /* 
896                  * fail after 500 bytes so the server doesn't hang forever if a
897                  * device sends bad data.
898                  */
899                 if (count++ > 500)
900                 {
901                         NewPacket (priv);
902                         return (!Success);
903                 }
904
905                 if (c & PHASING_BIT)
906                 {
907                         NewPacket(priv);                        
908                         
909                         /*xf86Msg(X_CONFIG, "Push %2.2x\n",(char) c);*/
910                         XisbBlockDuration (priv->buffer, 10000);
911                         priv->packet[priv->packeti++] = c;
912                         count=ACECAD_PACKET_SIZE-1;
913                         while(count-- && (c = XisbRead(priv->buffer))>=0)
914                                 {
915                                 /*xf86Msg(X_CONFIG, "Push %2.2x\n",(char) c);*/
916                                 priv->packet[priv->packeti++] = c;
917                                 }
918                         XisbBlockDuration (priv->buffer, 0);
919                         if(c > 0)
920                                 return (Success);
921                 }
922         }
923         return (!Success);
924 }