[ACPI] merge acpi-2.6.12 branch into latest Linux 2.6.13-rc...
[linux-2.6] / drivers / usb / input / acecad.c
1 /*
2  *  Copyright (c) 2001-2005 Edouard TISSERANT   <edouard.tisserant@wanadoo.fr>
3  *  Copyright (c) 2004-2005 Stephane VOLTZ      <svoltz@numericable.fr>
4  *
5  *  USB Acecad "Acecad Flair" tablet support
6  *
7  *  Changelog:
8  *      v3.2 - Added sysfs support
9  */
10
11 /*
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25  *
26  */
27
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/input.h>
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/usb.h>
34
35 /*
36  * Version Information
37  */
38 #define DRIVER_VERSION "v3.2"
39 #define DRIVER_DESC    "USB Acecad Flair tablet driver"
40 #define DRIVER_LICENSE "GPL"
41 #define DRIVER_AUTHOR  "Edouard TISSERANT <edouard.tisserant@wanadoo.fr>"
42
43 MODULE_AUTHOR(DRIVER_AUTHOR);
44 MODULE_DESCRIPTION(DRIVER_DESC);
45 MODULE_LICENSE(DRIVER_LICENSE);
46
47 #define USB_VENDOR_ID_ACECAD    0x0460
48 #define USB_DEVICE_ID_FLAIR     0x0004
49 #define USB_DEVICE_ID_302       0x0008
50
51 struct usb_acecad {
52         char name[128];
53         char phys[64];
54         struct usb_device *usbdev;
55         struct input_dev dev;
56         struct urb *irq;
57
58         signed char *data;
59         dma_addr_t data_dma;
60 };
61
62 static void usb_acecad_irq(struct urb *urb, struct pt_regs *regs)
63 {
64         struct usb_acecad *acecad = urb->context;
65         unsigned char *data = acecad->data;
66         struct input_dev *dev = &acecad->dev;
67         int prox, status;
68
69         switch (urb->status) {
70                 case 0:
71                         /* success */
72                         break;
73                 case -ECONNRESET:
74                 case -ENOENT:
75                 case -ESHUTDOWN:
76                         /* this urb is terminated, clean up */
77                         dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
78                         return;
79                 default:
80                         dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
81                         goto resubmit;
82         }
83
84         prox = (data[0] & 0x04) >> 2;
85         input_report_key(dev, BTN_TOOL_PEN, prox);
86
87         if (prox) {
88                 int x = data[1] | (data[2] << 8);
89                 int y = data[3] | (data[4] << 8);
90                 /*Pressure should compute the same way for flair and 302*/
91                 int pressure = data[5] | ((int)data[6] << 8);
92                 int touch = data[0] & 0x01;
93                 int stylus = (data[0] & 0x10) >> 4;
94                 int stylus2 = (data[0] & 0x20) >> 5;
95                 input_report_abs(dev, ABS_X, x);
96                 input_report_abs(dev, ABS_Y, y);
97                 input_report_abs(dev, ABS_PRESSURE, pressure);
98                 input_report_key(dev, BTN_TOUCH, touch);
99                 input_report_key(dev, BTN_STYLUS, stylus);
100                 input_report_key(dev, BTN_STYLUS2, stylus2);
101         }
102
103         /* event termination */
104         input_sync(dev);
105
106 resubmit:
107         status = usb_submit_urb (urb, GFP_ATOMIC);
108         if (status)
109                 err ("can't resubmit intr, %s-%s/input0, status %d",
110                         acecad->usbdev->bus->bus_name, acecad->usbdev->devpath, status);
111 }
112
113 static int usb_acecad_open(struct input_dev *dev)
114 {
115         struct usb_acecad *acecad = dev->private;
116
117         acecad->irq->dev = acecad->usbdev;
118         if (usb_submit_urb(acecad->irq, GFP_KERNEL))
119                 return -EIO;
120
121         return 0;
122 }
123
124 static void usb_acecad_close(struct input_dev *dev)
125 {
126         struct usb_acecad *acecad = dev->private;
127
128         usb_kill_urb(acecad->irq);
129 }
130
131 static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_id *id)
132 {
133         struct usb_device *dev = interface_to_usbdev(intf);
134         struct usb_host_interface *interface = intf->cur_altsetting;
135         struct usb_endpoint_descriptor *endpoint;
136         struct usb_acecad *acecad;
137         int pipe, maxp;
138         char path[64];
139
140         if (interface->desc.bNumEndpoints != 1)
141                 return -ENODEV;
142
143         endpoint = &interface->endpoint[0].desc;
144
145         if (!(endpoint->bEndpointAddress & 0x80))
146                 return -ENODEV;
147
148         if ((endpoint->bmAttributes & 3) != 3)
149                 return -ENODEV;
150
151         pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
152         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
153
154         acecad = kcalloc(1, sizeof(struct usb_acecad), GFP_KERNEL);
155         if (!acecad)
156                 return -ENOMEM;
157
158         acecad->data = usb_buffer_alloc(dev, 8, SLAB_KERNEL, &acecad->data_dma);
159         if (!acecad->data)
160                 goto fail1;
161
162         acecad->irq = usb_alloc_urb(0, GFP_KERNEL);
163         if (!acecad->irq)
164                 goto fail2;
165
166         if (dev->manufacturer)
167                 strlcpy(acecad->name, dev->manufacturer, sizeof(acecad->name));
168
169         if (dev->product) {
170                 if (dev->manufacturer)
171                         strlcat(acecad->name, " ", sizeof(acecad->name));
172                 strlcat(acecad->name, dev->product, sizeof(acecad->name));
173         }
174
175         usb_make_path(dev, path, sizeof(path));
176         snprintf(acecad->phys, sizeof(acecad->phys), "%s/input0", path);
177
178         acecad->usbdev = dev;
179
180         acecad->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
181         acecad->dev.absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
182         acecad->dev.keybit[LONG(BTN_LEFT)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);
183         acecad->dev.keybit[LONG(BTN_DIGI)] = BIT(BTN_TOOL_PEN) |BIT(BTN_TOUCH) | BIT(BTN_STYLUS) | BIT(BTN_STYLUS2);
184
185         switch (id->driver_info) {
186                 case 0:
187                         acecad->dev.absmax[ABS_X] = 5000;
188                         acecad->dev.absmax[ABS_Y] = 3750;
189                         acecad->dev.absmax[ABS_PRESSURE] = 512;
190                         if (!strlen(acecad->name))
191                                 snprintf(acecad->name, sizeof(acecad->name),
192                                         "USB Acecad Flair Tablet %04x:%04x",
193                                         dev->descriptor.idVendor, dev->descriptor.idProduct);
194                         break;
195                 case 1:
196                         acecad->dev.absmax[ABS_X] = 3000;
197                         acecad->dev.absmax[ABS_Y] = 2250;
198                         acecad->dev.absmax[ABS_PRESSURE] = 1024;
199                         if (!strlen(acecad->name))
200                                 snprintf(acecad->name, sizeof(acecad->name),
201                                         "USB Acecad 302 Tablet %04x:%04x",
202                                         dev->descriptor.idVendor, dev->descriptor.idProduct);
203                         break;
204         }
205
206         acecad->dev.absfuzz[ABS_X] = 4;
207         acecad->dev.absfuzz[ABS_Y] = 4;
208
209         acecad->dev.private = acecad;
210         acecad->dev.open = usb_acecad_open;
211         acecad->dev.close = usb_acecad_close;
212
213         acecad->dev.name = acecad->name;
214         acecad->dev.phys = acecad->phys;
215         acecad->dev.id.bustype = BUS_USB;
216         acecad->dev.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
217         acecad->dev.id.product = le16_to_cpu(dev->descriptor.idProduct);
218         acecad->dev.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
219         acecad->dev.dev = &intf->dev;
220
221         usb_fill_int_urb(acecad->irq, dev, pipe,
222                         acecad->data, maxp > 8 ? 8 : maxp,
223                         usb_acecad_irq, acecad, endpoint->bInterval);
224         acecad->irq->transfer_dma = acecad->data_dma;
225         acecad->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
226
227         input_register_device(&acecad->dev);
228
229         printk(KERN_INFO "input: %s with packet size %d on %s\n",
230                 acecad->name, maxp, path);
231
232         usb_set_intfdata(intf, acecad);
233
234         return 0;
235
236  fail2: usb_buffer_free(dev, 8, acecad->data, acecad->data_dma);
237  fail1: kfree(acecad);
238         return -ENOMEM;
239 }
240
241 static void usb_acecad_disconnect(struct usb_interface *intf)
242 {
243         struct usb_acecad *acecad = usb_get_intfdata(intf);
244
245         usb_set_intfdata(intf, NULL);
246         if (acecad) {
247                 usb_kill_urb(acecad->irq);
248                 input_unregister_device(&acecad->dev);
249                 usb_free_urb(acecad->irq);
250                 usb_buffer_free(interface_to_usbdev(intf), 10, acecad->data, acecad->data_dma);
251                 kfree(acecad);
252         }
253 }
254
255 static struct usb_device_id usb_acecad_id_table [] = {
256         { USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_FLAIR), .driver_info = 0 },
257         { USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_302),   .driver_info = 1 },
258         { }
259 };
260
261 MODULE_DEVICE_TABLE(usb, usb_acecad_id_table);
262
263 static struct usb_driver usb_acecad_driver = {
264         .owner =        THIS_MODULE,
265         .name =         "usb_acecad",
266         .probe =        usb_acecad_probe,
267         .disconnect =   usb_acecad_disconnect,
268         .id_table =     usb_acecad_id_table,
269 };
270
271 static int __init usb_acecad_init(void)
272 {
273         int result = usb_register(&usb_acecad_driver);
274         if (result == 0)
275                 info(DRIVER_VERSION ":" DRIVER_DESC);
276         return result;
277 }
278
279 static void __exit usb_acecad_exit(void)
280 {
281         usb_deregister(&usb_acecad_driver);
282 }
283
284 module_init(usb_acecad_init);
285 module_exit(usb_acecad_exit);