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         unsigned long quirks;
 302         struct work_struct state_worker;
 303
 304 #ifdef CONFIG_SONY_FF
 305         __u8 left;
 306         __u8 right;
 307 #endif
 308
 309         __u8 led_state[MAX_LEDS];
 310         __u8 led_count;
 311 };
 312
 313 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
 314                              unsigned int *rsize)
 315 {
 316         *rsize = sizeof(ps3remote_rdesc);
 317         return ps3remote_rdesc;
 318 }
 319
 320 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
 321                              struct hid_field *field, struct hid_usage *usage,
 322                              unsigned long **bit, int *max)
 323 {
 324         unsigned int key = usage->hid & HID_USAGE;
 325
 326         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 327                 return -1;
 328
 329         switch (usage->collection_index) {
 330         case 1:
 331                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
 332                         return -1;
 333
 334                 key = ps3remote_keymap_joypad_buttons[key];
 335                 if (!key)
 336                         return -1;
 337                 break;
 338         case 2:
 339                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
 340                         return -1;
 341
 342                 key = ps3remote_keymap_remote_buttons[key];
 343                 if (!key)
 344                         return -1;
 345                 break;
 346         default:
 347                 return -1;
 348         }
 349
 350         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 351         return 1;
 352 }
 353
 354
 355 /* Sony Vaio VGX has wrongly mouse pointer declared as constant */
 356 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 357                 unsigned int *rsize)
 358 {
 359         struct sony_sc *sc = hid_get_drvdata(hdev);
 360
 361         /*
 362          * Some Sony RF receivers wrongly declare the mouse pointer as a
 363          * a constant non-data variable.
 364          */
 365         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
 366             /* usage page: generic desktop controls */
 367             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
 368             /* usage: mouse */
 369             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
 370             /* input (usage page for x,y axes): constant, variable, relative */
 371             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
 372                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
 373                 /* input: data, variable, relative */
 374                 rdesc[55] = 0x06;
 375         }
 376
 377         /*
 378          * The default Dualshock 4 USB descriptor doesn't assign
 379          * the gyroscope values to corresponding axes so we need a
 380          * modified one.
 381          */
 382         if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
 383                 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
 384                 rdesc = dualshock4_usb_rdesc;
 385                 *rsize = sizeof(dualshock4_usb_rdesc);
 386         }
 387
 388         /* The HID descriptor exposed over BT has a trailing zero byte */
 389         if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
 390                         ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
 391                         rdesc[83] == 0x75) {
 392                 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
 393                 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
 394                         sizeof(sixaxis_rdesc_fixup));
 395         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
 396                    *rsize > sizeof(sixaxis_rdesc_fixup2)) {
 397                 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
 398                          *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
 399                 *rsize = sizeof(sixaxis_rdesc_fixup2);
 400                 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
 401         }
 402
 403         if (sc->quirks & PS3REMOTE)
 404                 return ps3remote_fixup(hdev, rdesc, rsize);
 405
 406         return rdesc;
 407 }
 408
 409 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
 410                 __u8 *rd, int size)
 411 {
 412         struct sony_sc *sc = hid_get_drvdata(hdev);
 413
 414         /* Sixaxis HID report has acclerometers/gyro with MSByte first, this
 415          * has to be BYTE_SWAPPED before passing up to joystick interface
 416          */
 417         if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) &&
 418                         rd[0] == 0x01 && size == 49) {
 419                 swap(rd[41], rd[42]);
 420                 swap(rd[43], rd[44]);
 421                 swap(rd[45], rd[46]);
 422                 swap(rd[47], rd[48]);
 423         }
 424
 425         return 0;
 426 }
 427
 428 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
 429                         struct hid_field *field, struct hid_usage *usage,
 430                         unsigned long **bit, int *max)
 431 {
 432         struct sony_sc *sc = hid_get_drvdata(hdev);
 433
 434         if (sc->quirks & BUZZ_CONTROLLER) {
 435                 unsigned int key = usage->hid & HID_USAGE;
 436
 437                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 438                         return -1;
 439
 440                 switch (usage->collection_index) {
 441                 case 1:
 442                         if (key >= ARRAY_SIZE(buzz_keymap))
 443                                 return -1;
 444
 445                         key = buzz_keymap[key];
 446                         if (!key)
 447                                 return -1;
 448                         break;
 449                 default:
 450                         return -1;
 451                 }
 452
 453                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 454                 return 1;
 455         }
 456
 457         if (sc->quirks & PS3REMOTE)
 458                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
 459
 460         /* Let hid-core decide for the others */
 461         return 0;
 462 }
 463
 464 /*
 465  * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
 466  * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
 467  * so we need to override that forcing HID Output Reports on the Control EP.
 468  *
 469  * There is also another issue about HID Output Reports via USB, the Sixaxis
 470  * does not want the report_id as part of the data packet, so we have to
 471  * discard buf[0] when sending the actual control message, even for numbered
 472  * reports, humpf!
 473  */
 474 static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
 475                 size_t count, unsigned char report_type)
 476 {
 477         struct usb_interface *intf = to_usb_interface(hid->dev.parent);
 478         struct usb_device *dev = interface_to_usbdev(intf);
 479         struct usb_host_interface *interface = intf->cur_altsetting;
 480         int report_id = buf[0];
 481         int ret;
 482
 483         if (report_type == HID_OUTPUT_REPORT) {
 484                 /* Don't send the Report ID */
 485                 buf++;
 486                 count--;
 487         }
 488
 489         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 490                 HID_REQ_SET_REPORT,
 491                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 492                 ((report_type + 1) << 8) | report_id,
 493                 interface->desc.bInterfaceNumber, buf, count,
 494                 USB_CTRL_SET_TIMEOUT);
 495
 496         /* Count also the Report ID, in case of an Output report. */
 497         if (ret > 0 && report_type == HID_OUTPUT_REPORT)
 498                 ret++;
 499
 500         return ret;
 501 }
 502
 503 /*
 504  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
 505  * to "operational".  Without this, the ps3 controller will not report any
 506  * events.
 507  */
 508 static int sixaxis_set_operational_usb(struct hid_device *hdev)
 509 {
 510         int ret;
 511         char *buf = kmalloc(18, GFP_KERNEL);
 512
 513         if (!buf)
 514                 return -ENOMEM;
 515
 516         ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT);
 517
 518         if (ret < 0)
 519                 hid_err(hdev, "can't set operational mode\n");
 520
 521         kfree(buf);
 522
 523         return ret;
 524 }
 525
 526 static int sixaxis_set_operational_bt(struct hid_device *hdev)
 527 {
 528         unsigned char buf[] = { 0xf4,  0x42, 0x03, 0x00, 0x00 };
 529         return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
 530 }
 531
 532 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
 533 {
 534         struct list_head *report_list =
 535                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
 536         struct hid_report *report = list_entry(report_list->next,
 537                 struct hid_report, list);
 538         __s32 *value = report->field[0]->value;
 539
 540         value[0] = 0x00;
 541         value[1] = leds[0] ? 0xff : 0x00;
 542         value[2] = leds[1] ? 0xff : 0x00;
 543         value[3] = leds[2] ? 0xff : 0x00;
 544         value[4] = leds[3] ? 0xff : 0x00;
 545         value[5] = 0x00;
 546         value[6] = 0x00;
 547         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 548 }
 549
 550 static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
 551 {
 552         struct sony_sc *drv_data = hid_get_drvdata(hdev);
 553         int n;
 554
 555         BUG_ON(count > MAX_LEDS);
 556
 557         if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
 558                 buzz_set_leds(hdev, leds);
 559         } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) ||
 560                    (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
 561                 for (n = 0; n < count; n++)
 562                         drv_data->led_state[n] = leds[n];
 563                 schedule_work(&drv_data->state_worker);
 564         }
 565 }
 566
 567 static void sony_led_set_brightness(struct led_classdev *led,
 568                                     enum led_brightness value)
 569 {
 570         struct device *dev = led->dev->parent;
 571         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 572         struct sony_sc *drv_data;
 573
 574         int n;
 575
 576         drv_data = hid_get_drvdata(hdev);
 577         if (!drv_data) {
 578                 hid_err(hdev, "No device data\n");
 579                 return;
 580         }
 581
 582         for (n = 0; n < drv_data->led_count; n++) {
 583                 if (led == drv_data->leds[n]) {
 584                         if (value != drv_data->led_state[n]) {
 585                                 drv_data->led_state[n] = value;
 586                                 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
 587                         }
 588                         break;
 589                 }
 590         }
 591 }
 592
 593 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
 594 {
 595         struct device *dev = led->dev->parent;
 596         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 597         struct sony_sc *drv_data;
 598
 599         int n;
 600         int on = 0;
 601
 602         drv_data = hid_get_drvdata(hdev);
 603         if (!drv_data) {
 604                 hid_err(hdev, "No device data\n");
 605                 return LED_OFF;
 606         }
 607
 608         for (n = 0; n < drv_data->led_count; n++) {
 609                 if (led == drv_data->leds[n]) {
 610                         on = !!(drv_data->led_state[n]);
 611                         break;
 612                 }
 613         }
 614
 615         return on ? LED_FULL : LED_OFF;
 616 }
 617
 618 static void sony_leds_remove(struct hid_device *hdev)
 619 {
 620         struct sony_sc *drv_data;
 621         struct led_classdev *led;
 622         int n;
 623
 624         drv_data = hid_get_drvdata(hdev);
 625         BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
 626
 627         for (n = 0; n < drv_data->led_count; n++) {
 628                 led = drv_data->leds[n];
 629                 drv_data->leds[n] = NULL;
 630                 if (!led)
 631                         continue;
 632                 led_classdev_unregister(led);
 633                 kfree(led);
 634         }
 635
 636         drv_data->led_count = 0;
 637 }
 638
 639 static int sony_leds_init(struct hid_device *hdev)
 640 {
 641         struct sony_sc *drv_data;
 642         int n, ret = 0;
 643         int max_brightness;
 644         struct led_classdev *led;
 645         size_t name_sz;
 646         char *name;
 647         size_t name_len;
 648         const char *name_fmt;
 649         static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
 650
 651         drv_data = hid_get_drvdata(hdev);
 652         BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
 653
 654         if (drv_data->quirks & BUZZ_CONTROLLER) {
 655                 name_len = strlen("::buzz#");
 656                 name_fmt = "%s::buzz%d";
 657                 /* Validate expected report characteristics. */
 658                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
 659                         return -ENODEV;
 660         } else {
 661                 name_len = strlen("::sony#");
 662                 name_fmt = "%s::sony%d";
 663         }
 664
 665         if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) {
 666                 drv_data->led_count = 3;
 667                 max_brightness = 255;
 668         } else {
 669                 drv_data->led_count = 4;
 670                 max_brightness = 1;
 671         }
 672
 673         /* Clear LEDs as we have no way of reading their initial state. This is
 674          * only relevant if the driver is loaded after somebody actively set the
 675          * LEDs to on */
 676         sony_set_leds(hdev, initial_values, drv_data->led_count);
 677
 678         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
 679
 680         for (n = 0; n < drv_data->led_count; n++) {
 681                 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
 682                 if (!led) {
 683                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
 684                         ret = -ENOMEM;
 685                         goto error_leds;
 686                 }
 687
 688                 name = (void *)(&led[1]);
 689                 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
 690                 led->name = name;
 691                 led->brightness = 0;
 692                 led->max_brightness = max_brightness;
 693                 led->brightness_get = sony_led_get_brightness;
 694                 led->brightness_set = sony_led_set_brightness;
 695
 696                 ret = led_classdev_register(&hdev->dev, led);
 697                 if (ret) {
 698                         hid_err(hdev, "Failed to register LED %d\n", n);
 699                         kfree(led);
 700                         goto error_leds;
 701                 }
 702
 703                 drv_data->leds[n] = led;
 704         }
 705
 706         return ret;
 707
 708 error_leds:
 709         sony_leds_remove(hdev);
 710
 711         return ret;
 712 }
 713
 714 static void sixaxis_state_worker(struct work_struct *work)
 715 {
 716         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
 717         unsigned char buf[] = {
 718                 0x01,
 719                 0x00, 0xff, 0x00, 0xff, 0x00,
 720                 0x00, 0x00, 0x00, 0x00, 0x00,
 721                 0xff, 0x27, 0x10, 0x00, 0x32,
 722                 0xff, 0x27, 0x10, 0x00, 0x32,
 723                 0xff, 0x27, 0x10, 0x00, 0x32,
 724                 0xff, 0x27, 0x10, 0x00, 0x32,
 725                 0x00, 0x00, 0x00, 0x00, 0x00
 726         };
 727
 728 #ifdef CONFIG_SONY_FF
 729         buf[3] = sc->right ? 1 : 0;
 730         buf[5] = sc->left;
 731 #endif
 732
 733         buf[10] |= sc->led_state[0] << 1;
 734         buf[10] |= sc->led_state[1] << 2;
 735         buf[10] |= sc->led_state[2] << 3;
 736         buf[10] |= sc->led_state[3] << 4;
 737
 738         sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf),
 739                                         HID_OUTPUT_REPORT);
 740 }
 741
 742 static void dualshock4_state_worker(struct work_struct *work)
 743 {
 744         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
 745         struct hid_device *hdev = sc->hdev;
 746         struct list_head *head, *list;
 747         struct hid_report *report;
 748         __s32 *value;
 749
 750         list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
 751
 752         list_for_each(head, list) {
 753                 report = list_entry(head, struct hid_report, list);
 754
 755                 /* Report 5 is used to send data to the controller via USB */
 756                 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && report->id == 5)
 757                         break;
 758         }
 759
 760         if (head == list) {
 761                 hid_err(hdev, "Dualshock 4 output report not found\n");
 762                 return;
 763         }
 764
 765         value = report->field[0]->value;
 766         value[0] = 0x03;
 767
 768 #ifdef CONFIG_SONY_FF
 769         value[3] = sc->right;
 770         value[4] = sc->left;
 771 #endif
 772
 773         value[5] = sc->led_state[0];
 774         value[6] = sc->led_state[1];
 775         value[7] = sc->led_state[2];
 776
 777         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 778 }
 779
 780 #ifdef CONFIG_SONY_FF
 781 static int sony_play_effect(struct input_dev *dev, void *data,
 782                             struct ff_effect *effect)
 783 {
 784         struct hid_device *hid = input_get_drvdata(dev);
 785         struct sony_sc *sc = hid_get_drvdata(hid);
 786
 787         if (effect->type != FF_RUMBLE)
 788                 return 0;
 789
 790         sc->left = effect->u.rumble.strong_magnitude / 256;
 791         sc->right = effect->u.rumble.weak_magnitude / 256;
 792
 793         schedule_work(&sc->state_worker);
 794         return 0;
 795 }
 796
 797 static int sony_init_ff(struct hid_device *hdev)
 798 {
 799         struct hid_input *hidinput = list_entry(hdev->inputs.next,
 800                                                 struct hid_input, list);
 801         struct input_dev *input_dev = hidinput->input;
 802
 803         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
 804         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
 805 }
 806
 807 static void sony_destroy_ff(struct hid_device *hdev)
 808 {
 809         struct sony_sc *sc = hid_get_drvdata(hdev);
 810
 811         cancel_work_sync(&sc->state_worker);
 812 }
 813
 814 #else
 815 static int sony_init_ff(struct hid_device *hdev)
 816 {
 817         return 0;
 818 }
 819
 820 static void sony_destroy_ff(struct hid_device *hdev)
 821 {
 822 }
 823 #endif
 824
 825 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
 826 {
 827         int ret;
 828         unsigned long quirks = id->driver_data;
 829         struct sony_sc *sc;
 830         unsigned int connect_mask = HID_CONNECT_DEFAULT;
 831
 832         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
 833         if (sc == NULL) {
 834                 hid_err(hdev, "can't alloc sony descriptor\n");
 835                 return -ENOMEM;
 836         }
 837
 838         sc->quirks = quirks;
 839         hid_set_drvdata(hdev, sc);
 840         sc->hdev = hdev;
 841
 842         ret = hid_parse(hdev);
 843         if (ret) {
 844                 hid_err(hdev, "parse failed\n");
 845                 return ret;
 846         }
 847
 848         if (sc->quirks & VAIO_RDESC_CONSTANT)
 849                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
 850         else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
 851                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
 852         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
 853                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
 854
 855         ret = hid_hw_start(hdev, connect_mask);
 856         if (ret) {
 857                 hid_err(hdev, "hw start failed\n");
 858                 return ret;
 859         }
 860
 861         if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
 862                 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
 863                 ret = sixaxis_set_operational_usb(hdev);
 864                 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
 865         }
 866         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
 867                 ret = sixaxis_set_operational_bt(hdev);
 868         else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
 869                 ret = 0;
 870                 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
 871         } else {
 872                 ret = 0;
 873         }
 874
 875         if (ret < 0)
 876                 goto err_stop;
 877
 878         if (sc->quirks & SONY_LED_SUPPORT) {
 879                 ret = sony_leds_init(hdev);
 880                 if (ret < 0)
 881                         goto err_stop;
 882         }
 883
 884         ret = sony_init_ff(hdev);
 885         if (ret < 0)
 886                 goto err_stop;
 887
 888         return 0;
 889 err_stop:
 890         if (sc->quirks & SONY_LED_SUPPORT)
 891                 sony_leds_remove(hdev);
 892         hid_hw_stop(hdev);
 893         return ret;
 894 }
 895
 896 static void sony_remove(struct hid_device *hdev)
 897 {
 898         struct sony_sc *sc = hid_get_drvdata(hdev);
 899
 900         if (sc->quirks & SONY_LED_SUPPORT)
 901                 sony_leds_remove(hdev);
 902
 903         sony_destroy_ff(hdev);
 904
 905         hid_hw_stop(hdev);
 906 }
 907
 908 static const struct hid_device_id sony_devices[] = {
 909         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
 910                 .driver_data = SIXAXIS_CONTROLLER_USB },
 911         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
 912                 .driver_data = SIXAXIS_CONTROLLER_USB },
 913         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
 914                 .driver_data = SIXAXIS_CONTROLLER_BT },
 915         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
 916                 .driver_data = VAIO_RDESC_CONSTANT },
 917         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
 918                 .driver_data = VAIO_RDESC_CONSTANT },
 919         /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
 920          * Logitech joystick from the device descriptor. */
 921         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
 922                 .driver_data = BUZZ_CONTROLLER },
 923         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
 924                 .driver_data = BUZZ_CONTROLLER },
 925         /* PS3 BD Remote Control */
 926         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
 927                 .driver_data = PS3REMOTE },
 928         /* Logitech Harmony Adapter for PS3 */
 929         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
 930                 .driver_data = PS3REMOTE },
 931         /* Sony Dualshock 4 controllers for PS4 */
 932         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
 933                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
 934         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
 935                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
 936         { }
 937 };
 938 MODULE_DEVICE_TABLE(hid, sony_devices);
 939
 940 static struct hid_driver sony_driver = {
 941         .name          = "sony",
 942         .id_table      = sony_devices,
 943         .input_mapping = sony_mapping,
 944         .probe         = sony_probe,
 945         .remove        = sony_remove,
 946         .report_fixup  = sony_report_fixup,
 947         .raw_event     = sony_raw_event
 948 };
 949 module_hid_driver(sony_driver);
 950
 951 MODULE_LICENSE("GPL");