drivers/hid/hid-sony.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  HID driver for Sony / PS2 / PS3 / PS4 BD devices.
   4  *
   5  *  Copyright (c) 1999 Andreas Gal
   6  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
   7  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
   8  *  Copyright (c) 2008 Jiri Slaby
   9  *  Copyright (c) 2012 David Dillow <dave@thedillows.org>
  10  *  Copyright (c) 2006-2013 Jiri Kosina
  11  *  Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
  12  *  Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
  13  *  Copyright (c) 2018 Todd Kelner
  14  */
  15
  16 /*
  17  */
  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/leds.h>
  32 #include <linux/power_supply.h>
  33 #include <linux/spinlock.h>
  34 #include <linux/list.h>
  35 #include <linux/idr.h>
  36 #include <linux/input/mt.h>
  37 #include <linux/crc32.h>
  38 #include <asm/unaligned.h>
  39
  40 #include "hid-ids.h"
  41
  42 #define VAIO_RDESC_CONSTANT       BIT(0)
  43 #define SIXAXIS_CONTROLLER_USB    BIT(1)
  44 #define SIXAXIS_CONTROLLER_BT     BIT(2)
  45 #define BUZZ_CONTROLLER           BIT(3)
  46 #define PS3REMOTE                 BIT(4)
  47 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
  48 #define DUALSHOCK4_CONTROLLER_BT  BIT(6)
  49 #define DUALSHOCK4_DONGLE         BIT(7)
  50 #define MOTION_CONTROLLER_USB     BIT(8)
  51 #define MOTION_CONTROLLER_BT      BIT(9)
  52 #define NAVIGATION_CONTROLLER_USB BIT(10)
  53 #define NAVIGATION_CONTROLLER_BT  BIT(11)
  54 #define SINO_LITE_CONTROLLER      BIT(12)
  55 #define FUTUREMAX_DANCE_MAT       BIT(13)
  56 #define NSG_MR5U_REMOTE_BT        BIT(14)
  57 #define NSG_MR7U_REMOTE_BT        BIT(15)
  58 #define SHANWAN_GAMEPAD           BIT(16)
  59
  60 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
  61 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
  62 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
  63                                 NAVIGATION_CONTROLLER_BT)
  64 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
  65                                 DUALSHOCK4_CONTROLLER_BT | \
  66                                 DUALSHOCK4_DONGLE)
  67 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
  68                                 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
  69                                 NAVIGATION_CONTROLLER)
  70 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
  71                                 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
  72 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
  73                                 MOTION_CONTROLLER)
  74 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
  75                         MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
  76 #define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
  77
  78 #define MAX_LEDS 4
  79 #define NSG_MRXU_MAX_X 1667
  80 #define NSG_MRXU_MAX_Y 1868
  81
  82
  83 /* PS/3 Motion controller */
  84 static u8 motion_rdesc[] = {
  85         0x05, 0x01,         /*  Usage Page (Desktop),               */
  86         0x09, 0x04,         /*  Usage (Joystick),                   */
  87         0xA1, 0x01,         /*  Collection (Application),           */
  88         0xA1, 0x02,         /*      Collection (Logical),           */
  89         0x85, 0x01,         /*          Report ID (1),              */
  90         0x75, 0x01,         /*          Report Size (1),            */
  91         0x95, 0x15,         /*          Report Count (21),          */
  92         0x15, 0x00,         /*          Logical Minimum (0),        */
  93         0x25, 0x01,         /*          Logical Maximum (1),        */
  94         0x35, 0x00,         /*          Physical Minimum (0),       */
  95         0x45, 0x01,         /*          Physical Maximum (1),       */
  96         0x05, 0x09,         /*          Usage Page (Button),        */
  97         0x19, 0x01,         /*          Usage Minimum (01h),        */
  98         0x29, 0x15,         /*          Usage Maximum (15h),        */
  99         0x81, 0x02,         /*          Input (Variable),           * Buttons */
 100         0x95, 0x0B,         /*          Report Count (11),          */
 101         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 102         0x81, 0x03,         /*          Input (Constant, Variable), * Padding */
 103         0x15, 0x00,         /*          Logical Minimum (0),        */
 104         0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
 105         0x05, 0x01,         /*          Usage Page (Desktop),       */
 106         0xA1, 0x00,         /*          Collection (Physical),      */
 107         0x75, 0x08,         /*              Report Size (8),        */
 108         0x95, 0x01,         /*              Report Count (1),       */
 109         0x35, 0x00,         /*              Physical Minimum (0),   */
 110         0x46, 0xFF, 0x00,   /*              Physical Maximum (255), */
 111         0x09, 0x30,         /*              Usage (X),              */
 112         0x81, 0x02,         /*              Input (Variable),       * Trigger */
 113         0xC0,               /*          End Collection,             */
 114         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 115         0x75, 0x08,         /*          Report Size (8),            */
 116         0x95, 0x07,         /*          Report Count (7),           * skip 7 bytes */
 117         0x81, 0x02,         /*          Input (Variable),           */
 118         0x05, 0x01,         /*          Usage Page (Desktop),       */
 119         0x75, 0x10,         /*          Report Size (16),           */
 120         0x46, 0xFF, 0xFF,   /*          Physical Maximum (65535),   */
 121         0x27, 0xFF, 0xFF, 0x00, 0x00, /*      Logical Maximum (65535),    */
 122         0x95, 0x03,         /*          Report Count (3),           * 3x Accels */
 123         0x09, 0x33,         /*              Usage (rX),             */
 124         0x09, 0x34,         /*              Usage (rY),             */
 125         0x09, 0x35,         /*              Usage (rZ),             */
 126         0x81, 0x02,         /*          Input (Variable),           */
 127         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 128         0x95, 0x03,         /*          Report Count (3),           * Skip Accels 2nd frame */
 129         0x81, 0x02,         /*          Input (Variable),           */
 130         0x05, 0x01,         /*          Usage Page (Desktop),       */
 131         0x09, 0x01,         /*          Usage (Pointer),            */
 132         0x95, 0x03,         /*          Report Count (3),           * 3x Gyros */
 133         0x81, 0x02,         /*          Input (Variable),           */
 134         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 135         0x95, 0x03,         /*          Report Count (3),           * Skip Gyros 2nd frame */
 136         0x81, 0x02,         /*          Input (Variable),           */
 137         0x75, 0x0C,         /*          Report Size (12),           */
 138         0x46, 0xFF, 0x0F,   /*          Physical Maximum (4095),    */
 139         0x26, 0xFF, 0x0F,   /*          Logical Maximum (4095),     */
 140         0x95, 0x04,         /*          Report Count (4),           * Skip Temp and Magnetometers */
 141         0x81, 0x02,         /*          Input (Variable),           */
 142         0x75, 0x08,         /*          Report Size (8),            */
 143         0x46, 0xFF, 0x00,   /*          Physical Maximum (255),     */
 144         0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
 145         0x95, 0x06,         /*          Report Count (6),           * Skip Timestamp and Extension Bytes */
 146         0x81, 0x02,         /*          Input (Variable),           */
 147         0x75, 0x08,         /*          Report Size (8),            */
 148         0x95, 0x30,         /*          Report Count (48),          */
 149         0x09, 0x01,         /*          Usage (Pointer),            */
 150         0x91, 0x02,         /*          Output (Variable),          */
 151         0x75, 0x08,         /*          Report Size (8),            */
 152         0x95, 0x30,         /*          Report Count (48),          */
 153         0x09, 0x01,         /*          Usage (Pointer),            */
 154         0xB1, 0x02,         /*          Feature (Variable),         */
 155         0xC0,               /*      End Collection,                 */
 156         0xA1, 0x02,         /*      Collection (Logical),           */
 157         0x85, 0x02,         /*          Report ID (2),              */
 158         0x75, 0x08,         /*          Report Size (8),            */
 159         0x95, 0x30,         /*          Report Count (48),          */
 160         0x09, 0x01,         /*          Usage (Pointer),            */
 161         0xB1, 0x02,         /*          Feature (Variable),         */
 162         0xC0,               /*      End Collection,                 */
 163         0xA1, 0x02,         /*      Collection (Logical),           */
 164         0x85, 0xEE,         /*          Report ID (238),            */
 165         0x75, 0x08,         /*          Report Size (8),            */
 166         0x95, 0x30,         /*          Report Count (48),          */
 167         0x09, 0x01,         /*          Usage (Pointer),            */
 168         0xB1, 0x02,         /*          Feature (Variable),         */
 169         0xC0,               /*      End Collection,                 */
 170         0xA1, 0x02,         /*      Collection (Logical),           */
 171         0x85, 0xEF,         /*          Report ID (239),            */
 172         0x75, 0x08,         /*          Report Size (8),            */
 173         0x95, 0x30,         /*          Report Count (48),          */
 174         0x09, 0x01,         /*          Usage (Pointer),            */
 175         0xB1, 0x02,         /*          Feature (Variable),         */
 176         0xC0,               /*      End Collection,                 */
 177         0xC0                /*  End Collection                      */
 178 };
 179
 180 static u8 ps3remote_rdesc[] = {
 181         0x05, 0x01,          /* GUsagePage Generic Desktop */
 182         0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
 183         0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
 184
 185          /* Use collection 1 for joypad buttons */
 186          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 187
 188           /*
 189            * Ignore the 1st byte, maybe it is used for a controller
 190            * number but it's not needed for correct operation
 191            */
 192           0x75, 0x08,        /* GReportSize 0x08 [8] */
 193           0x95, 0x01,        /* GReportCount 0x01 [1] */
 194           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 195
 196           /*
 197            * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
 198            * buttons multiple keypresses are allowed
 199            */
 200           0x05, 0x09,        /* GUsagePage Button */
 201           0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
 202           0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
 203           0x14,              /* GLogicalMinimum [0] */
 204           0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
 205           0x75, 0x01,        /* GReportSize 0x01 [1] */
 206           0x95, 0x18,        /* GReportCount 0x18 [24] */
 207           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 208
 209           0xC0,              /* MEndCollection */
 210
 211          /* Use collection 2 for remote control buttons */
 212          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 213
 214           /* 5th byte is used for remote control buttons */
 215           0x05, 0x09,        /* GUsagePage Button */
 216           0x18,              /* LUsageMinimum [No button pressed] */
 217           0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
 218           0x14,              /* GLogicalMinimum [0] */
 219           0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
 220           0x75, 0x08,        /* GReportSize 0x08 [8] */
 221           0x95, 0x01,        /* GReportCount 0x01 [1] */
 222           0x80,              /* MInput  */
 223
 224           /*
 225            * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
 226            * 0xff and 11th is for press indication
 227            */
 228           0x75, 0x08,        /* GReportSize 0x08 [8] */
 229           0x95, 0x06,        /* GReportCount 0x06 [6] */
 230           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 231
 232           /* 12th byte is for battery strength */
 233           0x05, 0x06,        /* GUsagePage Generic Device Controls */
 234           0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
 235           0x14,              /* GLogicalMinimum [0] */
 236           0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
 237           0x75, 0x08,        /* GReportSize 0x08 [8] */
 238           0x95, 0x01,        /* GReportCount 0x01 [1] */
 239           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 240
 241           0xC0,              /* MEndCollection */
 242
 243          0xC0                /* MEndCollection [Game Pad] */
 244 };
 245
 246 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
 247         [0x01] = KEY_SELECT,
 248         [0x02] = BTN_THUMBL,            /* L3 */
 249         [0x03] = BTN_THUMBR,            /* R3 */
 250         [0x04] = BTN_START,
 251         [0x05] = KEY_UP,
 252         [0x06] = KEY_RIGHT,
 253         [0x07] = KEY_DOWN,
 254         [0x08] = KEY_LEFT,
 255         [0x09] = BTN_TL2,               /* L2 */
 256         [0x0a] = BTN_TR2,               /* R2 */
 257         [0x0b] = BTN_TL,                /* L1 */
 258         [0x0c] = BTN_TR,                /* R1 */
 259         [0x0d] = KEY_OPTION,            /* options/triangle */
 260         [0x0e] = KEY_BACK,              /* back/circle */
 261         [0x0f] = BTN_0,                 /* cross */
 262         [0x10] = KEY_SCREEN,            /* view/square */
 263         [0x11] = KEY_HOMEPAGE,          /* PS button */
 264         [0x14] = KEY_ENTER,
 265 };
 266 static const unsigned int ps3remote_keymap_remote_buttons[] = {
 267         [0x00] = KEY_1,
 268         [0x01] = KEY_2,
 269         [0x02] = KEY_3,
 270         [0x03] = KEY_4,
 271         [0x04] = KEY_5,
 272         [0x05] = KEY_6,
 273         [0x06] = KEY_7,
 274         [0x07] = KEY_8,
 275         [0x08] = KEY_9,
 276         [0x09] = KEY_0,
 277         [0x0e] = KEY_ESC,               /* return */
 278         [0x0f] = KEY_CLEAR,
 279         [0x16] = KEY_EJECTCD,
 280         [0x1a] = KEY_MENU,              /* top menu */
 281         [0x28] = KEY_TIME,
 282         [0x30] = KEY_PREVIOUS,
 283         [0x31] = KEY_NEXT,
 284         [0x32] = KEY_PLAY,
 285         [0x33] = KEY_REWIND,            /* scan back */
 286         [0x34] = KEY_FORWARD,           /* scan forward */
 287         [0x38] = KEY_STOP,
 288         [0x39] = KEY_PAUSE,
 289         [0x40] = KEY_CONTEXT_MENU,      /* pop up/menu */
 290         [0x60] = KEY_FRAMEBACK,         /* slow/step back */
 291         [0x61] = KEY_FRAMEFORWARD,      /* slow/step forward */
 292         [0x63] = KEY_SUBTITLE,
 293         [0x64] = KEY_AUDIO,
 294         [0x65] = KEY_ANGLE,
 295         [0x70] = KEY_INFO,              /* display */
 296         [0x80] = KEY_BLUE,
 297         [0x81] = KEY_RED,
 298         [0x82] = KEY_GREEN,
 299         [0x83] = KEY_YELLOW,
 300 };
 301
 302 static const unsigned int buzz_keymap[] = {
 303         /*
 304          * The controller has 4 remote buzzers, each with one LED and 5
 305          * buttons.
 306          *
 307          * We use the mapping chosen by the controller, which is:
 308          *
 309          * Key          Offset
 310          * -------------------
 311          * Buzz              1
 312          * Blue              5
 313          * Orange            4
 314          * Green             3
 315          * Yellow            2
 316          *
 317          * So, for example, the orange button on the third buzzer is mapped to
 318          * BTN_TRIGGER_HAPPY14
 319          */
 320          [1] = BTN_TRIGGER_HAPPY1,
 321          [2] = BTN_TRIGGER_HAPPY2,
 322          [3] = BTN_TRIGGER_HAPPY3,
 323          [4] = BTN_TRIGGER_HAPPY4,
 324          [5] = BTN_TRIGGER_HAPPY5,
 325          [6] = BTN_TRIGGER_HAPPY6,
 326          [7] = BTN_TRIGGER_HAPPY7,
 327          [8] = BTN_TRIGGER_HAPPY8,
 328          [9] = BTN_TRIGGER_HAPPY9,
 329         [10] = BTN_TRIGGER_HAPPY10,
 330         [11] = BTN_TRIGGER_HAPPY11,
 331         [12] = BTN_TRIGGER_HAPPY12,
 332         [13] = BTN_TRIGGER_HAPPY13,
 333         [14] = BTN_TRIGGER_HAPPY14,
 334         [15] = BTN_TRIGGER_HAPPY15,
 335         [16] = BTN_TRIGGER_HAPPY16,
 336         [17] = BTN_TRIGGER_HAPPY17,
 337         [18] = BTN_TRIGGER_HAPPY18,
 338         [19] = BTN_TRIGGER_HAPPY19,
 339         [20] = BTN_TRIGGER_HAPPY20,
 340 };
 341
 342 /* The Navigation controller is a partial DS3 and uses the same HID report
 343  * and hence the same keymap indices, however not not all axes/buttons
 344  * are physically present. We use the same axis and button mapping as
 345  * the DS3, which uses the Linux gamepad spec.
 346  */
 347 static const unsigned int navigation_absmap[] = {
 348         [0x30] = ABS_X,
 349         [0x31] = ABS_Y,
 350         [0x33] = ABS_Z, /* L2 */
 351 };
 352
 353 /* Buttons not physically available on the device, but still available
 354  * in the reports are explicitly set to 0 for documentation purposes.
 355  */
 356 static const unsigned int navigation_keymap[] = {
 357         [0x01] = 0, /* Select */
 358         [0x02] = BTN_THUMBL, /* L3 */
 359         [0x03] = 0, /* R3 */
 360         [0x04] = 0, /* Start */
 361         [0x05] = BTN_DPAD_UP, /* Up */
 362         [0x06] = BTN_DPAD_RIGHT, /* Right */
 363         [0x07] = BTN_DPAD_DOWN, /* Down */
 364         [0x08] = BTN_DPAD_LEFT, /* Left */
 365         [0x09] = BTN_TL2, /* L2 */
 366         [0x0a] = 0, /* R2 */
 367         [0x0b] = BTN_TL, /* L1 */
 368         [0x0c] = 0, /* R1 */
 369         [0x0d] = BTN_NORTH, /* Triangle */
 370         [0x0e] = BTN_EAST, /* Circle */
 371         [0x0f] = BTN_SOUTH, /* Cross */
 372         [0x10] = BTN_WEST, /* Square */
 373         [0x11] = BTN_MODE, /* PS */
 374 };
 375
 376 static const unsigned int sixaxis_absmap[] = {
 377         [0x30] = ABS_X,
 378         [0x31] = ABS_Y,
 379         [0x32] = ABS_RX, /* right stick X */
 380         [0x35] = ABS_RY, /* right stick Y */
 381 };
 382
 383 static const unsigned int sixaxis_keymap[] = {
 384         [0x01] = BTN_SELECT, /* Select */
 385         [0x02] = BTN_THUMBL, /* L3 */
 386         [0x03] = BTN_THUMBR, /* R3 */
 387         [0x04] = BTN_START, /* Start */
 388         [0x05] = BTN_DPAD_UP, /* Up */
 389         [0x06] = BTN_DPAD_RIGHT, /* Right */
 390         [0x07] = BTN_DPAD_DOWN, /* Down */
 391         [0x08] = BTN_DPAD_LEFT, /* Left */
 392         [0x09] = BTN_TL2, /* L2 */
 393         [0x0a] = BTN_TR2, /* R2 */
 394         [0x0b] = BTN_TL, /* L1 */
 395         [0x0c] = BTN_TR, /* R1 */
 396         [0x0d] = BTN_NORTH, /* Triangle */
 397         [0x0e] = BTN_EAST, /* Circle */
 398         [0x0f] = BTN_SOUTH, /* Cross */
 399         [0x10] = BTN_WEST, /* Square */
 400         [0x11] = BTN_MODE, /* PS */
 401 };
 402
 403 static const unsigned int ds4_absmap[] = {
 404         [0x30] = ABS_X,
 405         [0x31] = ABS_Y,
 406         [0x32] = ABS_RX, /* right stick X */
 407         [0x33] = ABS_Z, /* L2 */
 408         [0x34] = ABS_RZ, /* R2 */
 409         [0x35] = ABS_RY, /* right stick Y */
 410 };
 411
 412 static const unsigned int ds4_keymap[] = {
 413         [0x1] = BTN_WEST, /* Square */
 414         [0x2] = BTN_SOUTH, /* Cross */
 415         [0x3] = BTN_EAST, /* Circle */
 416         [0x4] = BTN_NORTH, /* Triangle */
 417         [0x5] = BTN_TL, /* L1 */
 418         [0x6] = BTN_TR, /* R1 */
 419         [0x7] = BTN_TL2, /* L2 */
 420         [0x8] = BTN_TR2, /* R2 */
 421         [0x9] = BTN_SELECT, /* Share */
 422         [0xa] = BTN_START, /* Options */
 423         [0xb] = BTN_THUMBL, /* L3 */
 424         [0xc] = BTN_THUMBR, /* R3 */
 425         [0xd] = BTN_MODE, /* PS */
 426 };
 427
 428 static const struct {int x; int y; } ds4_hat_mapping[] = {
 429         {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
 430         {0, 0}
 431 };
 432
 433 static enum power_supply_property sony_battery_props[] = {
 434         POWER_SUPPLY_PROP_PRESENT,
 435         POWER_SUPPLY_PROP_CAPACITY,
 436         POWER_SUPPLY_PROP_SCOPE,
 437         POWER_SUPPLY_PROP_STATUS,
 438 };
 439
 440 struct sixaxis_led {
 441         u8 time_enabled; /* the total time the led is active (0xff means forever) */
 442         u8 duty_length;  /* how long a cycle is in deciseconds (0 means "really fast") */
 443         u8 enabled;
 444         u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
 445         u8 duty_on;  /* % of duty_length the led is on (0xff mean 100%) */
 446 } __packed;
 447
 448 struct sixaxis_rumble {
 449         u8 padding;
 450         u8 right_duration; /* Right motor duration (0xff means forever) */
 451         u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
 452         u8 left_duration;    /* Left motor duration (0xff means forever) */
 453         u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
 454 } __packed;
 455
 456 struct sixaxis_output_report {
 457         u8 report_id;
 458         struct sixaxis_rumble rumble;
 459         u8 padding[4];
 460         u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
 461         struct sixaxis_led led[4];    /* LEDx at (4 - x) */
 462         struct sixaxis_led _reserved; /* LED5, not actually soldered */
 463 } __packed;
 464
 465 union sixaxis_output_report_01 {
 466         struct sixaxis_output_report data;
 467         u8 buf[36];
 468 };
 469
 470 struct motion_output_report_02 {
 471         u8 type, zero;
 472         u8 r, g, b;
 473         u8 zero2;
 474         u8 rumble;
 475 };
 476
 477 #define DS4_FEATURE_REPORT_0x02_SIZE 37
 478 #define DS4_FEATURE_REPORT_0x05_SIZE 41
 479 #define DS4_FEATURE_REPORT_0x81_SIZE 7
 480 #define DS4_FEATURE_REPORT_0xA3_SIZE 49
 481 #define DS4_INPUT_REPORT_0x11_SIZE 78
 482 #define DS4_OUTPUT_REPORT_0x05_SIZE 32
 483 #define DS4_OUTPUT_REPORT_0x11_SIZE 78
 484 #define SIXAXIS_REPORT_0xF2_SIZE 17
 485 #define SIXAXIS_REPORT_0xF5_SIZE 8
 486 #define MOTION_REPORT_0x02_SIZE 49
 487
 488 /* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
 489  * additional +2.
 490  */
 491 #define DS4_INPUT_REPORT_AXIS_OFFSET      1
 492 #define DS4_INPUT_REPORT_BUTTON_OFFSET    5
 493 #define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
 494 #define DS4_INPUT_REPORT_GYRO_X_OFFSET   13
 495 #define DS4_INPUT_REPORT_BATTERY_OFFSET  30
 496 #define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
 497
 498 #define SENSOR_SUFFIX " Motion Sensors"
 499 #define DS4_TOUCHPAD_SUFFIX " Touchpad"
 500
 501 /* Default to 4ms poll interval, which is same as USB (not adjustable). */
 502 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
 503 #define DS4_BT_MAX_POLL_INTERVAL_MS 62
 504 #define DS4_GYRO_RES_PER_DEG_S 1024
 505 #define DS4_ACC_RES_PER_G      8192
 506
 507 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
 508 #define SIXAXIS_ACC_RES_PER_G 113
 509
 510 static DEFINE_SPINLOCK(sony_dev_list_lock);
 511 static LIST_HEAD(sony_device_list);
 512 static DEFINE_IDA(sony_device_id_allocator);
 513
 514 /* Used for calibration of DS4 accelerometer and gyro. */
 515 struct ds4_calibration_data {
 516         int abs_code;
 517         short bias;
 518         /* Calibration requires scaling against a sensitivity value, which is a
 519          * float. Store sensitivity as a fraction to limit floating point
 520          * calculations until final calibration.
 521          */
 522         int sens_numer;
 523         int sens_denom;
 524 };
 525
 526 enum ds4_dongle_state {
 527         DONGLE_DISCONNECTED,
 528         DONGLE_CALIBRATING,
 529         DONGLE_CONNECTED,
 530         DONGLE_DISABLED
 531 };
 532
 533 enum sony_worker {
 534         SONY_WORKER_STATE,
 535         SONY_WORKER_HOTPLUG
 536 };
 537
 538 struct sony_sc {
 539         spinlock_t lock;
 540         struct list_head list_node;
 541         struct hid_device *hdev;
 542         struct input_dev *touchpad;
 543         struct input_dev *sensor_dev;
 544         struct led_classdev *leds[MAX_LEDS];
 545         unsigned long quirks;
 546         struct work_struct hotplug_worker;
 547         struct work_struct state_worker;
 548         void (*send_output_report)(struct sony_sc *);
 549         struct power_supply *battery;
 550         struct power_supply_desc battery_desc;
 551         int device_id;
 552         unsigned fw_version;
 553         unsigned hw_version;
 554         u8 *output_report_dmabuf;
 555
 556 #ifdef CONFIG_SONY_FF
 557         u8 left;
 558         u8 right;
 559 #endif
 560
 561         u8 mac_address[6];
 562         u8 hotplug_worker_initialized;
 563         u8 state_worker_initialized;
 564         u8 defer_initialization;
 565         u8 cable_state;
 566         u8 battery_charging;
 567         u8 battery_capacity;
 568         u8 led_state[MAX_LEDS];
 569         u8 led_delay_on[MAX_LEDS];
 570         u8 led_delay_off[MAX_LEDS];
 571         u8 led_count;
 572
 573         bool timestamp_initialized;
 574         u16 prev_timestamp;
 575         unsigned int timestamp_us;
 576
 577         u8 ds4_bt_poll_interval;
 578         enum ds4_dongle_state ds4_dongle_state;
 579         /* DS4 calibration data */
 580         struct ds4_calibration_data ds4_calib_data[6];
 581 };
 582
 583 static void sony_set_leds(struct sony_sc *sc);
 584
 585 static inline void sony_schedule_work(struct sony_sc *sc,
 586                                       enum sony_worker which)
 587 {
 588         unsigned long flags;
 589
 590         switch (which) {
 591         case SONY_WORKER_STATE:
 592                 spin_lock_irqsave(&sc->lock, flags);
 593                 if (!sc->defer_initialization && sc->state_worker_initialized)
 594                         schedule_work(&sc->state_worker);
 595                 spin_unlock_irqrestore(&sc->lock, flags);
 596                 break;
 597         case SONY_WORKER_HOTPLUG:
 598                 if (sc->hotplug_worker_initialized)
 599                         schedule_work(&sc->hotplug_worker);
 600                 break;
 601         }
 602 }
 603
 604 static ssize_t ds4_show_poll_interval(struct device *dev,
 605                                 struct device_attribute
 606                                 *attr, char *buf)
 607 {
 608         struct hid_device *hdev = to_hid_device(dev);
 609         struct sony_sc *sc = hid_get_drvdata(hdev);
 610
 611         return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
 612 }
 613
 614 static ssize_t ds4_store_poll_interval(struct device *dev,
 615                                 struct device_attribute *attr,
 616                                 const char *buf, size_t count)
 617 {
 618         struct hid_device *hdev = to_hid_device(dev);
 619         struct sony_sc *sc = hid_get_drvdata(hdev);
 620         unsigned long flags;
 621         u8 interval;
 622
 623         if (kstrtou8(buf, 0, &interval))
 624                 return -EINVAL;
 625
 626         if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
 627                 return -EINVAL;
 628
 629         spin_lock_irqsave(&sc->lock, flags);
 630         sc->ds4_bt_poll_interval = interval;
 631         spin_unlock_irqrestore(&sc->lock, flags);
 632
 633         sony_schedule_work(sc, SONY_WORKER_STATE);
 634
 635         return count;
 636 }
 637
 638 static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
 639                 ds4_store_poll_interval);
 640
 641 static ssize_t sony_show_firmware_version(struct device *dev,
 642                                 struct device_attribute
 643                                 *attr, char *buf)
 644 {
 645         struct hid_device *hdev = to_hid_device(dev);
 646         struct sony_sc *sc = hid_get_drvdata(hdev);
 647
 648         return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
 649 }
 650
 651 static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
 652
 653 static ssize_t sony_show_hardware_version(struct device *dev,
 654                                 struct device_attribute
 655                                 *attr, char *buf)
 656 {
 657         struct hid_device *hdev = to_hid_device(dev);
 658         struct sony_sc *sc = hid_get_drvdata(hdev);
 659
 660         return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
 661 }
 662
 663 static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
 664
 665 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
 666                              unsigned int *rsize)
 667 {
 668         *rsize = sizeof(motion_rdesc);
 669         return motion_rdesc;
 670 }
 671
 672 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
 673                              unsigned int *rsize)
 674 {
 675         *rsize = sizeof(ps3remote_rdesc);
 676         return ps3remote_rdesc;
 677 }
 678
 679 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
 680                              struct hid_field *field, struct hid_usage *usage,
 681                              unsigned long **bit, int *max)
 682 {
 683         unsigned int key = usage->hid & HID_USAGE;
 684
 685         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 686                 return -1;
 687
 688         switch (usage->collection_index) {
 689         case 1:
 690                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
 691                         return -1;
 692
 693                 key = ps3remote_keymap_joypad_buttons[key];
 694                 if (!key)
 695                         return -1;
 696                 break;
 697         case 2:
 698                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
 699                         return -1;
 700
 701                 key = ps3remote_keymap_remote_buttons[key];
 702                 if (!key)
 703                         return -1;
 704                 break;
 705         default:
 706                 return -1;
 707         }
 708
 709         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 710         return 1;
 711 }
 712
 713 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
 714                           struct hid_field *field, struct hid_usage *usage,
 715                           unsigned long **bit, int *max)
 716 {
 717         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
 718                 unsigned int key = usage->hid & HID_USAGE;
 719
 720                 if (key >= ARRAY_SIZE(sixaxis_keymap))
 721                         return -1;
 722
 723                 key = navigation_keymap[key];
 724                 if (!key)
 725                         return -1;
 726
 727                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 728                 return 1;
 729         } else if (usage->hid == HID_GD_POINTER) {
 730                 /* See comment in sixaxis_mapping, basically the L2 (and R2)
 731                  * triggers are reported through GD Pointer.
 732                  * In addition we ignore any analog button 'axes' and only
 733                  * support digital buttons.
 734                  */
 735                 switch (usage->usage_index) {
 736                 case 8: /* L2 */
 737                         usage->hid = HID_GD_Z;
 738                         break;
 739                 default:
 740                         return -1;
 741                 }
 742
 743                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
 744                 return 1;
 745         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
 746                 unsigned int abs = usage->hid & HID_USAGE;
 747
 748                 if (abs >= ARRAY_SIZE(navigation_absmap))
 749                         return -1;
 750
 751                 abs = navigation_absmap[abs];
 752
 753                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
 754                 return 1;
 755         }
 756
 757         return -1;
 758 }
 759
 760
 761 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
 762                           struct hid_field *field, struct hid_usage *usage,
 763                           unsigned long **bit, int *max)
 764 {
 765         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
 766                 unsigned int key = usage->hid & HID_USAGE;
 767
 768                 if (key >= ARRAY_SIZE(sixaxis_keymap))
 769                         return -1;
 770
 771                 key = sixaxis_keymap[key];
 772                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 773                 return 1;
 774         } else if (usage->hid == HID_GD_POINTER) {
 775                 /* The DS3 provides analog values for most buttons and even
 776                  * for HAT axes through GD Pointer. L2 and R2 are reported
 777                  * among these as well instead of as GD Z / RZ. Remap L2
 778                  * and R2 and ignore other analog 'button axes' as there is
 779                  * no good way for reporting them.
 780                  */
 781                 switch (usage->usage_index) {
 782                 case 8: /* L2 */
 783                         usage->hid = HID_GD_Z;
 784                         break;
 785                 case 9: /* R2 */
 786                         usage->hid = HID_GD_RZ;
 787                         break;
 788                 default:
 789                         return -1;
 790                 }
 791
 792                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
 793                 return 1;
 794         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
 795                 unsigned int abs = usage->hid & HID_USAGE;
 796
 797                 if (abs >= ARRAY_SIZE(sixaxis_absmap))
 798                         return -1;
 799
 800                 abs = sixaxis_absmap[abs];
 801
 802                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
 803                 return 1;
 804         }
 805
 806         return -1;
 807 }
 808
 809 static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
 810                        struct hid_field *field, struct hid_usage *usage,
 811                        unsigned long **bit, int *max)
 812 {
 813         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
 814                 unsigned int key = usage->hid & HID_USAGE;
 815
 816                 if (key >= ARRAY_SIZE(ds4_keymap))
 817                         return -1;
 818
 819                 key = ds4_keymap[key];
 820                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 821                 return 1;
 822         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
 823                 unsigned int abs = usage->hid & HID_USAGE;
 824
 825                 /* Let the HID parser deal with the HAT. */
 826                 if (usage->hid == HID_GD_HATSWITCH)
 827                         return 0;
 828
 829                 if (abs >= ARRAY_SIZE(ds4_absmap))
 830                         return -1;
 831
 832                 abs = ds4_absmap[abs];
 833                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
 834                 return 1;
 835         }
 836
 837         return 0;
 838 }
 839
 840 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
 841                 unsigned int *rsize)
 842 {
 843         struct sony_sc *sc = hid_get_drvdata(hdev);
 844
 845         if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
 846                 return rdesc;
 847
 848         /*
 849          * Some Sony RF receivers wrongly declare the mouse pointer as a
 850          * a constant non-data variable.
 851          */
 852         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
 853             /* usage page: generic desktop controls */
 854             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
 855             /* usage: mouse */
 856             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
 857             /* input (usage page for x,y axes): constant, variable, relative */
 858             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
 859                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
 860                 /* input: data, variable, relative */
 861                 rdesc[55] = 0x06;
 862         }
 863
 864         if (sc->quirks & MOTION_CONTROLLER)
 865                 return motion_fixup(hdev, rdesc, rsize);
 866
 867         if (sc->quirks & PS3REMOTE)
 868                 return ps3remote_fixup(hdev, rdesc, rsize);
 869
 870         /*
 871          * Some knock-off USB dongles incorrectly report their button count
 872          * as 13 instead of 16 causing three non-functional buttons.
 873          */
 874         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
 875                 /* Report Count (13) */
 876                 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
 877                 /* Usage Maximum (13) */
 878                 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
 879                 /* Report Count (3) */
 880                 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
 881                 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
 882                 rdesc[24] = 0x10;
 883                 rdesc[38] = 0x10;
 884                 rdesc[44] = 0x00;
 885         }
 886
 887         return rdesc;
 888 }
 889
 890 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
 891 {
 892         static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
 893         unsigned long flags;
 894         int offset;
 895         u8 cable_state, battery_capacity, battery_charging;
 896
 897         /*
 898          * The sixaxis is charging if the battery value is 0xee
 899          * and it is fully charged if the value is 0xef.
 900          * It does not report the actual level while charging so it
 901          * is set to 100% while charging is in progress.
 902          */
 903         offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
 904
 905         if (rd[offset] >= 0xee) {
 906                 battery_capacity = 100;
 907                 battery_charging = !(rd[offset] & 0x01);
 908                 cable_state = 1;
 909         } else {
 910                 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
 911                 battery_capacity = sixaxis_battery_capacity[index];
 912                 battery_charging = 0;
 913                 cable_state = 0;
 914         }
 915
 916         spin_lock_irqsave(&sc->lock, flags);
 917         sc->cable_state = cable_state;
 918         sc->battery_capacity = battery_capacity;
 919         sc->battery_charging = battery_charging;
 920         spin_unlock_irqrestore(&sc->lock, flags);
 921
 922         if (sc->quirks & SIXAXIS_CONTROLLER) {
 923                 int val;
 924
 925                 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
 926                 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
 927                 input_report_abs(sc->sensor_dev, ABS_X, val);
 928
 929                 /* Y and Z are swapped and inversed */
 930                 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
 931                 input_report_abs(sc->sensor_dev, ABS_Y, val);
 932
 933                 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
 934                 input_report_abs(sc->sensor_dev, ABS_Z, val);
 935
 936                 input_sync(sc->sensor_dev);
 937         }
 938 }
 939
 940 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
 941 {
 942         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
 943                                                 struct hid_input, list);
 944         struct input_dev *input_dev = hidinput->input;
 945         unsigned long flags;
 946         int n, m, offset, num_touch_data, max_touch_data;
 947         u8 cable_state, battery_capacity, battery_charging;
 948         u16 timestamp;
 949
 950         /* When using Bluetooth the header is 2 bytes longer, so skip these. */
 951         int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
 952
 953         /* Second bit of third button byte is for the touchpad button. */
 954         offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
 955         input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
 956
 957         /*
 958          * The default behavior of the Dualshock 4 is to send reports using
 959          * report type 1 when running over Bluetooth. However, when feature
 960          * report 2 is requested during the controller initialization it starts
 961          * sending input reports in report 17. Since report 17 is undefined
 962          * in the default HID descriptor, the HID layer won't generate events.
 963          * While it is possible (and this was done before) to fixup the HID
 964          * descriptor to add this mapping, it was better to do this manually.
 965          * The reason is there were various pieces software both open and closed
 966          * source, relying on the descriptors to be the same across various
 967          * operating systems. If the descriptors wouldn't match some
 968          * applications e.g. games on Wine would not be able to function due
 969          * to different descriptors, which such applications are not parsing.
 970          */
 971         if (rd[0] == 17) {
 972                 int value;
 973
 974                 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
 975                 input_report_abs(input_dev, ABS_X, rd[offset]);
 976                 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
 977                 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
 978                 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
 979
 980                 value = rd[offset+4] & 0xf;
 981                 if (value > 7)
 982                         value = 8; /* Center 0, 0 */
 983                 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
 984                 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
 985
 986                 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
 987                 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
 988                 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
 989                 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
 990
 991                 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
 992                 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
 993                 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
 994                 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
 995                 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
 996                 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
 997                 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
 998                 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
 999
1000                 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
1001
1002                 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
1003                 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
1004
1005                 input_sync(input_dev);
1006         }
1007
1008         /* Convert timestamp (in 5.33us unit) to timestamp_us */
1009         offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
1010         timestamp = get_unaligned_le16(&rd[offset]);
1011         if (!sc->timestamp_initialized) {
1012                 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1013                 sc->timestamp_initialized = true;
1014         } else {
1015                 u16 delta;
1016
1017                 if (sc->prev_timestamp > timestamp)
1018                         delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1019                 else
1020                         delta = timestamp - sc->prev_timestamp;
1021                 sc->timestamp_us += (delta * 16) / 3;
1022         }
1023         sc->prev_timestamp = timestamp;
1024         input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1025
1026         offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
1027         for (n = 0; n < 6; n++) {
1028                 /* Store data in int for more precision during mult_frac. */
1029                 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1030                 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1031
1032                 /* High precision is needed during calibration, but the
1033                  * calibrated values are within 32-bit.
1034                  * Note: we swap numerator 'x' and 'numer' in mult_frac for
1035                  *       precision reasons so we don't need 64-bit.
1036                  */
1037                 int calib_data = mult_frac(calib->sens_numer,
1038                                            raw_data - calib->bias,
1039                                            calib->sens_denom);
1040
1041                 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1042                 offset += 2;
1043         }
1044         input_sync(sc->sensor_dev);
1045
1046         /*
1047          * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1048          * and the 5th bit contains the USB cable state.
1049          */
1050         offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1051         cable_state = (rd[offset] >> 4) & 0x01;
1052         battery_capacity = rd[offset] & 0x0F;
1053
1054         /*
1055          * When a USB power source is connected the battery level ranges from
1056          * 0 to 10, and when running on battery power it ranges from 0 to 9.
1057          * A battery level above 10 when plugged in means charge completed.
1058          */
1059         if (!cable_state || battery_capacity > 10)
1060                 battery_charging = 0;
1061         else
1062                 battery_charging = 1;
1063
1064         if (!cable_state)
1065                 battery_capacity++;
1066         if (battery_capacity > 10)
1067                 battery_capacity = 10;
1068
1069         battery_capacity *= 10;
1070
1071         spin_lock_irqsave(&sc->lock, flags);
1072         sc->cable_state = cable_state;
1073         sc->battery_capacity = battery_capacity;
1074         sc->battery_charging = battery_charging;
1075         spin_unlock_irqrestore(&sc->lock, flags);
1076
1077         /*
1078          * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1079          * and 35 on Bluetooth.
1080          * The first byte indicates the number of touch data in the report.
1081          * Trackpad data starts 2 bytes later (e.g. 35 for USB).
1082          */
1083         offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1084         max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1085         if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1086                 num_touch_data = rd[offset];
1087         else
1088                 num_touch_data = 1;
1089         offset += 1;
1090
1091         for (m = 0; m < num_touch_data; m++) {
1092                 /* Skip past timestamp */
1093                 offset += 1;
1094
1095                 /*
1096                  * The first 7 bits of the first byte is a counter and bit 8 is
1097                  * a touch indicator that is 0 when pressed and 1 when not
1098                  * pressed.
1099                  * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1100                  * The data for the second touch is in the same format and
1101                  * immediately follows the data for the first.
1102                  */
1103                 for (n = 0; n < 2; n++) {
1104                         u16 x, y;
1105                         bool active;
1106
1107                         x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1108                         y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1109
1110                         active = !(rd[offset] >> 7);
1111                         input_mt_slot(sc->touchpad, n);
1112                         input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1113
1114                         if (active) {
1115                                 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1116                                 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1117                         }
1118
1119                         offset += 4;
1120                 }
1121                 input_mt_sync_frame(sc->touchpad);
1122                 input_sync(sc->touchpad);
1123         }
1124 }
1125
1126 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1127 {
1128         int n, offset, relx, rely;
1129         u8 active;
1130
1131         /*
1132          * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
1133          *   the touch-related data starts at offset 2.
1134          * For the first byte, bit 0 is set when touchpad button is pressed.
1135          * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
1136          * This drag key is mapped to BTN_LEFT.  It is operational only when a
1137          *   touch point is active.
1138          * Bit 4 is set when only the first touch point is active.
1139          * Bit 6 is set when only the second touch point is active.
1140          * Bits 5 and 7 are set when both touch points are active.
1141          * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
1142          * The following byte, offset 5, has the touch width and length.
1143          *   Bits 0-4=X (width), bits 5-7=Y (length).
1144          * A signed relative X coordinate is at offset 6.
1145          * The bytes at offset 7-9 are the second touch X/Y coordinates.
1146          * Offset 10 has the second touch width and length.
1147          * Offset 11 has the relative Y coordinate.
1148          */
1149         offset = 1;
1150
1151         input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1152         active = (rd[offset] >> 4);
1153         relx = (s8) rd[offset+5];
1154         rely = ((s8) rd[offset+10]) * -1;
1155
1156         offset++;
1157
1158         for (n = 0; n < 2; n++) {
1159                 u16 x, y;
1160                 u8 contactx, contacty;
1161
1162                 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1163                 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1164
1165                 input_mt_slot(sc->touchpad, n);
1166                 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1167
1168                 if (active & 0x03) {
1169                         contactx = rd[offset+3] & 0x0F;
1170                         contacty = rd[offset+3] >> 4;
1171                         input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1172                                 max(contactx, contacty));
1173                         input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1174                                 min(contactx, contacty));
1175                         input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1176                                 (bool) (contactx > contacty));
1177                         input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1178                         input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1179                                 NSG_MRXU_MAX_Y - y);
1180                         /*
1181                          * The relative coordinates belong to the first touch
1182                          * point, when present, or to the second touch point
1183                          * when the first is not active.
1184                          */
1185                         if ((n == 0) || ((n == 1) && (active & 0x01))) {
1186                                 input_report_rel(sc->touchpad, REL_X, relx);
1187                                 input_report_rel(sc->touchpad, REL_Y, rely);
1188                         }
1189                 }
1190
1191                 offset += 5;
1192                 active >>= 2;
1193         }
1194
1195         input_mt_sync_frame(sc->touchpad);
1196
1197         input_sync(sc->touchpad);
1198 }
1199
1200 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1201                 u8 *rd, int size)
1202 {
1203         struct sony_sc *sc = hid_get_drvdata(hdev);
1204
1205         /*
1206          * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1207          * has to be BYTE_SWAPPED before passing up to joystick interface
1208          */
1209         if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1210                 /*
1211                  * When connected via Bluetooth the Sixaxis occasionally sends
1212                  * a report with the second byte 0xff and the rest zeroed.
1213                  *
1214                  * This report does not reflect the actual state of the
1215                  * controller must be ignored to avoid generating false input
1216                  * events.
1217                  */
1218                 if (rd[1] == 0xff)
1219                         return -EINVAL;
1220
1221                 swap(rd[41], rd[42]);
1222                 swap(rd[43], rd[44]);
1223                 swap(rd[45], rd[46]);
1224                 swap(rd[47], rd[48]);
1225
1226                 sixaxis_parse_report(sc, rd, size);
1227         } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1228                 sixaxis_parse_report(sc, rd, size);
1229         } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1230                         size == 49) {
1231                 sixaxis_parse_report(sc, rd, size);
1232         } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1233                         size == 64) {
1234                 dualshock4_parse_report(sc, rd, size);
1235         } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1236                         size == 78)) {
1237                 /* CRC check */
1238                 u8 bthdr = 0xA1;
1239                 u32 crc;
1240                 u32 report_crc;
1241
1242                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1243                 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1244                 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1245                 if (crc != report_crc) {
1246                         hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1247                                 report_crc, crc);
1248                         return -EILSEQ;
1249                 }
1250
1251                 dualshock4_parse_report(sc, rd, size);
1252         } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1253                         size == 64) {
1254                 unsigned long flags;
1255                 enum ds4_dongle_state dongle_state;
1256
1257                 /*
1258                  * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1259                  * if a DS4 is actually connected (indicated by '0').
1260                  * For non-dongle, this bit is always 0 (connected).
1261                  */
1262                 bool connected = (rd[31] & 0x04) ? false : true;
1263
1264                 spin_lock_irqsave(&sc->lock, flags);
1265                 dongle_state = sc->ds4_dongle_state;
1266                 spin_unlock_irqrestore(&sc->lock, flags);
1267
1268                 /*
1269                  * The dongle always sends input reports even when no
1270                  * DS4 is attached. When a DS4 is connected, we need to
1271                  * obtain calibration data before we can use it.
1272                  * The code below tracks dongle state and kicks of
1273                  * calibration when needed and only allows us to process
1274                  * input if a DS4 is actually connected.
1275                  */
1276                 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1277                         hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1278                         sony_set_leds(sc);
1279
1280                         spin_lock_irqsave(&sc->lock, flags);
1281                         sc->ds4_dongle_state = DONGLE_CALIBRATING;
1282                         spin_unlock_irqrestore(&sc->lock, flags);
1283
1284                         sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1285
1286                         /* Don't process the report since we don't have
1287                          * calibration data, but let hidraw have it anyway.
1288                          */
1289                         return 0;
1290                 } else if ((dongle_state == DONGLE_CONNECTED ||
1291                             dongle_state == DONGLE_DISABLED) && !connected) {
1292                         hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1293
1294                         spin_lock_irqsave(&sc->lock, flags);
1295                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1296                         spin_unlock_irqrestore(&sc->lock, flags);
1297
1298                         /* Return 0, so hidraw can get the report. */
1299                         return 0;
1300                 } else if (dongle_state == DONGLE_CALIBRATING ||
1301                            dongle_state == DONGLE_DISABLED ||
1302                            dongle_state == DONGLE_DISCONNECTED) {
1303                         /* Return 0, so hidraw can get the report. */
1304                         return 0;
1305                 }
1306
1307                 dualshock4_parse_report(sc, rd, size);
1308
1309         } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1310                 nsg_mrxu_parse_report(sc, rd, size);
1311                 return 1;
1312         }
1313
1314         if (sc->defer_initialization) {
1315                 sc->defer_initialization = 0;
1316                 sony_schedule_work(sc, SONY_WORKER_STATE);
1317         }
1318
1319         return 0;
1320 }
1321
1322 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1323                         struct hid_field *field, struct hid_usage *usage,
1324                         unsigned long **bit, int *max)
1325 {
1326         struct sony_sc *sc = hid_get_drvdata(hdev);
1327
1328         if (sc->quirks & BUZZ_CONTROLLER) {
1329                 unsigned int key = usage->hid & HID_USAGE;
1330
1331                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1332                         return -1;
1333
1334                 switch (usage->collection_index) {
1335                 case 1:
1336                         if (key >= ARRAY_SIZE(buzz_keymap))
1337                                 return -1;
1338
1339                         key = buzz_keymap[key];
1340                         if (!key)
1341                                 return -1;
1342                         break;
1343                 default:
1344                         return -1;
1345                 }
1346
1347                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1348                 return 1;
1349         }
1350
1351         if (sc->quirks & PS3REMOTE)
1352                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1353
1354         if (sc->quirks & NAVIGATION_CONTROLLER)
1355                 return navigation_mapping(hdev, hi, field, usage, bit, max);
1356
1357         if (sc->quirks & SIXAXIS_CONTROLLER)
1358                 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1359
1360         if (sc->quirks & DUALSHOCK4_CONTROLLER)
1361                 return ds4_mapping(hdev, hi, field, usage, bit, max);
1362
1363
1364         /* Let hid-core decide for the others */
1365         return 0;
1366 }
1367
1368 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1369                 int w, int h, int touch_major, int touch_minor, int orientation)
1370 {
1371         size_t name_sz;
1372         char *name;
1373         int ret;
1374
1375         sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1376         if (!sc->touchpad)
1377                 return -ENOMEM;
1378
1379         input_set_drvdata(sc->touchpad, sc);
1380         sc->touchpad->dev.parent = &sc->hdev->dev;
1381         sc->touchpad->phys = sc->hdev->phys;
1382         sc->touchpad->uniq = sc->hdev->uniq;
1383         sc->touchpad->id.bustype = sc->hdev->bus;
1384         sc->touchpad->id.vendor = sc->hdev->vendor;
1385         sc->touchpad->id.product = sc->hdev->product;
1386         sc->touchpad->id.version = sc->hdev->version;
1387
1388         /* Append a suffix to the controller name as there are various
1389          * DS4 compatible non-Sony devices with different names.
1390          */
1391         name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1392         name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1393         if (!name)
1394                 return -ENOMEM;
1395         snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1396         sc->touchpad->name = name;
1397
1398         /* We map the button underneath the touchpad to BTN_LEFT. */
1399         __set_bit(EV_KEY, sc->touchpad->evbit);
1400         __set_bit(BTN_LEFT, sc->touchpad->keybit);
1401         __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1402
1403         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1404         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1405
1406         if (touch_major > 0) {
1407                 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1408                         0, touch_major, 0, 0);
1409                 if (touch_minor > 0)
1410                         input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1411                                 0, touch_minor, 0, 0);
1412                 if (orientation > 0)
1413                         input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1414                                 0, orientation, 0, 0);
1415         }
1416
1417         if (sc->quirks & NSG_MRXU_REMOTE) {
1418                 __set_bit(EV_REL, sc->touchpad->evbit);
1419         }
1420
1421         ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1422         if (ret < 0)
1423                 return ret;
1424
1425         ret = input_register_device(sc->touchpad);
1426         if (ret < 0)
1427                 return ret;
1428
1429         return 0;
1430 }
1431
1432 static int sony_register_sensors(struct sony_sc *sc)
1433 {
1434         size_t name_sz;
1435         char *name;
1436         int ret;
1437         int range;
1438
1439         sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1440         if (!sc->sensor_dev)
1441                 return -ENOMEM;
1442
1443         input_set_drvdata(sc->sensor_dev, sc);
1444         sc->sensor_dev->dev.parent = &sc->hdev->dev;
1445         sc->sensor_dev->phys = sc->hdev->phys;
1446         sc->sensor_dev->uniq = sc->hdev->uniq;
1447         sc->sensor_dev->id.bustype = sc->hdev->bus;
1448         sc->sensor_dev->id.vendor = sc->hdev->vendor;
1449         sc->sensor_dev->id.product = sc->hdev->product;
1450         sc->sensor_dev->id.version = sc->hdev->version;
1451
1452         /* Append a suffix to the controller name as there are various
1453          * DS4 compatible non-Sony devices with different names.
1454          */
1455         name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1456         name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1457         if (!name)
1458                 return -ENOMEM;
1459         snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1460         sc->sensor_dev->name = name;
1461
1462         if (sc->quirks & SIXAXIS_CONTROLLER) {
1463                 /* For the DS3 we only support the accelerometer, which works
1464                  * quite well even without calibration. The device also has
1465                  * a 1-axis gyro, but it is very difficult to manage from within
1466                  * the driver even to get data, the sensor is inaccurate and
1467                  * the behavior is very different between hardware revisions.
1468                  */
1469                 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1470                 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1471                 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1472                 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1473                 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1474                 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1475         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1476                 range = DS4_ACC_RES_PER_G*4;
1477                 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1478                 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1479                 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1480                 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1481                 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1482                 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1483
1484                 range = DS4_GYRO_RES_PER_DEG_S*2048;
1485                 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1486                 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1487                 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1488                 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1489                 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1490                 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1491
1492                 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1493                 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1494         }
1495
1496         __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1497
1498         ret = input_register_device(sc->sensor_dev);
1499         if (ret < 0)
1500                 return ret;
1501
1502         return 0;
1503 }
1504
1505 /*
1506  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1507  * to "operational".  Without this, the ps3 controller will not report any
1508  * events.
1509  */
1510 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1511 {
1512         struct sony_sc *sc = hid_get_drvdata(hdev);
1513         const int buf_size =
1514                 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1515         u8 *buf;
1516         int ret;
1517
1518         buf = kmalloc(buf_size, GFP_KERNEL);
1519         if (!buf)
1520                 return -ENOMEM;
1521
1522         ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1523                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1524         if (ret < 0) {
1525                 hid_err(hdev, "can't set operational mode: step 1\n");
1526                 goto out;
1527         }
1528
1529         /*
1530          * Some compatible controllers like the Speedlink Strike FX and
1531          * Gasia need another query plus an USB interrupt to get operational.
1532          */
1533         ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1534                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1535         if (ret < 0) {
1536                 hid_err(hdev, "can't set operational mode: step 2\n");
1537                 goto out;
1538         }
1539
1540         /*
1541          * But the USB interrupt would cause SHANWAN controllers to
1542          * start rumbling non-stop, so skip step 3 for these controllers.
1543          */
1544         if (sc->quirks & SHANWAN_GAMEPAD)
1545                 goto out;
1546
1547         ret = hid_hw_output_report(hdev, buf, 1);
1548         if (ret < 0) {
1549                 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1550                 ret = 0;
1551         }
1552
1553 out:
1554         kfree(buf);
1555
1556         return ret;
1557 }
1558
1559 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1560 {
1561         static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1562         u8 *buf;
1563         int ret;
1564
1565         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1566         if (!buf)
1567                 return -ENOMEM;
1568
1569         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1570                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1571
1572         kfree(buf);
1573
1574         return ret;
1575 }
1576
1577 /*
1578  * Request DS4 calibration data for the motion sensors.
1579  * For Bluetooth this also affects the operating mode (see below).
1580  */
1581 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1582 {
1583         u8 *buf;
1584         int ret;
1585         short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1586         short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1587         short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1588         short gyro_speed_plus, gyro_speed_minus;
1589         short acc_x_plus, acc_x_minus;
1590         short acc_y_plus, acc_y_minus;
1591         short acc_z_plus, acc_z_minus;
1592         int speed_2x;
1593         int range_2g;
1594
1595         /* For Bluetooth we use a different request, which supports CRC.
1596          * Note: in Bluetooth mode feature report 0x02 also changes the state
1597          * of the controller, so that it sends input reports of type 0x11.
1598          */
1599         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1600                 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1601                 if (!buf)
1602                         return -ENOMEM;
1603
1604                 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1605                                          DS4_FEATURE_REPORT_0x02_SIZE,
1606                                          HID_FEATURE_REPORT,
1607                                          HID_REQ_GET_REPORT);
1608                 if (ret < 0)
1609                         goto err_stop;
1610         } else {
1611                 u8 bthdr = 0xA3;
1612                 u32 crc;
1613                 u32 report_crc;
1614                 int retries;
1615
1616                 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1617                 if (!buf)
1618                         return -ENOMEM;
1619
1620                 for (retries = 0; retries < 3; retries++) {
1621                         ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1622                                                  DS4_FEATURE_REPORT_0x05_SIZE,
1623                                                  HID_FEATURE_REPORT,
1624                                                  HID_REQ_GET_REPORT);
1625                         if (ret < 0)
1626                                 goto err_stop;
1627
1628                         /* CRC check */
1629                         crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1630                         crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1631                         report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1632                         if (crc != report_crc) {
1633                                 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1634                                         report_crc, crc);
1635                                 if (retries < 2) {
1636                                         hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1637                                         continue;
1638                                 } else {
1639                                         ret = -EILSEQ;
1640                                         goto err_stop;
1641                                 }
1642                         } else {
1643                                 break;
1644                         }
1645                 }
1646         }
1647
1648         gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
1649         gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
1650         gyro_roll_bias   = get_unaligned_le16(&buf[5]);
1651         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1652                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1653                 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1654                 gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
1655                 gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
1656                 gyro_roll_plus   = get_unaligned_le16(&buf[15]);
1657                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1658         } else {
1659                 /* BT + Dongle */
1660                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1661                 gyro_yaw_plus    = get_unaligned_le16(&buf[9]);
1662                 gyro_roll_plus   = get_unaligned_le16(&buf[11]);
1663                 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1664                 gyro_yaw_minus   = get_unaligned_le16(&buf[15]);
1665                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1666         }
1667         gyro_speed_plus  = get_unaligned_le16(&buf[19]);
1668         gyro_speed_minus = get_unaligned_le16(&buf[21]);
1669         acc_x_plus       = get_unaligned_le16(&buf[23]);
1670         acc_x_minus      = get_unaligned_le16(&buf[25]);
1671         acc_y_plus       = get_unaligned_le16(&buf[27]);
1672         acc_y_minus      = get_unaligned_le16(&buf[29]);
1673         acc_z_plus       = get_unaligned_le16(&buf[31]);
1674         acc_z_minus      = get_unaligned_le16(&buf[33]);
1675
1676         /* Set gyroscope calibration and normalization parameters.
1677          * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1678          */
1679         speed_2x = (gyro_speed_plus + gyro_speed_minus);
1680         sc->ds4_calib_data[0].abs_code = ABS_RX;
1681         sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1682         sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1683         sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1684
1685         sc->ds4_calib_data[1].abs_code = ABS_RY;
1686         sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1687         sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1688         sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1689
1690         sc->ds4_calib_data[2].abs_code = ABS_RZ;
1691         sc->ds4_calib_data[2].bias = gyro_roll_bias;
1692         sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1693         sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1694
1695         /* Set accelerometer calibration and normalization parameters.
1696          * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1697          */
1698         range_2g = acc_x_plus - acc_x_minus;
1699         sc->ds4_calib_data[3].abs_code = ABS_X;
1700         sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1701         sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1702         sc->ds4_calib_data[3].sens_denom = range_2g;
1703
1704         range_2g = acc_y_plus - acc_y_minus;
1705         sc->ds4_calib_data[4].abs_code = ABS_Y;
1706         sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1707         sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1708         sc->ds4_calib_data[4].sens_denom = range_2g;
1709
1710         range_2g = acc_z_plus - acc_z_minus;
1711         sc->ds4_calib_data[5].abs_code = ABS_Z;
1712         sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1713         sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1714         sc->ds4_calib_data[5].sens_denom = range_2g;
1715
1716 err_stop:
1717         kfree(buf);
1718         return ret;
1719 }
1720
1721 static void dualshock4_calibration_work(struct work_struct *work)
1722 {
1723         struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1724         unsigned long flags;
1725         enum ds4_dongle_state dongle_state;
1726         int ret;
1727
1728         ret = dualshock4_get_calibration_data(sc);
1729         if (ret < 0) {
1730                 /* This call is very unlikely to fail for the dongle. When it
1731                  * fails we are probably in a very bad state, so mark the
1732                  * dongle as disabled. We will re-enable the dongle if a new
1733                  * DS4 hotplug is detect from sony_raw_event as any issues
1734                  * are likely resolved then (the dongle is quite stupid).
1735                  */
1736                 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1737                 dongle_state = DONGLE_DISABLED;
1738         } else {
1739                 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1740                 dongle_state = DONGLE_CONNECTED;
1741         }
1742
1743         spin_lock_irqsave(&sc->lock, flags);
1744         sc->ds4_dongle_state = dongle_state;
1745         spin_unlock_irqrestore(&sc->lock, flags);
1746 }
1747
1748 static int dualshock4_get_version_info(struct sony_sc *sc)
1749 {
1750         u8 *buf;
1751         int ret;
1752
1753         buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1754         if (!buf)
1755                 return -ENOMEM;
1756
1757         ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1758                                  DS4_FEATURE_REPORT_0xA3_SIZE,
1759                                  HID_FEATURE_REPORT,
1760                                  HID_REQ_GET_REPORT);
1761         if (ret < 0) {
1762                 kfree(buf);
1763                 return ret;
1764         }
1765
1766         sc->hw_version = get_unaligned_le16(&buf[35]);
1767         sc->fw_version = get_unaligned_le16(&buf[41]);
1768
1769         kfree(buf);
1770         return 0;
1771 }
1772
1773 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1774 {
1775         static const u8 sixaxis_leds[10][4] = {
1776                                 { 0x01, 0x00, 0x00, 0x00 },
1777                                 { 0x00, 0x01, 0x00, 0x00 },
1778                                 { 0x00, 0x00, 0x01, 0x00 },
1779                                 { 0x00, 0x00, 0x00, 0x01 },
1780                                 { 0x01, 0x00, 0x00, 0x01 },
1781                                 { 0x00, 0x01, 0x00, 0x01 },
1782                                 { 0x00, 0x00, 0x01, 0x01 },
1783                                 { 0x01, 0x00, 0x01, 0x01 },
1784                                 { 0x00, 0x01, 0x01, 0x01 },
1785                                 { 0x01, 0x01, 0x01, 0x01 }
1786         };
1787
1788         int id = sc->device_id;
1789
1790         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1791
1792         if (id < 0)
1793                 return;
1794
1795         id %= 10;
1796         memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1797 }
1798
1799 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1800 {
1801         /* The first 4 color/index entries match what the PS4 assigns */
1802         static const u8 color_code[7][3] = {
1803                         /* Blue   */    { 0x00, 0x00, 0x40 },
1804                         /* Red    */    { 0x40, 0x00, 0x00 },
1805                         /* Green  */    { 0x00, 0x40, 0x00 },
1806                         /* Pink   */    { 0x20, 0x00, 0x20 },
1807                         /* Orange */    { 0x02, 0x01, 0x00 },
1808                         /* Teal   */    { 0x00, 0x01, 0x01 },
1809                         /* White  */    { 0x01, 0x01, 0x01 }
1810         };
1811
1812         int id = sc->device_id;
1813
1814         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1815
1816         if (id < 0)
1817                 return;
1818
1819         id %= 7;
1820         memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1821 }
1822
1823 static void buzz_set_leds(struct sony_sc *sc)
1824 {
1825         struct hid_device *hdev = sc->hdev;
1826         struct list_head *report_list =
1827                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1828         struct hid_report *report = list_entry(report_list->next,
1829                 struct hid_report, list);
1830         s32 *value = report->field[0]->value;
1831
1832         BUILD_BUG_ON(MAX_LEDS < 4);
1833
1834         value[0] = 0x00;
1835         value[1] = sc->led_state[0] ? 0xff : 0x00;
1836         value[2] = sc->led_state[1] ? 0xff : 0x00;
1837         value[3] = sc->led_state[2] ? 0xff : 0x00;
1838         value[4] = sc->led_state[3] ? 0xff : 0x00;
1839         value[5] = 0x00;
1840         value[6] = 0x00;
1841         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1842 }
1843
1844 static void sony_set_leds(struct sony_sc *sc)
1845 {
1846         if (!(sc->quirks & BUZZ_CONTROLLER))
1847                 sony_schedule_work(sc, SONY_WORKER_STATE);
1848         else
1849                 buzz_set_leds(sc);
1850 }
1851
1852 static void sony_led_set_brightness(struct led_classdev *led,
1853                                     enum led_brightness value)
1854 {
1855         struct device *dev = led->dev->parent;
1856         struct hid_device *hdev = to_hid_device(dev);
1857         struct sony_sc *drv_data;
1858
1859         int n;
1860         int force_update;
1861
1862         drv_data = hid_get_drvdata(hdev);
1863         if (!drv_data) {
1864                 hid_err(hdev, "No device data\n");
1865                 return;
1866         }
1867
1868         /*
1869          * The Sixaxis on USB will override any LED settings sent to it
1870          * and keep flashing all of the LEDs until the PS button is pressed.
1871          * Updates, even if redundant, must be always be sent to the
1872          * controller to avoid having to toggle the state of an LED just to
1873          * stop the flashing later on.
1874          */
1875         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1876
1877         for (n = 0; n < drv_data->led_count; n++) {
1878                 if (led == drv_data->leds[n] && (force_update ||
1879                         (value != drv_data->led_state[n] ||
1880                         drv_data->led_delay_on[n] ||
1881                         drv_data->led_delay_off[n]))) {
1882
1883                         drv_data->led_state[n] = value;
1884
1885                         /* Setting the brightness stops the blinking */
1886                         drv_data->led_delay_on[n] = 0;
1887                         drv_data->led_delay_off[n] = 0;
1888
1889                         sony_set_leds(drv_data);
1890                         break;
1891                 }
1892         }
1893 }
1894
1895 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1896 {
1897         struct device *dev = led->dev->parent;
1898         struct hid_device *hdev = to_hid_device(dev);
1899         struct sony_sc *drv_data;
1900
1901         int n;
1902
1903         drv_data = hid_get_drvdata(hdev);
1904         if (!drv_data) {
1905                 hid_err(hdev, "No device data\n");
1906                 return LED_OFF;
1907         }
1908
1909         for (n = 0; n < drv_data->led_count; n++) {
1910                 if (led == drv_data->leds[n])
1911                         return drv_data->led_state[n];
1912         }
1913
1914         return LED_OFF;
1915 }
1916
1917 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1918                                 unsigned long *delay_off)
1919 {
1920         struct device *dev = led->dev->parent;
1921         struct hid_device *hdev = to_hid_device(dev);
1922         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1923         int n;
1924         u8 new_on, new_off;
1925
1926         if (!drv_data) {
1927                 hid_err(hdev, "No device data\n");
1928                 return -EINVAL;
1929         }
1930
1931         /* Max delay is 255 deciseconds or 2550 milliseconds */
1932         if (*delay_on > 2550)
1933                 *delay_on = 2550;
1934         if (*delay_off > 2550)
1935                 *delay_off = 2550;
1936
1937         /* Blink at 1 Hz if both values are zero */
1938         if (!*delay_on && !*delay_off)
1939                 *delay_on = *delay_off = 500;
1940
1941         new_on = *delay_on / 10;
1942         new_off = *delay_off / 10;
1943
1944         for (n = 0; n < drv_data->led_count; n++) {
1945                 if (led == drv_data->leds[n])
1946                         break;
1947         }
1948
1949         /* This LED is not registered on this device */
1950         if (n >= drv_data->led_count)
1951                 return -EINVAL;
1952
1953         /* Don't schedule work if the values didn't change */
1954         if (new_on != drv_data->led_delay_on[n] ||
1955                 new_off != drv_data->led_delay_off[n]) {
1956                 drv_data->led_delay_on[n] = new_on;
1957                 drv_data->led_delay_off[n] = new_off;
1958                 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1959         }
1960
1961         return 0;
1962 }
1963
1964 static int sony_leds_init(struct sony_sc *sc)
1965 {
1966         struct hid_device *hdev = sc->hdev;
1967         int n, ret = 0;
1968         int use_ds4_names;
1969         struct led_classdev *led;
1970         size_t name_sz;
1971         char *name;
1972         size_t name_len;
1973         const char *name_fmt;
1974         static const char * const ds4_name_str[] = { "red", "green", "blue",
1975                                                   "global" };
1976         u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1977         u8 use_hw_blink[MAX_LEDS] = { 0 };
1978
1979         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1980
1981         if (sc->quirks & BUZZ_CONTROLLER) {
1982                 sc->led_count = 4;
1983                 use_ds4_names = 0;
1984                 name_len = strlen("::buzz#");
1985                 name_fmt = "%s::buzz%d";
1986                 /* Validate expected report characteristics. */
1987                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1988                         return -ENODEV;
1989         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1990                 dualshock4_set_leds_from_id(sc);
1991                 sc->led_state[3] = 1;
1992                 sc->led_count = 4;
1993                 memset(max_brightness, 255, 3);
1994                 use_hw_blink[3] = 1;
1995                 use_ds4_names = 1;
1996                 name_len = 0;
1997                 name_fmt = "%s:%s";
1998         } else if (sc->quirks & MOTION_CONTROLLER) {
1999                 sc->led_count = 3;
2000                 memset(max_brightness, 255, 3);
2001                 use_ds4_names = 1;
2002                 name_len = 0;
2003                 name_fmt = "%s:%s";
2004         } else if (sc->quirks & NAVIGATION_CONTROLLER) {
2005                 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
2006
2007                 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2008                 sc->led_count = 1;
2009                 memset(use_hw_blink, 1, 4);
2010                 use_ds4_names = 0;
2011                 name_len = strlen("::sony#");
2012                 name_fmt = "%s::sony%d";
2013         } else {
2014                 sixaxis_set_leds_from_id(sc);
2015                 sc->led_count = 4;
2016                 memset(use_hw_blink, 1, 4);
2017                 use_ds4_names = 0;
2018                 name_len = strlen("::sony#");
2019                 name_fmt = "%s::sony%d";
2020         }
2021
2022         /*
2023          * Clear LEDs as we have no way of reading their initial state. This is
2024          * only relevant if the driver is loaded after somebody actively set the
2025          * LEDs to on
2026          */
2027         sony_set_leds(sc);
2028
2029         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2030
2031         for (n = 0; n < sc->led_count; n++) {
2032
2033                 if (use_ds4_names)
2034                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2035
2036                 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2037                 if (!led) {
2038                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2039                         return -ENOMEM;
2040                 }
2041
2042                 name = (void *)(&led[1]);
2043                 if (use_ds4_names)
2044                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2045                         ds4_name_str[n]);
2046                 else
2047                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2048                 led->name = name;
2049                 led->brightness = sc->led_state[n];
2050                 led->max_brightness = max_brightness[n];
2051                 led->flags = LED_CORE_SUSPENDRESUME;
2052                 led->brightness_get = sony_led_get_brightness;
2053                 led->brightness_set = sony_led_set_brightness;
2054
2055                 if (use_hw_blink[n])
2056                         led->blink_set = sony_led_blink_set;
2057
2058                 sc->leds[n] = led;
2059
2060                 ret = devm_led_classdev_register(&hdev->dev, led);
2061                 if (ret) {
2062                         hid_err(hdev, "Failed to register LED %d\n", n);
2063                         return ret;
2064                 }
2065         }
2066
2067         return 0;
2068 }
2069
2070 static void sixaxis_send_output_report(struct sony_sc *sc)
2071 {
2072         static const union sixaxis_output_report_01 default_report = {
2073                 .buf = {
2074                         0x01,
2075                         0x01, 0xff, 0x00, 0xff, 0x00,
2076                         0x00, 0x00, 0x00, 0x00, 0x00,
2077                         0xff, 0x27, 0x10, 0x00, 0x32,
2078                         0xff, 0x27, 0x10, 0x00, 0x32,
2079                         0xff, 0x27, 0x10, 0x00, 0x32,
2080                         0xff, 0x27, 0x10, 0x00, 0x32,
2081                         0x00, 0x00, 0x00, 0x00, 0x00
2082                 }
2083         };
2084         struct sixaxis_output_report *report =
2085                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2086         int n;
2087
2088         /* Initialize the report with default values */
2089         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2090
2091 #ifdef CONFIG_SONY_FF
2092         report->rumble.right_motor_on = sc->right ? 1 : 0;
2093         report->rumble.left_motor_force = sc->left;
2094 #endif
2095
2096         report->leds_bitmap |= sc->led_state[0] << 1;
2097         report->leds_bitmap |= sc->led_state[1] << 2;
2098         report->leds_bitmap |= sc->led_state[2] << 3;
2099         report->leds_bitmap |= sc->led_state[3] << 4;
2100
2101         /* Set flag for all leds off, required for 3rd party INTEC controller */
2102         if ((report->leds_bitmap & 0x1E) == 0)
2103                 report->leds_bitmap |= 0x20;
2104
2105         /*
2106          * The LEDs in the report are indexed in reverse order to their
2107          * corresponding light on the controller.
2108          * Index 0 = LED 4, index 1 = LED 3, etc...
2109          *
2110          * In the case of both delay values being zero (blinking disabled) the
2111          * default report values should be used or the controller LED will be
2112          * always off.
2113          */
2114         for (n = 0; n < 4; n++) {
2115                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2116                         report->led[3 - n].duty_off = sc->led_delay_off[n];
2117                         report->led[3 - n].duty_on = sc->led_delay_on[n];
2118                 }
2119         }
2120
2121         /* SHANWAN controllers require output reports via intr channel */
2122         if (sc->quirks & SHANWAN_GAMEPAD)
2123                 hid_hw_output_report(sc->hdev, (u8 *)report,
2124                                 sizeof(struct sixaxis_output_report));
2125         else
2126                 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2127                                 sizeof(struct sixaxis_output_report),
2128                                 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2129 }
2130
2131 static void dualshock4_send_output_report(struct sony_sc *sc)
2132 {
2133         struct hid_device *hdev = sc->hdev;
2134         u8 *buf = sc->output_report_dmabuf;
2135         int offset;
2136
2137         /*
2138          * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2139          * control the interval at which Dualshock 4 reports data:
2140          * 0x00 - 1ms
2141          * 0x01 - 1ms
2142          * 0x02 - 2ms
2143          * 0x3E - 62ms
2144          * 0x3F - disabled
2145          */
2146         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2147                 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2148                 buf[0] = 0x05;
2149                 buf[1] = 0x07; /* blink + LEDs + motor */
2150                 offset = 4;
2151         } else {
2152                 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2153                 buf[0] = 0x11;
2154                 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2155                 buf[3] = 0x07; /* blink + LEDs + motor */
2156                 offset = 6;
2157         }
2158
2159 #ifdef CONFIG_SONY_FF
2160         buf[offset++] = sc->right;
2161         buf[offset++] = sc->left;
2162 #else
2163         offset += 2;
2164 #endif
2165
2166         /* LED 3 is the global control */
2167         if (sc->led_state[3]) {
2168                 buf[offset++] = sc->led_state[0];
2169                 buf[offset++] = sc->led_state[1];
2170                 buf[offset++] = sc->led_state[2];
2171         } else {
2172                 offset += 3;
2173         }
2174
2175         /* If both delay values are zero the DualShock 4 disables blinking. */
2176         buf[offset++] = sc->led_delay_on[3];
2177         buf[offset++] = sc->led_delay_off[3];
2178
2179         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2180                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2181         else {
2182                 /* CRC generation */
2183                 u8 bthdr = 0xA2;
2184                 u32 crc;
2185
2186                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2187                 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2188                 put_unaligned_le32(crc, &buf[74]);
2189                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2190         }
2191 }
2192
2193 static void motion_send_output_report(struct sony_sc *sc)
2194 {
2195         struct hid_device *hdev = sc->hdev;
2196         struct motion_output_report_02 *report =
2197                 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2198
2199         memset(report, 0, MOTION_REPORT_0x02_SIZE);
2200
2201         report->type = 0x02; /* set leds */
2202         report->r = sc->led_state[0];
2203         report->g = sc->led_state[1];
2204         report->b = sc->led_state[2];
2205
2206 #ifdef CONFIG_SONY_FF
2207         report->rumble = max(sc->right, sc->left);
2208 #endif
2209
2210         hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2211 }
2212
2213 static inline void sony_send_output_report(struct sony_sc *sc)
2214 {
2215         if (sc->send_output_report)
2216                 sc->send_output_report(sc);
2217 }
2218
2219 static void sony_state_worker(struct work_struct *work)
2220 {
2221         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2222
2223         sc->send_output_report(sc);
2224 }
2225
2226 static int sony_allocate_output_report(struct sony_sc *sc)
2227 {
2228         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2229                         (sc->quirks & NAVIGATION_CONTROLLER))
2230                 sc->output_report_dmabuf =
2231                         devm_kmalloc(&sc->hdev->dev,
2232                                 sizeof(union sixaxis_output_report_01),
2233                                 GFP_KERNEL);
2234         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2235                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2236                                                 DS4_OUTPUT_REPORT_0x11_SIZE,
2237                                                 GFP_KERNEL);
2238         else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2239                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2240                                                 DS4_OUTPUT_REPORT_0x05_SIZE,
2241                                                 GFP_KERNEL);
2242         else if (sc->quirks & MOTION_CONTROLLER)
2243                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2244                                                 MOTION_REPORT_0x02_SIZE,
2245                                                 GFP_KERNEL);
2246         else
2247                 return 0;
2248
2249         if (!sc->output_report_dmabuf)
2250                 return -ENOMEM;
2251
2252         return 0;
2253 }
2254
2255 #ifdef CONFIG_SONY_FF
2256 static int sony_play_effect(struct input_dev *dev, void *data,
2257                             struct ff_effect *effect)
2258 {
2259         struct hid_device *hid = input_get_drvdata(dev);
2260         struct sony_sc *sc = hid_get_drvdata(hid);
2261
2262         if (effect->type != FF_RUMBLE)
2263                 return 0;
2264
2265         sc->left = effect->u.rumble.strong_magnitude / 256;
2266         sc->right = effect->u.rumble.weak_magnitude / 256;
2267
2268         sony_schedule_work(sc, SONY_WORKER_STATE);
2269         return 0;
2270 }
2271
2272 static int sony_init_ff(struct sony_sc *sc)
2273 {
2274         struct hid_input *hidinput;
2275         struct input_dev *input_dev;
2276
2277         if (list_empty(&sc->hdev->inputs)) {
2278                 hid_err(sc->hdev, "no inputs found\n");
2279                 return -ENODEV;
2280         }
2281         hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2282         input_dev = hidinput->input;
2283
2284         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2285         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2286 }
2287
2288 #else
2289 static int sony_init_ff(struct sony_sc *sc)
2290 {
2291         return 0;
2292 }
2293
2294 #endif
2295
2296 static int sony_battery_get_property(struct power_supply *psy,
2297                                      enum power_supply_property psp,
2298                                      union power_supply_propval *val)
2299 {
2300         struct sony_sc *sc = power_supply_get_drvdata(psy);
2301         unsigned long flags;
2302         int ret = 0;
2303         u8 battery_charging, battery_capacity, cable_state;
2304
2305         spin_lock_irqsave(&sc->lock, flags);
2306         battery_charging = sc->battery_charging;
2307         battery_capacity = sc->battery_capacity;
2308         cable_state = sc->cable_state;
2309         spin_unlock_irqrestore(&sc->lock, flags);
2310
2311         switch (psp) {
2312         case POWER_SUPPLY_PROP_PRESENT:
2313                 val->intval = 1;
2314                 break;
2315         case POWER_SUPPLY_PROP_SCOPE:
2316                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2317                 break;
2318         case POWER_SUPPLY_PROP_CAPACITY:
2319                 val->intval = battery_capacity;
2320                 break;
2321         case POWER_SUPPLY_PROP_STATUS:
2322                 if (battery_charging)
2323                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
2324                 else
2325                         if (battery_capacity == 100 && cable_state)
2326                                 val->intval = POWER_SUPPLY_STATUS_FULL;
2327                         else
2328                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2329                 break;
2330         default:
2331                 ret = -EINVAL;
2332                 break;
2333         }
2334         return ret;
2335 }
2336
2337 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2338 {
2339         const char *battery_str_fmt = append_dev_id ?
2340                 "sony_controller_battery_%pMR_%i" :
2341                 "sony_controller_battery_%pMR";
2342         struct power_supply_config psy_cfg = { .drv_data = sc, };
2343         struct hid_device *hdev = sc->hdev;
2344         int ret;
2345
2346         /*
2347          * Set the default battery level to 100% to avoid low battery warnings
2348          * if the battery is polled before the first device report is received.
2349          */
2350         sc->battery_capacity = 100;
2351
2352         sc->battery_desc.properties = sony_battery_props;
2353         sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2354         sc->battery_desc.get_property = sony_battery_get_property;
2355         sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2356         sc->battery_desc.use_for_apm = 0;
2357         sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2358                                           battery_str_fmt, sc->mac_address, sc->device_id);
2359         if (!sc->battery_desc.name)
2360                 return -ENOMEM;
2361
2362         sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2363                                             &psy_cfg);
2364         if (IS_ERR(sc->battery)) {
2365                 ret = PTR_ERR(sc->battery);
2366                 hid_err(hdev, "Unable to register battery device\n");
2367                 return ret;
2368         }
2369
2370         power_supply_powers(sc->battery, &hdev->dev);
2371         return 0;
2372 }
2373
2374 /*
2375  * If a controller is plugged in via USB while already connected via Bluetooth
2376  * it will show up as two devices. A global list of connected controllers and
2377  * their MAC addresses is maintained to ensure that a device is only connected
2378  * once.
2379  *
2380  * Some USB-only devices masquerade as Sixaxis controllers and all have the
2381  * same dummy Bluetooth address, so a comparison of the connection type is
2382  * required.  Devices are only rejected in the case where two devices have
2383  * matching Bluetooth addresses on different bus types.
2384  */
2385 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2386                                                 struct sony_sc *sc1)
2387 {
2388         const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2389         const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2390
2391         return sc0_not_bt == sc1_not_bt;
2392 }
2393
2394 static int sony_check_add_dev_list(struct sony_sc *sc)
2395 {
2396         struct sony_sc *entry;
2397         unsigned long flags;
2398         int ret;
2399
2400         spin_lock_irqsave(&sony_dev_list_lock, flags);
2401
2402         list_for_each_entry(entry, &sony_device_list, list_node) {
2403                 ret = memcmp(sc->mac_address, entry->mac_address,
2404                                 sizeof(sc->mac_address));
2405                 if (!ret) {
2406                         if (sony_compare_connection_type(sc, entry)) {
2407                                 ret = 1;
2408                         } else {
2409                                 ret = -EEXIST;
2410                                 hid_info(sc->hdev,
2411                                 "controller with MAC address %pMR already connected\n",
2412                                 sc->mac_address);
2413                         }
2414                         goto unlock;
2415                 }
2416         }
2417
2418         ret = 0;
2419         list_add(&(sc->list_node), &sony_device_list);
2420
2421 unlock:
2422         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2423         return ret;
2424 }
2425
2426 static void sony_remove_dev_list(struct sony_sc *sc)
2427 {
2428         unsigned long flags;
2429
2430         if (sc->list_node.next) {
2431                 spin_lock_irqsave(&sony_dev_list_lock, flags);
2432                 list_del(&(sc->list_node));
2433                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2434         }
2435 }
2436
2437 static int sony_get_bt_devaddr(struct sony_sc *sc)
2438 {
2439         int ret;
2440
2441         /* HIDP stores the device MAC address as a string in the uniq field. */
2442         ret = strlen(sc->hdev->uniq);
2443         if (ret != 17)
2444                 return -EINVAL;
2445
2446         ret = sscanf(sc->hdev->uniq,
2447                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2448                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2449                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2450
2451         if (ret != 6)
2452                 return -EINVAL;
2453
2454         return 0;
2455 }
2456
2457 static int sony_check_add(struct sony_sc *sc)
2458 {
2459         u8 *buf = NULL;
2460         int n, ret;
2461
2462         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2463             (sc->quirks & MOTION_CONTROLLER_BT) ||
2464             (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2465             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2466                 /*
2467                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2468                  * address from the uniq string where HIDP stores it.
2469                  * As uniq cannot be guaranteed to be a MAC address in all cases
2470                  * a failure of this function should not prevent the connection.
2471                  */
2472                 if (sony_get_bt_devaddr(sc) < 0) {
2473                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2474                         return 0;
2475                 }
2476         } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2477                 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2478                 if (!buf)
2479                         return -ENOMEM;
2480
2481                 /*
2482                  * The MAC address of a DS4 controller connected via USB can be
2483                  * retrieved with feature report 0x81. The address begins at
2484                  * offset 1.
2485                  */
2486                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2487                                 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2488                                 HID_REQ_GET_REPORT);
2489
2490                 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2491                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2492                         ret = ret < 0 ? ret : -EINVAL;
2493                         goto out_free;
2494                 }
2495
2496                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2497
2498                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2499                          "%pMR", sc->mac_address);
2500         } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2501                         (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2502                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2503                 if (!buf)
2504                         return -ENOMEM;
2505
2506                 /*
2507                  * The MAC address of a Sixaxis controller connected via USB can
2508                  * be retrieved with feature report 0xf2. The address begins at
2509                  * offset 4.
2510                  */
2511                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2512                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2513                                 HID_REQ_GET_REPORT);
2514
2515                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2516                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2517                         ret = ret < 0 ? ret : -EINVAL;
2518                         goto out_free;
2519                 }
2520
2521                 /*
2522                  * The Sixaxis device MAC in the report is big-endian and must
2523                  * be byte-swapped.
2524                  */
2525                 for (n = 0; n < 6; n++)
2526                         sc->mac_address[5-n] = buf[4+n];
2527
2528                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2529                          "%pMR", sc->mac_address);
2530         } else {
2531                 return 0;
2532         }
2533
2534         ret = sony_check_add_dev_list(sc);
2535
2536 out_free:
2537
2538         kfree(buf);
2539
2540         return ret;
2541 }
2542
2543 static int sony_set_device_id(struct sony_sc *sc)
2544 {
2545         int ret;
2546
2547         /*
2548          * Only DualShock 4 or Sixaxis controllers get an id.
2549          * All others are set to -1.
2550          */
2551         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2552             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2553                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2554                                         GFP_KERNEL);
2555                 if (ret < 0) {
2556                         sc->device_id = -1;
2557                         return ret;
2558                 }
2559                 sc->device_id = ret;
2560         } else {
2561                 sc->device_id = -1;
2562         }
2563
2564         return 0;
2565 }
2566
2567 static void sony_release_device_id(struct sony_sc *sc)
2568 {
2569         if (sc->device_id >= 0) {
2570                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2571                 sc->device_id = -1;
2572         }
2573 }
2574
2575 static inline void sony_init_output_report(struct sony_sc *sc,
2576                                 void (*send_output_report)(struct sony_sc *))
2577 {
2578         sc->send_output_report = send_output_report;
2579
2580         if (!sc->state_worker_initialized)
2581                 INIT_WORK(&sc->state_worker, sony_state_worker);
2582
2583         sc->state_worker_initialized = 1;
2584 }
2585
2586 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2587 {
2588         unsigned long flags;
2589
2590         if (sc->hotplug_worker_initialized)
2591                 cancel_work_sync(&sc->hotplug_worker);
2592         if (sc->state_worker_initialized) {
2593                 spin_lock_irqsave(&sc->lock, flags);
2594                 sc->state_worker_initialized = 0;
2595                 spin_unlock_irqrestore(&sc->lock, flags);
2596                 cancel_work_sync(&sc->state_worker);
2597         }
2598 }
2599
2600 static int sony_input_configured(struct hid_device *hdev,
2601                                         struct hid_input *hidinput)
2602 {
2603         struct sony_sc *sc = hid_get_drvdata(hdev);
2604         int append_dev_id;
2605         int ret;
2606
2607         ret = sony_set_device_id(sc);
2608         if (ret < 0) {
2609                 hid_err(hdev, "failed to allocate the device id\n");
2610                 goto err_stop;
2611         }
2612
2613         ret = append_dev_id = sony_check_add(sc);
2614         if (ret < 0)
2615                 goto err_stop;
2616
2617         ret = sony_allocate_output_report(sc);
2618         if (ret < 0) {
2619                 hid_err(hdev, "failed to allocate the output report buffer\n");
2620                 goto err_stop;
2621         }
2622
2623         if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2624                 /*
2625                  * The Sony Sixaxis does not handle HID Output Reports on the
2626                  * Interrupt EP like it could, so we need to force HID Output
2627                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
2628                  *
2629                  * There is also another issue about HID Output Reports via USB,
2630                  * the Sixaxis does not want the report_id as part of the data
2631                  * packet, so we have to discard buf[0] when sending the actual
2632                  * control message, even for numbered reports, humpf!
2633                  *
2634                  * Additionally, the Sixaxis on USB isn't properly initialized
2635                  * until the PS logo button is pressed and as such won't retain
2636                  * any state set by an output report, so the initial
2637                  * configuration report is deferred until the first input
2638                  * report arrives.
2639                  */
2640                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2641                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2642                 sc->defer_initialization = 1;
2643
2644                 ret = sixaxis_set_operational_usb(hdev);
2645                 if (ret < 0) {
2646                         hid_err(hdev, "Failed to set controller into operational mode\n");
2647                         goto err_stop;
2648                 }
2649
2650                 sony_init_output_report(sc, sixaxis_send_output_report);
2651         } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2652                 /*
2653                  * The Navigation controller wants output reports sent on the ctrl
2654                  * endpoint when connected via Bluetooth.
2655                  */
2656                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2657
2658                 ret = sixaxis_set_operational_bt(hdev);
2659                 if (ret < 0) {
2660                         hid_err(hdev, "Failed to set controller into operational mode\n");
2661                         goto err_stop;
2662                 }
2663
2664                 sony_init_output_report(sc, sixaxis_send_output_report);
2665         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2666                 /*
2667                  * The Sony Sixaxis does not handle HID Output Reports on the
2668                  * Interrupt EP and the device only becomes active when the
2669                  * PS button is pressed. See comment for Navigation controller
2670                  * above for more details.
2671                  */
2672                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2673                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2674                 sc->defer_initialization = 1;
2675
2676                 ret = sixaxis_set_operational_usb(hdev);
2677                 if (ret < 0) {
2678                         hid_err(hdev, "Failed to set controller into operational mode\n");
2679                         goto err_stop;
2680                 }
2681
2682                 ret = sony_register_sensors(sc);
2683                 if (ret) {
2684                         hid_err(sc->hdev,
2685                         "Unable to initialize motion sensors: %d\n", ret);
2686                         goto err_stop;
2687                 }
2688
2689                 sony_init_output_report(sc, sixaxis_send_output_report);
2690         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2691                 /*
2692                  * The Sixaxis wants output reports sent on the ctrl endpoint
2693                  * when connected via Bluetooth.
2694                  */
2695                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2696
2697                 ret = sixaxis_set_operational_bt(hdev);
2698                 if (ret < 0) {
2699                         hid_err(hdev, "Failed to set controller into operational mode\n");
2700                         goto err_stop;
2701                 }
2702
2703                 ret = sony_register_sensors(sc);
2704                 if (ret) {
2705                         hid_err(sc->hdev,
2706                         "Unable to initialize motion sensors: %d\n", ret);
2707                         goto err_stop;
2708                 }
2709
2710                 sony_init_output_report(sc, sixaxis_send_output_report);
2711         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2712                 ret = dualshock4_get_calibration_data(sc);
2713                 if (ret < 0) {
2714                         hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2715                         goto err_stop;
2716                 }
2717
2718                 ret = dualshock4_get_version_info(sc);
2719                 if (ret < 0) {
2720                         hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2721                         goto err_stop;
2722                 }
2723
2724                 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2725                 if (ret) {
2726                         /* Make zero for cleanup reasons of sysfs entries. */
2727                         sc->fw_version = 0;
2728                         sc->hw_version = 0;
2729                         hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2730                         goto err_stop;
2731                 }
2732
2733                 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2734                 if (ret) {
2735                         sc->hw_version = 0;
2736                         hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2737                         goto err_stop;
2738                 }
2739
2740                 /*
2741                  * The Dualshock 4 touchpad supports 2 touches and has a
2742                  * resolution of 1920x942 (44.86 dots/mm).
2743                  */
2744                 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2745                 if (ret) {
2746                         hid_err(sc->hdev,
2747                         "Unable to initialize multi-touch slots: %d\n",
2748                         ret);
2749                         goto err_stop;
2750                 }
2751
2752                 ret = sony_register_sensors(sc);
2753                 if (ret) {
2754                         hid_err(sc->hdev,
2755                         "Unable to initialize motion sensors: %d\n", ret);
2756                         goto err_stop;
2757                 }
2758
2759                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2760                         sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2761                         ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2762                         if (ret)
2763                                 hid_warn(sc->hdev,
2764                                  "can't create sysfs bt_poll_interval attribute err: %d\n",
2765                                  ret);
2766                 }
2767
2768                 if (sc->quirks & DUALSHOCK4_DONGLE) {
2769                         INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2770                         sc->hotplug_worker_initialized = 1;
2771                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2772                 }
2773
2774                 sony_init_output_report(sc, dualshock4_send_output_report);
2775         } else if (sc->quirks & NSG_MRXU_REMOTE) {
2776                 /*
2777                  * The NSG-MRxU touchpad supports 2 touches and has a
2778                  * resolution of 1667x1868
2779                  */
2780                 ret = sony_register_touchpad(sc, 2,
2781                         NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2782                 if (ret) {
2783                         hid_err(sc->hdev,
2784                         "Unable to initialize multi-touch slots: %d\n",
2785                         ret);
2786                         goto err_stop;
2787                 }
2788
2789         } else if (sc->quirks & MOTION_CONTROLLER) {
2790                 sony_init_output_report(sc, motion_send_output_report);
2791         } else {
2792                 ret = 0;
2793         }
2794
2795         if (sc->quirks & SONY_LED_SUPPORT) {
2796                 ret = sony_leds_init(sc);
2797                 if (ret < 0)
2798                         goto err_stop;
2799         }
2800
2801         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2802                 ret = sony_battery_probe(sc, append_dev_id);
2803                 if (ret < 0)
2804                         goto err_stop;
2805
2806                 /* Open the device to receive reports with battery info */
2807                 ret = hid_hw_open(hdev);
2808                 if (ret < 0) {
2809                         hid_err(hdev, "hw open failed\n");
2810                         goto err_stop;
2811                 }
2812         }
2813
2814         if (sc->quirks & SONY_FF_SUPPORT) {
2815                 ret = sony_init_ff(sc);
2816                 if (ret < 0)
2817                         goto err_close;
2818         }
2819
2820         return 0;
2821 err_close:
2822         hid_hw_close(hdev);
2823 err_stop:
2824         /* Piggy back on the default ds4_bt_ poll_interval to determine
2825          * if we need to remove the file as we don't know for sure if we
2826          * executed that logic.
2827          */
2828         if (sc->ds4_bt_poll_interval)
2829                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2830         if (sc->fw_version)
2831                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2832         if (sc->hw_version)
2833                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2834         sony_cancel_work_sync(sc);
2835         sony_remove_dev_list(sc);
2836         sony_release_device_id(sc);
2837         return ret;
2838 }
2839
2840 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2841 {
2842         int ret;
2843         unsigned long quirks = id->driver_data;
2844         struct sony_sc *sc;
2845         unsigned int connect_mask = HID_CONNECT_DEFAULT;
2846
2847         if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2848                 quirks |= FUTUREMAX_DANCE_MAT;
2849
2850         if (!strcmp(hdev->name, "SHANWAN PS3 GamePad"))
2851                 quirks |= SHANWAN_GAMEPAD;
2852
2853         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2854         if (sc == NULL) {
2855                 hid_err(hdev, "can't alloc sony descriptor\n");
2856                 return -ENOMEM;
2857         }
2858
2859         spin_lock_init(&sc->lock);
2860
2861         sc->quirks = quirks;
2862         hid_set_drvdata(hdev, sc);
2863         sc->hdev = hdev;
2864
2865         ret = hid_parse(hdev);
2866         if (ret) {
2867                 hid_err(hdev, "parse failed\n");
2868                 return ret;
2869         }
2870
2871         if (sc->quirks & VAIO_RDESC_CONSTANT)
2872                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2873         else if (sc->quirks & SIXAXIS_CONTROLLER)
2874                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2875
2876         /* Patch the hw version on DS3/4 compatible devices, so applications can
2877          * distinguish between the default HID mappings and the mappings defined
2878          * by the Linux game controller spec. This is important for the SDL2
2879          * library, which has a game controller database, which uses device ids
2880          * in combination with version as a key.
2881          */
2882         if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
2883                 hdev->version |= 0x8000;
2884
2885         ret = hid_hw_start(hdev, connect_mask);
2886         if (ret) {
2887                 hid_err(hdev, "hw start failed\n");
2888                 return ret;
2889         }
2890
2891         /* sony_input_configured can fail, but this doesn't result
2892          * in hid_hw_start failures (intended). Check whether
2893          * the HID layer claimed the device else fail.
2894          * We don't know the actual reason for the failure, most
2895          * likely it is due to EEXIST in case of double connection
2896          * of USB and Bluetooth, but could have been due to ENOMEM
2897          * or other reasons as well.
2898          */
2899         if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2900                 hid_err(hdev, "failed to claim input\n");
2901                 hid_hw_stop(hdev);
2902                 return -ENODEV;
2903         }
2904
2905         return ret;
2906 }
2907
2908 static void sony_remove(struct hid_device *hdev)
2909 {
2910         struct sony_sc *sc = hid_get_drvdata(hdev);
2911
2912         hid_hw_close(hdev);
2913
2914         if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2915                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2916
2917         if (sc->fw_version)
2918                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2919
2920         if (sc->hw_version)
2921                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2922
2923         sony_cancel_work_sync(sc);
2924
2925         sony_remove_dev_list(sc);
2926
2927         sony_release_device_id(sc);
2928
2929         hid_hw_stop(hdev);
2930 }
2931
2932 #ifdef CONFIG_PM
2933
2934 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2935 {
2936 #ifdef CONFIG_SONY_FF
2937
2938         /* On suspend stop any running force-feedback events */
2939         if (SONY_FF_SUPPORT) {
2940                 struct sony_sc *sc = hid_get_drvdata(hdev);
2941
2942                 sc->left = sc->right = 0;
2943                 sony_send_output_report(sc);
2944         }
2945
2946 #endif
2947         return 0;
2948 }
2949
2950 static int sony_resume(struct hid_device *hdev)
2951 {
2952         struct sony_sc *sc = hid_get_drvdata(hdev);
2953
2954         /*
2955          * The Sixaxis and navigation controllers on USB need to be
2956          * reinitialized on resume or they won't behave properly.
2957          */
2958         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2959                 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2960                 sixaxis_set_operational_usb(sc->hdev);
2961                 sc->defer_initialization = 1;
2962         }
2963
2964         return 0;
2965 }
2966
2967 #endif
2968
2969 static const struct hid_device_id sony_devices[] = {
2970         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2971                 .driver_data = SIXAXIS_CONTROLLER_USB },
2972         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2973                 .driver_data = NAVIGATION_CONTROLLER_USB },
2974         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2975                 .driver_data = NAVIGATION_CONTROLLER_BT },
2976         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2977                 .driver_data = MOTION_CONTROLLER_USB },
2978         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2979                 .driver_data = MOTION_CONTROLLER_BT },
2980         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2981                 .driver_data = SIXAXIS_CONTROLLER_BT },
2982         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2983                 .driver_data = VAIO_RDESC_CONSTANT },
2984         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2985                 .driver_data = VAIO_RDESC_CONSTANT },
2986         /*
2987          * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2988          * Logitech joystick from the device descriptor.
2989          */
2990         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2991                 .driver_data = BUZZ_CONTROLLER },
2992         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2993                 .driver_data = BUZZ_CONTROLLER },
2994         /* PS3 BD Remote Control */
2995         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2996                 .driver_data = PS3REMOTE },
2997         /* Logitech Harmony Adapter for PS3 */
2998         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2999                 .driver_data = PS3REMOTE },
3000         /* SMK-Link PS3 BD Remote Control */
3001         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
3002                 .driver_data = PS3REMOTE },
3003         /* Sony Dualshock 4 controllers for PS4 */
3004         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3005                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3006         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3007                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3008         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3009                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3010         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3011                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3012         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
3013                 .driver_data = DUALSHOCK4_DONGLE },
3014         /* Nyko Core Controller for PS3 */
3015         { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
3016                 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
3017         /* SMK-Link NSG-MR5U Remote Control */
3018         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3019                 .driver_data = NSG_MR5U_REMOTE_BT },
3020         /* SMK-Link NSG-MR7U Remote Control */
3021         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3022                 .driver_data = NSG_MR7U_REMOTE_BT },
3023         { }
3024 };
3025 MODULE_DEVICE_TABLE(hid, sony_devices);
3026
3027 static struct hid_driver sony_driver = {
3028         .name             = "sony",
3029         .id_table         = sony_devices,
3030         .input_mapping    = sony_mapping,
3031         .input_configured = sony_input_configured,
3032         .probe            = sony_probe,
3033         .remove           = sony_remove,
3034         .report_fixup     = sony_report_fixup,
3035         .raw_event        = sony_raw_event,
3036
3037 #ifdef CONFIG_PM
3038         .suspend          = sony_suspend,
3039         .resume           = sony_resume,
3040         .reset_resume     = sony_resume,
3041 #endif
3042 };
3043
3044 static int __init sony_init(void)
3045 {
3046         dbg_hid("Sony:%s\n", __func__);
3047
3048         return hid_register_driver(&sony_driver);
3049 }
3050
3051 static void __exit sony_exit(void)
3052 {
3053         dbg_hid("Sony:%s\n", __func__);
3054
3055         hid_unregister_driver(&sony_driver);
3056         ida_destroy(&sony_device_id_allocator);
3057 }
3058 module_init(sony_init);
3059 module_exit(sony_exit);
3060
3061 MODULE_LICENSE("GPL");