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(s: val, base: 0, res: &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, max: 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(buf: buffer, fmt: "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, max: 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(buf: buffer, fmt: "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(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(urb: ar2->urb[1], GFP_KERNEL); |
239 | if (r) { |
240 | usb_kill_urb(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(urb: ar2->urb[1]); |
252 | usb_kill_urb(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(dev: idev); |
258 | int r; |
259 | |
260 | dev_dbg(&ar2->intf[0]->dev, "%s()\n" , __func__); |
261 | |
262 | r = usb_autopm_get_interface(intf: 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(lock: &ati_remote2_mutex); |
280 | |
281 | usb_autopm_put_interface(intf: ar2->intf[0]); |
282 | |
283 | return 0; |
284 | |
285 | fail2: |
286 | mutex_unlock(lock: &ati_remote2_mutex); |
287 | usb_autopm_put_interface(intf: 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(dev: 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(lock: &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(dev: idev, EV_REL, REL_X, value: (s8) data[1]); |
332 | input_event(dev: idev, EV_REL, REL_Y, value: (s8) data[2]); |
333 | input_sync(dev: 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(m: 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(m: 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(dev: idev, EV_KEY, code: ar2->keycode[mode][index], value: data[1]); |
420 | input_sync(dev: 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(udev: 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(udev: 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(udev: 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(udev: 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(dev: 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: &scancode)) |
501 | return -EINVAL; |
502 | |
503 | mode = scancode >> 8; |
504 | if (mode > ATI_REMOTE2_PC) |
505 | return -EINVAL; |
506 | |
507 | offset = ati_remote2_lookup(hw_code: 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(dev: 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: &scancode)) |
541 | return -EINVAL; |
542 | |
543 | mode = scancode >> 8; |
544 | if (mode > ATI_REMOTE2_PC) |
545 | return -EINVAL; |
546 | |
547 | offset = ati_remote2_lookup(hw_code: 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(dev: idev, data: 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(hw_code: 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(dev: ar2->udev, id: &idev->id); |
618 | idev->dev.parent = &ar2->udev->dev; |
619 | |
620 | retval = input_register_device(idev); |
621 | if (retval) |
622 | input_free_device(dev: 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(dev: udev, size: 4, GFP_KERNEL, dma: &ar2->buf_dma[i]); |
634 | if (!ar2->buf[i]) |
635 | return -ENOMEM; |
636 | |
637 | ar2->urb[i] = usb_alloc_urb(iso_packets: 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); |
643 | maxp = maxp > 4 ? 4 : maxp; |
644 | |
645 | usb_fill_int_urb(urb: ar2->urb[i], dev: udev, pipe, transfer_buffer: ar2->buf[i], buffer_length: maxp, |
646 | complete_fn: i ? ati_remote2_complete_key : ati_remote2_complete_mouse, |
647 | context: ar2, interval: 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(urb: ar2->urb[i]); |
661 | usb_free_coherent(dev: ar2->udev, size: 4, addr: ar2->buf[i], dma: 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(dev: ar2->udev, usb_sndctrlpipe(ar2->udev, 0), |
688 | request: 0x20, |
689 | USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, |
690 | value: channel, index: 0x0, NULL, size: 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(dev: udev, ifnum: 0); |
706 | struct ati_remote2 *ar2 = usb_get_intfdata(intf); |
707 | |
708 | return sprintf(buf, fmt: "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(dev: udev, ifnum: 0); |
717 | struct ati_remote2 *ar2 = usb_get_intfdata(intf); |
718 | unsigned int mask; |
719 | int r; |
720 | |
721 | r = kstrtouint(s: buf, base: 0, res: &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(intf: 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, ch_mask: mask); |
739 | if (!r) |
740 | ar2->channel_mask = mask; |
741 | } |
742 | |
743 | mutex_unlock(lock: &ati_remote2_mutex); |
744 | |
745 | usb_autopm_put_interface(intf: 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(dev: udev, ifnum: 0); |
756 | struct ati_remote2 *ar2 = usb_get_intfdata(intf); |
757 | |
758 | return sprintf(buf, fmt: "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(dev: udev, ifnum: 0); |
767 | struct ati_remote2 *ar2 = usb_get_intfdata(intf); |
768 | unsigned int mask; |
769 | int err; |
770 | |
771 | err = kstrtouint(s: buf, base: 0, res: &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(size: 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(dev: udev, ifnum: 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(driver: &ati_remote2_driver, iface: ar2->intf[1], data: 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, ch_mask: ar2->channel_mask); |
856 | if (r) |
857 | goto fail3; |
858 | |
859 | usb_make_path(dev: udev, buf: ar2->phys, size: sizeof(ar2->phys)); |
860 | strlcat(p: ar2->phys, q: "/input0" , avail: sizeof(ar2->phys)); |
861 | |
862 | strlcat(p: ar2->name, q: "ATI Remote Wonder II" , avail: sizeof(ar2->name)); |
863 | |
864 | r = sysfs_create_group(kobj: &udev->dev.kobj, grp: &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(intf: interface, data: ar2); |
873 | |
874 | interface->needs_remote_wakeup = 1; |
875 | |
876 | return 0; |
877 | |
878 | fail4: |
879 | sysfs_remove_group(kobj: &udev->dev.kobj, grp: &ati_remote2_attr_group); |
880 | fail3: |
881 | ati_remote2_urb_cleanup(ar2); |
882 | fail2: |
883 | usb_driver_release_interface(driver: &ati_remote2_driver, iface: ar2->intf[1]); |
884 | fail1: |
885 | kfree(objp: 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(intf: interface); |
899 | usb_set_intfdata(intf: interface, NULL); |
900 | |
901 | input_unregister_device(ar2->idev); |
902 | |
903 | sysfs_remove_group(kobj: &ar2->udev->dev.kobj, grp: &ati_remote2_attr_group); |
904 | |
905 | ati_remote2_urb_cleanup(ar2); |
906 | |
907 | usb_driver_release_interface(driver: &ati_remote2_driver, iface: ar2->intf[1]); |
908 | |
909 | kfree(objp: 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(intf: 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(lock: &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(intf: 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(lock: &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(intf: 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, ch_mask: 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(lock: &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(intf: 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(intf: 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(lock: &ati_remote2_mutex); |
1031 | |
1032 | return r; |
1033 | } |
1034 | |
1035 | module_usb_driver(ati_remote2_driver); |
1036 | |