OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [tablet/] [gtco.c] - Blame information for rev 65

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*    -*- linux-c -*-
2
 
3
GTCO digitizer USB driver
4
 
5
Use the err(), dbg() and info() macros from usb.h for system logging
6
 
7
TO CHECK:  Is pressure done right on report 5?
8
 
9
Copyright (C) 2006  GTCO CalComp
10
 
11
This program is free software; you can redistribute it and/or
12
modify it under the terms of the GNU General Public License
13
as published by the Free Software Foundation; version 2
14
of the License.
15
 
16
This program is distributed in the hope that it will be useful,
17
but WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
GNU General Public License for more details.
20
 
21
You should have received a copy of the GNU General Public License
22
along with this program; if not, write to the Free Software
23
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24
 
25
Permission to use, copy, modify, distribute, and sell this software and its
26
documentation for any purpose is hereby granted without fee, provided that
27
the above copyright notice appear in all copies and that both that
28
copyright notice and this permission notice appear in supporting
29
documentation, and that the name of GTCO-CalComp not be used in advertising
30
or publicity pertaining to distribution of the software without specific,
31
written prior permission. GTCO-CalComp makes no representations about the
32
suitability of this software for any purpose.  It is provided "as is"
33
without express or implied warranty.
34
 
35
GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
36
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
37
EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR
38
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
39
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
40
TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
41
PERFORMANCE OF THIS SOFTWARE.
42
 
43
GTCO CalComp, Inc.
44
7125 Riverwood Drive
45
Columbia, MD 21046
46
 
47
Jeremy Roberson jroberson@gtcocalcomp.com
48
Scott Hill shill@gtcocalcomp.com
49
*/
50
 
51
 
52
 
53
/*#define DEBUG*/
54
 
55
#include <linux/kernel.h>
56
#include <linux/module.h>
57
#include <linux/errno.h>
58
#include <linux/init.h>
59
#include <linux/slab.h>
60
#include <linux/input.h>
61
#include <linux/usb.h>
62
#include <asm/uaccess.h>
63
#include <asm/unaligned.h>
64
#include <asm/byteorder.h>
65
 
66
 
67
#include <linux/version.h>
68
#include <linux/usb/input.h>
69
 
70
/* Version with a Major number of 2 is for kernel inclusion only. */
71
#define  GTCO_VERSION   "2.00.0006"
72
 
73
 
74
/*   MACROS  */
75
 
76
#define VENDOR_ID_GTCO        0x078C
77
#define PID_400               0x400
78
#define PID_401               0x401
79
#define PID_1000              0x1000
80
#define PID_1001              0x1001
81
#define PID_1002              0x1002
82
 
83
/* Max size of a single report */
84
#define REPORT_MAX_SIZE       10
85
 
86
 
87
/* Bitmask whether pen is in range */
88
#define MASK_INRANGE 0x20
89
#define MASK_BUTTON  0x01F
90
 
91
#define  PATHLENGTH     64
92
 
93
/* DATA STRUCTURES */
94
 
