1 /******************************************************************************
2 * touchkitusb.c -- Driver for eGalax TouchKit USB Touchscreens
4 * Copyright (C) 2004-2005 by Daniel Ritz <daniel.ritz@gmx.ch>
5 * Copyright (C) by Todd E. Johnson (mtouchusb.c)
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of the
10 * License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * Based upon mtouchusb.c
23 *****************************************************************************/
27 #include <linux/config.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/usb/input.h>
34 #define TOUCHKIT_MIN_XC 0x0
35 #define TOUCHKIT_MAX_XC 0x07ff
36 #define TOUCHKIT_XC_FUZZ 0x0
37 #define TOUCHKIT_XC_FLAT 0x0
38 #define TOUCHKIT_MIN_YC 0x0
39 #define TOUCHKIT_MAX_YC 0x07ff
40 #define TOUCHKIT_YC_FUZZ 0x0
41 #define TOUCHKIT_YC_FLAT 0x0
42 #define TOUCHKIT_REPORT_DATA_SIZE 16
44 #define TOUCHKIT_DOWN 0x01
46 #define TOUCHKIT_PKT_TYPE_MASK 0xFE
47 #define TOUCHKIT_PKT_TYPE_REPT 0x80
48 #define TOUCHKIT_PKT_TYPE_DIAG 0x0A
50 #define DRIVER_VERSION "v0.1"
51 #define DRIVER_AUTHOR "Daniel Ritz <daniel.ritz@gmx.ch>"
52 #define DRIVER_DESC "eGalax TouchKit USB HID Touchscreen Driver"
55 module_param(swap_xy
, bool, 0644);
56 MODULE_PARM_DESC(swap_xy
, "If set X and Y axes are swapped.");
61 char buffer
[TOUCHKIT_REPORT_DATA_SIZE
];
64 struct usb_device
*udev
;
65 struct input_dev
*input
;
70 static struct usb_device_id touchkit_devices
[] = {
71 {USB_DEVICE(0x3823, 0x0001)},
72 {USB_DEVICE(0x0123, 0x0001)},
73 {USB_DEVICE(0x0eef, 0x0001)},
74 {USB_DEVICE(0x0eef, 0x0002)},
78 /* helpers to read the data */
79 static inline int touchkit_get_touched(char *data
)
81 return (data
[0] & TOUCHKIT_DOWN
) ? 1 : 0;
84 static inline int touchkit_get_x(char *data
)
86 return ((data
[3] & 0x0F) << 7) | (data
[4] & 0x7F);
89 static inline int touchkit_get_y(char *data
)
91 return ((data
[1] & 0x0F) << 7) | (data
[2] & 0x7F);
95 /* processes one input packet. */
96 static void touchkit_process_pkt(struct touchkit_usb
*touchkit
,
97 struct pt_regs
*regs
, char *pkt
)
101 /* only process report packets */
102 if ((pkt
[0] & TOUCHKIT_PKT_TYPE_MASK
) != TOUCHKIT_PKT_TYPE_REPT
)
106 y
= touchkit_get_x(pkt
);
107 x
= touchkit_get_y(pkt
);
109 x
= touchkit_get_x(pkt
);
110 y
= touchkit_get_y(pkt
);
113 input_regs(touchkit
->input
, regs
);
114 input_report_key(touchkit
->input
, BTN_TOUCH
, touchkit_get_touched(pkt
));
115 input_report_abs(touchkit
->input
, ABS_X
, x
);
116 input_report_abs(touchkit
->input
, ABS_Y
, y
);
117 input_sync(touchkit
->input
);
121 static int touchkit_get_pkt_len(char *buf
)
123 switch (buf
[0] & TOUCHKIT_PKT_TYPE_MASK
) {
124 case TOUCHKIT_PKT_TYPE_REPT
:
127 case TOUCHKIT_PKT_TYPE_DIAG
:
134 static void touchkit_process(struct touchkit_usb
*touchkit
, int len
,
135 struct pt_regs
*regs
)
138 int pkt_len
, buf_len
, pos
;
140 /* if the buffer contains data, append */
141 if (unlikely(touchkit
->buf_len
)) {
144 /* if only 1 byte in buffer, add another one to get length */
145 if (touchkit
->buf_len
== 1)
146 touchkit
->buffer
[1] = touchkit
->data
[0];
148 pkt_len
= touchkit_get_pkt_len(touchkit
->buffer
);
150 /* unknown packet: drop everything */
154 /* append, process */
155 tmp
= pkt_len
- touchkit
->buf_len
;
156 memcpy(touchkit
->buffer
+ touchkit
->buf_len
, touchkit
->data
, tmp
);
157 touchkit_process_pkt(touchkit
, regs
, touchkit
->buffer
);
159 buffer
= touchkit
->data
+ tmp
;
162 buffer
= touchkit
->data
;
166 /* only one byte left in buffer */
167 if (unlikely(buf_len
== 1)) {
168 touchkit
->buffer
[0] = buffer
[0];
169 touchkit
->buf_len
= 1;
173 /* loop over the buffer */
175 while (pos
< buf_len
) {
177 pkt_len
= touchkit_get_pkt_len(buffer
+ pos
);
179 /* unknown packet: drop everything */
180 if (unlikely(!pkt_len
))
183 /* full packet: process */
184 if (likely(pkt_len
<= buf_len
)) {
185 touchkit_process_pkt(touchkit
, regs
, buffer
+ pos
);
187 /* incomplete packet: save in buffer */
188 memcpy(touchkit
->buffer
, buffer
+ pos
, buf_len
- pos
);
189 touchkit
->buf_len
= buf_len
- pos
;
196 static void touchkit_irq(struct urb
*urb
, struct pt_regs
*regs
)
198 struct touchkit_usb
*touchkit
= urb
->context
;
201 switch (urb
->status
) {
206 /* this urb is timing out */
207 dbg("%s - urb timed out - was the device unplugged?",
213 /* this urb is terminated, clean up */
214 dbg("%s - urb shutting down with status: %d",
215 __FUNCTION__
, urb
->status
);
218 dbg("%s - nonzero urb status received: %d",
219 __FUNCTION__
, urb
->status
);
223 touchkit_process(touchkit
, urb
->actual_length
, regs
);
226 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
228 err("%s - usb_submit_urb failed with result: %d",
229 __FUNCTION__
, retval
);
232 static int touchkit_open(struct input_dev
*input
)
234 struct touchkit_usb
*touchkit
= input
->private;
236 touchkit
->irq
->dev
= touchkit
->udev
;
238 if (usb_submit_urb(touchkit
->irq
, GFP_ATOMIC
))
244 static void touchkit_close(struct input_dev
*input
)
246 struct touchkit_usb
*touchkit
= input
->private;
248 usb_kill_urb(touchkit
->irq
);
251 static int touchkit_alloc_buffers(struct usb_device
*udev
,
252 struct touchkit_usb
*touchkit
)
254 touchkit
->data
= usb_buffer_alloc(udev
, TOUCHKIT_REPORT_DATA_SIZE
,
255 SLAB_ATOMIC
, &touchkit
->data_dma
);
263 static void touchkit_free_buffers(struct usb_device
*udev
,
264 struct touchkit_usb
*touchkit
)
267 usb_buffer_free(udev
, TOUCHKIT_REPORT_DATA_SIZE
,
268 touchkit
->data
, touchkit
->data_dma
);
271 static int touchkit_probe(struct usb_interface
*intf
,
272 const struct usb_device_id
*id
)
274 struct touchkit_usb
*touchkit
;
275 struct input_dev
*input_dev
;
276 struct usb_host_interface
*interface
;
277 struct usb_endpoint_descriptor
*endpoint
;
278 struct usb_device
*udev
= interface_to_usbdev(intf
);
280 interface
= intf
->cur_altsetting
;
281 endpoint
= &interface
->endpoint
[0].desc
;
283 touchkit
= kzalloc(sizeof(struct touchkit_usb
), GFP_KERNEL
);
284 input_dev
= input_allocate_device();
285 if (!touchkit
|| !input_dev
)
288 if (touchkit_alloc_buffers(udev
, touchkit
))
291 touchkit
->irq
= usb_alloc_urb(0, GFP_KERNEL
);
292 if (!touchkit
->irq
) {
293 dbg("%s - usb_alloc_urb failed: touchkit->irq", __FUNCTION__
);
294 goto out_free_buffers
;
297 touchkit
->udev
= udev
;
298 touchkit
->input
= input_dev
;
300 if (udev
->manufacturer
)
301 strlcpy(touchkit
->name
, udev
->manufacturer
, sizeof(touchkit
->name
));
304 if (udev
->manufacturer
)
305 strlcat(touchkit
->name
, " ", sizeof(touchkit
->name
));
306 strlcat(touchkit
->name
, udev
->product
, sizeof(touchkit
->name
));
309 if (!strlen(touchkit
->name
))
310 snprintf(touchkit
->name
, sizeof(touchkit
->name
),
311 "USB Touchscreen %04x:%04x",
312 le16_to_cpu(udev
->descriptor
.idVendor
),
313 le16_to_cpu(udev
->descriptor
.idProduct
));
315 usb_make_path(udev
, touchkit
->phys
, sizeof(touchkit
->phys
));
316 strlcpy(touchkit
->phys
, "/input0", sizeof(touchkit
->phys
));
318 input_dev
->name
= touchkit
->name
;
319 input_dev
->phys
= touchkit
->phys
;
320 usb_to_input_id(udev
, &input_dev
->id
);
321 input_dev
->cdev
.dev
= &intf
->dev
;
322 input_dev
->private = touchkit
;
323 input_dev
->open
= touchkit_open
;
324 input_dev
->close
= touchkit_close
;
326 input_dev
->evbit
[0] = BIT(EV_KEY
) | BIT(EV_ABS
);
327 input_dev
->keybit
[LONG(BTN_TOUCH
)] = BIT(BTN_TOUCH
);
328 input_set_abs_params(input_dev
, ABS_X
, TOUCHKIT_MIN_XC
, TOUCHKIT_MAX_XC
,
329 TOUCHKIT_XC_FUZZ
, TOUCHKIT_XC_FLAT
);
330 input_set_abs_params(input_dev
, ABS_Y
, TOUCHKIT_MIN_YC
, TOUCHKIT_MAX_YC
,
331 TOUCHKIT_YC_FUZZ
, TOUCHKIT_YC_FLAT
);
333 usb_fill_int_urb(touchkit
->irq
, touchkit
->udev
,
334 usb_rcvintpipe(touchkit
->udev
, 0x81),
335 touchkit
->data
, TOUCHKIT_REPORT_DATA_SIZE
,
336 touchkit_irq
, touchkit
, endpoint
->bInterval
);
338 touchkit
->irq
->transfer_dma
= touchkit
->data_dma
;
339 touchkit
->irq
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
341 input_register_device(touchkit
->input
);
343 usb_set_intfdata(intf
, touchkit
);
347 touchkit_free_buffers(udev
, touchkit
);
349 input_free_device(input_dev
);
354 static void touchkit_disconnect(struct usb_interface
*intf
)
356 struct touchkit_usb
*touchkit
= usb_get_intfdata(intf
);
358 dbg("%s - called", __FUNCTION__
);
363 dbg("%s - touchkit is initialized, cleaning up", __FUNCTION__
);
364 usb_set_intfdata(intf
, NULL
);
365 usb_kill_urb(touchkit
->irq
);
366 input_unregister_device(touchkit
->input
);
367 usb_free_urb(touchkit
->irq
);
368 touchkit_free_buffers(interface_to_usbdev(intf
), touchkit
);
372 MODULE_DEVICE_TABLE(usb
, touchkit_devices
);
374 static struct usb_driver touchkit_driver
= {
375 .name
= "touchkitusb",
376 .probe
= touchkit_probe
,
377 .disconnect
= touchkit_disconnect
,
378 .id_table
= touchkit_devices
,
381 static int __init
touchkit_init(void)
383 return usb_register(&touchkit_driver
);
386 static void __exit
touchkit_cleanup(void)
388 usb_deregister(&touchkit_driver
);
391 module_init(touchkit_init
);
392 module_exit(touchkit_cleanup
);
394 MODULE_AUTHOR(DRIVER_AUTHOR
);
395 MODULE_DESCRIPTION(DRIVER_DESC
);
396 MODULE_LICENSE("GPL");