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