Merge branch 'master' into upstream-fixes
[linux-2.6] / drivers / usb / input / ati_remote2.c
1 /*
2  * ati_remote2 - ATI/Philips USB RF remote driver
3  *
4  * Copyright (C) 2005 Ville Syrjala <syrjala@sci.fi>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2
8  * as published by the Free Software Foundation.
9  */
10
11 #include <linux/usb/input.h>
12
13 #define DRIVER_DESC    "ATI/Philips USB RF remote driver"
14 #define DRIVER_VERSION "0.1"
15
16 MODULE_DESCRIPTION(DRIVER_DESC);
17 MODULE_VERSION(DRIVER_VERSION);
18 MODULE_AUTHOR("Ville Syrjala <syrjala@sci.fi>");
19 MODULE_LICENSE("GPL");
20
21 static unsigned int mode_mask = 0x1F;
22 module_param(mode_mask, uint, 0644);
23 MODULE_PARM_DESC(mode_mask, "Bitmask of modes to accept <4:PC><3:AUX4><2:AUX3><1:AUX2><0:AUX1>");
24
25 static struct usb_device_id ati_remote2_id_table[] = {
26         { USB_DEVICE(0x0471, 0x0602) }, /* ATI Remote Wonder II */
27         { }
28 };
29 MODULE_DEVICE_TABLE(usb, ati_remote2_id_table);
30
31 static struct {
32         int hw_code;
33         int key_code;
34 } ati_remote2_key_table[] = {
35         { 0x00, KEY_0 },
36         { 0x01, KEY_1 },
37         { 0x02, KEY_2 },
38         { 0x03, KEY_3 },
39         { 0x04, KEY_4 },
40         { 0x05, KEY_5 },
41         { 0x06, KEY_6 },
42         { 0x07, KEY_7 },
43         { 0x08, KEY_8 },
44         { 0x09, KEY_9 },
45         { 0x0c, KEY_POWER },
46         { 0x0d, KEY_MUTE },
47         { 0x10, KEY_VOLUMEUP },
48         { 0x11, KEY_VOLUMEDOWN },
49         { 0x20, KEY_CHANNELUP },
50         { 0x21, KEY_CHANNELDOWN },
51         { 0x28, KEY_FORWARD },
52         { 0x29, KEY_REWIND },
53         { 0x2c, KEY_PLAY },
54         { 0x30, KEY_PAUSE },
55         { 0x31, KEY_STOP },
56         { 0x37, KEY_RECORD },
57         { 0x38, KEY_DVD },
58         { 0x39, KEY_TV },
59         { 0x54, KEY_MENU },
60         { 0x58, KEY_UP },
61         { 0x59, KEY_DOWN },
62         { 0x5a, KEY_LEFT },
63         { 0x5b, KEY_RIGHT },
64         { 0x5c, KEY_OK },
65         { 0x78, KEY_A },
66         { 0x79, KEY_B },
67         { 0x7a, KEY_C },
68         { 0x7b, KEY_D },
69         { 0x7c, KEY_E },
70         { 0x7d, KEY_F },
71         { 0x82, KEY_ENTER },
72         { 0x8e, KEY_VENDOR },
73         { 0x96, KEY_COFFEE },
74         { 0xa9, BTN_LEFT },
75         { 0xaa, BTN_RIGHT },
76         { 0xbe, KEY_QUESTION },
77         { 0xd5, KEY_FRONT },
78         { 0xd0, KEY_EDIT },
79         { 0xf9, KEY_INFO },
80         { (0x00 << 8) | 0x3f, KEY_PROG1 },
81         { (0x01 << 8) | 0x3f, KEY_PROG2 },
82         { (0x02 << 8) | 0x3f, KEY_PROG3 },
83         { (0x03 << 8) | 0x3f, KEY_PROG4 },
84         { (0x04 << 8) | 0x3f, KEY_PC },
85         { 0, KEY_RESERVED }
86 };
87
88 struct ati_remote2 {
89         struct input_dev *idev;
90         struct usb_device *udev;
91
92         struct usb_interface *intf[2];
93         struct usb_endpoint_descriptor *ep[2];
94         struct urb *urb[2];
95         void *buf[2];
96         dma_addr_t buf_dma[2];
97
98         unsigned long jiffies;
99         int mode;
100
101         char name[64];
102         char phys[64];
103 };
104
105 static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id);
106 static void ati_remote2_disconnect(struct usb_interface *interface);
107
108 static struct usb_driver ati_remote2_driver = {
109         .name       = "ati_remote2",
110         .probe      = ati_remote2_probe,
111         .disconnect = ati_remote2_disconnect,
112         .id_table   = ati_remote2_id_table,
113 };
114
115 static int ati_remote2_open(struct input_dev *idev)
116 {
117         struct ati_remote2 *ar2 = idev->private;
118         int r;
119
120         r = usb_submit_urb(ar2->urb[0], GFP_KERNEL);
121         if (r) {
122                 dev_err(&ar2->intf[0]->dev,
123                         "%s: usb_submit_urb() = %d\n", __FUNCTION__, r);
124                 return r;
125         }
126         r = usb_submit_urb(ar2->urb[1], GFP_KERNEL);
127         if (r) {
128                 usb_kill_urb(ar2->urb[0]);
129                 dev_err(&ar2->intf[1]->dev,
130                         "%s: usb_submit_urb() = %d\n", __FUNCTION__, r);
131                 return r;
132         }
133
134         return 0;
135 }
136
137 static void ati_remote2_close(struct input_dev *idev)
138 {
139         struct ati_remote2 *ar2 = idev->private;
140
141         usb_kill_urb(ar2->urb[0]);
142         usb_kill_urb(ar2->urb[1]);
143 }
144
145 static void ati_remote2_input_mouse(struct ati_remote2 *ar2)
146 {
147         struct input_dev *idev = ar2->idev;
148         u8 *data = ar2->buf[0];
149
150         if (data[0] > 4) {
151                 dev_err(&ar2->intf[0]->dev,
152                         "Unknown mode byte (%02x %02x %02x %02x)\n",
153                         data[3], data[2], data[1], data[0]);
154                 return;
155         }
156
157         if (!((1 << data[0]) & mode_mask))
158                 return;
159
160         input_event(idev, EV_REL, REL_X, (s8) data[1]);
161         input_event(idev, EV_REL, REL_Y, (s8) data[2]);
162         input_sync(idev);
163 }
164
165 static int ati_remote2_lookup(unsigned int hw_code)
166 {
167         int i;
168
169         for (i = 0; ati_remote2_key_table[i].key_code != KEY_RESERVED; i++)
170                 if (ati_remote2_key_table[i].hw_code == hw_code)
171                         return i;
172
173         return -1;
174 }
175
176 static void ati_remote2_input_key(struct ati_remote2 *ar2)
177 {
178         struct input_dev *idev = ar2->idev;
179         u8 *data = ar2->buf[1];
180         int hw_code, index;
181
182         if (data[0] > 4) {
183                 dev_err(&ar2->intf[1]->dev,
184                         "Unknown mode byte (%02x %02x %02x %02x)\n",
185                         data[3], data[2], data[1], data[0]);
186                 return;
187         }
188
189         hw_code = data[2];
190         /*
191          * Mode keys (AUX1-AUX4, PC) all generate the same code byte.
192          * Use the mode byte to figure out which one was pressed.
193          */
194         if (hw_code == 0x3f) {
195                 /*
196                  * For some incomprehensible reason the mouse pad generates
197                  * events which look identical to the events from the last
198                  * pressed mode key. Naturally we don't want to generate key
199                  * events for the mouse pad so we filter out any subsequent
200                  * events from the same mode key.
201                  */
202                 if (ar2->mode == data[0])
203                         return;
204
205                 if (data[1] == 0)
206                         ar2->mode = data[0];
207
208                 hw_code |= data[0] << 8;
209         }
210
211         if (!((1 << data[0]) & mode_mask))
212                 return;
213
214         index = ati_remote2_lookup(hw_code);
215         if (index < 0) {
216                 dev_err(&ar2->intf[1]->dev,
217                         "Unknown code byte (%02x %02x %02x %02x)\n",
218                         data[3], data[2], data[1], data[0]);
219                 return;
220         }
221
222         switch (data[1]) {
223         case 0: /* release */
224                 break;
225         case 1: /* press */
226                 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_DELAY]);
227                 break;
228         case 2: /* repeat */
229
230                 /* No repeat for mouse buttons. */
231                 if (ati_remote2_key_table[index].key_code == BTN_LEFT ||
232                     ati_remote2_key_table[index].key_code == BTN_RIGHT)
233                         return;
234
235                 if (!time_after_eq(jiffies, ar2->jiffies))
236                         return;
237
238                 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_PERIOD]);
239                 break;
240         default:
241                 dev_err(&ar2->intf[1]->dev,
242                         "Unknown state byte (%02x %02x %02x %02x)\n",
243                         data[3], data[2], data[1], data[0]);
244                 return;
245         }
246
247         input_event(idev, EV_KEY, ati_remote2_key_table[index].key_code, data[1]);
248         input_sync(idev);
249 }
250
251 static void ati_remote2_complete_mouse(struct urb *urb)
252 {
253         struct ati_remote2 *ar2 = urb->context;
254         int r;
255
256         switch (urb->status) {
257         case 0:
258                 ati_remote2_input_mouse(ar2);
259                 break;
260         case -ENOENT:
261         case -EILSEQ:
262         case -ECONNRESET:
263         case -ESHUTDOWN:
264                 dev_dbg(&ar2->intf[0]->dev,
265                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
266                 return;
267         default:
268                 dev_err(&ar2->intf[0]->dev,
269                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
270         }
271
272         r = usb_submit_urb(urb, GFP_ATOMIC);
273         if (r)
274                 dev_err(&ar2->intf[0]->dev,
275                         "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r);
276 }
277
278 static void ati_remote2_complete_key(struct urb *urb)
279 {
280         struct ati_remote2 *ar2 = urb->context;
281         int r;
282
283         switch (urb->status) {
284         case 0:
285                 ati_remote2_input_key(ar2);
286                 break;
287         case -ENOENT:
288         case -EILSEQ:
289         case -ECONNRESET:
290         case -ESHUTDOWN:
291                 dev_dbg(&ar2->intf[1]->dev,
292                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
293                 return;
294         default:
295                 dev_err(&ar2->intf[1]->dev,
296                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
297         }
298
299         r = usb_submit_urb(urb, GFP_ATOMIC);
300         if (r)
301                 dev_err(&ar2->intf[1]->dev,
302                         "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r);
303 }
304
305 static int ati_remote2_input_init(struct ati_remote2 *ar2)
306 {
307         struct input_dev *idev;
308         int i;
309
310         idev = input_allocate_device();
311         if (!idev)
312                 return -ENOMEM;
313
314         ar2->idev = idev;
315         idev->private = ar2;
316
317         idev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_REL);
318         idev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT);
319         idev->relbit[0] = BIT(REL_X) | BIT(REL_Y);
320         for (i = 0; ati_remote2_key_table[i].key_code != KEY_RESERVED; i++)
321                 set_bit(ati_remote2_key_table[i].key_code, idev->keybit);
322
323         idev->rep[REP_DELAY]  = 250;
324         idev->rep[REP_PERIOD] = 33;
325
326         idev->open = ati_remote2_open;
327         idev->close = ati_remote2_close;
328
329         idev->name = ar2->name;
330         idev->phys = ar2->phys;
331
332         usb_to_input_id(ar2->udev, &idev->id);
333         idev->cdev.dev = &ar2->udev->dev;
334
335         i = input_register_device(idev);
336         if (i)
337                 input_free_device(idev);
338
339         return i;
340 }
341
342 static int ati_remote2_urb_init(struct ati_remote2 *ar2)
343 {
344         struct usb_device *udev = ar2->udev;
345         int i, pipe, maxp;
346
347         for (i = 0; i < 2; i++) {
348                 ar2->buf[i] = usb_buffer_alloc(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]);
349                 if (!ar2->buf[i])
350                         return -ENOMEM;
351
352                 ar2->urb[i] = usb_alloc_urb(0, GFP_KERNEL);
353                 if (!ar2->urb[i])
354                         return -ENOMEM;
355
356                 pipe = usb_rcvintpipe(udev, ar2->ep[i]->bEndpointAddress);
357                 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
358                 maxp = maxp > 4 ? 4 : maxp;
359
360                 usb_fill_int_urb(ar2->urb[i], udev, pipe, ar2->buf[i], maxp,
361                                  i ? ati_remote2_complete_key : ati_remote2_complete_mouse,
362                                  ar2, ar2->ep[i]->bInterval);
363                 ar2->urb[i]->transfer_dma = ar2->buf_dma[i];
364                 ar2->urb[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
365         }
366
367         return 0;
368 }
369
370 static void ati_remote2_urb_cleanup(struct ati_remote2 *ar2)
371 {
372         int i;
373
374         for (i = 0; i < 2; i++) {
375                 if (ar2->urb[i])
376                         usb_free_urb(ar2->urb[i]);
377
378                 if (ar2->buf[i])
379                         usb_buffer_free(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]);
380         }
381 }
382
383 static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id)
384 {
385         struct usb_device *udev = interface_to_usbdev(interface);
386         struct usb_host_interface *alt = interface->cur_altsetting;
387         struct ati_remote2 *ar2;
388         int r;
389
390         if (alt->desc.bInterfaceNumber)
391                 return -ENODEV;
392
393         ar2 = kzalloc(sizeof (struct ati_remote2), GFP_KERNEL);
394         if (!ar2)
395                 return -ENOMEM;
396
397         ar2->udev = udev;
398
399         ar2->intf[0] = interface;
400         ar2->ep[0] = &alt->endpoint[0].desc;
401
402         ar2->intf[1] = usb_ifnum_to_if(udev, 1);
403         r = usb_driver_claim_interface(&ati_remote2_driver, ar2->intf[1], ar2);
404         if (r)
405                 goto fail1;
406         alt = ar2->intf[1]->cur_altsetting;
407         ar2->ep[1] = &alt->endpoint[0].desc;
408
409         r = ati_remote2_urb_init(ar2);
410         if (r)
411                 goto fail2;
412
413         usb_make_path(udev, ar2->phys, sizeof(ar2->phys));
414         strlcat(ar2->phys, "/input0", sizeof(ar2->phys));
415
416         strlcat(ar2->name, "ATI Remote Wonder II", sizeof(ar2->name));
417
418         r = ati_remote2_input_init(ar2);
419         if (r)
420                 goto fail2;
421
422         usb_set_intfdata(interface, ar2);
423
424         return 0;
425
426  fail2:
427         ati_remote2_urb_cleanup(ar2);
428
429         usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
430  fail1:
431         kfree(ar2);
432
433         return r;
434 }
435
436 static void ati_remote2_disconnect(struct usb_interface *interface)
437 {
438         struct ati_remote2 *ar2;
439         struct usb_host_interface *alt = interface->cur_altsetting;
440
441         if (alt->desc.bInterfaceNumber)
442                 return;
443
444         ar2 = usb_get_intfdata(interface);
445         usb_set_intfdata(interface, NULL);
446
447         input_unregister_device(ar2->idev);
448
449         ati_remote2_urb_cleanup(ar2);
450
451         usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
452
453         kfree(ar2);
454 }
455
456 static int __init ati_remote2_init(void)
457 {
458         int r;
459
460         r = usb_register(&ati_remote2_driver);
461         if (r)
462                 printk(KERN_ERR "ati_remote2: usb_register() = %d\n", r);
463         else
464                 printk(KERN_INFO "ati_remote2: " DRIVER_DESC " " DRIVER_VERSION "\n");
465
466         return r;
467 }
468
469 static void __exit ati_remote2_exit(void)
470 {
471         usb_deregister(&ati_remote2_driver);
472 }
473
474 module_init(ati_remote2_init);
475 module_exit(ati_remote2_exit);