1
2
3
4
5
6
7
8
9
10
11
12#include <linux/usb/input.h>
13
14#define DRIVER_DESC "ATI/Philips USB RF remote driver"
15#define DRIVER_VERSION "0.3"
16
17MODULE_DESCRIPTION(DRIVER_DESC);
18MODULE_VERSION(DRIVER_VERSION);
19MODULE_AUTHOR("Ville Syrjala <syrjala@sci.fi>");
20MODULE_LICENSE("GPL");
21
22
23
24
25
26
27
28
29
30
31
32
33
34enum {
35 ATI_REMOTE2_MAX_CHANNEL_MASK = 0xFFFF,
36 ATI_REMOTE2_MAX_MODE_MASK = 0x1F,
37};
38
39static int ati_remote2_set_mask(const char *val,
40 struct kernel_param *kp, unsigned int max)
41{
42 unsigned long mask;
43 int ret;
44
45 if (!val)
46 return -EINVAL;
47
48 ret = strict_strtoul(val, 0, &mask);
49 if (ret)
50 return ret;
51
52 if (mask & ~max)
53 return -EINVAL;
54
55 *(unsigned int *)kp->arg = mask;
56
57 return 0;
58}
59
60static int ati_remote2_set_channel_mask(const char *val,
61 struct kernel_param *kp)
62{
63 pr_debug("%s()\n", __func__);
64
65 return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_CHANNEL_MASK);
66}
67
68static int ati_remote2_get_channel_mask(char *buffer, struct kernel_param *kp)
69{
70 pr_debug("%s()\n", __func__);
71
72 return sprintf(buffer, "0x%04x", *(unsigned int *)kp->arg);
73}
74
75static int ati_remote2_set_mode_mask(const char *val, struct kernel_param *kp)
76{
77 pr_debug("%s()\n", __func__);
78
79 return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_MODE_MASK);
80}
81
82static int ati_remote2_get_mode_mask(char *buffer, struct kernel_param *kp)
83{
84 pr_debug("%s()\n", __func__);
85
86 return sprintf(buffer, "0x%02x", *(unsigned int *)kp->arg);
87}
88
89static unsigned int channel_mask = ATI_REMOTE2_MAX_CHANNEL_MASK;
90#define param_check_channel_mask(name, p) __param_check(name, p, unsigned int)
91#define param_set_channel_mask ati_remote2_set_channel_mask
92#define param_get_channel_mask ati_remote2_get_channel_mask
93module_param(channel_mask, channel_mask, 0644);
94MODULE_PARM_DESC(channel_mask, "Bitmask of channels to accept <15:Channel16>...<1:Channel2><0:Channel1>");
95
96static unsigned int mode_mask = ATI_REMOTE2_MAX_MODE_MASK;
97#define param_check_mode_mask(name, p) __param_check(name, p, unsigned int)
98#define param_set_mode_mask ati_remote2_set_mode_mask
99#define param_get_mode_mask ati_remote2_get_mode_mask
100module_param(mode_mask, mode_mask, 0644);
101MODULE_PARM_DESC(mode_mask, "Bitmask of modes to accept <4:PC><3:AUX4><2:AUX3><1:AUX2><0:AUX1>");
102
103static struct usb_device_id ati_remote2_id_table[] = {
104 { USB_DEVICE(0x0471, 0x0602) },
105 { }
106};
107MODULE_DEVICE_TABLE(usb, ati_remote2_id_table);
108
109static DEFINE_MUTEX(ati_remote2_mutex);
110
111enum {
112 ATI_REMOTE2_OPENED = 0x1,
113 ATI_REMOTE2_SUSPENDED = 0x2,
114};
115
116enum {
117 ATI_REMOTE2_AUX1,
118 ATI_REMOTE2_AUX2,
119 ATI_REMOTE2_AUX3,
120 ATI_REMOTE2_AUX4,
121 ATI_REMOTE2_PC,
122 ATI_REMOTE2_MODES,
123};
124
125static const struct {
126 u8 hw_code;
127 u16 keycode;
128} ati_remote2_key_table[] = {
129 { 0x00, KEY_0 },
130 { 0x01, KEY_1 },
131 { 0x02, KEY_2 },
132 { 0x03, KEY_3 },
133 { 0x04, KEY_4 },
134 { 0x05, KEY_5 },
135 { 0x06, KEY_6 },
136 { 0x07, KEY_7 },
137 { 0x08, KEY_8 },
138 { 0x09, KEY_9 },
139 { 0x0c, KEY_POWER },
140 { 0x0d, KEY_MUTE },
141 { 0x10, KEY_VOLUMEUP },
142 { 0x11, KEY_VOLUMEDOWN },
143 { 0x20, KEY_CHANNELUP },
144 { 0x21, KEY_CHANNELDOWN },
145 { 0x28, KEY_FORWARD },
146 { 0x29, KEY_REWIND },
147 { 0x2c, KEY_PLAY },
148 { 0x30, KEY_PAUSE },
149 { 0x31, KEY_STOP },
150 { 0x37, KEY_RECORD },
151 { 0x38, KEY_DVD },
152 { 0x39, KEY_TV },
153 { 0x3f, KEY_PROG1 },
154 { 0x54, KEY_MENU },
155 { 0x58, KEY_UP },
156 { 0x59, KEY_DOWN },
157 { 0x5a, KEY_LEFT },
158 { 0x5b, KEY_RIGHT },
159 { 0x5c, KEY_OK },
160 { 0x78, KEY_A },
161 { 0x79, KEY_B },
162 { 0x7a, KEY_C },
163 { 0x7b, KEY_D },
164 { 0x7c, KEY_E },
165 { 0x7d, KEY_F },
166 { 0x82, KEY_ENTER },
167 { 0x8e, KEY_VENDOR },
168 { 0x96, KEY_COFFEE },
169 { 0xa9, BTN_LEFT },
170 { 0xaa, BTN_RIGHT },
171 { 0xbe, KEY_QUESTION },
172 { 0xd0, KEY_EDIT },
173 { 0xd5, KEY_FRONT },
174 { 0xf9, KEY_INFO },
175};
176
177struct ati_remote2 {
178 struct input_dev *idev;
179 struct usb_device *udev;
180
181 struct usb_interface *intf[2];
182 struct usb_endpoint_descriptor *ep[2];
183 struct urb *urb[2];
184 void *buf[2];
185 dma_addr_t buf_dma[2];
186
187 unsigned long jiffies;
188 int mode;
189
190 char name[64];
191 char phys[64];
192
193
194 u16 keycode[ATI_REMOTE2_MODES][ARRAY_SIZE(ati_remote2_key_table)];
195
196 unsigned int flags;
197
198 unsigned int channel_mask;
199 unsigned int mode_mask;
200};
201
202static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id);
203static void ati_remote2_disconnect(struct usb_interface *interface);
204static int ati_remote2_suspend(struct usb_interface *interface, pm_message_t message);
205static int ati_remote2_resume(struct usb_interface *interface);
206static int ati_remote2_reset_resume(struct usb_interface *interface);
207static int ati_remote2_pre_reset(struct usb_interface *interface);
208static int ati_remote2_post_reset(struct usb_interface *interface);
209
210static struct usb_driver ati_remote2_driver = {
211 .name = "ati_remote2",
212 .probe = ati_remote2_probe,
213 .disconnect = ati_remote2_disconnect,
214 .id_table = ati_remote2_id_table,
215 .suspend = ati_remote2_suspend,
216 .resume = ati_remote2_resume,
217 .reset_resume = ati_remote2_reset_resume,
218 .pre_reset = ati_remote2_pre_reset,
219 .post_reset = ati_remote2_post_reset,
220 .supports_autosuspend = 1,
221};
222
223static int ati_remote2_submit_urbs(struct ati_remote2 *ar2)
224{
225 int r;
226
227 r = usb_submit_urb(ar2->urb[0], GFP_KERNEL);
228 if (r) {
229 dev_err(&ar2->intf[0]->dev,
230 "%s(): usb_submit_urb() = %d\n", __func__, r);
231 return r;
232 }
233 r = usb_submit_urb(ar2->urb[1], GFP_KERNEL);
234 if (r) {
235 usb_kill_urb(ar2->urb[0]);
236 dev_err(&ar2->intf[1]->dev,
237 "%s(): usb_submit_urb() = %d\n", __func__, r);
238 return r;
239 }
240
241 return 0;
242}
243
244static void ati_remote2_kill_urbs(struct ati_remote2 *ar2)
245{
246 usb_kill_urb(ar2->urb[1]);
247 usb_kill_urb(ar2->urb[0]);
248}
249
250static int ati_remote2_open(struct input_dev *idev)
251{
252 struct ati_remote2 *ar2 = input_get_drvdata(idev);
253 int r;
254
255 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
256
257 r = usb_autopm_get_interface(ar2->intf[0]);
258 if (r) {
259 dev_err(&ar2->intf[0]->dev,
260 "%s(): usb_autopm_get_interface() = %d\n", __func__, r);
261 goto fail1;
262 }
263
264 mutex_lock(&ati_remote2_mutex);
265
266 if (!(ar2->flags & ATI_REMOTE2_SUSPENDED)) {
267 r = ati_remote2_submit_urbs(ar2);
268 if (r)
269 goto fail2;
270 }
271
272 ar2->flags |= ATI_REMOTE2_OPENED;
273
274 mutex_unlock(&ati_remote2_mutex);
275
276 usb_autopm_put_interface(ar2->intf[0]);
277
278 return 0;
279
280 fail2:
281 mutex_unlock(&ati_remote2_mutex);
282 usb_autopm_put_interface(ar2->intf[0]);
283 fail1:
284 return r;
285}
286
287static void ati_remote2_close(struct input_dev *idev)
288{
289 struct ati_remote2 *ar2 = input_get_drvdata(idev);
290
291 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
292
293 mutex_lock(&ati_remote2_mutex);
294
295 if (!(ar2->flags & ATI_REMOTE2_SUSPENDED))
296 ati_remote2_kill_urbs(ar2);
297
298 ar2->flags &= ~ATI_REMOTE2_OPENED;
299
300 mutex_unlock(&ati_remote2_mutex);
301}
302
303static void ati_remote2_input_mouse(struct ati_remote2 *ar2)
304{
305 struct input_dev *idev = ar2->idev;
306 u8 *data = ar2->buf[0];
307 int channel, mode;
308
309 channel = data[0] >> 4;
310
311 if (!((1 << channel) & ar2->channel_mask))
312 return;
313
314 mode = data[0] & 0x0F;
315
316 if (mode > ATI_REMOTE2_PC) {
317 dev_err(&ar2->intf[0]->dev,
318 "Unknown mode byte (%02x %02x %02x %02x)\n",
319 data[3], data[2], data[1], data[0]);
320 return;
321 }
322
323 if (!((1 << mode) & ar2->mode_mask))
324 return;
325
326 input_event(idev, EV_REL, REL_X, (s8) data[1]);
327 input_event(idev, EV_REL, REL_Y, (s8) data[2]);
328 input_sync(idev);
329}
330
331static int ati_remote2_lookup(unsigned int hw_code)
332{
333 int i;
334
335 for (i = 0; i < ARRAY_SIZE(ati_remote2_key_table); i++)
336 if (ati_remote2_key_table[i].hw_code == hw_code)
337 return i;
338
339 return -1;
340}
341
342static void ati_remote2_input_key(struct ati_remote2 *ar2)
343{
344 struct input_dev *idev = ar2->idev;
345 u8 *data = ar2->buf[1];
346 int channel, mode, hw_code, index;
347
348 channel = data[0] >> 4;
349
350 if (!((1 << channel) & ar2->channel_mask))
351 return;
352
353 mode = data[0] & 0x0F;
354
355 if (mode > ATI_REMOTE2_PC) {
356 dev_err(&ar2->intf[1]->dev,
357 "Unknown mode byte (%02x %02x %02x %02x)\n",
358 data[3], data[2], data[1], data[0]);
359 return;
360 }
361
362 hw_code = data[2];
363 if (hw_code == 0x3f) {
364
365
366
367
368
369
370
371 if (ar2->mode == mode)
372 return;
373
374 if (data[1] == 0)
375 ar2->mode = mode;
376 }
377
378 if (!((1 << mode) & ar2->mode_mask))
379 return;
380
381 index = ati_remote2_lookup(hw_code);
382 if (index < 0) {
383 dev_err(&ar2->intf[1]->dev,
384 "Unknown code byte (%02x %02x %02x %02x)\n",
385 data[3], data[2], data[1], data[0]);
386 return;
387 }
388
389 switch (data[1]) {
390 case 0:
391 break;
392 case 1:
393 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_DELAY]);
394 break;
395 case 2:
396
397
398 if (ar2->keycode[mode][index] == BTN_LEFT ||
399 ar2->keycode[mode][index] == BTN_RIGHT)
400 return;
401
402 if (!time_after_eq(jiffies, ar2->jiffies))
403 return;
404
405 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_PERIOD]);
406 break;
407 default:
408 dev_err(&ar2->intf[1]->dev,
409 "Unknown state byte (%02x %02x %02x %02x)\n",
410 data[3], data[2], data[1], data[0]);
411 return;
412 }
413
414 input_event(idev, EV_KEY, ar2->keycode[mode][index], data[1]);
415 input_sync(idev);
416}
417
418static void ati_remote2_complete_mouse(struct urb *urb)
419{
420 struct ati_remote2 *ar2 = urb->context;
421 int r;
422
423 switch (urb->status) {
424 case 0:
425 usb_mark_last_busy(ar2->udev);
426 ati_remote2_input_mouse(ar2);
427 break;
428 case -ENOENT:
429 case -EILSEQ:
430 case -ECONNRESET:
431 case -ESHUTDOWN:
432 dev_dbg(&ar2->intf[0]->dev,
433 "%s(): urb status = %d\n", __func__, urb->status);
434 return;
435 default:
436 usb_mark_last_busy(ar2->udev);
437 dev_err(&ar2->intf[0]->dev,
438 "%s(): urb status = %d\n", __func__, urb->status);
439 }
440
441 r = usb_submit_urb(urb, GFP_ATOMIC);
442 if (r)
443 dev_err(&ar2->intf[0]->dev,
444 "%s(): usb_submit_urb() = %d\n", __func__, r);
445}
446
447static void ati_remote2_complete_key(struct urb *urb)
448{
449 struct ati_remote2 *ar2 = urb->context;
450 int r;
451
452 switch (urb->status) {
453 case 0:
454 usb_mark_last_busy(ar2->udev);
455 ati_remote2_input_key(ar2);
456 break;
457 case -ENOENT:
458 case -EILSEQ:
459 case -ECONNRESET:
460 case -ESHUTDOWN:
461 dev_dbg(&ar2->intf[1]->dev,
462 "%s(): urb status = %d\n", __func__, urb->status);
463 return;
464 default:
465 usb_mark_last_busy(ar2->udev);
466 dev_err(&ar2->intf[1]->dev,
467 "%s(): urb status = %d\n", __func__, urb->status);
468 }
469
470 r = usb_submit_urb(urb, GFP_ATOMIC);
471 if (r)
472 dev_err(&ar2->intf[1]->dev,
473 "%s(): usb_submit_urb() = %d\n", __func__, r);
474}
475
476static int ati_remote2_getkeycode(struct input_dev *idev,
477 int scancode, int *keycode)
478{
479 struct ati_remote2 *ar2 = input_get_drvdata(idev);
480 int index, mode;
481
482 mode = scancode >> 8;
483 if (mode > ATI_REMOTE2_PC || !((1 << mode) & ar2->mode_mask))
484 return -EINVAL;
485
486 index = ati_remote2_lookup(scancode & 0xFF);
487 if (index < 0)
488 return -EINVAL;
489
490 *keycode = ar2->keycode[mode][index];
491 return 0;
492}
493
494static int ati_remote2_setkeycode(struct input_dev *idev, int scancode, int keycode)
495{
496 struct ati_remote2 *ar2 = input_get_drvdata(idev);
497 int index, mode, old_keycode;
498
499 mode = scancode >> 8;
500 if (mode > ATI_REMOTE2_PC || !((1 << mode) & ar2->mode_mask))
501 return -EINVAL;
502
503 index = ati_remote2_lookup(scancode & 0xFF);
504 if (index < 0)
505 return -EINVAL;
506
507 if (keycode < KEY_RESERVED || keycode > KEY_MAX)
508 return -EINVAL;
509
510 old_keycode = ar2->keycode[mode][index];
511 ar2->keycode[mode][index] = keycode;
512 __set_bit(keycode, idev->keybit);
513
514 for (mode = 0; mode < ATI_REMOTE2_MODES; mode++) {
515 for (index = 0; index < ARRAY_SIZE(ati_remote2_key_table); index++) {
516 if (ar2->keycode[mode][index] == old_keycode)
517 return 0;
518 }
519 }
520
521 __clear_bit(old_keycode, idev->keybit);
522
523 return 0;
524}
525
526static int ati_remote2_input_init(struct ati_remote2 *ar2)
527{
528 struct input_dev *idev;
529 int index, mode, retval;
530
531 idev = input_allocate_device();
532 if (!idev)
533 return -ENOMEM;
534
535 ar2->idev = idev;
536 input_set_drvdata(idev, ar2);
537
538 idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | BIT_MASK(EV_REL);
539 idev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
540 BIT_MASK(BTN_RIGHT);
541 idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
542
543 for (mode = 0; mode < ATI_REMOTE2_MODES; mode++) {
544 for (index = 0; index < ARRAY_SIZE(ati_remote2_key_table); index++) {
545 ar2->keycode[mode][index] = ati_remote2_key_table[index].keycode;
546 __set_bit(ar2->keycode[mode][index], idev->keybit);
547 }
548 }
549
550
551 index = ati_remote2_lookup(0x3f);
552 ar2->keycode[ATI_REMOTE2_AUX1][index] = KEY_PROG1;
553 ar2->keycode[ATI_REMOTE2_AUX2][index] = KEY_PROG2;
554 ar2->keycode[ATI_REMOTE2_AUX3][index] = KEY_PROG3;
555 ar2->keycode[ATI_REMOTE2_AUX4][index] = KEY_PROG4;
556 ar2->keycode[ATI_REMOTE2_PC][index] = KEY_PC;
557 __set_bit(KEY_PROG1, idev->keybit);
558 __set_bit(KEY_PROG2, idev->keybit);
559 __set_bit(KEY_PROG3, idev->keybit);
560 __set_bit(KEY_PROG4, idev->keybit);
561 __set_bit(KEY_PC, idev->keybit);
562
563 idev->rep[REP_DELAY] = 250;
564 idev->rep[REP_PERIOD] = 33;
565
566 idev->open = ati_remote2_open;
567 idev->close = ati_remote2_close;
568
569 idev->getkeycode = ati_remote2_getkeycode;
570 idev->setkeycode = ati_remote2_setkeycode;
571
572 idev->name = ar2->name;
573 idev->phys = ar2->phys;
574
575 usb_to_input_id(ar2->udev, &idev->id);
576 idev->dev.parent = &ar2->udev->dev;
577
578 retval = input_register_device(idev);
579 if (retval)
580 input_free_device(idev);
581
582 return retval;
583}
584
585static int ati_remote2_urb_init(struct ati_remote2 *ar2)
586{
587 struct usb_device *udev = ar2->udev;
588 int i, pipe, maxp;
589
590 for (i = 0; i < 2; i++) {
591 ar2->buf[i] = usb_buffer_alloc(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]);
592 if (!ar2->buf[i])
593 return -ENOMEM;
594
595 ar2->urb[i] = usb_alloc_urb(0, GFP_KERNEL);
596 if (!ar2->urb[i])
597 return -ENOMEM;
598
599 pipe = usb_rcvintpipe(udev, ar2->ep[i]->bEndpointAddress);
600 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
601 maxp = maxp > 4 ? 4 : maxp;
602
603 usb_fill_int_urb(ar2->urb[i], udev, pipe, ar2->buf[i], maxp,
604 i ? ati_remote2_complete_key : ati_remote2_complete_mouse,
605 ar2, ar2->ep[i]->bInterval);
606 ar2->urb[i]->transfer_dma = ar2->buf_dma[i];
607 ar2->urb[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
608 }
609
610 return 0;
611}
612
613static void ati_remote2_urb_cleanup(struct ati_remote2 *ar2)
614{
615 int i;
616
617 for (i = 0; i < 2; i++) {
618 usb_free_urb(ar2->urb[i]);
619 usb_buffer_free(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]);
620 }
621}
622
623static int ati_remote2_setup(struct ati_remote2 *ar2, unsigned int ch_mask)
624{
625 int r, i, channel;
626
627
628
629
630
631
632
633
634
635
636 channel = 0;
637 for (i = 0; i < 16; i++) {
638 if ((1 << i) & ch_mask) {
639 if (!(~(1 << i) & ch_mask))
640 channel = i + 1;
641 break;
642 }
643 }
644
645 r = usb_control_msg(ar2->udev, usb_sndctrlpipe(ar2->udev, 0),
646 0x20,
647 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
648 channel, 0x0, NULL, 0, USB_CTRL_SET_TIMEOUT);
649 if (r) {
650 dev_err(&ar2->udev->dev, "%s - failed to set channel due to error: %d\n",
651 __func__, r);
652 return r;
653 }
654
655 return 0;
656}
657
658static ssize_t ati_remote2_show_channel_mask(struct device *dev,
659 struct device_attribute *attr,
660 char *buf)
661{
662 struct usb_device *udev = to_usb_device(dev);
663 struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
664 struct ati_remote2 *ar2 = usb_get_intfdata(intf);
665
666 return sprintf(buf, "0x%04x\n", ar2->channel_mask);
667}
668
669static ssize_t ati_remote2_store_channel_mask(struct device *dev,
670 struct device_attribute *attr,
671 const char *buf, size_t count)
672{
673 struct usb_device *udev = to_usb_device(dev);
674 struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
675 struct ati_remote2 *ar2 = usb_get_intfdata(intf);
676 unsigned long mask;
677 int r;
678
679 if (strict_strtoul(buf, 0, &mask))
680 return -EINVAL;
681
682 if (mask & ~ATI_REMOTE2_MAX_CHANNEL_MASK)
683 return -EINVAL;
684
685 r = usb_autopm_get_interface(ar2->intf[0]);
686 if (r) {
687 dev_err(&ar2->intf[0]->dev,
688 "%s(): usb_autopm_get_interface() = %d\n", __func__, r);
689 return r;
690 }
691
692 mutex_lock(&ati_remote2_mutex);
693
694 if (mask != ar2->channel_mask && !ati_remote2_setup(ar2, mask))
695 ar2->channel_mask = mask;
696
697 mutex_unlock(&ati_remote2_mutex);
698
699 usb_autopm_put_interface(ar2->intf[0]);
700
701 return count;
702}
703
704static ssize_t ati_remote2_show_mode_mask(struct device *dev,
705 struct device_attribute *attr,
706 char *buf)
707{
708 struct usb_device *udev = to_usb_device(dev);
709 struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
710 struct ati_remote2 *ar2 = usb_get_intfdata(intf);
711
712 return sprintf(buf, "0x%02x\n", ar2->mode_mask);
713}
714
715static ssize_t ati_remote2_store_mode_mask(struct device *dev,
716 struct device_attribute *attr,
717 const char *buf, size_t count)
718{
719 struct usb_device *udev = to_usb_device(dev);
720 struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
721 struct ati_remote2 *ar2 = usb_get_intfdata(intf);
722 unsigned long mask;
723
724 if (strict_strtoul(buf, 0, &mask))
725 return -EINVAL;
726
727 if (mask & ~ATI_REMOTE2_MAX_MODE_MASK)
728 return -EINVAL;
729
730 ar2->mode_mask = mask;
731
732 return count;
733}
734
735static DEVICE_ATTR(channel_mask, 0644, ati_remote2_show_channel_mask,
736 ati_remote2_store_channel_mask);
737
738static DEVICE_ATTR(mode_mask, 0644, ati_remote2_show_mode_mask,
739 ati_remote2_store_mode_mask);
740
741static struct attribute *ati_remote2_attrs[] = {
742 &dev_attr_channel_mask.attr,
743 &dev_attr_mode_mask.attr,
744 NULL,
745};
746
747static struct attribute_group ati_remote2_attr_group = {
748 .attrs = ati_remote2_attrs,
749};
750
751static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id)
752{
753 struct usb_device *udev = interface_to_usbdev(interface);
754 struct usb_host_interface *alt = interface->cur_altsetting;
755 struct ati_remote2 *ar2;
756 int r;
757
758 if (alt->desc.bInterfaceNumber)
759 return -ENODEV;
760
761 ar2 = kzalloc(sizeof (struct ati_remote2), GFP_KERNEL);
762 if (!ar2)
763 return -ENOMEM;
764
765 ar2->udev = udev;
766
767 ar2->intf[0] = interface;
768 ar2->ep[0] = &alt->endpoint[0].desc;
769
770 ar2->intf[1] = usb_ifnum_to_if(udev, 1);
771 r = usb_driver_claim_interface(&ati_remote2_driver, ar2->intf[1], ar2);
772 if (r)
773 goto fail1;
774 alt = ar2->intf[1]->cur_altsetting;
775 ar2->ep[1] = &alt->endpoint[0].desc;
776
777 r = ati_remote2_urb_init(ar2);
778 if (r)
779 goto fail2;
780
781 ar2->channel_mask = channel_mask;
782 ar2->mode_mask = mode_mask;
783
784 r = ati_remote2_setup(ar2, ar2->channel_mask);
785 if (r)
786 goto fail2;
787
788 usb_make_path(udev, ar2->phys, sizeof(ar2->phys));
789 strlcat(ar2->phys, "/input0", sizeof(ar2->phys));
790
791 strlcat(ar2->name, "ATI Remote Wonder II", sizeof(ar2->name));
792
793 r = sysfs_create_group(&udev->dev.kobj, &ati_remote2_attr_group);
794 if (r)
795 goto fail2;
796
797 r = ati_remote2_input_init(ar2);
798 if (r)
799 goto fail3;
800
801 usb_set_intfdata(interface, ar2);
802
803 interface->needs_remote_wakeup = 1;
804
805 return 0;
806
807 fail3:
808 sysfs_remove_group(&udev->dev.kobj, &ati_remote2_attr_group);
809 fail2:
810 ati_remote2_urb_cleanup(ar2);
811 usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
812 fail1:
813 kfree(ar2);
814
815 return r;
816}
817
818static void ati_remote2_disconnect(struct usb_interface *interface)
819{
820 struct ati_remote2 *ar2;
821 struct usb_host_interface *alt = interface->cur_altsetting;
822
823 if (alt->desc.bInterfaceNumber)
824 return;
825
826 ar2 = usb_get_intfdata(interface);
827 usb_set_intfdata(interface, NULL);
828
829 input_unregister_device(ar2->idev);
830
831 sysfs_remove_group(&ar2->udev->dev.kobj, &ati_remote2_attr_group);
832
833 ati_remote2_urb_cleanup(ar2);
834
835 usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
836
837 kfree(ar2);
838}
839
840static int ati_remote2_suspend(struct usb_interface *interface,
841 pm_message_t message)
842{
843 struct ati_remote2 *ar2;
844 struct usb_host_interface *alt = interface->cur_altsetting;
845
846 if (alt->desc.bInterfaceNumber)
847 return 0;
848
849 ar2 = usb_get_intfdata(interface);
850
851 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
852
853 mutex_lock(&ati_remote2_mutex);
854
855 if (ar2->flags & ATI_REMOTE2_OPENED)
856 ati_remote2_kill_urbs(ar2);
857
858 ar2->flags |= ATI_REMOTE2_SUSPENDED;
859
860 mutex_unlock(&ati_remote2_mutex);
861
862 return 0;
863}
864
865static int ati_remote2_resume(struct usb_interface *interface)
866{
867 struct ati_remote2 *ar2;
868 struct usb_host_interface *alt = interface->cur_altsetting;
869 int r = 0;
870
871 if (alt->desc.bInterfaceNumber)
872 return 0;
873
874 ar2 = usb_get_intfdata(interface);
875
876 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
877
878 mutex_lock(&ati_remote2_mutex);
879
880 if (ar2->flags & ATI_REMOTE2_OPENED)
881 r = ati_remote2_submit_urbs(ar2);
882
883 if (!r)
884 ar2->flags &= ~ATI_REMOTE2_SUSPENDED;
885
886 mutex_unlock(&ati_remote2_mutex);
887
888 return r;
889}
890
891static int ati_remote2_reset_resume(struct usb_interface *interface)
892{
893 struct ati_remote2 *ar2;
894 struct usb_host_interface *alt = interface->cur_altsetting;
895 int r = 0;
896
897 if (alt->desc.bInterfaceNumber)
898 return 0;
899
900 ar2 = usb_get_intfdata(interface);
901
902 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
903
904 mutex_lock(&ati_remote2_mutex);
905
906 r = ati_remote2_setup(ar2, ar2->channel_mask);
907 if (r)
908 goto out;
909
910 if (ar2->flags & ATI_REMOTE2_OPENED)
911 r = ati_remote2_submit_urbs(ar2);
912
913 if (!r)
914 ar2->flags &= ~ATI_REMOTE2_SUSPENDED;
915
916 out:
917 mutex_unlock(&ati_remote2_mutex);
918
919 return r;
920}
921
922static int ati_remote2_pre_reset(struct usb_interface *interface)
923{
924 struct ati_remote2 *ar2;
925 struct usb_host_interface *alt = interface->cur_altsetting;
926
927 if (alt->desc.bInterfaceNumber)
928 return 0;
929
930 ar2 = usb_get_intfdata(interface);
931
932 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
933
934 mutex_lock(&ati_remote2_mutex);
935
936 if (ar2->flags == ATI_REMOTE2_OPENED)
937 ati_remote2_kill_urbs(ar2);
938
939 return 0;
940}
941
942static int ati_remote2_post_reset(struct usb_interface *interface)
943{
944 struct ati_remote2 *ar2;
945 struct usb_host_interface *alt = interface->cur_altsetting;
946 int r = 0;
947
948 if (alt->desc.bInterfaceNumber)
949 return 0;
950
951 ar2 = usb_get_intfdata(interface);
952
953 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
954
955 if (ar2->flags == ATI_REMOTE2_OPENED)
956 r = ati_remote2_submit_urbs(ar2);
957
958 mutex_unlock(&ati_remote2_mutex);
959
960 return r;
961}
962
963static int __init ati_remote2_init(void)
964{
965 int r;
966
967 r = usb_register(&ati_remote2_driver);
968 if (r)
969 printk(KERN_ERR "ati_remote2: usb_register() = %d\n", r);
970 else
971 printk(KERN_INFO "ati_remote2: " DRIVER_DESC " " DRIVER_VERSION "\n");
972
973 return r;
974}
975
976static void __exit ati_remote2_exit(void)
977{
978 usb_deregister(&ati_remote2_driver);
979}
980
981module_init(ati_remote2_init);
982module_exit(ati_remote2_exit);
983
