[PATCH] Generic HID layer - API
[linux-2.6] / drivers / usb / input / itmtouch.c
1 /******************************************************************************
2  * itmtouch.c  --  Driver for ITM touchscreen panel
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  *
18  * Based upon original work by Chris Collins <xfire-itmtouch@xware.cx>.
19  *
20  * Kudos to ITM for providing me with the datasheet for the panel,
21  * even though it was a day later than I had finished writing this
22  * driver.
23  *
24  * It has meant that I've been able to correct my interpretation of the
25  * protocol packets however.
26  *
27  * CC -- 2003/9/29
28  *
29  * History
30  * 1.0 & 1.1  2003 (CC) vojtech@suse.cz
31  *   Original version for 2.4.x kernels
32  *
33  * 1.2  02/03/2005 (HCE) hc@mivu.no
34  *   Complete rewrite to support Linux 2.6.10, thanks to mtouchusb.c for hints.
35  *   Unfortunately no calibration support at this time.
36  *
37  * 1.2.1  09/03/2005 (HCE) hc@mivu.no
38  *   Code cleanup and adjusting syntax to start matching kernel standards
39  * 
40  * 1.2.2  10/05/2006 (MJA) massad@gmail.com
41  *   Flag for detecting if the screen was being touch was incorrectly 
42  *   inverted, so no touch events were being detected.  
43  *   
44  *****************************************************************************/
45
46 #include <linux/kernel.h>
47 #include <linux/slab.h>
48 #include <linux/module.h>
49 #include <linux/init.h>
50 #include <linux/usb/input.h>
51
52 /* only an 8 byte buffer necessary for a single packet */
53 #define ITM_BUFSIZE                     8
54 #define PATH_SIZE                       64
55
56 #define USB_VENDOR_ID_ITMINC            0x0403
57 #define USB_PRODUCT_ID_TOUCHPANEL       0xf9e9
58
59 #define DRIVER_AUTHOR "Hans-Christian Egtvedt <hc@mivu.no>"
60 #define DRIVER_VERSION "v1.2.2"
61 #define DRIVER_DESC "USB ITM Inc Touch Panel Driver"
62 #define DRIVER_LICENSE "GPL"
63
64 MODULE_AUTHOR( DRIVER_AUTHOR );
65 MODULE_DESCRIPTION( DRIVER_DESC );
66 MODULE_LICENSE( DRIVER_LICENSE );
67
68 struct itmtouch_dev {
69         struct usb_device       *usbdev; /* usb device */
70         struct input_dev        *inputdev; /* input device */
71         struct urb              *readurb; /* urb */
72         char                    rbuf[ITM_BUFSIZE]; /* data */
73         int                     users;
74         char name[128];
75         char phys[64];
76 };
77
78 static struct usb_device_id itmtouch_ids [] = {
79         { USB_DEVICE(USB_VENDOR_ID_ITMINC, USB_PRODUCT_ID_TOUCHPANEL) },
80         { }
81 };
82
83 static void itmtouch_irq(struct urb *urb)
84 {
85         struct itmtouch_dev *itmtouch = urb->context;
86         unsigned char *data = urb->transfer_buffer;
87         struct input_dev *dev = itmtouch->inputdev;
88         int retval;
89
90         switch (urb->status) {
91         case 0:
92                 /* success */
93                 break;
94         case -ETIME:
95                 /* this urb is timing out */
96                 dbg("%s - urb timed out - was the device unplugged?",
97                     __FUNCTION__);
98                 return;
99         case -ECONNRESET:
100         case -ENOENT:
101         case -ESHUTDOWN:
102                 /* this urb is terminated, clean up */
103                 dbg("%s - urb shutting down with status: %d",
104                     __FUNCTION__, urb->status);
105                 return;
106         default:
107                 dbg("%s - nonzero urb status received: %d",
108                     __FUNCTION__, urb->status);
109                 goto exit;
110         }
111
112         /* if pressure has been released, then don't report X/Y */
113         if (!(data[7] & 0x20)) {
114                 input_report_abs(dev, ABS_X, (data[0] & 0x1F) << 7 | (data[3] & 0x7F));
115                 input_report_abs(dev, ABS_Y, (data[1] & 0x1F) << 7 | (data[4] & 0x7F));
116         }
117
118         input_report_abs(dev, ABS_PRESSURE, (data[2] & 1) << 7 | (data[5] & 0x7F));
119         input_report_key(dev, BTN_TOUCH, ~data[7] & 0x20);
120         input_sync(dev);
121
122 exit:
123         retval = usb_submit_urb (urb, GFP_ATOMIC);
124         if (retval)
125                 printk(KERN_ERR "%s - usb_submit_urb failed with result: %d",
126                                 __FUNCTION__, retval);
127 }
128
129 static int itmtouch_open(struct input_dev *input)
130 {
131         struct itmtouch_dev *itmtouch = input->private;
132
133         itmtouch->readurb->dev = itmtouch->usbdev;
134
135         if (usb_submit_urb(itmtouch->readurb, GFP_KERNEL))
136                 return -EIO;
137
138         return 0;
139 }
140
141 static void itmtouch_close(struct input_dev *input)
142 {
143         struct itmtouch_dev *itmtouch = input->private;
144
145         usb_kill_urb(itmtouch->readurb);
146 }
147
148 static int itmtouch_probe(struct usb_interface *intf, const struct usb_device_id *id)
149 {
150         struct itmtouch_dev *itmtouch;
151         struct input_dev *input_dev;
152         struct usb_host_interface *interface;
153         struct usb_endpoint_descriptor *endpoint;
154         struct usb_device *udev = interface_to_usbdev(intf);
155         unsigned int pipe;
156         unsigned int maxp;
157
158         interface = intf->cur_altsetting;
159         endpoint = &interface->endpoint[0].desc;
160
161         itmtouch = kzalloc(sizeof(struct itmtouch_dev), GFP_KERNEL);
162         input_dev = input_allocate_device();
163         if (!itmtouch || !input_dev) {
164                 err("%s - Out of memory.", __FUNCTION__);
165                 goto fail;
166         }
167
168         itmtouch->usbdev = udev;
169         itmtouch->inputdev = input_dev;
170
171         if (udev->manufacturer)
172                 strlcpy(itmtouch->name, udev->manufacturer, sizeof(itmtouch->name));
173
174         if (udev->product) {
175                 if (udev->manufacturer)
176                         strlcat(itmtouch->name, " ", sizeof(itmtouch->name));
177                 strlcat(itmtouch->name, udev->product, sizeof(itmtouch->name));
178         }
179
180         if (!strlen(itmtouch->name))
181                 sprintf(itmtouch->name, "USB ITM touchscreen");
182
183         usb_make_path(udev, itmtouch->phys, sizeof(itmtouch->phys));
184         strlcpy(itmtouch->phys, "/input0", sizeof(itmtouch->phys));
185
186         input_dev->name = itmtouch->name;
187         input_dev->phys = itmtouch->phys;
188         usb_to_input_id(udev, &input_dev->id);
189         input_dev->cdev.dev = &intf->dev;
190         input_dev->private = itmtouch;
191
192         input_dev->open = itmtouch_open;
193         input_dev->close = itmtouch_close;
194
195         input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
196         input_dev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
197         input_dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
198
199         /* device limits */
200         /* as specified by the ITM datasheet, X and Y are 12bit,
201          * Z (pressure) is 8 bit. However, the fields are defined up
202          * to 14 bits for future possible expansion.
203          */
204         input_set_abs_params(input_dev, ABS_X, 0, 0x0FFF, 2, 0);
205         input_set_abs_params(input_dev, ABS_Y, 0, 0x0FFF, 2, 0);
206         input_set_abs_params(input_dev, ABS_PRESSURE, 0, 0xFF, 2, 0);
207
208         /* initialise the URB so we can read from the transport stream */
209         pipe = usb_rcvintpipe(itmtouch->usbdev, endpoint->bEndpointAddress);
210         maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
211
212         if (maxp > ITM_BUFSIZE)
213                 maxp = ITM_BUFSIZE;
214
215         itmtouch->readurb = usb_alloc_urb(0, GFP_KERNEL);
216         if (!itmtouch->readurb) {
217                 dbg("%s - usb_alloc_urb failed: itmtouch->readurb", __FUNCTION__);
218                 goto fail;
219         }
220
221         usb_fill_int_urb(itmtouch->readurb, itmtouch->usbdev, pipe, itmtouch->rbuf,
222                          maxp, itmtouch_irq, itmtouch, endpoint->bInterval);
223
224         input_register_device(itmtouch->inputdev);
225
226         usb_set_intfdata(intf, itmtouch);
227
228         return 0;
229
230  fail:  input_free_device(input_dev);
231         kfree(itmtouch);
232         return -ENOMEM;
233 }
234
235 static void itmtouch_disconnect(struct usb_interface *intf)
236 {
237         struct itmtouch_dev *itmtouch = usb_get_intfdata(intf);
238
239         usb_set_intfdata(intf, NULL);
240
241         if (itmtouch) {
242                 input_unregister_device(itmtouch->inputdev);
243                 usb_kill_urb(itmtouch->readurb);
244                 usb_free_urb(itmtouch->readurb);
245                 kfree(itmtouch);
246         }
247 }
248
249 MODULE_DEVICE_TABLE(usb, itmtouch_ids);
250
251 static struct usb_driver itmtouch_driver = {
252         .name =         "itmtouch",
253         .probe =        itmtouch_probe,
254         .disconnect =   itmtouch_disconnect,
255         .id_table =     itmtouch_ids,
256 };
257
258 static int __init itmtouch_init(void)
259 {
260         info(DRIVER_DESC " " DRIVER_VERSION);
261         info(DRIVER_AUTHOR);
262         return usb_register(&itmtouch_driver);
263 }
264
265 static void __exit itmtouch_exit(void)
266 {
267         usb_deregister(&itmtouch_driver);
268 }
269
270 module_init(itmtouch_init);
271 module_exit(itmtouch_exit);