drivers/hid/hid-sony.c

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