drivers/input/misc/ati_remote2.c

   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);