1 /* 2 * HID driver for Sony / PS2 / PS3 BD devices. 3 * 4 * Copyright (c) 1999 Andreas Gal 5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 7 * Copyright (c) 2008 Jiri Slaby 8 * Copyright (c) 2012 David Dillow <dave@thedillows.org> 9 * Copyright (c) 2006-2013 Jiri Kosina 10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com> 11 */ 12 13 /* 14 * This program is free software; you can redistribute it and/or modify it 15 * under the terms of the GNU General Public License as published by the Free 16 * Software Foundation; either version 2 of the License, or (at your option) 17 * any later version. 18 */ 19 20 /* NOTE: in order for the Sony PS3 BD Remote Control to be found by 21 * a Bluetooth host, the key combination Start+Enter has to be kept pressed 22 * for about 7 seconds with the Bluetooth Host Controller in discovering mode. 23 * 24 * There will be no PIN request from the device. 25 */ 26 27 #include <linux/device.h> 28 #include <linux/hid.h> 29 #include <linux/module.h> 30 #include <linux/slab.h> 31 #include <linux/usb.h> 32 #include <linux/leds.h> 33 34 #include "hid-ids.h" 35 36 #define VAIO_RDESC_CONSTANT (1 << 0) 37 #define SIXAXIS_CONTROLLER_USB (1 << 1) 38 #define SIXAXIS_CONTROLLER_BT (1 << 2) 39 #define BUZZ_CONTROLLER (1 << 3) 40 #define PS3REMOTE (1 << 4) 41 42 static const u8 sixaxis_rdesc_fixup[] = { 43 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C, 44 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF, 45 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02 46 }; 47 48 static const u8 sixaxis_rdesc_fixup2[] = { 49 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02, 50 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00, 51 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95, 52 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45, 53 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81, 54 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff, 55 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05, 56 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95, 57 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30, 58 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02, 59 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81, 60 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95, 61 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09, 62 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02, 63 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02, 64 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95, 65 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02, 66 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 67 0xb1, 0x02, 0xc0, 0xc0, 68 }; 69 70 static __u8 ps3remote_rdesc[] = { 71 0x05, 0x01, /* GUsagePage Generic Desktop */ 72 0x09, 0x05, /* LUsage 0x05 [Game Pad] */ 73 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */ 74 75 /* Use collection 1 for joypad buttons */ 76 0xA1, 0x02, /* MCollection Logical (interrelated data) */ 77 78 /* Ignore the 1st byte, maybe it is used for a controller 79 * number but it's not needed for correct operation */ 80 0x75, 0x08, /* GReportSize 0x08 [8] */ 81 0x95, 0x01, /* GReportCount 0x01 [1] */ 82 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */ 83 84 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these 85 * buttons multiple keypresses are allowed */ 86 0x05, 0x09, /* GUsagePage Button */ 87 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */ 88 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */ 89 0x14, /* GLogicalMinimum [0] */ 90 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */ 91 0x75, 0x01, /* GReportSize 0x01 [1] */ 92 0x95, 0x18, /* GReportCount 0x18 [24] */ 93 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */ 94 95 0xC0, /* MEndCollection */ 96 97 /* Use collection 2 for remote control buttons */ 98 0xA1, 0x02, /* MCollection Logical (interrelated data) */ 99 100 /* 5th byte is used for remote control buttons */ 101 0x05, 0x09, /* GUsagePage Button */ 102 0x18, /* LUsageMinimum [No button pressed] */ 103 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */ 104 0x14, /* GLogicalMinimum [0] */ 105 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */ 106 0x75, 0x08, /* GReportSize 0x08 [8] */ 107 0x95, 0x01, /* GReportCount 0x01 [1] */ 108 0x80, /* MInput */ 109 110 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at 111 * 0xff and 11th is for press indication */ 112 0x75, 0x08, /* GReportSize 0x08 [8] */ 113 0x95, 0x06, /* GReportCount 0x06 [6] */ 114 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */ 115 116 /* 12th byte is for battery strength */ 117 0x05, 0x06, /* GUsagePage Generic Device Controls */ 118 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */ 119 0x14, /* GLogicalMinimum [0] */ 120 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */ 121 0x75, 0x08, /* GReportSize 0x08 [8] */ 122 0x95, 0x01, /* GReportCount 0x01 [1] */ 123 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */ 124 125 0xC0, /* MEndCollection */ 126 127 0xC0 /* MEndCollection [Game Pad] */ 128 }; 129 130 static const unsigned int ps3remote_keymap_joypad_buttons[] = { 131 [0x01] = KEY_SELECT, 132 [0x02] = BTN_THUMBL, /* L3 */ 133 [0x03] = BTN_THUMBR, /* R3 */ 134 [0x04] = BTN_START, 135 [0x05] = KEY_UP, 136 [0x06] = KEY_RIGHT, 137 [0x07] = KEY_DOWN, 138 [0x08] = KEY_LEFT, 139 [0x09] = BTN_TL2, /* L2 */ 140 [0x0a] = BTN_TR2, /* R2 */ 141 [0x0b] = BTN_TL, /* L1 */ 142 [0x0c] = BTN_TR, /* R1 */ 143 [0x0d] = KEY_OPTION, /* options/triangle */ 144 [0x0e] = KEY_BACK, /* back/circle */ 145 [0x0f] = BTN_0, /* cross */ 146 [0x10] = KEY_SCREEN, /* view/square */ 147 [0x11] = KEY_HOMEPAGE, /* PS button */ 148 [0x14] = KEY_ENTER, 149 }; 150 static const unsigned int ps3remote_keymap_remote_buttons[] = { 151 [0x00] = KEY_1, 152 [0x01] = KEY_2, 153 [0x02] = KEY_3, 154 [0x03] = KEY_4, 155 [0x04] = KEY_5, 156 [0x05] = KEY_6, 157 [0x06] = KEY_7, 158 [0x07] = KEY_8, 159 [0x08] = KEY_9, 160 [0x09] = KEY_0, 161 [0x0e] = KEY_ESC, /* return */ 162 [0x0f] = KEY_CLEAR, 163 [0x16] = KEY_EJECTCD, 164 [0x1a] = KEY_MENU, /* top menu */ 165 [0x28] = KEY_TIME, 166 [0x30] = KEY_PREVIOUS, 167 [0x31] = KEY_NEXT, 168 [0x32] = KEY_PLAY, 169 [0x33] = KEY_REWIND, /* scan back */ 170 [0x34] = KEY_FORWARD, /* scan forward */ 171 [0x38] = KEY_STOP, 172 [0x39] = KEY_PAUSE, 173 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */ 174 [0x60] = KEY_FRAMEBACK, /* slow/step back */ 175 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */ 176 [0x63] = KEY_SUBTITLE, 177 [0x64] = KEY_AUDIO, 178 [0x65] = KEY_ANGLE, 179 [0x70] = KEY_INFO, /* display */ 180 [0x80] = KEY_BLUE, 181 [0x81] = KEY_RED, 182 [0x82] = KEY_GREEN, 183 [0x83] = KEY_YELLOW, 184 }; 185 186 static const unsigned int buzz_keymap[] = { 187 /* The controller has 4 remote buzzers, each with one LED and 5 188 * buttons. 189 * 190 * We use the mapping chosen by the controller, which is: 191 * 192 * Key Offset 193 * ------------------- 194 * Buzz 1 195 * Blue 5 196 * Orange 4 197 * Green 3 198 * Yellow 2 199 * 200 * So, for example, the orange button on the third buzzer is mapped to 201 * BTN_TRIGGER_HAPPY14 202 */ 203 [ 1] = BTN_TRIGGER_HAPPY1, 204 [ 2] = BTN_TRIGGER_HAPPY2, 205 [ 3] = BTN_TRIGGER_HAPPY3, 206 [ 4] = BTN_TRIGGER_HAPPY4, 207 [ 5] = BTN_TRIGGER_HAPPY5, 208 [ 6] = BTN_TRIGGER_HAPPY6, 209 [ 7] = BTN_TRIGGER_HAPPY7, 210 [ 8] = BTN_TRIGGER_HAPPY8, 211 [ 9] = BTN_TRIGGER_HAPPY9, 212 [10] = BTN_TRIGGER_HAPPY10, 213 [11] = BTN_TRIGGER_HAPPY11, 214 [12] = BTN_TRIGGER_HAPPY12, 215 [13] = BTN_TRIGGER_HAPPY13, 216 [14] = BTN_TRIGGER_HAPPY14, 217 [15] = BTN_TRIGGER_HAPPY15, 218 [16] = BTN_TRIGGER_HAPPY16, 219 [17] = BTN_TRIGGER_HAPPY17, 220 [18] = BTN_TRIGGER_HAPPY18, 221 [19] = BTN_TRIGGER_HAPPY19, 222 [20] = BTN_TRIGGER_HAPPY20, 223 }; 224 225 struct sony_sc { 226 unsigned long quirks; 227 228 void *extra; 229 }; 230 231 struct buzz_extra { 232 int led_state; 233 struct led_classdev *leds[4]; 234 }; 235 236 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc, 237 unsigned int *rsize) 238 { 239 *rsize = sizeof(ps3remote_rdesc); 240 return ps3remote_rdesc; 241 } 242 243 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi, 244 struct hid_field *field, struct hid_usage *usage, 245 unsigned long **bit, int *max) 246 { 247 unsigned int key = usage->hid & HID_USAGE; 248 249 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 250 return -1; 251 252 switch (usage->collection_index) { 253 case 1: 254 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons)) 255 return -1; 256 257 key = ps3remote_keymap_joypad_buttons[key]; 258 if (!key) 259 return -1; 260 break; 261 case 2: 262 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons)) 263 return -1; 264 265 key = ps3remote_keymap_remote_buttons[key]; 266 if (!key) 267 return -1; 268 break; 269 default: 270 return -1; 271 } 272 273 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 274 return 1; 275 } 276 277 278 /* Sony Vaio VGX has wrongly mouse pointer declared as constant */ 279 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc, 280 unsigned int *rsize) 281 { 282 struct sony_sc *sc = hid_get_drvdata(hdev); 283 284 /* 285 * Some Sony RF receivers wrongly declare the mouse pointer as a 286 * a constant non-data variable. 287 */ 288 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 && 289 /* usage page: generic desktop controls */ 290 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */ 291 /* usage: mouse */ 292 rdesc[2] == 0x09 && rdesc[3] == 0x02 && 293 /* input (usage page for x,y axes): constant, variable, relative */ 294 rdesc[54] == 0x81 && rdesc[55] == 0x07) { 295 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n"); 296 /* input: data, variable, relative */ 297 rdesc[55] = 0x06; 298 } 299 300 /* The HID descriptor exposed over BT has a trailing zero byte */ 301 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) || 302 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) && 303 rdesc[83] == 0x75) { 304 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n"); 305 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup, 306 sizeof(sixaxis_rdesc_fixup)); 307 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB && 308 *rsize > sizeof(sixaxis_rdesc_fixup2)) { 309 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n", 310 *rsize, (int)sizeof(sixaxis_rdesc_fixup2)); 311 *rsize = sizeof(sixaxis_rdesc_fixup2); 312 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize); 313 } 314 315 if (sc->quirks & PS3REMOTE) 316 return ps3remote_fixup(hdev, rdesc, rsize); 317 318 return rdesc; 319 } 320 321 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report, 322 __u8 *rd, int size) 323 { 324 struct sony_sc *sc = hid_get_drvdata(hdev); 325 326 /* Sixaxis HID report has acclerometers/gyro with MSByte first, this 327 * has to be BYTE_SWAPPED before passing up to joystick interface 328 */ 329 if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) && 330 rd[0] == 0x01 && size == 49) { 331 swap(rd[41], rd[42]); 332 swap(rd[43], rd[44]); 333 swap(rd[45], rd[46]); 334 swap(rd[47], rd[48]); 335 } 336 337 return 0; 338 } 339 340 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi, 341 struct hid_field *field, struct hid_usage *usage, 342 unsigned long **bit, int *max) 343 { 344 struct sony_sc *sc = hid_get_drvdata(hdev); 345 346 if (sc->quirks & BUZZ_CONTROLLER) { 347 unsigned int key = usage->hid & HID_USAGE; 348 349 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) 350 return -1; 351 352 switch (usage->collection_index) { 353 case 1: 354 if (key >= ARRAY_SIZE(buzz_keymap)) 355 return -1; 356 357 key = buzz_keymap[key]; 358 if (!key) 359 return -1; 360 break; 361 default: 362 return -1; 363 } 364 365 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key); 366 return 1; 367 } 368 369 if (sc->quirks & PS3REMOTE) 370 return ps3remote_mapping(hdev, hi, field, usage, bit, max); 371 372 /* Let hid-core decide for the others */ 373 return 0; 374 } 375 376 /* 377 * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP 378 * like it should according to usbhid/hid-core.c::usbhid_output_raw_report() 379 * so we need to override that forcing HID Output Reports on the Control EP. 380 * 381 * There is also another issue about HID Output Reports via USB, the Sixaxis 382 * does not want the report_id as part of the data packet, so we have to 383 * discard buf[0] when sending the actual control message, even for numbered 384 * reports, humpf! 385 */ 386 static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf, 387 size_t count, unsigned char report_type) 388 { 389 struct usb_interface *intf = to_usb_interface(hid->dev.parent); 390 struct usb_device *dev = interface_to_usbdev(intf); 391 struct usb_host_interface *interface = intf->cur_altsetting; 392 int report_id = buf[0]; 393 int ret; 394 395 if (report_type == HID_OUTPUT_REPORT) { 396 /* Don't send the Report ID */ 397 buf++; 398 count--; 399 } 400 401 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 402 HID_REQ_SET_REPORT, 403 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 404 ((report_type + 1) << 8) | report_id, 405 interface->desc.bInterfaceNumber, buf, count, 406 USB_CTRL_SET_TIMEOUT); 407 408 /* Count also the Report ID, in case of an Output report. */ 409 if (ret > 0 && report_type == HID_OUTPUT_REPORT) 410 ret++; 411 412 return ret; 413 } 414 415 /* 416 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller 417 * to "operational". Without this, the ps3 controller will not report any 418 * events. 419 */ 420 static int sixaxis_set_operational_usb(struct hid_device *hdev) 421 { 422 int ret; 423 char *buf = kmalloc(18, GFP_KERNEL); 424 425 if (!buf) 426 return -ENOMEM; 427 428 ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT); 429 430 if (ret < 0) 431 hid_err(hdev, "can't set operational mode\n"); 432 433 kfree(buf); 434 435 return ret; 436 } 437 438 static int sixaxis_set_operational_bt(struct hid_device *hdev) 439 { 440 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 }; 441 return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); 442 } 443 444 static void buzz_set_leds(struct hid_device *hdev, int leds) 445 { 446 struct list_head *report_list = 447 &hdev->report_enum[HID_OUTPUT_REPORT].report_list; 448 struct hid_report *report = list_entry(report_list->next, 449 struct hid_report, list); 450 __s32 *value = report->field[0]->value; 451 452 value[0] = 0x00; 453 value[1] = (leds & 1) ? 0xff : 0x00; 454 value[2] = (leds & 2) ? 0xff : 0x00; 455 value[3] = (leds & 4) ? 0xff : 0x00; 456 value[4] = (leds & 8) ? 0xff : 0x00; 457 value[5] = 0x00; 458 value[6] = 0x00; 459 hid_hw_request(hdev, report, HID_REQ_SET_REPORT); 460 } 461 462 static void buzz_led_set_brightness(struct led_classdev *led, 463 enum led_brightness value) 464 { 465 struct device *dev = led->dev->parent; 466 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 467 struct sony_sc *drv_data; 468 struct buzz_extra *buzz; 469 470 int n; 471 472 drv_data = hid_get_drvdata(hdev); 473 if (!drv_data || !drv_data->extra) { 474 hid_err(hdev, "No device data\n"); 475 return; 476 } 477 buzz = drv_data->extra; 478 479 for (n = 0; n < 4; n++) { 480 if (led == buzz->leds[n]) { 481 int on = !! (buzz->led_state & (1 << n)); 482 if (value == LED_OFF && on) { 483 buzz->led_state &= ~(1 << n); 484 buzz_set_leds(hdev, buzz->led_state); 485 } else if (value != LED_OFF && !on) { 486 buzz->led_state |= (1 << n); 487 buzz_set_leds(hdev, buzz->led_state); 488 } 489 break; 490 } 491 } 492 } 493 494 static enum led_brightness buzz_led_get_brightness(struct led_classdev *led) 495 { 496 struct device *dev = led->dev->parent; 497 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 498 struct sony_sc *drv_data; 499 struct buzz_extra *buzz; 500 501 int n; 502 int on = 0; 503 504 drv_data = hid_get_drvdata(hdev); 505 if (!drv_data || !drv_data->extra) { 506 hid_err(hdev, "No device data\n"); 507 return LED_OFF; 508 } 509 buzz = drv_data->extra; 510 511 for (n = 0; n < 4; n++) { 512 if (led == buzz->leds[n]) { 513 on = !! (buzz->led_state & (1 << n)); 514 break; 515 } 516 } 517 518 return on ? LED_FULL : LED_OFF; 519 } 520 521 static int buzz_init(struct hid_device *hdev) 522 { 523 struct sony_sc *drv_data; 524 struct buzz_extra *buzz; 525 int n, ret = 0; 526 struct led_classdev *led; 527 size_t name_sz; 528 char *name; 529 530 drv_data = hid_get_drvdata(hdev); 531 BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER)); 532 533 /* Validate expected report characteristics. */ 534 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7)) 535 return -ENODEV; 536 537 buzz = kzalloc(sizeof(*buzz), GFP_KERNEL); 538 if (!buzz) { 539 hid_err(hdev, "Insufficient memory, cannot allocate driver data\n"); 540 return -ENOMEM; 541 } 542 drv_data->extra = buzz; 543 544 /* Clear LEDs as we have no way of reading their initial state. This is 545 * only relevant if the driver is loaded after somebody actively set the 546 * LEDs to on */ 547 buzz_set_leds(hdev, 0x00); 548 549 name_sz = strlen(dev_name(&hdev->dev)) + strlen("::buzz#") + 1; 550 551 for (n = 0; n < 4; n++) { 552 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL); 553 if (!led) { 554 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n); 555 goto error_leds; 556 } 557 558 name = (void *)(&led[1]); 559 snprintf(name, name_sz, "%s::buzz%d", dev_name(&hdev->dev), n + 1); 560 led->name = name; 561 led->brightness = 0; 562 led->max_brightness = 1; 563 led->brightness_get = buzz_led_get_brightness; 564 led->brightness_set = buzz_led_set_brightness; 565 566 if (led_classdev_register(&hdev->dev, led)) { 567 hid_err(hdev, "Failed to register LED %d\n", n); 568 kfree(led); 569 goto error_leds; 570 } 571 572 buzz->leds[n] = led; 573 } 574 575 return ret; 576 577 error_leds: 578 for (n = 0; n < 4; n++) { 579 led = buzz->leds[n]; 580 buzz->leds[n] = NULL; 581 if (!led) 582 continue; 583 led_classdev_unregister(led); 584 kfree(led); 585 } 586 587 kfree(drv_data->extra); 588 drv_data->extra = NULL; 589 return ret; 590 } 591 592 static void buzz_remove(struct hid_device *hdev) 593 { 594 struct sony_sc *drv_data; 595 struct buzz_extra *buzz; 596 struct led_classdev *led; 597 int n; 598 599 drv_data = hid_get_drvdata(hdev); 600 BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER)); 601 602 buzz = drv_data->extra; 603 604 for (n = 0; n < 4; n++) { 605 led = buzz->leds[n]; 606 buzz->leds[n] = NULL; 607 if (!led) 608 continue; 609 led_classdev_unregister(led); 610 kfree(led); 611 } 612 613 kfree(drv_data->extra); 614 drv_data->extra = NULL; 615 } 616 617 #ifdef CONFIG_SONY_FF 618 static int sony_play_effect(struct input_dev *dev, void *data, 619 struct ff_effect *effect) 620 { 621 unsigned char buf[] = { 622 0x01, 623 0x00, 0xff, 0x00, 0xff, 0x00, 624 0x00, 0x00, 0x00, 0x00, 0x03, 625 0xff, 0x27, 0x10, 0x00, 0x32, 626 0xff, 0x27, 0x10, 0x00, 0x32, 627 0xff, 0x27, 0x10, 0x00, 0x32, 628 0xff, 0x27, 0x10, 0x00, 0x32, 629 0x00, 0x00, 0x00, 0x00, 0x00 630 }; 631 __u8 left; 632 __u8 right; 633 struct hid_device *hid = input_get_drvdata(dev); 634 635 if (effect->type != FF_RUMBLE) 636 return 0; 637 638 left = effect->u.rumble.strong_magnitude / 256; 639 right = effect->u.rumble.weak_magnitude ? 1 : 0; 640 641 buf[3] = right; 642 buf[5] = left; 643 644 return hid->hid_output_raw_report(hid, buf, sizeof(buf), 645 HID_OUTPUT_REPORT); 646 } 647 648 static int sony_init_ff(struct hid_device *hdev) 649 { 650 struct hid_input *hidinput = list_entry(hdev->inputs.next, 651 struct hid_input, list); 652 struct input_dev *input_dev = hidinput->input; 653 654 input_set_capability(input_dev, EV_FF, FF_RUMBLE); 655 return input_ff_create_memless(input_dev, NULL, sony_play_effect); 656 } 657 658 #else 659 static int sony_init_ff(struct hid_device *hdev) 660 { 661 return 0; 662 } 663 #endif 664 665 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) 666 { 667 int ret; 668 unsigned long quirks = id->driver_data; 669 struct sony_sc *sc; 670 unsigned int connect_mask = HID_CONNECT_DEFAULT; 671 672 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL); 673 if (sc == NULL) { 674 hid_err(hdev, "can't alloc sony descriptor\n"); 675 return -ENOMEM; 676 } 677 678 sc->quirks = quirks; 679 hid_set_drvdata(hdev, sc); 680 681 ret = hid_parse(hdev); 682 if (ret) { 683 hid_err(hdev, "parse failed\n"); 684 return ret; 685 } 686 687 if (sc->quirks & VAIO_RDESC_CONSTANT) 688 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 689 else if (sc->quirks & SIXAXIS_CONTROLLER_USB) 690 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 691 else if (sc->quirks & SIXAXIS_CONTROLLER_BT) 692 connect_mask |= HID_CONNECT_HIDDEV_FORCE; 693 694 ret = hid_hw_start(hdev, connect_mask); 695 if (ret) { 696 hid_err(hdev, "hw start failed\n"); 697 return ret; 698 } 699 700 if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 701 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report; 702 ret = sixaxis_set_operational_usb(hdev); 703 } 704 else if (sc->quirks & SIXAXIS_CONTROLLER_BT) 705 ret = sixaxis_set_operational_bt(hdev); 706 else if (sc->quirks & BUZZ_CONTROLLER) 707 ret = buzz_init(hdev); 708 else 709 ret = 0; 710 711 if (ret < 0) 712 goto err_stop; 713 714 ret = sony_init_ff(hdev); 715 if (ret < 0) 716 goto err_stop; 717 718 return 0; 719 err_stop: 720 hid_hw_stop(hdev); 721 return ret; 722 } 723 724 static void sony_remove(struct hid_device *hdev) 725 { 726 struct sony_sc *sc = hid_get_drvdata(hdev); 727 728 if (sc->quirks & BUZZ_CONTROLLER) 729 buzz_remove(hdev); 730 731 hid_hw_stop(hdev); 732 } 733 734 static const struct hid_device_id sony_devices[] = { 735 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 736 .driver_data = SIXAXIS_CONTROLLER_USB }, 737 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER), 738 .driver_data = SIXAXIS_CONTROLLER_USB }, 739 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER), 740 .driver_data = SIXAXIS_CONTROLLER_BT }, 741 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE), 742 .driver_data = VAIO_RDESC_CONSTANT }, 743 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE), 744 .driver_data = VAIO_RDESC_CONSTANT }, 745 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as 746 * Logitech joystick from the device descriptor. */ 747 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER), 748 .driver_data = BUZZ_CONTROLLER }, 749 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER), 750 .driver_data = BUZZ_CONTROLLER }, 751 /* PS3 BD Remote Control */ 752 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE), 753 .driver_data = PS3REMOTE }, 754 /* Logitech Harmony Adapter for PS3 */ 755 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3), 756 .driver_data = PS3REMOTE }, 757 { } 758 }; 759 MODULE_DEVICE_TABLE(hid, sony_devices); 760 761 static struct hid_driver sony_driver = { 762 .name = "sony", 763 .id_table = sony_devices, 764 .input_mapping = sony_mapping, 765 .probe = sony_probe, 766 .remove = sony_remove, 767 .report_fixup = sony_report_fixup, 768 .raw_event = sony_raw_event 769 }; 770 module_hid_driver(sony_driver); 771 772 MODULE_LICENSE("GPL"); 773