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 14 #define DRIVER_DESC "ATI/Philips USB RF remote driver" 15 #define DRIVER_VERSION "0.3" 16 17 MODULE_DESCRIPTION(DRIVER_DESC); 18 MODULE_VERSION(DRIVER_VERSION); 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 by 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 static unsigned int channel_mask = 0xFFFF; 35 module_param(channel_mask, uint, 0644); 36 MODULE_PARM_DESC(channel_mask, "Bitmask of channels to accept <15:Channel16>...<1:Channel2><0:Channel1>"); 37 38 static unsigned int mode_mask = 0x1F; 39 module_param(mode_mask, uint, 0644); 40 MODULE_PARM_DESC(mode_mask, "Bitmask of modes to accept <4:PC><3:AUX4><2:AUX3><1:AUX2><0:AUX1>"); 41 42 static struct usb_device_id ati_remote2_id_table[] = { 43 { USB_DEVICE(0x0471, 0x0602) }, /* ATI Remote Wonder II */ 44 { } 45 }; 46 MODULE_DEVICE_TABLE(usb, ati_remote2_id_table); 47 48 static DEFINE_MUTEX(ati_remote2_mutex); 49 50 enum { 51 ATI_REMOTE2_OPENED = 0x1, 52 ATI_REMOTE2_SUSPENDED = 0x2, 53 }; 54 55 enum { 56 ATI_REMOTE2_AUX1, 57 ATI_REMOTE2_AUX2, 58 ATI_REMOTE2_AUX3, 59 ATI_REMOTE2_AUX4, 60 ATI_REMOTE2_PC, 61 ATI_REMOTE2_MODES, 62 }; 63 64 static const struct { 65 u8 hw_code; 66 u16 keycode; 67 } ati_remote2_key_table[] = { 68 { 0x00, KEY_0 }, 69 { 0x01, KEY_1 }, 70 { 0x02, KEY_2 }, 71 { 0x03, KEY_3 }, 72 { 0x04, KEY_4 }, 73 { 0x05, KEY_5 }, 74 { 0x06, KEY_6 }, 75 { 0x07, KEY_7 }, 76 { 0x08, KEY_8 }, 77 { 0x09, KEY_9 }, 78 { 0x0c, KEY_POWER }, 79 { 0x0d, KEY_MUTE }, 80 { 0x10, KEY_VOLUMEUP }, 81 { 0x11, KEY_VOLUMEDOWN }, 82 { 0x20, KEY_CHANNELUP }, 83 { 0x21, KEY_CHANNELDOWN }, 84 { 0x28, KEY_FORWARD }, 85 { 0x29, KEY_REWIND }, 86 { 0x2c, KEY_PLAY }, 87 { 0x30, KEY_PAUSE }, 88 { 0x31, KEY_STOP }, 89 { 0x37, KEY_RECORD }, 90 { 0x38, KEY_DVD }, 91 { 0x39, KEY_TV }, 92 { 0x3f, KEY_PROG1 }, /* AUX1-AUX4 and PC */ 93 { 0x54, KEY_MENU }, 94 { 0x58, KEY_UP }, 95 { 0x59, KEY_DOWN }, 96 { 0x5a, KEY_LEFT }, 97 { 0x5b, KEY_RIGHT }, 98 { 0x5c, KEY_OK }, 99 { 0x78, KEY_A }, 100 { 0x79, KEY_B }, 101 { 0x7a, KEY_C }, 102 { 0x7b, KEY_D }, 103 { 0x7c, KEY_E }, 104 { 0x7d, KEY_F }, 105 { 0x82, KEY_ENTER }, 106 { 0x8e, KEY_VENDOR }, 107 { 0x96, KEY_COFFEE }, 108 { 0xa9, BTN_LEFT }, 109 { 0xaa, BTN_RIGHT }, 110 { 0xbe, KEY_QUESTION }, 111 { 0xd0, KEY_EDIT }, 112 { 0xd5, KEY_FRONT }, 113 { 0xf9, KEY_INFO }, 114 }; 115 116 struct ati_remote2 { 117 struct input_dev *idev; 118 struct usb_device *udev; 119 120 struct usb_interface *intf[2]; 121 struct usb_endpoint_descriptor *ep[2]; 122 struct urb *urb[2]; 123 void *buf[2]; 124 dma_addr_t buf_dma[2]; 125 126 unsigned long jiffies; 127 int mode; 128 129 char name[64]; 130 char phys[64]; 131 132 /* Each mode (AUX1-AUX4 and PC) can have an independent keymap. */ 133 u16 keycode[ATI_REMOTE2_MODES][ARRAY_SIZE(ati_remote2_key_table)]; 134 135 unsigned int flags; 136 }; 137 138 static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id); 139 static void ati_remote2_disconnect(struct usb_interface *interface); 140 static int ati_remote2_suspend(struct usb_interface *interface, pm_message_t message); 141 static int ati_remote2_resume(struct usb_interface *interface); 142 143 static struct usb_driver ati_remote2_driver = { 144 .name = "ati_remote2", 145 .probe = ati_remote2_probe, 146 .disconnect = ati_remote2_disconnect, 147 .id_table = ati_remote2_id_table, 148 .suspend = ati_remote2_suspend, 149 .resume = ati_remote2_resume, 150 .supports_autosuspend = 1, 151 }; 152 153 static int ati_remote2_submit_urbs(struct ati_remote2 *ar2) 154 { 155 int r; 156 157 r = usb_submit_urb(ar2->urb[0], GFP_KERNEL); 158 if (r) { 159 dev_err(&ar2->intf[0]->dev, 160 "%s(): usb_submit_urb() = %d\n", __func__, r); 161 return r; 162 } 163 r = usb_submit_urb(ar2->urb[1], GFP_KERNEL); 164 if (r) { 165 usb_kill_urb(ar2->urb[0]); 166 dev_err(&ar2->intf[1]->dev, 167 "%s(): usb_submit_urb() = %d\n", __func__, r); 168 return r; 169 } 170 171 return 0; 172 } 173 174 static void ati_remote2_kill_urbs(struct ati_remote2 *ar2) 175 { 176 usb_kill_urb(ar2->urb[1]); 177 usb_kill_urb(ar2->urb[0]); 178 } 179 180 static int ati_remote2_open(struct input_dev *idev) 181 { 182 struct ati_remote2 *ar2 = input_get_drvdata(idev); 183 int r; 184 185 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__); 186 187 r = usb_autopm_get_interface(ar2->intf[0]); 188 if (r) { 189 dev_err(&ar2->intf[0]->dev, 190 "%s(): usb_autopm_get_interface() = %d\n", __func__, r); 191 goto fail1; 192 } 193 194 mutex_lock(&ati_remote2_mutex); 195 196 if (!(ar2->flags & ATI_REMOTE2_SUSPENDED)) { 197 r = ati_remote2_submit_urbs(ar2); 198 if (r) 199 goto fail2; 200 } 201 202 ar2->flags |= ATI_REMOTE2_OPENED; 203 204 mutex_unlock(&ati_remote2_mutex); 205 206 usb_autopm_put_interface(ar2->intf[0]); 207 208 return 0; 209 210 fail2: 211 mutex_unlock(&ati_remote2_mutex); 212 usb_autopm_put_interface(ar2->intf[0]); 213 fail1: 214 return r; 215 } 216 217 static void ati_remote2_close(struct input_dev *idev) 218 { 219 struct ati_remote2 *ar2 = input_get_drvdata(idev); 220 221 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__); 222 223 mutex_lock(&ati_remote2_mutex); 224 225 if (!(ar2->flags & ATI_REMOTE2_SUSPENDED)) 226 ati_remote2_kill_urbs(ar2); 227 228 ar2->flags &= ~ATI_REMOTE2_OPENED; 229 230 mutex_unlock(&ati_remote2_mutex); 231 } 232 233 static void ati_remote2_input_mouse(struct ati_remote2 *ar2) 234 { 235 struct input_dev *idev = ar2->idev; 236 u8 *data = ar2->buf[0]; 237 int channel, mode; 238 239 channel = data[0] >> 4; 240 241 if (!((1 << channel) & channel_mask)) 242 return; 243 244 mode = data[0] & 0x0F; 245 246 if (mode > ATI_REMOTE2_PC) { 247 dev_err(&ar2->intf[0]->dev, 248 "Unknown mode byte (%02x %02x %02x %02x)\n", 249 data[3], data[2], data[1], data[0]); 250 return; 251 } 252 253 if (!((1 << mode) & mode_mask)) 254 return; 255 256 input_event(idev, EV_REL, REL_X, (s8) data[1]); 257 input_event(idev, EV_REL, REL_Y, (s8) data[2]); 258 input_sync(idev); 259 } 260 261 static int ati_remote2_lookup(unsigned int hw_code) 262 { 263 int i; 264 265 for (i = 0; i < ARRAY_SIZE(ati_remote2_key_table); i++) 266 if (ati_remote2_key_table[i].hw_code == hw_code) 267 return i; 268 269 return -1; 270 } 271 272 static void ati_remote2_input_key(struct ati_remote2 *ar2) 273 { 274 struct input_dev *idev = ar2->idev; 275 u8 *data = ar2->buf[1]; 276 int channel, mode, hw_code, index; 277 278 channel = data[0] >> 4; 279 280 if (!((1 << channel) & channel_mask)) 281 return; 282 283 mode = data[0] & 0x0F; 284 285 if (mode > ATI_REMOTE2_PC) { 286 dev_err(&ar2->intf[1]->dev, 287 "Unknown mode byte (%02x %02x %02x %02x)\n", 288 data[3], data[2], data[1], data[0]); 289 return; 290 } 291 292 hw_code = data[2]; 293 if (hw_code == 0x3f) { 294 /* 295 * For some incomprehensible reason the mouse pad generates 296 * events which look identical to the events from the last 297 * pressed mode key. Naturally we don't want to generate key 298 * events for the mouse pad so we filter out any subsequent 299 * events from the same mode key. 300 */ 301 if (ar2->mode == mode) 302 return; 303 304 if (data[1] == 0) 305 ar2->mode = mode; 306 } 307 308 if (!((1 << mode) & mode_mask)) 309 return; 310 311 index = ati_remote2_lookup(hw_code); 312 if (index < 0) { 313 dev_err(&ar2->intf[1]->dev, 314 "Unknown code byte (%02x %02x %02x %02x)\n", 315 data[3], data[2], data[1], data[0]); 316 return; 317 } 318 319 switch (data[1]) { 320 case 0: /* release */ 321 break; 322 case 1: /* press */ 323 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_DELAY]); 324 break; 325 case 2: /* repeat */ 326 327 /* No repeat for mouse buttons. */ 328 if (ar2->keycode[mode][index] == BTN_LEFT || 329 ar2->keycode[mode][index] == BTN_RIGHT) 330 return; 331 332 if (!time_after_eq(jiffies, ar2->jiffies)) 333 return; 334 335 ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_PERIOD]); 336 break; 337 default: 338 dev_err(&ar2->intf[1]->dev, 339 "Unknown state byte (%02x %02x %02x %02x)\n", 340 data[3], data[2], data[1], data[0]); 341 return; 342 } 343 344 input_event(idev, EV_KEY, ar2->keycode[mode][index], data[1]); 345 input_sync(idev); 346 } 347 348 static void ati_remote2_complete_mouse(struct urb *urb) 349 { 350 struct ati_remote2 *ar2 = urb->context; 351 int r; 352 353 switch (urb->status) { 354 case 0: 355 usb_mark_last_busy(ar2->udev); 356 ati_remote2_input_mouse(ar2); 357 break; 358 case -ENOENT: 359 case -EILSEQ: 360 case -ECONNRESET: 361 case -ESHUTDOWN: 362 dev_dbg(&ar2->intf[0]->dev, 363 "%s(): urb status = %d\n", __func__, urb->status); 364 return; 365 default: 366 usb_mark_last_busy(ar2->udev); 367 dev_err(&ar2->intf[0]->dev, 368 "%s(): urb status = %d\n", __func__, urb->status); 369 } 370 371 r = usb_submit_urb(urb, GFP_ATOMIC); 372 if (r) 373 dev_err(&ar2->intf[0]->dev, 374 "%s(): usb_submit_urb() = %d\n", __func__, r); 375 } 376 377 static void ati_remote2_complete_key(struct urb *urb) 378 { 379 struct ati_remote2 *ar2 = urb->context; 380 int r; 381 382 switch (urb->status) { 383 case 0: 384 usb_mark_last_busy(ar2->udev); 385 ati_remote2_input_key(ar2); 386 break; 387 case -ENOENT: 388 case -EILSEQ: 389 case -ECONNRESET: 390 case -ESHUTDOWN: 391 dev_dbg(&ar2->intf[1]->dev, 392 "%s(): urb status = %d\n", __func__, urb->status); 393 return; 394 default: 395 usb_mark_last_busy(ar2->udev); 396 dev_err(&ar2->intf[1]->dev, 397 "%s(): urb status = %d\n", __func__, urb->status); 398 } 399 400 r = usb_submit_urb(urb, GFP_ATOMIC); 401 if (r) 402 dev_err(&ar2->intf[1]->dev, 403 "%s(): usb_submit_urb() = %d\n", __func__, r); 404 } 405 406 static int ati_remote2_getkeycode(struct input_dev *idev, 407 int scancode, int *keycode) 408 { 409 struct ati_remote2 *ar2 = input_get_drvdata(idev); 410 int index, mode; 411 412 mode = scancode >> 8; 413 if (mode > ATI_REMOTE2_PC || !((1 << mode) & mode_mask)) 414 return -EINVAL; 415 416 index = ati_remote2_lookup(scancode & 0xFF); 417 if (index < 0) 418 return -EINVAL; 419 420 *keycode = ar2->keycode[mode][index]; 421 return 0; 422 } 423 424 static int ati_remote2_setkeycode(struct input_dev *idev, int scancode, int keycode) 425 { 426 struct ati_remote2 *ar2 = input_get_drvdata(idev); 427 int index, mode, old_keycode; 428 429 mode = scancode >> 8; 430 if (mode > ATI_REMOTE2_PC || !((1 << mode) & mode_mask)) 431 return -EINVAL; 432 433 index = ati_remote2_lookup(scancode & 0xFF); 434 if (index < 0) 435 return -EINVAL; 436 437 if (keycode < KEY_RESERVED || keycode > KEY_MAX) 438 return -EINVAL; 439 440 old_keycode = ar2->keycode[mode][index]; 441 ar2->keycode[mode][index] = keycode; 442 set_bit(keycode, idev->keybit); 443 444 for (mode = 0; mode < ATI_REMOTE2_MODES; mode++) { 445 for (index = 0; index < ARRAY_SIZE(ati_remote2_key_table); index++) { 446 if (ar2->keycode[mode][index] == old_keycode) 447 return 0; 448 } 449 } 450 451 clear_bit(old_keycode, idev->keybit); 452 453 return 0; 454 } 455 456 static int ati_remote2_input_init(struct ati_remote2 *ar2) 457 { 458 struct input_dev *idev; 459 int index, mode, retval; 460 461 idev = input_allocate_device(); 462 if (!idev) 463 return -ENOMEM; 464 465 ar2->idev = idev; 466 input_set_drvdata(idev, ar2); 467 468 idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | BIT_MASK(EV_REL); 469 idev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) | 470 BIT_MASK(BTN_RIGHT); 471 idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y); 472 473 for (mode = 0; mode < ATI_REMOTE2_MODES; mode++) { 474 for (index = 0; index < ARRAY_SIZE(ati_remote2_key_table); index++) { 475 ar2->keycode[mode][index] = ati_remote2_key_table[index].keycode; 476 set_bit(ar2->keycode[mode][index], idev->keybit); 477 } 478 } 479 480 /* AUX1-AUX4 and PC generate the same scancode. */ 481 index = ati_remote2_lookup(0x3f); 482 ar2->keycode[ATI_REMOTE2_AUX1][index] = KEY_PROG1; 483 ar2->keycode[ATI_REMOTE2_AUX2][index] = KEY_PROG2; 484 ar2->keycode[ATI_REMOTE2_AUX3][index] = KEY_PROG3; 485 ar2->keycode[ATI_REMOTE2_AUX4][index] = KEY_PROG4; 486 ar2->keycode[ATI_REMOTE2_PC][index] = KEY_PC; 487 set_bit(KEY_PROG1, idev->keybit); 488 set_bit(KEY_PROG2, idev->keybit); 489 set_bit(KEY_PROG3, idev->keybit); 490 set_bit(KEY_PROG4, idev->keybit); 491 set_bit(KEY_PC, idev->keybit); 492 493 idev->rep[REP_DELAY] = 250; 494 idev->rep[REP_PERIOD] = 33; 495 496 idev->open = ati_remote2_open; 497 idev->close = ati_remote2_close; 498 499 idev->getkeycode = ati_remote2_getkeycode; 500 idev->setkeycode = ati_remote2_setkeycode; 501 502 idev->name = ar2->name; 503 idev->phys = ar2->phys; 504 505 usb_to_input_id(ar2->udev, &idev->id); 506 idev->dev.parent = &ar2->udev->dev; 507 508 retval = input_register_device(idev); 509 if (retval) 510 input_free_device(idev); 511 512 return retval; 513 } 514 515 static int ati_remote2_urb_init(struct ati_remote2 *ar2) 516 { 517 struct usb_device *udev = ar2->udev; 518 int i, pipe, maxp; 519 520 for (i = 0; i < 2; i++) { 521 ar2->buf[i] = usb_buffer_alloc(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]); 522 if (!ar2->buf[i]) 523 return -ENOMEM; 524 525 ar2->urb[i] = usb_alloc_urb(0, GFP_KERNEL); 526 if (!ar2->urb[i]) 527 return -ENOMEM; 528 529 pipe = usb_rcvintpipe(udev, ar2->ep[i]->bEndpointAddress); 530 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe)); 531 maxp = maxp > 4 ? 4 : maxp; 532 533 usb_fill_int_urb(ar2->urb[i], udev, pipe, ar2->buf[i], maxp, 534 i ? ati_remote2_complete_key : ati_remote2_complete_mouse, 535 ar2, ar2->ep[i]->bInterval); 536 ar2->urb[i]->transfer_dma = ar2->buf_dma[i]; 537 ar2->urb[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 538 } 539 540 return 0; 541 } 542 543 static void ati_remote2_urb_cleanup(struct ati_remote2 *ar2) 544 { 545 int i; 546 547 for (i = 0; i < 2; i++) { 548 usb_free_urb(ar2->urb[i]); 549 usb_buffer_free(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]); 550 } 551 } 552 553 static int ati_remote2_setup(struct ati_remote2 *ar2) 554 { 555 int r, i, channel; 556 557 /* 558 * Configure receiver to only accept input from remote "channel" 559 * channel == 0 -> Accept input from any remote channel 560 * channel == 1 -> Only accept input from remote channel 1 561 * channel == 2 -> Only accept input from remote channel 2 562 * ... 563 * channel == 16 -> Only accept input from remote channel 16 564 */ 565 566 channel = 0; 567 for (i = 0; i < 16; i++) { 568 if ((1 << i) & channel_mask) { 569 if (!(~(1 << i) & 0xFFFF & channel_mask)) 570 channel = i + 1; 571 break; 572 } 573 } 574 575 r = usb_control_msg(ar2->udev, usb_sndctrlpipe(ar2->udev, 0), 576 0x20, 577 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 578 channel, 0x0, NULL, 0, USB_CTRL_SET_TIMEOUT); 579 if (r) { 580 dev_err(&ar2->udev->dev, "%s - failed to set channel due to error: %d\n", 581 __func__, r); 582 return r; 583 } 584 585 return 0; 586 } 587 588 static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id) 589 { 590 struct usb_device *udev = interface_to_usbdev(interface); 591 struct usb_host_interface *alt = interface->cur_altsetting; 592 struct ati_remote2 *ar2; 593 int r; 594 595 if (alt->desc.bInterfaceNumber) 596 return -ENODEV; 597 598 ar2 = kzalloc(sizeof (struct ati_remote2), GFP_KERNEL); 599 if (!ar2) 600 return -ENOMEM; 601 602 ar2->udev = udev; 603 604 ar2->intf[0] = interface; 605 ar2->ep[0] = &alt->endpoint[0].desc; 606 607 ar2->intf[1] = usb_ifnum_to_if(udev, 1); 608 r = usb_driver_claim_interface(&ati_remote2_driver, ar2->intf[1], ar2); 609 if (r) 610 goto fail1; 611 alt = ar2->intf[1]->cur_altsetting; 612 ar2->ep[1] = &alt->endpoint[0].desc; 613 614 r = ati_remote2_urb_init(ar2); 615 if (r) 616 goto fail2; 617 618 r = ati_remote2_setup(ar2); 619 if (r) 620 goto fail2; 621 622 usb_make_path(udev, ar2->phys, sizeof(ar2->phys)); 623 strlcat(ar2->phys, "/input0", sizeof(ar2->phys)); 624 625 strlcat(ar2->name, "ATI Remote Wonder II", sizeof(ar2->name)); 626 627 r = ati_remote2_input_init(ar2); 628 if (r) 629 goto fail2; 630 631 usb_set_intfdata(interface, ar2); 632 633 interface->needs_remote_wakeup = 1; 634 635 return 0; 636 637 fail2: 638 ati_remote2_urb_cleanup(ar2); 639 640 usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]); 641 fail1: 642 kfree(ar2); 643 644 return r; 645 } 646 647 static void ati_remote2_disconnect(struct usb_interface *interface) 648 { 649 struct ati_remote2 *ar2; 650 struct usb_host_interface *alt = interface->cur_altsetting; 651 652 if (alt->desc.bInterfaceNumber) 653 return; 654 655 ar2 = usb_get_intfdata(interface); 656 usb_set_intfdata(interface, NULL); 657 658 input_unregister_device(ar2->idev); 659 660 ati_remote2_urb_cleanup(ar2); 661 662 usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]); 663 664 kfree(ar2); 665 } 666 667 static int ati_remote2_suspend(struct usb_interface *interface, 668 pm_message_t message) 669 { 670 struct ati_remote2 *ar2; 671 struct usb_host_interface *alt = interface->cur_altsetting; 672 673 if (alt->desc.bInterfaceNumber) 674 return 0; 675 676 ar2 = usb_get_intfdata(interface); 677 678 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__); 679 680 mutex_lock(&ati_remote2_mutex); 681 682 if (ar2->flags & ATI_REMOTE2_OPENED) 683 ati_remote2_kill_urbs(ar2); 684 685 ar2->flags |= ATI_REMOTE2_SUSPENDED; 686 687 mutex_unlock(&ati_remote2_mutex); 688 689 return 0; 690 } 691 692 static int ati_remote2_resume(struct usb_interface *interface) 693 { 694 struct ati_remote2 *ar2; 695 struct usb_host_interface *alt = interface->cur_altsetting; 696 int r = 0; 697 698 if (alt->desc.bInterfaceNumber) 699 return 0; 700 701 ar2 = usb_get_intfdata(interface); 702 703 dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__); 704 705 mutex_lock(&ati_remote2_mutex); 706 707 if (ar2->flags & ATI_REMOTE2_OPENED) 708 r = ati_remote2_submit_urbs(ar2); 709 710 if (!r) 711 ar2->flags &= ~ATI_REMOTE2_SUSPENDED; 712 713 mutex_unlock(&ati_remote2_mutex); 714 715 return r; 716 } 717 718 static int __init ati_remote2_init(void) 719 { 720 int r; 721 722 r = usb_register(&ati_remote2_driver); 723 if (r) 724 printk(KERN_ERR "ati_remote2: usb_register() = %d\n", r); 725 else 726 printk(KERN_INFO "ati_remote2: " DRIVER_DESC " " DRIVER_VERSION "\n"); 727 728 return r; 729 } 730 731 static void __exit ati_remote2_exit(void) 732 { 733 usb_deregister(&ati_remote2_driver); 734 } 735 736 module_init(ati_remote2_init); 737 module_exit(ati_remote2_exit); 738