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