1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89#include <linux/kernel.h>
90#include <linux/errno.h>
91#include <linux/init.h>
92#include <linux/slab.h>
93#include <linux/module.h>
94#include <linux/mutex.h>
95#include <linux/usb/input.h>
96#include <linux/wait.h>
97#include <linux/jiffies.h>
98#include <media/rc-core.h>
99
100
101
102
103
104#define ATI_REMOTE_VENDOR_ID 0x0bc7
105#define LOLA_REMOTE_PRODUCT_ID 0x0002
106#define LOLA2_REMOTE_PRODUCT_ID 0x0003
107#define ATI_REMOTE_PRODUCT_ID 0x0004
108#define NVIDIA_REMOTE_PRODUCT_ID 0x0005
109#define MEDION_REMOTE_PRODUCT_ID 0x0006
110#define FIREFLY_REMOTE_PRODUCT_ID 0x0008
111
112#define DRIVER_VERSION "2.2.1"
113#define DRIVER_AUTHOR "Torrey Hoffman <thoffman@arnor.net>"
114#define DRIVER_DESC "ATI/X10 RF USB Remote Control"
115
116#define NAME_BUFSIZE 80
117#define DATA_BUFSIZE 63
118
119
120
121
122
123
124
125
126
127#define FILTER_TIME 60
128#define REPEAT_DELAY 500
129
130static unsigned long channel_mask;
131module_param(channel_mask, ulong, 0644);
132MODULE_PARM_DESC(channel_mask, "Bitmask of remote control channels to ignore");
133
134static int debug;
135module_param(debug, int, 0644);
136MODULE_PARM_DESC(debug, "Enable extra debug messages and information");
137
138static int repeat_filter = FILTER_TIME;
139module_param(repeat_filter, int, 0644);
140MODULE_PARM_DESC(repeat_filter, "Repeat filter time, default = 60 msec");
141
142static int repeat_delay = REPEAT_DELAY;
143module_param(repeat_delay, int, 0644);
144MODULE_PARM_DESC(repeat_delay, "Delay before sending repeats, default = 500 msec");
145
146static bool mouse = true;
147module_param(mouse, bool, 0444);
148MODULE_PARM_DESC(mouse, "Enable mouse device, default = yes");
149
150#define dbginfo(dev, format, arg...) \
151 do { if (debug) dev_info(dev , format , ## arg); } while (0)
152#undef err
153#define err(format, arg...) printk(KERN_ERR format , ## arg)
154
155struct ati_receiver_type {
156
157 const char *default_keymap;
158 const char *(*get_default_keymap)(struct usb_interface *interface);
159};
160
161static const char *get_medion_keymap(struct usb_interface *interface)
162{
163 struct usb_device *udev = interface_to_usbdev(interface);
164
165
166
167
168
169
170
171 if (udev->manufacturer && udev->product) {
172 if (udev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_WAKEUP) {
173
174 if (!strcmp(udev->manufacturer, "X10 Wireless Technology Inc")
175 && !strcmp(udev->product, "USB Receiver"))
176 return RC_MAP_MEDION_X10_DIGITAINER;
177
178 if (!strcmp(udev->manufacturer, "X10 WTI")
179 && !strcmp(udev->product, "RF receiver"))
180 return RC_MAP_MEDION_X10_OR2X;
181 } else {
182
183 if (!strcmp(udev->manufacturer, "X10 Wireless Technology Inc")
184 && !strcmp(udev->product, "USB Receiver"))
185 return RC_MAP_MEDION_X10;
186 }
187 }
188
189 dev_info(&interface->dev,
190 "Unknown Medion X10 receiver, using default ati_remote Medion keymap\n");
191
192 return RC_MAP_MEDION_X10;
193}
194
195static const struct ati_receiver_type type_ati = {
196 .default_keymap = RC_MAP_ATI_X10
197};
198static const struct ati_receiver_type type_medion = {
199 .get_default_keymap = get_medion_keymap
200};
201static const struct ati_receiver_type type_firefly = {
202 .default_keymap = RC_MAP_SNAPSTREAM_FIREFLY
203};
204
205static struct usb_device_id ati_remote_table[] = {
206 {
207 USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA_REMOTE_PRODUCT_ID),
208 .driver_info = (unsigned long)&type_ati
209 },
210 {
211 USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA2_REMOTE_PRODUCT_ID),
212 .driver_info = (unsigned long)&type_ati
213 },
214 {
215 USB_DEVICE(ATI_REMOTE_VENDOR_ID, ATI_REMOTE_PRODUCT_ID),
216 .driver_info = (unsigned long)&type_ati
217 },
218 {
219 USB_DEVICE(ATI_REMOTE_VENDOR_ID, NVIDIA_REMOTE_PRODUCT_ID),
220 .driver_info = (unsigned long)&type_ati
221 },
222 {
223 USB_DEVICE(ATI_REMOTE_VENDOR_ID, MEDION_REMOTE_PRODUCT_ID),
224 .driver_info = (unsigned long)&type_medion
225 },
226 {
227 USB_DEVICE(ATI_REMOTE_VENDOR_ID, FIREFLY_REMOTE_PRODUCT_ID),
228 .driver_info = (unsigned long)&type_firefly
229 },
230 {}
231};
232
233MODULE_DEVICE_TABLE(usb, ati_remote_table);
234
235
236#define HI(a) ((unsigned char)((a) >> 8))
237#define LO(a) ((unsigned char)((a) & 0xff))
238
239#define SEND_FLAG_IN_PROGRESS 1
240#define SEND_FLAG_COMPLETE 2
241
242
243static char init1[] = { 0x01, 0x00, 0x20, 0x14 };
244static char init2[] = { 0x01, 0x00, 0x20, 0x14, 0x20, 0x20, 0x20 };
245
246struct ati_remote {
247 struct input_dev *idev;
248 struct rc_dev *rdev;
249 struct usb_device *udev;
250 struct usb_interface *interface;
251
252 struct urb *irq_urb;
253 struct urb *out_urb;
254 struct usb_endpoint_descriptor *endpoint_in;
255 struct usb_endpoint_descriptor *endpoint_out;
256 unsigned char *inbuf;
257 unsigned char *outbuf;
258 dma_addr_t inbuf_dma;
259 dma_addr_t outbuf_dma;
260
261 unsigned char old_data;
262 unsigned long old_jiffies;
263 unsigned long acc_jiffies;
264 unsigned long first_jiffies;
265
266 unsigned int repeat_count;
267
268 char rc_name[NAME_BUFSIZE];
269 char rc_phys[NAME_BUFSIZE];
270 char mouse_name[NAME_BUFSIZE];
271 char mouse_phys[NAME_BUFSIZE];
272
273 wait_queue_head_t wait;
274 int send_flags;
275
276 int users;
277 struct mutex open_mutex;
278};
279
280
281#define KIND_END 0
282#define KIND_LITERAL 1
283#define KIND_FILTERED 2
284#define KIND_LU 3
285#define KIND_RU 4
286#define KIND_LD 5
287#define KIND_RD 6
288#define KIND_ACCEL 7
289
290
291static const struct {
292 short kind;
293 unsigned char data;
294 int type;
295 unsigned int code;
296 int value;
297} ati_remote_tbl[] = {
298
299 {KIND_ACCEL, 0x70, EV_REL, REL_X, -1},
300 {KIND_ACCEL, 0x71, EV_REL, REL_X, 1},
301 {KIND_ACCEL, 0x72, EV_REL, REL_Y, -1},
302 {KIND_ACCEL, 0x73, EV_REL, REL_Y, 1},
303
304 {KIND_LU, 0x74, EV_REL, 0, 0},
305 {KIND_RU, 0x75, EV_REL, 0, 0},
306 {KIND_LD, 0x77, EV_REL, 0, 0},
307 {KIND_RD, 0x76, EV_REL, 0, 0},
308
309
310 {KIND_LITERAL, 0x78, EV_KEY, BTN_LEFT, 1},
311 {KIND_LITERAL, 0x79, EV_KEY, BTN_LEFT, 0},
312 {KIND_LITERAL, 0x7c, EV_KEY, BTN_RIGHT, 1},
313 {KIND_LITERAL, 0x7d, EV_KEY, BTN_RIGHT, 0},
314
315
316
317 {KIND_FILTERED, 0x7a, EV_KEY, BTN_SIDE, 1},
318 {KIND_FILTERED, 0x7e, EV_KEY, BTN_EXTRA, 1},
319
320
321 {KIND_END, 0x00, EV_MAX + 1, 0, 0}
322};
323
324
325
326
327static void ati_remote_dump(struct device *dev, unsigned char *data,
328 unsigned int len)
329{
330 if (len == 1) {
331 if (data[0] != (unsigned char)0xff && data[0] != 0x00)
332 dev_warn(dev, "Weird byte 0x%02x\n", data[0]);
333 } else if (len == 4)
334 dev_warn(dev, "Weird key %*ph\n", 4, data);
335 else
336 dev_warn(dev, "Weird data, len=%d %*ph ...\n", len, 6, data);
337}
338
339
340
341
342static int ati_remote_open(struct ati_remote *ati_remote)
343{
344 int err = 0;
345
346 mutex_lock(&ati_remote->open_mutex);
347
348 if (ati_remote->users++ != 0)
349 goto out;
350
351
352 ati_remote->irq_urb->dev = ati_remote->udev;
353 if (usb_submit_urb(ati_remote->irq_urb, GFP_KERNEL)) {
354 dev_err(&ati_remote->interface->dev,
355 "%s: usb_submit_urb failed!\n", __func__);
356 err = -EIO;
357 }
358
359out: mutex_unlock(&ati_remote->open_mutex);
360 return err;
361}
362
363
364
365
366static void ati_remote_close(struct ati_remote *ati_remote)
367{
368 mutex_lock(&ati_remote->open_mutex);
369 if (--ati_remote->users == 0)
370 usb_kill_urb(ati_remote->irq_urb);
371 mutex_unlock(&ati_remote->open_mutex);
372}
373
374static int ati_remote_input_open(struct input_dev *inputdev)
375{
376 struct ati_remote *ati_remote = input_get_drvdata(inputdev);
377 return ati_remote_open(ati_remote);
378}
379
380static void ati_remote_input_close(struct input_dev *inputdev)
381{
382 struct ati_remote *ati_remote = input_get_drvdata(inputdev);
383 ati_remote_close(ati_remote);
384}
385
386static int ati_remote_rc_open(struct rc_dev *rdev)
387{
388 struct ati_remote *ati_remote = rdev->priv;
389 return ati_remote_open(ati_remote);
390}
391
392static void ati_remote_rc_close(struct rc_dev *rdev)
393{
394 struct ati_remote *ati_remote = rdev->priv;
395 ati_remote_close(ati_remote);
396}
397
398
399
400
401static void ati_remote_irq_out(struct urb *urb)
402{
403 struct ati_remote *ati_remote = urb->context;
404
405 if (urb->status) {
406 dev_dbg(&ati_remote->interface->dev, "%s: status %d\n",
407 __func__, urb->status);
408 return;
409 }
410
411 ati_remote->send_flags |= SEND_FLAG_COMPLETE;
412 wmb();
413 wake_up(&ati_remote->wait);
414}
415
416
417
418
419
420
421static int ati_remote_sendpacket(struct ati_remote *ati_remote, u16 cmd,
422 unsigned char *data)
423{
424 int retval = 0;
425
426
427 memcpy(ati_remote->out_urb->transfer_buffer + 1, data, LO(cmd));
428 ((char *) ati_remote->out_urb->transfer_buffer)[0] = HI(cmd);
429
430 ati_remote->out_urb->transfer_buffer_length = LO(cmd) + 1;
431 ati_remote->out_urb->dev = ati_remote->udev;
432 ati_remote->send_flags = SEND_FLAG_IN_PROGRESS;
433
434 retval = usb_submit_urb(ati_remote->out_urb, GFP_ATOMIC);
435 if (retval) {
436 dev_dbg(&ati_remote->interface->dev,
437 "sendpacket: usb_submit_urb failed: %d\n", retval);
438 return retval;
439 }
440
441 wait_event_timeout(ati_remote->wait,
442 ((ati_remote->out_urb->status != -EINPROGRESS) ||
443 (ati_remote->send_flags & SEND_FLAG_COMPLETE)),
444 HZ);
445 usb_kill_urb(ati_remote->out_urb);
446
447 return retval;
448}
449
450
451
452
453
454
455
456
457
458
459static int ati_remote_compute_accel(struct ati_remote *ati_remote)
460{
461 static const char accel[] = { 1, 2, 4, 6, 9, 13, 20 };
462 unsigned long now = jiffies;
463 int acc;
464
465 if (time_after(now, ati_remote->old_jiffies + msecs_to_jiffies(250))) {
466 acc = 1;
467 ati_remote->acc_jiffies = now;
468 }
469 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(125)))
470 acc = accel[0];
471 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(250)))
472 acc = accel[1];
473 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(500)))
474 acc = accel[2];
475 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(1000)))
476 acc = accel[3];
477 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(1500)))
478 acc = accel[4];
479 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(2000)))
480 acc = accel[5];
481 else
482 acc = accel[6];
483
484 return acc;
485}
486
487
488
489
490static void ati_remote_input_report(struct urb *urb)
491{
492 struct ati_remote *ati_remote = urb->context;
493 unsigned char *data= ati_remote->inbuf;
494 struct input_dev *dev = ati_remote->idev;
495 int index = -1;
496 int acc;
497 int remote_num;
498 unsigned char scancode;
499 u32 wheel_keycode = KEY_RESERVED;
500 int i;
501
502
503
504
505
506
507
508
509
510 if ( (urb->actual_length != 4) || (data[0] != 0x14) ||
511 ((data[3] & 0x0f) != 0x00) ) {
512 ati_remote_dump(&urb->dev->dev, data, urb->actual_length);
513 return;
514 }
515
516 if (data[1] != ((data[2] + data[3] + 0xd5) & 0xff)) {
517 dbginfo(&ati_remote->interface->dev,
518 "wrong checksum in input: %*ph\n", 4, data);
519 return;
520 }
521
522
523
524 remote_num = (data[3] >> 4) & 0x0f;
525 if (channel_mask & (1 << (remote_num + 1))) {
526 dbginfo(&ati_remote->interface->dev,
527 "Masked input from channel 0x%02x: data %02x,%02x, "
528 "mask= 0x%02lx\n",
529 remote_num, data[1], data[2], channel_mask);
530 return;
531 }
532
533
534
535
536
537 scancode = data[2] & 0x7f;
538
539 dbginfo(&ati_remote->interface->dev,
540 "channel 0x%02x; key data %02x, scancode %02x\n",
541 remote_num, data[2], scancode);
542
543 if (scancode >= 0x70) {
544
545
546
547
548
549
550 wheel_keycode = rc_g_keycode_from_table(ati_remote->rdev,
551 scancode & 0x78);
552
553 if (wheel_keycode == KEY_RESERVED) {
554
555
556
557
558
559 for (i = 0; ati_remote_tbl[i].kind != KIND_END; i++) {
560 if (scancode == ati_remote_tbl[i].data) {
561 index = i;
562 break;
563 }
564 }
565 }
566 }
567
568 if (index >= 0 && ati_remote_tbl[index].kind == KIND_LITERAL) {
569 input_event(dev, ati_remote_tbl[index].type,
570 ati_remote_tbl[index].code,
571 ati_remote_tbl[index].value);
572 input_sync(dev);
573
574 ati_remote->old_jiffies = jiffies;
575 return;
576 }
577
578 if (index < 0 || ati_remote_tbl[index].kind == KIND_FILTERED) {
579 unsigned long now = jiffies;
580
581
582 if (ati_remote->old_data == data[2] &&
583 time_before(now, ati_remote->old_jiffies +
584 msecs_to_jiffies(repeat_filter))) {
585 ati_remote->repeat_count++;
586 } else {
587 ati_remote->repeat_count = 0;
588 ati_remote->first_jiffies = now;
589 }
590
591 ati_remote->old_data = data[2];
592 ati_remote->old_jiffies = now;
593
594
595
596
597
598 if (ati_remote->repeat_count > 0 &&
599 (ati_remote->repeat_count < 5 ||
600 time_before(now, ati_remote->first_jiffies +
601 msecs_to_jiffies(repeat_delay))))
602 return;
603
604 if (index < 0) {
605
606 int count = 1;
607
608 if (wheel_keycode != KEY_RESERVED) {
609
610
611
612
613
614
615 count = (scancode & 0x07) + 1;
616 scancode &= 0x78;
617 }
618
619 while (count--) {
620
621
622
623
624
625 rc_keydown_notimeout(ati_remote->rdev, scancode,
626 data[2]);
627 rc_keyup(ati_remote->rdev);
628 }
629 return;
630 }
631
632 input_event(dev, ati_remote_tbl[index].type,
633 ati_remote_tbl[index].code, 1);
634 input_sync(dev);
635 input_event(dev, ati_remote_tbl[index].type,
636 ati_remote_tbl[index].code, 0);
637 input_sync(dev);
638
639 } else {
640
641
642
643
644
645
646 acc = ati_remote_compute_accel(ati_remote);
647
648 switch (ati_remote_tbl[index].kind) {
649 case KIND_ACCEL:
650 input_event(dev, ati_remote_tbl[index].type,
651 ati_remote_tbl[index].code,
652 ati_remote_tbl[index].value * acc);
653 break;
654 case KIND_LU:
655 input_report_rel(dev, REL_X, -acc);
656 input_report_rel(dev, REL_Y, -acc);
657 break;
658 case KIND_RU:
659 input_report_rel(dev, REL_X, acc);
660 input_report_rel(dev, REL_Y, -acc);
661 break;
662 case KIND_LD:
663 input_report_rel(dev, REL_X, -acc);
664 input_report_rel(dev, REL_Y, acc);
665 break;
666 case KIND_RD:
667 input_report_rel(dev, REL_X, acc);
668 input_report_rel(dev, REL_Y, acc);
669 break;
670 default:
671 dev_dbg(&ati_remote->interface->dev,
672 "ati_remote kind=%d\n",
673 ati_remote_tbl[index].kind);
674 }
675 input_sync(dev);
676
677 ati_remote->old_jiffies = jiffies;
678 ati_remote->old_data = data[2];
679 }
680}
681
682
683
684
685static void ati_remote_irq_in(struct urb *urb)
686{
687 struct ati_remote *ati_remote = urb->context;
688 int retval;
689
690 switch (urb->status) {
691 case 0:
692 ati_remote_input_report(urb);
693 break;
694 case -ECONNRESET:
695 case -ENOENT:
696 case -ESHUTDOWN:
697 dev_dbg(&ati_remote->interface->dev,
698 "%s: urb error status, unlink?\n",
699 __func__);
700 return;
701 default:
702 dev_dbg(&ati_remote->interface->dev,
703 "%s: Nonzero urb status %d\n",
704 __func__, urb->status);
705 }
706
707 retval = usb_submit_urb(urb, GFP_ATOMIC);
708 if (retval)
709 dev_err(&ati_remote->interface->dev,
710 "%s: usb_submit_urb()=%d\n",
711 __func__, retval);
712}
713
714
715
716
717static int ati_remote_alloc_buffers(struct usb_device *udev,
718 struct ati_remote *ati_remote)
719{
720 ati_remote->inbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC,
721 &ati_remote->inbuf_dma);
722 if (!ati_remote->inbuf)
723 return -1;
724
725 ati_remote->outbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC,
726 &ati_remote->outbuf_dma);
727 if (!ati_remote->outbuf)
728 return -1;
729
730 ati_remote->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
731 if (!ati_remote->irq_urb)
732 return -1;
733
734 ati_remote->out_urb = usb_alloc_urb(0, GFP_KERNEL);
735 if (!ati_remote->out_urb)
736 return -1;
737
738 return 0;
739}
740
741
742
743
744static void ati_remote_free_buffers(struct ati_remote *ati_remote)
745{
746 usb_free_urb(ati_remote->irq_urb);
747 usb_free_urb(ati_remote->out_urb);
748
749 usb_free_coherent(ati_remote->udev, DATA_BUFSIZE,
750 ati_remote->inbuf, ati_remote->inbuf_dma);
751
752 usb_free_coherent(ati_remote->udev, DATA_BUFSIZE,
753 ati_remote->outbuf, ati_remote->outbuf_dma);
754}
755
756static void ati_remote_input_init(struct ati_remote *ati_remote)
757{
758 struct input_dev *idev = ati_remote->idev;
759 int i;
760
761 idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
762 idev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
763 BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_SIDE) | BIT_MASK(BTN_EXTRA);
764 idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
765 for (i = 0; ati_remote_tbl[i].kind != KIND_END; i++)
766 if (ati_remote_tbl[i].type == EV_KEY)
767 set_bit(ati_remote_tbl[i].code, idev->keybit);
768
769 input_set_drvdata(idev, ati_remote);
770
771 idev->open = ati_remote_input_open;
772 idev->close = ati_remote_input_close;
773
774 idev->name = ati_remote->mouse_name;
775 idev->phys = ati_remote->mouse_phys;
776
777 usb_to_input_id(ati_remote->udev, &idev->id);
778 idev->dev.parent = &ati_remote->interface->dev;
779}
780
781static void ati_remote_rc_init(struct ati_remote *ati_remote)
782{
783 struct rc_dev *rdev = ati_remote->rdev;
784
785 rdev->priv = ati_remote;
786 rdev->driver_type = RC_DRIVER_SCANCODE;
787 rdev->allowed_protos = RC_BIT_OTHER;
788 rdev->driver_name = "ati_remote";
789
790 rdev->open = ati_remote_rc_open;
791 rdev->close = ati_remote_rc_close;
792
793 rdev->input_name = ati_remote->rc_name;
794 rdev->input_phys = ati_remote->rc_phys;
795
796 usb_to_input_id(ati_remote->udev, &rdev->input_id);
797 rdev->dev.parent = &ati_remote->interface->dev;
798}
799
800static int ati_remote_initialize(struct ati_remote *ati_remote)
801{
802 struct usb_device *udev = ati_remote->udev;
803 int pipe, maxp;
804
805 init_waitqueue_head(&ati_remote->wait);
806
807
808 pipe = usb_rcvintpipe(udev, ati_remote->endpoint_in->bEndpointAddress);
809 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
810 maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp;
811
812 usb_fill_int_urb(ati_remote->irq_urb, udev, pipe, ati_remote->inbuf,
813 maxp, ati_remote_irq_in, ati_remote,
814 ati_remote->endpoint_in->bInterval);
815 ati_remote->irq_urb->transfer_dma = ati_remote->inbuf_dma;
816 ati_remote->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
817
818
819 pipe = usb_sndintpipe(udev, ati_remote->endpoint_out->bEndpointAddress);
820 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
821 maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp;
822
823 usb_fill_int_urb(ati_remote->out_urb, udev, pipe, ati_remote->outbuf,
824 maxp, ati_remote_irq_out, ati_remote,
825 ati_remote->endpoint_out->bInterval);
826 ati_remote->out_urb->transfer_dma = ati_remote->outbuf_dma;
827 ati_remote->out_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
828
829
830 if ((ati_remote_sendpacket(ati_remote, 0x8004, init1)) ||
831 (ati_remote_sendpacket(ati_remote, 0x8007, init2))) {
832 dev_err(&ati_remote->interface->dev,
833 "Initializing ati_remote hardware failed.\n");
834 return -EIO;
835 }
836
837 return 0;
838}
839
840
841
842
843static int ati_remote_probe(struct usb_interface *interface,
844 const struct usb_device_id *id)
845{
846 struct usb_device *udev = interface_to_usbdev(interface);
847 struct usb_host_interface *iface_host = interface->cur_altsetting;
848 struct usb_endpoint_descriptor *endpoint_in, *endpoint_out;
849 struct ati_receiver_type *type = (struct ati_receiver_type *)id->driver_info;
850 struct ati_remote *ati_remote;
851 struct input_dev *input_dev;
852 struct rc_dev *rc_dev;
853 int err = -ENOMEM;
854
855 if (iface_host->desc.bNumEndpoints != 2) {
856 err("%s: Unexpected desc.bNumEndpoints\n", __func__);
857 return -ENODEV;
858 }
859
860 endpoint_in = &iface_host->endpoint[0].desc;
861 endpoint_out = &iface_host->endpoint[1].desc;
862
863 if (!usb_endpoint_is_int_in(endpoint_in)) {
864 err("%s: Unexpected endpoint_in\n", __func__);
865 return -ENODEV;
866 }
867 if (le16_to_cpu(endpoint_in->wMaxPacketSize) == 0) {
868 err("%s: endpoint_in message size==0? \n", __func__);
869 return -ENODEV;
870 }
871
872 ati_remote = kzalloc(sizeof (struct ati_remote), GFP_KERNEL);
873 rc_dev = rc_allocate_device();
874 if (!ati_remote || !rc_dev)
875 goto exit_free_dev_rdev;
876
877
878 if (ati_remote_alloc_buffers(udev, ati_remote))
879 goto exit_free_buffers;
880
881 ati_remote->endpoint_in = endpoint_in;
882 ati_remote->endpoint_out = endpoint_out;
883 ati_remote->udev = udev;
884 ati_remote->rdev = rc_dev;
885 ati_remote->interface = interface;
886
887 usb_make_path(udev, ati_remote->rc_phys, sizeof(ati_remote->rc_phys));
888 strlcpy(ati_remote->mouse_phys, ati_remote->rc_phys,
889 sizeof(ati_remote->mouse_phys));
890
891 strlcat(ati_remote->rc_phys, "/input0", sizeof(ati_remote->rc_phys));
892 strlcat(ati_remote->mouse_phys, "/input1", sizeof(ati_remote->mouse_phys));
893
894 if (udev->manufacturer)
895 strlcpy(ati_remote->rc_name, udev->manufacturer,
896 sizeof(ati_remote->rc_name));
897
898 if (udev->product)
899 snprintf(ati_remote->rc_name, sizeof(ati_remote->rc_name),
900 "%s %s", ati_remote->rc_name, udev->product);
901
902 if (!strlen(ati_remote->rc_name))
903 snprintf(ati_remote->rc_name, sizeof(ati_remote->rc_name),
904 DRIVER_DESC "(%04x,%04x)",
905 le16_to_cpu(ati_remote->udev->descriptor.idVendor),
906 le16_to_cpu(ati_remote->udev->descriptor.idProduct));
907
908 snprintf(ati_remote->mouse_name, sizeof(ati_remote->mouse_name),
909 "%s mouse", ati_remote->rc_name);
910
911 rc_dev->map_name = RC_MAP_ATI_X10;
912
913
914 if (type) {
915 if (type->default_keymap)
916 rc_dev->map_name = type->default_keymap;
917 else if (type->get_default_keymap)
918 rc_dev->map_name = type->get_default_keymap(interface);
919 }
920
921 ati_remote_rc_init(ati_remote);
922 mutex_init(&ati_remote->open_mutex);
923
924
925 err = ati_remote_initialize(ati_remote);
926 if (err)
927 goto exit_kill_urbs;
928
929
930 err = rc_register_device(ati_remote->rdev);
931 if (err)
932 goto exit_kill_urbs;
933
934
935 ati_remote->rdev->input_dev->rep[REP_DELAY] = repeat_delay;
936
937
938 if (mouse) {
939 input_dev = input_allocate_device();
940 if (!input_dev) {
941 err = -ENOMEM;
942 goto exit_unregister_device;
943 }
944
945 ati_remote->idev = input_dev;
946 ati_remote_input_init(ati_remote);
947 err = input_register_device(input_dev);
948
949 if (err)
950 goto exit_free_input_device;
951 }
952
953 usb_set_intfdata(interface, ati_remote);
954 return 0;
955
956 exit_free_input_device:
957 input_free_device(input_dev);
958 exit_unregister_device:
959 rc_unregister_device(rc_dev);
960 rc_dev = NULL;
961 exit_kill_urbs:
962 usb_kill_urb(ati_remote->irq_urb);
963 usb_kill_urb(ati_remote->out_urb);
964 exit_free_buffers:
965 ati_remote_free_buffers(ati_remote);
966 exit_free_dev_rdev:
967 rc_free_device(rc_dev);
968 kfree(ati_remote);
969 return err;
970}
971
972
973
974
975static void ati_remote_disconnect(struct usb_interface *interface)
976{
977 struct ati_remote *ati_remote;
978
979 ati_remote = usb_get_intfdata(interface);
980 usb_set_intfdata(interface, NULL);
981 if (!ati_remote) {
982 dev_warn(&interface->dev, "%s - null device?\n", __func__);
983 return;
984 }
985
986 usb_kill_urb(ati_remote->irq_urb);
987 usb_kill_urb(ati_remote->out_urb);
988 if (ati_remote->idev)
989 input_unregister_device(ati_remote->idev);
990 rc_unregister_device(ati_remote->rdev);
991 ati_remote_free_buffers(ati_remote);
992 kfree(ati_remote);
993}
994
995
996static struct usb_driver ati_remote_driver = {
997 .name = "ati_remote",
998 .probe = ati_remote_probe,
999 .disconnect = ati_remote_disconnect,
1000 .id_table = ati_remote_table,
1001};
1002
1003module_usb_driver(ati_remote_driver);
1004
1005MODULE_AUTHOR(DRIVER_AUTHOR);
1006MODULE_DESCRIPTION(DRIVER_DESC);
1007MODULE_LICENSE("GPL");
1008