Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[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, struct pt_regs *regs)
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_regs(idev, regs);
161         input_event(idev, EV_REL, REL_X, (s8) data[1]);
162         input_event(idev, EV_REL, REL_Y, (s8) data[2]);
163         input_sync(idev);
164 }
165
166 static int ati_remote2_lookup(unsigned int hw_code)
167 {
168         int i;
169
170         for (i = 0; ati_remote2_key_table[i].key_code != KEY_RESERVED; i++)
171                 if (ati_remote2_key_table[i].hw_code == hw_code)
172                         return i;
173
174         return -1;
175 }
176
177 static void ati_remote2_input_key(struct ati_remote2 *ar2, struct pt_regs *regs)
178 {
179         struct input_dev *idev = ar2->idev;
180         u8 *data = ar2->buf[1];
181         int hw_code, index;
182
183         if (data[0] > 4) {
184                 dev_err(&ar2->intf[1]->dev,
185                         "Unknown mode byte (%02x %02x %02x %02x)\n",
186                         data[3], data[2], data[1], data[0]);
187                 return;
188         }
189
190         hw_code = data[2];
191         /*
192          * Mode keys (AUX1-AUX4, PC) all generate the same code byte.
193          * Use the mode byte to figure out which one was pressed.
194          */
195         if (hw_code == 0x3f) {
196                 /*
197                  * For some incomprehensible reason the mouse pad generates
198                  * events which look identical to the events from the last
199                  * pressed mode key. Naturally we don't want to generate key
200                  * events for the mouse pad so we filter out any subsequent
201                  * events from the same mode key.
202                  */
203                 if (ar2->mode == data[0])
204                         return;
205
206                 if (data[1] == 0)
207                         ar2->mode = data[0];
208
209                 hw_code |= data[0] << 8;
210         }
211
212         if (!((1 << data[0]) & mode_mask))
213                 return;
214
215         index = ati_remote2_lookup(hw_code);
216         if (index < 0) {
217                 dev_err(&ar2->intf[1]->dev,
218                         "Unknown code byte (%02x %02x %02x %02x)\n",
219                         data[3], data[2], data[1], data[0]);
220                 return;
221         }
222
223         switch (data[1]) {
224         case 0: /* release */
225                 break;
226         case 1: /* press */
227                 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_DELAY]);
228                 break;
229         case 2: /* repeat */
230
231                 /* No repeat for mouse buttons. */
232                 if (ati_remote2_key_table[index].key_code == BTN_LEFT ||
233                     ati_remote2_key_table[index].key_code == BTN_RIGHT)
234                         return;
235
236                 if (!time_after_eq(jiffies, ar2->jiffies))
237                         return;
238
239                 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_PERIOD]);
240                 break;
241         default:
242                 dev_err(&ar2->intf[1]->dev,
243                         "Unknown state byte (%02x %02x %02x %02x)\n",
244                         data[3], data[2], data[1], data[0]);
245                 return;
246         }
247
248         input_regs(idev, regs);
249         input_event(idev, EV_KEY, ati_remote2_key_table[index].key_code, data[1]);
250         input_sync(idev);
251 }
252
253 static void ati_remote2_complete_mouse(struct urb *urb, struct pt_regs *regs)
254 {
255         struct ati_remote2 *ar2 = urb->context;
256         int r;
257
258         switch (urb->status) {
259         case 0:
260                 ati_remote2_input_mouse(ar2, regs);
261                 break;
262         case -ENOENT:
263         case -EILSEQ:
264         case -ECONNRESET:
265         case -ESHUTDOWN:
266                 dev_dbg(&ar2->intf[0]->dev,
267                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
268                 return;
269         default:
270                 dev_err(&ar2->intf[0]->dev,
271                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
272         }
273
274         r = usb_submit_urb(urb, GFP_ATOMIC);
275         if (r)
276                 dev_err(&ar2->intf[0]->dev,
277                         "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r);
278 }
279
280 static void ati_remote2_complete_key(struct urb *urb, struct pt_regs *regs)
281 {
282         struct ati_remote2 *ar2 = urb->context;
283         int r;
284
285         switch (urb->status) {
286         case 0:
287                 ati_remote2_input_key(ar2, regs);
288                 break;
289         case -ENOENT:
290         case -EILSEQ:
291         case -ECONNRESET:
292         case -ESHUTDOWN:
293                 dev_dbg(&ar2->intf[1]->dev,
294                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
295                 return;
296         default:
297                 dev_err(&ar2->intf[1]->dev,
298                         "%s(): urb status = %d\n", __FUNCTION__, urb->status);
299         }
300
301         r = usb_submit_urb(urb, GFP_ATOMIC);
302         if (r)
303                 dev_err(&ar2->intf[1]->dev,
304                         "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r);
305 }
306
307 static int ati_remote2_input_init(struct ati_remote2 *ar2)
308 {
309         struct input_dev *idev;
310         int i;
311
312         idev = input_allocate_device();
313         if (!idev)
314                 return -ENOMEM;
315
316         ar2->idev = idev;
317         idev->private = ar2;
318
319         idev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_REL);
320         idev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT);
321         idev->relbit[0] = BIT(REL_X) | BIT(REL_Y);
322         for (i = 0; ati_remote2_key_table[i].key_code != KEY_RESERVED; i++)
323                 set_bit(ati_remote2_key_table[i].key_code, idev->keybit);
324
325         idev->rep[REP_DELAY]  = 250;
326         idev->rep[REP_PERIOD] = 33;
327
328         idev->open = ati_remote2_open;
329         idev->close = ati_remote2_close;
330
331         idev->name = ar2->name;
332         idev->phys = ar2->phys;
333
334         usb_to_input_id(ar2->udev, &idev->id);
335         idev->cdev.dev = &ar2->udev->dev;
336
337         i = input_register_device(idev);
338         if (i)
339                 input_free_device(idev);
340
341         return i;
342 }
343
344 static int ati_remote2_urb_init(struct ati_remote2 *ar2)
345 {
346         struct usb_device *udev = ar2->udev;
347         int i, pipe, maxp;
348
349         for (i = 0; i < 2; i++) {
350                 ar2->buf[i] = usb_buffer_alloc(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]);
351                 if (!ar2->buf[i])
352                         return -ENOMEM;
353
354                 ar2->urb[i] = usb_alloc_urb(0, GFP_KERNEL);
355                 if (!ar2->urb[i])
356                         return -ENOMEM;
357
358                 pipe = usb_rcvintpipe(udev, ar2->ep[i]->bEndpointAddress);
359                 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
360                 maxp = maxp > 4 ? 4 : maxp;
361
362                 usb_fill_int_urb(ar2->urb[i], udev, pipe, ar2->buf[i], maxp,
363                                  i ? ati_remote2_complete_key : ati_remote2_complete_mouse,
364                                  ar2, ar2->ep[i]->bInterval);
365                 ar2->urb[i]->transfer_dma = ar2->buf_dma[i];
366                 ar2->urb[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
367         }
368
369         return 0;
370 }
371
372 static void ati_remote2_urb_cleanup(struct ati_remote2 *ar2)
373 {
374         int i;
375
376         for (i = 0; i < 2; i++) {
377                 if (ar2->urb[i])
378                         usb_free_urb(ar2->urb[i]);
379
380                 if (ar2->buf[i])
381                         usb_buffer_free(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]);
382         }
383 }
384
385 static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id)
386 {
387         struct usb_device *udev = interface_to_usbdev(interface);
388         struct usb_host_interface *alt = interface->cur_altsetting;
389         struct ati_remote2 *ar2;
390         int r;
391
392         if (alt->desc.bInterfaceNumber)
393                 return -ENODEV;
394
395         ar2 = kzalloc(sizeof (struct ati_remote2), GFP_KERNEL);
396         if (!ar2)
397                 return -ENOMEM;
398
399         ar2->udev = udev;
400
401         ar2->intf[0] = interface;
402         ar2->ep[0] = &alt->endpoint[0].desc;
403
404         ar2->intf[1] = usb_ifnum_to_if(udev, 1);
405         r = usb_driver_claim_interface(&ati_remote2_driver, ar2->intf[1], ar2);
406         if (r)
407                 goto fail1;
408         alt = ar2->intf[1]->cur_altsetting;
409         ar2->ep[1] = &alt->endpoint[0].desc;
410
411         r = ati_remote2_urb_init(ar2);
412         if (r)
413                 goto fail2;
414
415         usb_make_path(udev, ar2->phys, sizeof(ar2->phys));
416         strlcat(ar2->phys, "/input0", sizeof(ar2->phys));
417
418         strlcat(ar2->name, "ATI Remote Wonder II", sizeof(ar2->name));
419
420         r = ati_remote2_input_init(ar2);
421         if (r)
422                 goto fail2;
423
424         usb_set_intfdata(interface, ar2);
425
426         return 0;
427
428  fail2:
429         ati_remote2_urb_cleanup(ar2);
430
431         usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
432  fail1:
433         kfree(ar2);
434
435         return r;
436 }
437
438 static void ati_remote2_disconnect(struct usb_interface *interface)
439 {
440         struct ati_remote2 *ar2;
441         struct usb_host_interface *alt = interface->cur_altsetting;
442
443         if (alt->desc.bInterfaceNumber)
444                 return;
445
446         ar2 = usb_get_intfdata(interface);
447         usb_set_intfdata(interface, NULL);
448
449         input_unregister_device(ar2->idev);
450
451         ati_remote2_urb_cleanup(ar2);
452
453         usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
454
455         kfree(ar2);
456 }
457
458 static int __init ati_remote2_init(void)
459 {
460         int r;
461
462         r = usb_register(&ati_remote2_driver);
463         if (r)
464                 printk(KERN_ERR "ati_remote2: usb_register() = %d\n", r);
465         else
466                 printk(KERN_INFO "ati_remote2: " DRIVER_DESC " " DRIVER_VERSION "\n");
467
468         return r;
469 }
470
471 static void __exit ati_remote2_exit(void)
472 {
473         usb_deregister(&ati_remote2_driver);
474 }
475
476 module_init(ati_remote2_init);
477 module_exit(ati_remote2_exit);