95
/* Device table */
96
static struct usb_device_id gtco_usbid_table [] = {
97
        { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
98
        { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
99
        { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
100
        { USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
101
        { USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
102
        { }
103
};
104
MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
105
 
106
 
107
/* Structure to hold all of our device specific stuff */
108
struct gtco {
109
 
110
        struct input_dev  *inputdevice; /* input device struct pointer  */
111
        struct usb_device *usbdev; /* the usb device for this device */
112
        struct urb        *urbinfo;      /* urb for incoming reports      */
113
        dma_addr_t        buf_dma;  /* dma addr of the data buffer*/
114
        unsigned char *   buffer;   /* databuffer for reports */
115
 
116
        char  usbpath[PATHLENGTH];
117
        int   openCount;
118
 
119
        /* Information pulled from Report Descriptor */
120
        u32  usage;
121
        u32  min_X;
122
        u32  max_X;
123
        u32  min_Y;
124
        u32  max_Y;
125
        s8   mintilt_X;
126
        s8   maxtilt_X;
127
        s8   mintilt_Y;
128
        s8   maxtilt_Y;
129
        u32  maxpressure;
130
        u32  minpressure;
131
};
132
 
133
 
134
 
135
/*   Code for parsing the HID REPORT DESCRIPTOR          */
136
 
137
/* From HID1.11 spec */
138
struct hid_descriptor
139
{
140
        struct usb_descriptor_header header;
141
        __le16   bcdHID;
142
        u8       bCountryCode;
143
        u8       bNumDescriptors;
144
        u8       bDescriptorType;
145
        __le16   wDescriptorLength;
146
} __attribute__ ((packed));
147
 
148
 
149
#define HID_DESCRIPTOR_SIZE   9
150
#define HID_DEVICE_TYPE       33
151
#define REPORT_DEVICE_TYPE    34
152
 
153
 
154
#define PREF_TAG(x)     ((x)>>4)
155
#define PREF_TYPE(x)    ((x>>2)&0x03)
156
#define PREF_SIZE(x)    ((x)&0x03)
157
 
158
#define TYPE_MAIN       0
159
#define TYPE_GLOBAL     1
160
#define TYPE_LOCAL      2
161
#define TYPE_RESERVED   3
162
 
163
#define TAG_MAIN_INPUT        0x8
164
#define TAG_MAIN_OUTPUT       0x9
165
#define TAG_MAIN_FEATURE      0xB
166
#define TAG_MAIN_COL_START    0xA
167
#define TAG_MAIN_COL_END      0xC
168
 
169
#define TAG_GLOB_USAGE        0
170
#define TAG_GLOB_LOG_MIN      1
171
#define TAG_GLOB_LOG_MAX      2
172
#define TAG_GLOB_PHYS_MIN     3
173
#define TAG_GLOB_PHYS_MAX     4
174
#define TAG_GLOB_UNIT_EXP     5
175
#define TAG_GLOB_UNIT         6
176
#define TAG_GLOB_REPORT_SZ    7
177
#define TAG_GLOB_REPORT_ID    8
178
#define TAG_GLOB_REPORT_CNT   9
179
#define TAG_GLOB_PUSH         10
180
#define TAG_GLOB_POP          11
181
 
182
#define TAG_GLOB_MAX          12
183
 
184
#define DIGITIZER_USAGE_TIP_PRESSURE   0x30
185
#define DIGITIZER_USAGE_TILT_X         0x3D
186
#define DIGITIZER_USAGE_TILT_Y         0x3E
187
 
188
 
189
/*
190
 *   This is an abbreviated parser for the HID Report Descriptor.  We
191
 *   know what devices we are talking to, so this is by no means meant
192
 *   to be generic.  We can make some safe assumptions:
193
 *
194
 *   - We know there are no LONG tags, all short
195
 *   - We know that we have no MAIN Feature and MAIN Output items
196
 *   - We know what the IRQ reports are supposed to look like.
197
 *
198
 *   The main purpose of this is to use the HID report desc to figure
199
 *   out the mins and maxs of the fields in the IRQ reports.  The IRQ
200
 *   reports for 400/401 change slightly if the max X is bigger than 64K.
201
 *
202
 */
203
static void parse_hid_report_descriptor(struct gtco *device, char * report,
204
                                        int length)
205
{
206
        int   x, i = 0;
207
 
208
        /* Tag primitive vars */
209
        __u8   prefix;
210
        __u8   size;
211
        __u8   tag;
212
        __u8   type;
213
        __u8   data   = 0;
214
        __u16  data16 = 0;
215
        __u32  data32 = 0;
216
 
217
        /* For parsing logic */
218
        int   inputnum = 0;
219
        __u32 usage = 0;
220
 
221
        /* Global Values, indexed by TAG */
222
        __u32 globalval[TAG_GLOB_MAX];
223
        __u32 oldval[TAG_GLOB_MAX];
224
 
225
        /* Debug stuff */
226
        char  maintype = 'x';
227
        char  globtype[12];
228
        int   indent = 0;
229
        char  indentstr[10] = "";
230
 
231
 
232
        dbg("======>>>>>>PARSE<<<<<<======");
233
 
234
        /* Walk  this report and pull out the info we need */
235
        while (i < length) {
236
                prefix = report[i];
237
 
238
                /* Skip over prefix */
239
                i++;
240
 
241
                /* Determine data size and save the data in the proper variable */
242
                size = PREF_SIZE(prefix);
243
                switch (size) {
244
                case 1:
245
                        data = report[i];
246
                        break;
247
                case 2:
248
                        data16 = le16_to_cpu(get_unaligned((__le16 *)&report[i]));
249
                        break;
250
                case 3:
251
                        size = 4;
252
                        data32 = le32_to_cpu(get_unaligned((__le32 *)&report[i]));
253
                        break;
254
                }
255
 
256
                /* Skip size of data */
257
                i += size;
258
 
259
                /* What we do depends on the tag type */
260
                tag  = PREF_TAG(prefix);
261
                type = PREF_TYPE(prefix);
262
                switch (type) {
263
                case TYPE_MAIN:
264
                        strcpy(globtype, "");
265
                        switch (tag) {
266
 
267
                        case TAG_MAIN_INPUT:
268
                                /*
269
                                 * The INPUT MAIN tag signifies this is
270
                                 * information from a report.  We need to
271
                                 * figure out what it is and store the
272
                                 * min/max values
273
                                 */
274
 
275
                                maintype = 'I';
276
                                if (data == 2)
277
                                        strcpy(globtype, "Variable");
278
                                else if (data == 3)
279
                                        strcpy(globtype, "Var|Const");
280
 
281
                                dbg("::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits",
282
                                    globalval[TAG_GLOB_REPORT_ID], inputnum,
283
                                    globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
284
                                    globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
285
                                    globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
286
 
287
 
288
                                /*
289
                                  We can assume that the first two input items
290
                                  are always the X and Y coordinates.  After
291
                                  that, we look for everything else by
292
                                  local usage value
293
                                 */
294
                                switch (inputnum) {
295
                                case 0:  /* X coord */
296
                                        dbg("GER: X Usage: 0x%x", usage);
297
                                        if (device->max_X == 0) {
298
                                                device->max_X = globalval[TAG_GLOB_LOG_MAX];
299
                                                device->min_X = globalval[TAG_GLOB_LOG_MIN];
300
                                        }
301
                                        break;
302
 
303
                                case 1:  /* Y coord */
304
                                        dbg("GER: Y Usage: 0x%x", usage);
305
                                        if (device->max_Y == 0) {
306
                                                device->max_Y = globalval[TAG_GLOB_LOG_MAX];
307
                                                device->min_Y = globalval[TAG_GLOB_LOG_MIN];
308
                                        }
309
                                        break;
310
 
311
                                default:
312
                                        /* Tilt X */
313
                                        if (usage == DIGITIZER_USAGE_TILT_X) {
314
                                                if (device->maxtilt_X == 0) {
315
                                                        device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
316
                                                        device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
317
                                                }
318
                                        }
319
 
320
                                        /* Tilt Y */
321
                                        if (usage == DIGITIZER_USAGE_TILT_Y) {
322
                                                if (device->maxtilt_Y == 0) {
323
                                                        device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
324
                                                        device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
325
                                                }
326
                                        }
327
 
328
                                        /* Pressure */
329
                                        if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
330
                                                if (device->maxpressure == 0) {
331
                                                        device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
332
                                                        device->minpressure = globalval[TAG_GLOB_LOG_MIN];
333
                                                }
334
                                        }
335
 
336
                                        break;
337
                                }
338
 
339
                                inputnum++;
340
                                break;
341
 
342
                        case TAG_MAIN_OUTPUT:
343
                                maintype = 'O';
344
                                break;
345
 
346
                        case TAG_MAIN_FEATURE:
347
                                maintype = 'F';
348
                                break;
349
 
350
                        case TAG_MAIN_COL_START:
351
                                maintype = 'S';
352
 
353
                                if (data == 0) {
354
                                        dbg("======>>>>>> Physical");
355
                                        strcpy(globtype, "Physical");
356
                                } else
357
                                        dbg("======>>>>>>");
358
 
359
                                /* Indent the debug output */
360
                                indent++;
361
                                for (x = 0; x < indent; x++)
362
                                        indentstr[x] = '-';
363
                                indentstr[x] = 0;
364
 
365
                                /* Save global tags */
366
                                for (x = 0; x < TAG_GLOB_MAX; x++)
367
                                        oldval[x] = globalval[x];
368
 
369
                                break;
370
 
371
                        case TAG_MAIN_COL_END:
372
                                dbg("<<<<<<======");
373
                                maintype = 'E';
374
                                indent--;
375
                                for (x = 0; x < indent; x++)
376
                                        indentstr[x] = '-';
377
                                indentstr[x] = 0;
378
 
379
                                /* Copy global tags back */
380
                                for (x = 0; x < TAG_GLOB_MAX; x++)
381
                                        globalval[x] = oldval[x];
382
 
383
                                break;
384
                        }
385
 
386
                        switch (size) {
387
                        case 1:
388
                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
389
                                    indentstr, tag, maintype, size, globtype, data);
390
                                break;
391
 
392
                        case 2:
393
                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
394
                                    indentstr, tag, maintype, size, globtype, data16);
395
                                break;
396
 
397
                        case 4:
398
                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
399
                                    indentstr, tag, maintype, size, globtype, data32);
400
                                break;
401
                        }
402
                        break;
403
 
404
                case TYPE_GLOBAL:
405
                        switch (tag) {
406
                        case TAG_GLOB_USAGE:
407
                                /*
408
                                 * First time we hit the global usage tag,
409
                                 * it should tell us the type of device
410
                                 */
411
                                if (device->usage == 0)
412
                                        device->usage = data;
413
 
414
                                strcpy(globtype, "USAGE");
415
                                break;
416
 
417
                        case TAG_GLOB_LOG_MIN:
418
                                strcpy(globtype, "LOG_MIN");
419
                                break;
420
 
421
                        case TAG_GLOB_LOG_MAX:
422
                                strcpy(globtype, "LOG_MAX");
423
                                break;
424
 
425
                        case TAG_GLOB_PHYS_MIN:
426
                                strcpy(globtype, "PHYS_MIN");
427
                                break;
428
 
429
                        case TAG_GLOB_PHYS_MAX:
430
                                strcpy(globtype, "PHYS_MAX");
431
                                break;
432
 
433
                        case TAG_GLOB_UNIT_EXP:
434
                                strcpy(globtype, "EXP");
435
                                break;
436
 
437
                        case TAG_GLOB_UNIT:
438
                                strcpy(globtype, "UNIT");
439
                                break;
440
 
441
                        case TAG_GLOB_REPORT_SZ:
442
                                strcpy(globtype, "REPORT_SZ");
443
                                break;
444
 
445
                        case TAG_GLOB_REPORT_ID:
446
                                strcpy(globtype, "REPORT_ID");
447
                                /* New report, restart numbering */
448
                                inputnum = 0;
449
                                break;
450
 
451
                        case TAG_GLOB_REPORT_CNT:
452
                                strcpy(globtype, "REPORT_CNT");
453
                                break;
454
 
455
                        case TAG_GLOB_PUSH:
456
                                strcpy(globtype, "PUSH");
457
                                break;
458
 
459
                        case TAG_GLOB_POP:
460
                                strcpy(globtype, "POP");
461
                                break;
462
                        }
463
 
464
                        /* Check to make sure we have a good tag number
465
                           so we don't overflow array */
466
                        if (tag < TAG_GLOB_MAX) {
467
                                switch (size) {
468
                                case 1:
469
                                        dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
470
                                            indentstr, globtype, tag, size, data);
471
                                        globalval[tag] = data;
472
                                        break;
473
 
474
                                case 2:
475
                                        dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
476
                                            indentstr, globtype, tag, size, data16);
477
                                        globalval[tag] = data16;
478
                                        break;
479
 
480
                                case 4:
481
                                        dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
482
                                            indentstr, globtype, tag, size, data32);
483
                                        globalval[tag] = data32;
484
                                        break;
485
                                }
486
                        } else {
487
                                dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
488
                                    indentstr, tag, size);
489
                        }
490
                        break;
491
 
492
                case TYPE_LOCAL:
493
                        switch (tag) {
494
                        case TAG_GLOB_USAGE:
495
                                strcpy(globtype, "USAGE");
496
                                /* Always 1 byte */
497
                                usage = data;
498
                                break;
499
 
500
                        case TAG_GLOB_LOG_MIN:
501
                                strcpy(globtype, "MIN");
502
                                break;
503
 
504
                        case TAG_GLOB_LOG_MAX:
505
                                strcpy(globtype, "MAX");
506
                                break;
507
 
508
                        default:
509
                                strcpy(globtype, "UNKNOWN");
510
                                break;
511
                        }
512
 
513
                        switch (size) {
514
                        case 1:
515
                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
516
                                    indentstr, tag, globtype, size, data);
517
                                break;
518
 
519
                        case 2:
520
                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
521
                                    indentstr, tag, globtype, size, data16);
