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