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