522
                                break;
523
 
524
                        case 4:
525
                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
526
                                    indentstr, tag, globtype, size, data32);
527
                                break;
528
                        }
529
 
530
                        break;
531
                }
532
        }
533
}
534
 
535
/*   INPUT DRIVER Routines                               */
536
 
537
/*
538
 * Called when opening the input device.  This will submit the URB to
539
 * the usb system so we start getting reports
540
 */
541
static int gtco_input_open(struct input_dev *inputdev)
542
{
543
        struct gtco *device = input_get_drvdata(inputdev);
544
 
545
        device->urbinfo->dev = device->usbdev;
546
        if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
547
                return -EIO;
548
 
549
        return 0;
550
}
551
 
552
/*
553
 * Called when closing the input device.  This will unlink the URB
554
 */
555
static void gtco_input_close(struct input_dev *inputdev)
556
{
557
        struct gtco *device = input_get_drvdata(inputdev);
558
 
559
        usb_kill_urb(device->urbinfo);
560
}
561
 
562
 
563
/*
564
 *  Setup input device capabilities.  Tell the input system what this
565
 *  device is capable of generating.
566
 *
567
 *  This information is based on what is read from the HID report and
568
 *  placed in the struct gtco structure
569
 *
570
 */
571
static void gtco_setup_caps(struct input_dev *inputdev)
572
{
573
        struct gtco *device = input_get_drvdata(inputdev);
574
 
575
        /* Which events */
576
        inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
577
                BIT_MASK(EV_MSC);
578
 
579
        /* Misc event menu block */
580
        inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
581
                BIT_MASK(MSC_RAW);
582
 
583
        /* Absolute values based on HID report info */
584
        input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
585
                             0, 0);
