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