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