586
        input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
587
                             0, 0);
588
 
589
        /* Proximity */
590
        input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
591
 
592
        /* Tilt & pressure */
593
        input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
594
                             device->maxtilt_X, 0, 0);
595
        input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
596
                             device->maxtilt_Y, 0, 0);
597
        input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
598
                             device->maxpressure, 0, 0);
599
 
600
        /* Transducer */
601
        input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
602
}
603
 
604
/*   USB Routines  */
605
 
606
/*
607
 * URB callback routine.  Called when we get IRQ reports from the
608
 *  digitizer.
609
 *
610
 *  This bridges the USB and input device worlds.  It generates events
611
 *  on the input device based on the USB reports.
612
 */
613
static void gtco_urb_callback(struct urb *urbinfo)
614
{
615
        struct gtco *device = urbinfo->context;
616
        struct input_dev  *inputdev;
617
        int               rc;
618
        u32               val = 0;
619
        s8                valsigned = 0;
620
        char              le_buffer[2];
621
 
622
        inputdev = device->inputdevice;
623
 
624
        /* Was callback OK? */
625
        if (urbinfo->status == -ECONNRESET ||
626
            urbinfo->status == -ENOENT ||
627
            urbinfo->status == -ESHUTDOWN) {
628
 
629
                /* Shutdown is occurring. Return and don't queue up any more */
630
                return;
631
        }
632
 
633
        if (urbinfo->status != 0) {
634
                /*
635
                 * Some unknown error.  Hopefully temporary. Just go and
636
                 * requeue an URB
637
                 */
638
                goto resubmit;
639
        }
640
 
641
        /*
642
         * Good URB, now process
643
         */
644
 
645
        /* PID dependent when we interpret the report */
646
        if (inputdev->id.product == PID_1000 ||
647
            inputdev->id.product == PID_1001 ||
648
            inputdev->id.product == PID_1002) {
649
 
650
                /*
651
                 * Switch on the report ID
652
                 * Conveniently, the reports have more information, the higher
653
                 * the report number.  We can just fall through the case
654
                 * statements if we start with the highest number report
655
                 */
656
                switch (device->buffer[0]) {
657
                case 5:
658
                        /* Pressure is 9 bits */
659
                        val = ((u16)(device->buffer[8]) << 1);
660
                        val |= (u16)(device->buffer[7] >> 7);
661
                        input_report_abs(inputdev, ABS_PRESSURE,
662
                                         device->buffer[8]);
663
 
664
                        /* Mask out the Y tilt value used for pressure */
665
                        device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
666
 
667
                        /* Fall thru */
668
                case 4:
669
                        /* Tilt */
670
 
671
                        /* Sign extend these 7 bit numbers.  */
672
                        if (device->buffer[6] & 0x40)
673
                                device->buffer[6] |= 0x80;
674
 
675
                        if (device->buffer[7] & 0x40)
676
                                device->buffer[7] |= 0x80;
677
 
678
 
679
                        valsigned = (device->buffer[6]);
680
                        input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
681
 
682
                        valsigned = (device->buffer[7]);
683
                        input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
684
 
685
                        /* Fall thru */
686
                case 2:
687
                case 3:
688
                        /* Convert buttons, only 5 bits possible */
689
                        val = (device->buffer[5]) & MASK_BUTTON;
690
 
691
                        /* We don't apply any meaning to the bitmask,
692
                           just report */
693
                        input_event(inputdev, EV_MSC, MSC_SERIAL, val);
694
 
695
                        /*  Fall thru */
696
                case 1:
697
                        /* All reports have X and Y coords in the same place */
698
                        val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
699
                        input_report_abs(inputdev, ABS_X, val);
700
 
701
                        val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3]));
