| 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, >co->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(>co_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(>co_driverinfo_table);
|
| 1052 |
|
|
}
|
| 1053 |
|
|
|
| 1054 |
|
|
module_init(gtco_init);
|
| 1055 |
|
|
module_exit(gtco_exit);
|
| 1056 |
|
|
|
| 1057 |
|
|
MODULE_LICENSE("GPL");
|