702
                        input_report_abs(inputdev, ABS_Y, val);
703
 
704
                        /* Ditto for proximity bit */
705
                        val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
706
                        input_report_abs(inputdev, ABS_DISTANCE, val);
707
 
708
                        /* Report 1 is an exception to how we handle buttons */
709
                        /* Buttons are an index, not a bitmask */
710
                        if (device->buffer[0] == 1) {
711
 
712
                                /*
713
                                 * Convert buttons, 5 bit index
714
                                 * Report value of index set as one,
715
                                 * the rest as 0
716
                                 */
717
                                val = device->buffer[5] & MASK_BUTTON;
718
                                dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
719
                                    val, val);
720
 
721
                                /*
722
                                 * We don't apply any meaning to the button
723
                                 * index, just report it
724
                                 */
725
                                input_event(inputdev, EV_MSC, MSC_SERIAL, val);
726
                        }
727
                        break;
728
 
729
                case 7:
730
                        /* Menu blocks */
731
                        input_event(inputdev, EV_MSC, MSC_SCAN,
732
                                    device->buffer[1]);
733
                        break;
734
                }
735
        }
736
 
737
        /* Other pid class */
738
        if (inputdev->id.product == PID_400 ||
739
            inputdev->id.product == PID_401) {
740
 
741
                /* Report 2 */
742
                if (device->buffer[0] == 2) {
743
                        /* Menu blocks */
744
                        input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
745
                }
746
 
747
                /*  Report 1 */
748
                if (device->buffer[0] == 1) {
749
                        char buttonbyte;
750
 
751
                        /*  IF X max > 64K, we still a bit from the y report */
752
                        if (device->max_X > 0x10000) {
753
 
754
                                val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
755
                                val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
756
 
757
                                input_report_abs(inputdev, ABS_X, val);
758
 
759
                                le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
760
                                le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
761
 
762
                                le_buffer[1]  = (u8)(device->buffer[4] >> 1);
763
                                le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
764
 
765
                                val = le16_to_cpu(get_unaligned((__le16 *)le_buffer));
766
                                input_report_abs(inputdev, ABS_Y, val);
767
 
768
                                /*
769
                                 * Shift the button byte right by one to
770
                                 * make it look like the standard report
771
                                 */
772
                                buttonbyte = device->buffer[5] >> 1;
773
                        } else {
774
 
775
                                val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
776
                                input_report_abs(inputdev, ABS_X, val);
777
 
778
                                val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3]));
779
                                input_report_abs(inputdev, ABS_Y, val);
780
 
781
                                buttonbyte = device->buffer[5];
782
                        }
783
 
784
                        /* BUTTONS and PROXIMITY */
785
                        val = buttonbyte & MASK_INRANGE ? 1 : 0;
786
                        input_report_abs(inputdev, ABS_DISTANCE, val);
787
 
788
                        /* Convert buttons, only 4 bits possible */
789
                        val = buttonbyte & 0x0F;
790
#ifdef USE_BUTTONS
791
                        for (i = 0; i < 5; i++)
792
                                input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
793
#else
794
                        /* We don't apply any meaning to the bitmask, just report */
795
                        input_event(inputdev, EV_MSC, MSC_SERIAL, val);
796
#endif
797
 
798
                        /* TRANSDUCER */
799
                        input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
800
                }
801
        }
802
 
803
        /* Everybody gets report ID's */
804
        input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
805
 
806
        /* Sync it up */
807
        input_sync(inputdev);
808
 
809
 resubmit:
810
        rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
811
        if (rc != 0)
812
                err("usb_submit_urb failed rc=0x%x", rc);
813
}
814
 
815
/*
816
 *  The probe routine.  This is called when the kernel find the matching USB
817
 *   vendor/product.  We do the following:
818
 *
819
 *    - Allocate mem for a local structure to manage the device
820
 *    - Request a HID Report Descriptor from the device and parse it to
821
 *      find out the device parameters
822
 *    - Create an input device and assign it attributes
823
 *   - Allocate an URB so the device can talk to us when the input
824
 *      queue is open
825
 */
826
static int gtco_probe(struct usb_interface *usbinterface,
827
                      const struct usb_device_id *id)
828
{
829
 
830
        struct gtco             *gtco;
831
        struct input_dev        *input_dev;
832
        struct hid_descriptor   *hid_desc;
833
        char                    *report = NULL;
834
        int                     result = 0, retry;
835
        int                     error;
836
        struct usb_endpoint_descriptor *endpoint;
837
 
838
        /* Allocate memory for device structure */
839
        gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
840
        input_dev = input_allocate_device();
841
        if (!gtco || !input_dev) {
842
                err("No more memory");
843
                error = -ENOMEM;
844
                goto err_free_devs;
845
        }
846
 
847
        /* Set pointer to the input device */
848
        gtco->inputdevice = input_dev;
849
 
850
        /* Save interface information */
851
        gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
852
 
853
        /* Allocate some data for incoming reports */
854
        gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE,
855
                                        GFP_KERNEL, &gtco->buf_dma);
856
        if (!gtco->buffer) {
857
                err("No more memory for us buffers");
858
                error = -ENOMEM;
859
                goto err_free_devs;
860
        }
861
 
862
        /* Allocate URB for reports */
863
        gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
864
        if (!gtco->urbinfo) {
865
                err("Failed to allocate URB");
866
                return -ENOMEM;
867
                goto err_free_buf;
868
        }
869
 
870
        /*
871
         * The endpoint is always altsetting 0, we know this since we know
872
         * this device only has one interrupt endpoint
873
         */
874
        endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
875
 
876
        /* Some debug */
877
        dbg("gtco # interfaces: %d", usbinterface->num_altsetting);
878
        dbg("num endpoints:     %d", usbinterface->cur_altsetting->desc.bNumEndpoints);
879
        dbg("interface class:   %d", usbinterface->cur_altsetting->desc.bInterfaceClass);
880
        dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, endpoint->bDescriptorType);
881
        if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
882
                dbg("endpoint: we have interrupt endpoint\n");
883
 
884
        dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen);
885
 
886
        /*
887
         * Find the HID descriptor so we can find out the size of the
888
         * HID report descriptor
889
         */
890
        if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
891
                                     HID_DEVICE_TYPE, &hid_desc) != 0){
892
                err("Can't retrieve exta USB descriptor to get hid report descriptor length");
893
                error = -EIO;
894
                goto err_free_urb;
895
        }
896
 
897
        dbg("Extra descriptor success: type:%d  len:%d",
898
            hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
899
 
900
        report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
901
        if (!report) {
902
                err("No more memory for report");
903
                error = -ENOMEM;
904
                goto err_free_urb;
905
        }
906
 
907
        /* Couple of tries to get reply */
908
        for (retry = 0; retry < 3; retry++) {
909
                result = usb_control_msg(gtco->usbdev,
910
                                         usb_rcvctrlpipe(gtco->usbdev, 0),
911
                                         USB_REQ_GET_DESCRIPTOR,
912
                                         USB_RECIP_INTERFACE | USB_DIR_IN,
913
                                         REPORT_DEVICE_TYPE << 8,
914
                                         0, /* interface */
915
                                         report,
916
                                         hid_desc->wDescriptorLength,
917
                                         5000); /* 5 secs */
918
 
919
                if (result == hid_desc->wDescriptorLength)
920
                        break;
921
        }
922
 
923
        /* If we didn't get the report, fail */
924
        dbg("usb_control_msg result: :%d", result);
925
        if (result != hid_desc->wDescriptorLength) {
926
                err("Failed to get HID Report Descriptor of size: %d",
927
                    hid_desc->wDescriptorLength);
928
                error = -EIO;
929
                goto err_free_urb;
930
        }
931
 
932
        /* Now we parse the report */
933
        parse_hid_report_descriptor(gtco, report, result);
934
 
935
        /* Now we delete it */
936
        kfree(report);
937
 
938
        /* Create a device file node */
939
        usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
940
        strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
941
 
942
        /* Set Input device functions */
943
        input_dev->open = gtco_input_open;
944
        input_dev->close = gtco_input_close;
945
 
946
        /* Set input device information */
947
        input_dev->name = "GTCO_CalComp";
948
        input_dev->phys = gtco->usbpath;
949
 
950
        input_set_drvdata(input_dev, gtco);
951
 
952
        /* Now set up all the input device capabilities */
953
        gtco_setup_caps(input_dev);
954
 
955
        /* Set input device required ID information */
956
        usb_to_input_id(gtco->usbdev, &input_dev->id);
957
        input_dev->dev.parent = &usbinterface->dev;
958
 
959
        /* Setup the URB, it will be posted later on open of input device */
960
        endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
961
 
962
        usb_fill_int_urb(gtco->urbinfo,
963
                         gtco->usbdev,
964
                         usb_rcvintpipe(gtco->usbdev,
965
                                        endpoint->bEndpointAddress),
966
                         gtco->buffer,
967
                         REPORT_MAX_SIZE,
968
                         gtco_urb_callback,
969
                         gtco,
970
                         endpoint->bInterval);
971
 
972
        gtco->urbinfo->transfer_dma = gtco->buf_dma;
973
        gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
974
 
975
        /* Save gtco pointer in USB interface gtco */
976
        usb_set_intfdata(usbinterface, gtco);
977
 
978
        /* All done, now register the input device */
979
        error = input_register_device(input_dev);
980
        if (error)
981
                goto err_free_urb;
982
 
983
        return 0;
984
 
985
 err_free_urb:
986
        usb_free_urb(gtco->urbinfo);
987
 err_free_buf:
988
        usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
989
                        gtco->buffer, gtco->buf_dma);
990
 err_free_devs:
991
        kfree(report);
992
        input_free_device(input_dev);
993
        kfree(gtco);
994
        return error;
995
}
996
 
997
/*
998
 *  This function is a standard USB function called when the USB device
999
 *  is disconnected.  We will get rid of the URV, de-register the input
1000
 *  device, and free up allocated memory
1001
 */
1002
static void gtco_disconnect(struct usb_interface *interface)
1003
{
1004
        /* Grab private device ptr */
1005
        struct gtco *gtco = usb_get_intfdata(interface);
1006
 
1007
        /* Now reverse all the registration stuff */
1008
        if (gtco) {
1009
                input_unregister_device(gtco->inputdevice);
1010
                usb_kill_urb(gtco->urbinfo);
1011
                usb_free_urb(gtco->urbinfo);
1012
                usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
1013
                                gtco->buffer, gtco->buf_dma);
1014
                kfree(gtco);
1015
        }
1016
 
1017
        info("gtco driver disconnected");
1018
}
1019
 
1020
/*   STANDARD MODULE LOAD ROUTINES  */
1021
 
1022
static struct usb_driver gtco_driverinfo_table = {
1023
        .name           = "gtco",
1024
        .id_table       = gtco_usbid_table,
1025
        .probe          = gtco_probe,
1026
        .disconnect     = gtco_disconnect,
1027
};
1028
 
1029
/*
1030
 *  Register this module with the USB subsystem
1031
 */
1032
static int __init gtco_init(void)
1033
{
1034
        int error;
1035
 
1036
        error = usb_register(&gtco_driverinfo_table);
1037
        if (error) {
1038
                err("usb_register() failed rc=0x%x", error);
1039
                return error;
1040
        }
1041
 
1042
        printk("GTCO usb driver version: %s", GTCO_VERSION);
1043
        return 0;
1044
}
1045
 
1046
/*
1047
 *   Deregister this module with the USB subsystem
1048
 */
1049
static void __exit gtco_exit(void)
1050
{
1051
        usb_deregister(&gtco_driverinfo_table);
1052
}
1053
 
1054
module_init(gtco_init);
1055
module_exit(gtco_exit);
1056
 
1057
MODULE_LICENSE("GPL");

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.