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                 int retries;
1601
1602                 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1603                 if (!buf)
1604                         return -ENOMEM;
1605
1606                 /* We should normally receive the feature report data we asked
1607                  * for, but hidraw applications such as Steam can issue feature
1608                  * reports as well. In particular for Dongle reconnects, Steam
1609                  * and this function are competing resulting in often receiving
1610                  * data for a different HID report, so retry a few times.
1611                  */
1612                 for (retries = 0; retries < 3; retries++) {
1613                         ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1614                                                  DS4_FEATURE_REPORT_0x02_SIZE,
1615                                                  HID_FEATURE_REPORT,
1616                                                  HID_REQ_GET_REPORT);
1617                         if (ret < 0)
1618                                 goto err_stop;
1619
1620                         if (buf[0] != 0x02) {
1621                                 if (retries < 2) {
1622                                         hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1623                                         continue;
1624                                 } else {
1625                                         ret = -EILSEQ;
1626                                         goto err_stop;
1627                                 }
1628                         } else {
1629                                 break;
1630                         }
1631                 }
1632         } else {
1633                 u8 bthdr = 0xA3;
1634                 u32 crc;
1635                 u32 report_crc;
1636                 int retries;
1637
1638                 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1639                 if (!buf)
1640                         return -ENOMEM;
1641
1642                 for (retries = 0; retries < 3; retries++) {
1643                         ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1644                                                  DS4_FEATURE_REPORT_0x05_SIZE,
1645                                                  HID_FEATURE_REPORT,
1646                                                  HID_REQ_GET_REPORT);
1647                         if (ret < 0)
1648                                 goto err_stop;
1649
1650                         /* CRC check */
1651                         crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1652                         crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1653                         report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1654                         if (crc != report_crc) {
1655                                 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1656                                         report_crc, crc);
1657                                 if (retries < 2) {
1658                                         hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1659                                         continue;
1660                                 } else {
1661                                         ret = -EILSEQ;
1662                                         goto err_stop;
1663                                 }
1664                         } else {
1665                                 break;
1666                         }
1667                 }
1668         }
1669
1670         gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
1671         gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
1672         gyro_roll_bias   = get_unaligned_le16(&buf[5]);
1673         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1674                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1675                 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1676                 gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
1677                 gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
1678                 gyro_roll_plus   = get_unaligned_le16(&buf[15]);
1679                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1680         } else {
1681                 /* BT + Dongle */
1682                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1683                 gyro_yaw_plus    = get_unaligned_le16(&buf[9]);
1684                 gyro_roll_plus   = get_unaligned_le16(&buf[11]);
1685                 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1686                 gyro_yaw_minus   = get_unaligned_le16(&buf[15]);
1687                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1688         }
1689         gyro_speed_plus  = get_unaligned_le16(&buf[19]);
1690         gyro_speed_minus = get_unaligned_le16(&buf[21]);
1691         acc_x_plus       = get_unaligned_le16(&buf[23]);
1692         acc_x_minus      = get_unaligned_le16(&buf[25]);
1693         acc_y_plus       = get_unaligned_le16(&buf[27]);
1694         acc_y_minus      = get_unaligned_le16(&buf[29]);
1695         acc_z_plus       = get_unaligned_le16(&buf[31]);
1696         acc_z_minus      = get_unaligned_le16(&buf[33]);
1697
1698         /* Set gyroscope calibration and normalization parameters.
1699          * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1700          */
1701         speed_2x = (gyro_speed_plus + gyro_speed_minus);
1702         sc->ds4_calib_data[0].abs_code = ABS_RX;
1703         sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1704         sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1705         sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1706
1707         sc->ds4_calib_data[1].abs_code = ABS_RY;
1708         sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1709         sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1710         sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1711
1712         sc->ds4_calib_data[2].abs_code = ABS_RZ;
1713         sc->ds4_calib_data[2].bias = gyro_roll_bias;
1714         sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1715         sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1716
1717         /* Set accelerometer calibration and normalization parameters.
1718          * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1719          */
1720         range_2g = acc_x_plus - acc_x_minus;
1721         sc->ds4_calib_data[3].abs_code = ABS_X;
1722         sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1723         sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1724         sc->ds4_calib_data[3].sens_denom = range_2g;
1725
1726         range_2g = acc_y_plus - acc_y_minus;
1727         sc->ds4_calib_data[4].abs_code = ABS_Y;
1728         sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1729         sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1730         sc->ds4_calib_data[4].sens_denom = range_2g;
1731
1732         range_2g = acc_z_plus - acc_z_minus;
1733         sc->ds4_calib_data[5].abs_code = ABS_Z;
1734         sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1735         sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1736         sc->ds4_calib_data[5].sens_denom = range_2g;
1737
1738 err_stop:
1739         kfree(buf);
1740         return ret;
1741 }
1742
1743 static void dualshock4_calibration_work(struct work_struct *work)
1744 {
1745         struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1746         unsigned long flags;
1747         enum ds4_dongle_state dongle_state;
1748         int ret;
1749
1750         ret = dualshock4_get_calibration_data(sc);
1751         if (ret < 0) {
1752                 /* This call is very unlikely to fail for the dongle. When it
1753                  * fails we are probably in a very bad state, so mark the
1754                  * dongle as disabled. We will re-enable the dongle if a new
1755                  * DS4 hotplug is detect from sony_raw_event as any issues
1756                  * are likely resolved then (the dongle is quite stupid).
1757                  */
1758                 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1759                 dongle_state = DONGLE_DISABLED;
1760         } else {
1761                 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1762                 dongle_state = DONGLE_CONNECTED;
1763         }
1764
1765         spin_lock_irqsave(&sc->lock, flags);
1766         sc->ds4_dongle_state = dongle_state;
1767         spin_unlock_irqrestore(&sc->lock, flags);
1768 }
1769
1770 static int dualshock4_get_version_info(struct sony_sc *sc)
1771 {
1772         u8 *buf;
1773         int ret;
1774
1775         buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1776         if (!buf)
1777                 return -ENOMEM;
1778
1779         ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1780                                  DS4_FEATURE_REPORT_0xA3_SIZE,
1781                                  HID_FEATURE_REPORT,
1782                                  HID_REQ_GET_REPORT);
1783         if (ret < 0) {
1784                 kfree(buf);
1785                 return ret;
1786         }
1787
1788         sc->hw_version = get_unaligned_le16(&buf[35]);
1789         sc->fw_version = get_unaligned_le16(&buf[41]);
1790
1791         kfree(buf);
1792         return 0;
1793 }
1794
1795 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1796 {
1797         static const u8 sixaxis_leds[10][4] = {
1798                                 { 0x01, 0x00, 0x00, 0x00 },
1799                                 { 0x00, 0x01, 0x00, 0x00 },
1800                                 { 0x00, 0x00, 0x01, 0x00 },
1801                                 { 0x00, 0x00, 0x00, 0x01 },
1802                                 { 0x01, 0x00, 0x00, 0x01 },
1803                                 { 0x00, 0x01, 0x00, 0x01 },
1804                                 { 0x00, 0x00, 0x01, 0x01 },
1805                                 { 0x01, 0x00, 0x01, 0x01 },
1806                                 { 0x00, 0x01, 0x01, 0x01 },
1807                                 { 0x01, 0x01, 0x01, 0x01 }
1808         };
1809
1810         int id = sc->device_id;
1811
1812         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1813
1814         if (id < 0)
1815                 return;
1816
1817         id %= 10;
1818         memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1819 }
1820
1821 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1822 {
1823         /* The first 4 color/index entries match what the PS4 assigns */
1824         static const u8 color_code[7][3] = {
1825                         /* Blue   */    { 0x00, 0x00, 0x40 },
1826                         /* Red    */    { 0x40, 0x00, 0x00 },
1827                         /* Green  */    { 0x00, 0x40, 0x00 },
1828                         /* Pink   */    { 0x20, 0x00, 0x20 },
1829                         /* Orange */    { 0x02, 0x01, 0x00 },
1830                         /* Teal   */    { 0x00, 0x01, 0x01 },
1831                         /* White  */    { 0x01, 0x01, 0x01 }
1832         };
1833
1834         int id = sc->device_id;
1835
1836         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1837
1838         if (id < 0)
1839                 return;
1840
1841         id %= 7;
1842         memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1843 }
1844
1845 static void buzz_set_leds(struct sony_sc *sc)
1846 {
1847         struct hid_device *hdev = sc->hdev;
1848         struct list_head *report_list =
1849                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1850         struct hid_report *report = list_entry(report_list->next,
1851                 struct hid_report, list);
1852         s32 *value = report->field[0]->value;
1853
1854         BUILD_BUG_ON(MAX_LEDS < 4);
1855
1856         value[0] = 0x00;
1857         value[1] = sc->led_state[0] ? 0xff : 0x00;
1858         value[2] = sc->led_state[1] ? 0xff : 0x00;
1859         value[3] = sc->led_state[2] ? 0xff : 0x00;
1860         value[4] = sc->led_state[3] ? 0xff : 0x00;
1861         value[5] = 0x00;
1862         value[6] = 0x00;
1863         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1864 }
1865
1866 static void sony_set_leds(struct sony_sc *sc)
1867 {
1868         if (!(sc->quirks & BUZZ_CONTROLLER))
1869                 sony_schedule_work(sc, SONY_WORKER_STATE);
1870         else
1871                 buzz_set_leds(sc);
1872 }
1873
1874 static void sony_led_set_brightness(struct led_classdev *led,
1875                                     enum led_brightness value)
1876 {
1877         struct device *dev = led->dev->parent;
1878         struct hid_device *hdev = to_hid_device(dev);
1879         struct sony_sc *drv_data;
1880
1881         int n;
1882         int force_update;
1883
1884         drv_data = hid_get_drvdata(hdev);
1885         if (!drv_data) {
1886                 hid_err(hdev, "No device data\n");
1887                 return;
1888         }
1889
1890         /*
1891          * The Sixaxis on USB will override any LED settings sent to it
1892          * and keep flashing all of the LEDs until the PS button is pressed.
1893          * Updates, even if redundant, must be always be sent to the
1894          * controller to avoid having to toggle the state of an LED just to
1895          * stop the flashing later on.
1896          */
1897         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1898
1899         for (n = 0; n < drv_data->led_count; n++) {
1900                 if (led == drv_data->leds[n] && (force_update ||
1901                         (value != drv_data->led_state[n] ||
1902                         drv_data->led_delay_on[n] ||
1903                         drv_data->led_delay_off[n]))) {
1904
1905                         drv_data->led_state[n] = value;
1906
1907                         /* Setting the brightness stops the blinking */
1908                         drv_data->led_delay_on[n] = 0;
1909                         drv_data->led_delay_off[n] = 0;
1910
1911                         sony_set_leds(drv_data);
1912                         break;
1913                 }
1914         }
1915 }
1916
1917 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1918 {
1919         struct device *dev = led->dev->parent;
1920         struct hid_device *hdev = to_hid_device(dev);
1921         struct sony_sc *drv_data;
1922
1923         int n;
1924
1925         drv_data = hid_get_drvdata(hdev);
1926         if (!drv_data) {
1927                 hid_err(hdev, "No device data\n");
1928                 return LED_OFF;
1929         }
1930
1931         for (n = 0; n < drv_data->led_count; n++) {
1932                 if (led == drv_data->leds[n])
1933                         return drv_data->led_state[n];
1934         }
1935
1936         return LED_OFF;
1937 }
1938
1939 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1940                                 unsigned long *delay_off)
1941 {
1942         struct device *dev = led->dev->parent;
1943         struct hid_device *hdev = to_hid_device(dev);
1944         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1945         int n;
1946         u8 new_on, new_off;
1947
1948         if (!drv_data) {
1949                 hid_err(hdev, "No device data\n");
1950                 return -EINVAL;
1951         }
1952
1953         /* Max delay is 255 deciseconds or 2550 milliseconds */
1954         if (*delay_on > 2550)
1955                 *delay_on = 2550;
1956         if (*delay_off > 2550)
1957                 *delay_off = 2550;
1958
1959         /* Blink at 1 Hz if both values are zero */
1960         if (!*delay_on && !*delay_off)
1961                 *delay_on = *delay_off = 500;
1962
1963         new_on = *delay_on / 10;
1964         new_off = *delay_off / 10;
1965
1966         for (n = 0; n < drv_data->led_count; n++) {
1967                 if (led == drv_data->leds[n])
1968                         break;
1969         }
1970
1971         /* This LED is not registered on this device */
1972         if (n >= drv_data->led_count)
1973                 return -EINVAL;
1974
1975         /* Don't schedule work if the values didn't change */
1976         if (new_on != drv_data->led_delay_on[n] ||
1977                 new_off != drv_data->led_delay_off[n]) {
1978                 drv_data->led_delay_on[n] = new_on;
1979                 drv_data->led_delay_off[n] = new_off;
1980                 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1981         }
1982
1983         return 0;
1984 }
1985
1986 static int sony_leds_init(struct sony_sc *sc)
1987 {
1988         struct hid_device *hdev = sc->hdev;
1989         int n, ret = 0;
1990         int use_ds4_names;
1991         struct led_classdev *led;
1992         size_t name_sz;
1993         char *name;
1994         size_t name_len;
1995         const char *name_fmt;
1996         static const char * const ds4_name_str[] = { "red", "green", "blue",
1997                                                   "global" };
1998         u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1999         u8 use_hw_blink[MAX_LEDS] = { 0 };
2000
2001         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
2002
2003         if (sc->quirks & BUZZ_CONTROLLER) {
2004                 sc->led_count = 4;
2005                 use_ds4_names = 0;
2006                 name_len = strlen("::buzz#");
2007                 name_fmt = "%s::buzz%d";
2008                 /* Validate expected report characteristics. */
2009                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
2010                         return -ENODEV;
2011         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2012                 dualshock4_set_leds_from_id(sc);
2013                 sc->led_state[3] = 1;
2014                 sc->led_count = 4;
2015                 memset(max_brightness, 255, 3);
2016                 use_hw_blink[3] = 1;
2017                 use_ds4_names = 1;
2018                 name_len = 0;
2019                 name_fmt = "%s:%s";
2020         } else if (sc->quirks & MOTION_CONTROLLER) {
2021                 sc->led_count = 3;
2022                 memset(max_brightness, 255, 3);
2023                 use_ds4_names = 1;
2024                 name_len = 0;
2025                 name_fmt = "%s:%s";
2026         } else if (sc->quirks & NAVIGATION_CONTROLLER) {
2027                 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
2028
2029                 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2030                 sc->led_count = 1;
2031                 memset(use_hw_blink, 1, 4);
2032                 use_ds4_names = 0;
2033                 name_len = strlen("::sony#");
2034                 name_fmt = "%s::sony%d";
2035         } else {
2036                 sixaxis_set_leds_from_id(sc);
2037                 sc->led_count = 4;
2038                 memset(use_hw_blink, 1, 4);
2039                 use_ds4_names = 0;
2040                 name_len = strlen("::sony#");
2041                 name_fmt = "%s::sony%d";
2042         }
2043
2044         /*
2045          * Clear LEDs as we have no way of reading their initial state. This is
2046          * only relevant if the driver is loaded after somebody actively set the
2047          * LEDs to on
2048          */
2049         sony_set_leds(sc);
2050
2051         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2052
2053         for (n = 0; n < sc->led_count; n++) {
2054
2055                 if (use_ds4_names)
2056                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2057
2058                 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2059                 if (!led) {
2060                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2061                         return -ENOMEM;
2062                 }
2063
2064                 name = (void *)(&led[1]);
2065                 if (use_ds4_names)
2066                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2067                         ds4_name_str[n]);
2068                 else
2069                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2070                 led->name = name;
2071                 led->brightness = sc->led_state[n];
2072                 led->max_brightness = max_brightness[n];
2073                 led->flags = LED_CORE_SUSPENDRESUME;
2074                 led->brightness_get = sony_led_get_brightness;
2075                 led->brightness_set = sony_led_set_brightness;
2076
2077                 if (use_hw_blink[n])
2078                         led->blink_set = sony_led_blink_set;
2079
2080                 sc->leds[n] = led;
2081
2082                 ret = devm_led_classdev_register(&hdev->dev, led);
2083                 if (ret) {
2084                         hid_err(hdev, "Failed to register LED %d\n", n);
2085                         return ret;
2086                 }
2087         }
2088
2089         return 0;
2090 }
2091
2092 static void sixaxis_send_output_report(struct sony_sc *sc)
2093 {
2094         static const union sixaxis_output_report_01 default_report = {
2095                 .buf = {
2096                         0x01,
2097                         0x01, 0xff, 0x00, 0xff, 0x00,
2098                         0x00, 0x00, 0x00, 0x00, 0x00,
2099                         0xff, 0x27, 0x10, 0x00, 0x32,
2100                         0xff, 0x27, 0x10, 0x00, 0x32,
2101                         0xff, 0x27, 0x10, 0x00, 0x32,
2102                         0xff, 0x27, 0x10, 0x00, 0x32,
2103                         0x00, 0x00, 0x00, 0x00, 0x00
2104                 }
2105         };
2106         struct sixaxis_output_report *report =
2107                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2108         int n;
2109
2110         /* Initialize the report with default values */
2111         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2112
2113 #ifdef CONFIG_SONY_FF
2114         report->rumble.right_motor_on = sc->right ? 1 : 0;
2115         report->rumble.left_motor_force = sc->left;
2116 #endif
2117
2118         report->leds_bitmap |= sc->led_state[0] << 1;
2119         report->leds_bitmap |= sc->led_state[1] << 2;
2120         report->leds_bitmap |= sc->led_state[2] << 3;
2121         report->leds_bitmap |= sc->led_state[3] << 4;
2122
2123         /* Set flag for all leds off, required for 3rd party INTEC controller */
2124         if ((report->leds_bitmap & 0x1E) == 0)
2125                 report->leds_bitmap |= 0x20;
2126
2127         /*
2128          * The LEDs in the report are indexed in reverse order to their
2129          * corresponding light on the controller.
2130          * Index 0 = LED 4, index 1 = LED 3, etc...
2131          *
2132          * In the case of both delay values being zero (blinking disabled) the
2133          * default report values should be used or the controller LED will be
2134          * always off.
2135          */
2136         for (n = 0; n < 4; n++) {
2137                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2138                         report->led[3 - n].duty_off = sc->led_delay_off[n];
2139                         report->led[3 - n].duty_on = sc->led_delay_on[n];
2140                 }
2141         }
2142
2143         /* SHANWAN controllers require output reports via intr channel */
2144         if (sc->quirks & SHANWAN_GAMEPAD)
2145                 hid_hw_output_report(sc->hdev, (u8 *)report,
2146                                 sizeof(struct sixaxis_output_report));
2147         else
2148                 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2149                                 sizeof(struct sixaxis_output_report),
2150                                 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2151 }
2152
2153 static void dualshock4_send_output_report(struct sony_sc *sc)
2154 {
2155         struct hid_device *hdev = sc->hdev;
2156         u8 *buf = sc->output_report_dmabuf;
2157         int offset;
2158
2159         /*
2160          * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2161          * control the interval at which Dualshock 4 reports data:
2162          * 0x00 - 1ms
2163          * 0x01 - 1ms
2164          * 0x02 - 2ms
2165          * 0x3E - 62ms
2166          * 0x3F - disabled
2167          */
2168         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2169                 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2170                 buf[0] = 0x05;
2171                 buf[1] = 0x07; /* blink + LEDs + motor */
2172                 offset = 4;
2173         } else {
2174                 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2175                 buf[0] = 0x11;
2176                 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2177                 buf[3] = 0x07; /* blink + LEDs + motor */
2178                 offset = 6;
2179         }
2180
2181 #ifdef CONFIG_SONY_FF
2182         buf[offset++] = sc->right;
2183         buf[offset++] = sc->left;
2184 #else
2185         offset += 2;
2186 #endif
2187
2188         /* LED 3 is the global control */
2189         if (sc->led_state[3]) {
2190                 buf[offset++] = sc->led_state[0];
2191                 buf[offset++] = sc->led_state[1];
2192                 buf[offset++] = sc->led_state[2];
2193         } else {
2194                 offset += 3;
2195         }
2196
2197         /* If both delay values are zero the DualShock 4 disables blinking. */
2198         buf[offset++] = sc->led_delay_on[3];
2199         buf[offset++] = sc->led_delay_off[3];
2200
2201         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2202                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2203         else {
2204                 /* CRC generation */
2205                 u8 bthdr = 0xA2;
2206                 u32 crc;
2207
2208                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2209                 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2210                 put_unaligned_le32(crc, &buf[74]);
2211                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2212         }
2213 }
2214
2215 static void motion_send_output_report(struct sony_sc *sc)
2216 {
2217         struct hid_device *hdev = sc->hdev;
2218         struct motion_output_report_02 *report =
2219                 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2220
2221         memset(report, 0, MOTION_REPORT_0x02_SIZE);
2222
2223         report->type = 0x02; /* set leds */
2224         report->r = sc->led_state[0];
2225         report->g = sc->led_state[1];
2226         report->b = sc->led_state[2];
2227
2228 #ifdef CONFIG_SONY_FF
2229         report->rumble = max(sc->right, sc->left);
2230 #endif
2231
2232         hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2233 }
2234
2235 static inline void sony_send_output_report(struct sony_sc *sc)
2236 {
2237         if (sc->send_output_report)
2238                 sc->send_output_report(sc);
2239 }
2240
2241 static void sony_state_worker(struct work_struct *work)
2242 {
2243         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2244
2245         sc->send_output_report(sc);
2246 }
2247
2248 static int sony_allocate_output_report(struct sony_sc *sc)
2249 {
2250         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2251                         (sc->quirks & NAVIGATION_CONTROLLER))
2252                 sc->output_report_dmabuf =
2253                         devm_kmalloc(&sc->hdev->dev,
2254                                 sizeof(union sixaxis_output_report_01),
2255                                 GFP_KERNEL);
2256         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2257                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2258                                                 DS4_OUTPUT_REPORT_0x11_SIZE,
2259                                                 GFP_KERNEL);
2260         else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2261                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2262                                                 DS4_OUTPUT_REPORT_0x05_SIZE,
2263                                                 GFP_KERNEL);
2264         else if (sc->quirks & MOTION_CONTROLLER)
2265                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2266                                                 MOTION_REPORT_0x02_SIZE,
2267                                                 GFP_KERNEL);
2268         else
2269                 return 0;
2270
2271         if (!sc->output_report_dmabuf)
2272                 return -ENOMEM;
2273
2274         return 0;
2275 }
2276
2277 #ifdef CONFIG_SONY_FF
2278 static int sony_play_effect(struct input_dev *dev, void *data,
2279                             struct ff_effect *effect)
2280 {
2281         struct hid_device *hid = input_get_drvdata(dev);
2282         struct sony_sc *sc = hid_get_drvdata(hid);
2283
2284         if (effect->type != FF_RUMBLE)
2285                 return 0;
2286
2287         sc->left = effect->u.rumble.strong_magnitude / 256;
2288         sc->right = effect->u.rumble.weak_magnitude / 256;
2289
2290         sony_schedule_work(sc, SONY_WORKER_STATE);
2291         return 0;
2292 }
2293
2294 static int sony_init_ff(struct sony_sc *sc)
2295 {
2296         struct hid_input *hidinput;
2297         struct input_dev *input_dev;
2298
2299         if (list_empty(&sc->hdev->inputs)) {
2300                 hid_err(sc->hdev, "no inputs found\n");
2301                 return -ENODEV;
2302         }
2303         hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2304         input_dev = hidinput->input;
2305
2306         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2307         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2308 }
2309
2310 #else
2311 static int sony_init_ff(struct sony_sc *sc)
2312 {
2313         return 0;
2314 }
2315
2316 #endif
2317
2318 static int sony_battery_get_property(struct power_supply *psy,
2319                                      enum power_supply_property psp,
2320                                      union power_supply_propval *val)
2321 {
2322         struct sony_sc *sc = power_supply_get_drvdata(psy);
2323         unsigned long flags;
2324         int ret = 0;
2325         u8 battery_charging, battery_capacity, cable_state;
2326
2327         spin_lock_irqsave(&sc->lock, flags);
2328         battery_charging = sc->battery_charging;
2329         battery_capacity = sc->battery_capacity;
2330         cable_state = sc->cable_state;
2331         spin_unlock_irqrestore(&sc->lock, flags);
2332
2333         switch (psp) {
2334         case POWER_SUPPLY_PROP_PRESENT:
2335                 val->intval = 1;
2336                 break;
2337         case POWER_SUPPLY_PROP_SCOPE:
2338                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2339                 break;
2340         case POWER_SUPPLY_PROP_CAPACITY:
2341                 val->intval = battery_capacity;
2342                 break;
2343         case POWER_SUPPLY_PROP_STATUS:
2344                 if (battery_charging)
2345                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
2346                 else
2347                         if (battery_capacity == 100 && cable_state)
2348                                 val->intval = POWER_SUPPLY_STATUS_FULL;
2349                         else
2350                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2351                 break;
2352         default:
2353                 ret = -EINVAL;
2354                 break;
2355         }
2356         return ret;
2357 }
2358
2359 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2360 {
2361         const char *battery_str_fmt = append_dev_id ?
2362                 "sony_controller_battery_%pMR_%i" :
2363                 "sony_controller_battery_%pMR";
2364         struct power_supply_config psy_cfg = { .drv_data = sc, };
2365         struct hid_device *hdev = sc->hdev;
2366         int ret;
2367
2368         /*
2369          * Set the default battery level to 100% to avoid low battery warnings
2370          * if the battery is polled before the first device report is received.
2371          */
2372         sc->battery_capacity = 100;
2373
2374         sc->battery_desc.properties = sony_battery_props;
2375         sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2376         sc->battery_desc.get_property = sony_battery_get_property;
2377         sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2378         sc->battery_desc.use_for_apm = 0;
2379         sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2380                                           battery_str_fmt, sc->mac_address, sc->device_id);
2381         if (!sc->battery_desc.name)
2382                 return -ENOMEM;
2383
2384         sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2385                                             &psy_cfg);
2386         if (IS_ERR(sc->battery)) {
2387                 ret = PTR_ERR(sc->battery);
2388                 hid_err(hdev, "Unable to register battery device\n");
2389                 return ret;
2390         }
2391
2392         power_supply_powers(sc->battery, &hdev->dev);
2393         return 0;
2394 }
2395
2396 /*
2397  * If a controller is plugged in via USB while already connected via Bluetooth
2398  * it will show up as two devices. A global list of connected controllers and
2399  * their MAC addresses is maintained to ensure that a device is only connected
2400  * once.
2401  *
2402  * Some USB-only devices masquerade as Sixaxis controllers and all have the
2403  * same dummy Bluetooth address, so a comparison of the connection type is
2404  * required.  Devices are only rejected in the case where two devices have
2405  * matching Bluetooth addresses on different bus types.
2406  */
2407 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2408                                                 struct sony_sc *sc1)
2409 {
2410         const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2411         const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2412
2413         return sc0_not_bt == sc1_not_bt;
2414 }
2415
2416 static int sony_check_add_dev_list(struct sony_sc *sc)
2417 {
2418         struct sony_sc *entry;
2419         unsigned long flags;
2420         int ret;
2421
2422         spin_lock_irqsave(&sony_dev_list_lock, flags);
2423
2424         list_for_each_entry(entry, &sony_device_list, list_node) {
2425                 ret = memcmp(sc->mac_address, entry->mac_address,
2426                                 sizeof(sc->mac_address));
2427                 if (!ret) {
2428                         if (sony_compare_connection_type(sc, entry)) {
2429                                 ret = 1;
2430                         } else {
2431                                 ret = -EEXIST;
2432                                 hid_info(sc->hdev,
2433                                 "controller with MAC address %pMR already connected\n",
2434                                 sc->mac_address);
2435                         }
2436                         goto unlock;
2437                 }
2438         }
2439
2440         ret = 0;
2441         list_add(&(sc->list_node), &sony_device_list);
2442
2443 unlock:
2444         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2445         return ret;
2446 }
2447
2448 static void sony_remove_dev_list(struct sony_sc *sc)
2449 {
2450         unsigned long flags;
2451
2452         if (sc->list_node.next) {
2453                 spin_lock_irqsave(&sony_dev_list_lock, flags);
2454                 list_del(&(sc->list_node));
2455                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2456         }
2457 }
2458
2459 static int sony_get_bt_devaddr(struct sony_sc *sc)
2460 {
2461         int ret;
2462
2463         /* HIDP stores the device MAC address as a string in the uniq field. */
2464         ret = strlen(sc->hdev->uniq);
2465         if (ret != 17)
2466                 return -EINVAL;
2467
2468         ret = sscanf(sc->hdev->uniq,
2469                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2470                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2471                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2472
2473         if (ret != 6)
2474                 return -EINVAL;
2475
2476         return 0;
2477 }
2478
2479 static int sony_check_add(struct sony_sc *sc)
2480 {
2481         u8 *buf = NULL;
2482         int n, ret;
2483
2484         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2485             (sc->quirks & MOTION_CONTROLLER_BT) ||
2486             (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2487             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2488                 /*
2489                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2490                  * address from the uniq string where HIDP stores it.
2491                  * As uniq cannot be guaranteed to be a MAC address in all cases
2492                  * a failure of this function should not prevent the connection.
2493                  */
2494                 if (sony_get_bt_devaddr(sc) < 0) {
2495                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2496                         return 0;
2497                 }
2498         } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2499                 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2500                 if (!buf)
2501                         return -ENOMEM;
2502
2503                 /*
2504                  * The MAC address of a DS4 controller connected via USB can be
2505                  * retrieved with feature report 0x81. The address begins at
2506                  * offset 1.
2507                  */
2508                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2509                                 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2510                                 HID_REQ_GET_REPORT);
2511
2512                 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2513                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2514                         ret = ret < 0 ? ret : -EINVAL;
2515                         goto out_free;
2516                 }
2517
2518                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2519
2520                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2521                          "%pMR", sc->mac_address);
2522         } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2523                         (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2524                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2525                 if (!buf)
2526                         return -ENOMEM;
2527
2528                 /*
2529                  * The MAC address of a Sixaxis controller connected via USB can
2530                  * be retrieved with feature report 0xf2. The address begins at
2531                  * offset 4.
2532                  */
2533                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2534                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2535                                 HID_REQ_GET_REPORT);
2536
2537                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2538                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2539                         ret = ret < 0 ? ret : -EINVAL;
2540                         goto out_free;
2541                 }
2542
2543                 /*
2544                  * The Sixaxis device MAC in the report is big-endian and must
2545                  * be byte-swapped.
2546                  */
2547                 for (n = 0; n < 6; n++)
2548                         sc->mac_address[5-n] = buf[4+n];
2549
2550                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2551                          "%pMR", sc->mac_address);
2552         } else {
2553                 return 0;
2554         }
2555
2556         ret = sony_check_add_dev_list(sc);
2557
2558 out_free:
2559
2560         kfree(buf);
2561
2562         return ret;
2563 }
2564
2565 static int sony_set_device_id(struct sony_sc *sc)
2566 {
2567         int ret;
2568
2569         /*
2570          * Only DualShock 4 or Sixaxis controllers get an id.
2571          * All others are set to -1.
2572          */
2573         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2574             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2575                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2576                                         GFP_KERNEL);
2577                 if (ret < 0) {
2578                         sc->device_id = -1;
2579                         return ret;
2580                 }
2581                 sc->device_id = ret;
2582         } else {
2583                 sc->device_id = -1;
2584         }
2585
2586         return 0;
2587 }
2588
2589 static void sony_release_device_id(struct sony_sc *sc)
2590 {
2591         if (sc->device_id >= 0) {
2592                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2593                 sc->device_id = -1;
2594         }
2595 }
2596
2597 static inline void sony_init_output_report(struct sony_sc *sc,
2598                                 void (*send_output_report)(struct sony_sc *))
2599 {
2600         sc->send_output_report = send_output_report;
2601
2602         if (!sc->state_worker_initialized)
2603                 INIT_WORK(&sc->state_worker, sony_state_worker);
2604
2605         sc->state_worker_initialized = 1;
2606 }
2607
2608 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2609 {
2610         unsigned long flags;
2611
2612         if (sc->hotplug_worker_initialized)
2613                 cancel_work_sync(&sc->hotplug_worker);
2614         if (sc->state_worker_initialized) {
2615                 spin_lock_irqsave(&sc->lock, flags);
2616                 sc->state_worker_initialized = 0;
2617                 spin_unlock_irqrestore(&sc->lock, flags);
2618                 cancel_work_sync(&sc->state_worker);
2619         }
2620 }
2621
2622 static int sony_input_configured(struct hid_device *hdev,
2623                                         struct hid_input *hidinput)
2624 {
2625         struct sony_sc *sc = hid_get_drvdata(hdev);
2626         int append_dev_id;
2627         int ret;
2628
2629         ret = sony_set_device_id(sc);
2630         if (ret < 0) {
2631                 hid_err(hdev, "failed to allocate the device id\n");
2632                 goto err_stop;
2633         }
2634
2635         ret = append_dev_id = sony_check_add(sc);
2636         if (ret < 0)
2637                 goto err_stop;
2638
2639         ret = sony_allocate_output_report(sc);
2640         if (ret < 0) {
2641                 hid_err(hdev, "failed to allocate the output report buffer\n");
2642                 goto err_stop;
2643         }
2644
2645         if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2646                 /*
2647                  * The Sony Sixaxis does not handle HID Output Reports on the
2648                  * Interrupt EP like it could, so we need to force HID Output
2649                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
2650                  *
2651                  * There is also another issue about HID Output Reports via USB,
2652                  * the Sixaxis does not want the report_id as part of the data
2653                  * packet, so we have to discard buf[0] when sending the actual
2654                  * control message, even for numbered reports, humpf!
2655                  *
2656                  * Additionally, the Sixaxis on USB isn't properly initialized
2657                  * until the PS logo button is pressed and as such won't retain
2658                  * any state set by an output report, so the initial
2659                  * configuration report is deferred until the first input
2660                  * report arrives.
2661                  */
2662                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2663                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2664                 sc->defer_initialization = 1;
2665
2666                 ret = sixaxis_set_operational_usb(hdev);
2667                 if (ret < 0) {
2668                         hid_err(hdev, "Failed to set controller into operational mode\n");
2669                         goto err_stop;
2670                 }
2671
2672                 sony_init_output_report(sc, sixaxis_send_output_report);
2673         } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2674                 /*
2675                  * The Navigation controller wants output reports sent on the ctrl
2676                  * endpoint when connected via Bluetooth.
2677                  */
2678                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2679
2680                 ret = sixaxis_set_operational_bt(hdev);
2681                 if (ret < 0) {
2682                         hid_err(hdev, "Failed to set controller into operational mode\n");
2683                         goto err_stop;
2684                 }
2685
2686                 sony_init_output_report(sc, sixaxis_send_output_report);
2687         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2688                 /*
2689                  * The Sony Sixaxis does not handle HID Output Reports on the
2690                  * Interrupt EP and the device only becomes active when the
2691                  * PS button is pressed. See comment for Navigation controller
2692                  * above for more details.
2693                  */
2694                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2695                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2696                 sc->defer_initialization = 1;
2697
2698                 ret = sixaxis_set_operational_usb(hdev);
2699                 if (ret < 0) {
2700                         hid_err(hdev, "Failed to set controller into operational mode\n");
2701                         goto err_stop;
2702                 }
2703
2704                 ret = sony_register_sensors(sc);
2705                 if (ret) {
2706                         hid_err(sc->hdev,
2707                         "Unable to initialize motion sensors: %d\n", ret);
2708                         goto err_stop;
2709                 }
2710
2711                 sony_init_output_report(sc, sixaxis_send_output_report);
2712         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2713                 /*
2714                  * The Sixaxis wants output reports sent on the ctrl endpoint
2715                  * when connected via Bluetooth.
2716                  */
2717                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2718
2719                 ret = sixaxis_set_operational_bt(hdev);
2720                 if (ret < 0) {
2721                         hid_err(hdev, "Failed to set controller into operational mode\n");
2722                         goto err_stop;
2723                 }
2724
2725                 ret = sony_register_sensors(sc);
2726                 if (ret) {
2727                         hid_err(sc->hdev,
2728                         "Unable to initialize motion sensors: %d\n", ret);
2729                         goto err_stop;
2730                 }
2731
2732                 sony_init_output_report(sc, sixaxis_send_output_report);
2733         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2734                 ret = dualshock4_get_calibration_data(sc);
2735                 if (ret < 0) {
2736                         hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2737                         goto err_stop;
2738                 }
2739
2740                 ret = dualshock4_get_version_info(sc);
2741                 if (ret < 0) {
2742                         hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2743                         goto err_stop;
2744                 }
2745
2746                 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2747                 if (ret) {
2748                         /* Make zero for cleanup reasons of sysfs entries. */
2749                         sc->fw_version = 0;
2750                         sc->hw_version = 0;
2751                         hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2752                         goto err_stop;
2753                 }
2754
2755                 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2756                 if (ret) {
2757                         sc->hw_version = 0;
2758                         hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2759                         goto err_stop;
2760                 }
2761
2762                 /*
2763                  * The Dualshock 4 touchpad supports 2 touches and has a
2764                  * resolution of 1920x942 (44.86 dots/mm).
2765                  */
2766                 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2767                 if (ret) {
2768                         hid_err(sc->hdev,
2769                         "Unable to initialize multi-touch slots: %d\n",
2770                         ret);
2771                         goto err_stop;
2772                 }
2773
2774                 ret = sony_register_sensors(sc);
2775                 if (ret) {
2776                         hid_err(sc->hdev,
2777                         "Unable to initialize motion sensors: %d\n", ret);
2778                         goto err_stop;
2779                 }
2780
2781                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2782                         sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2783                         ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2784                         if (ret)
2785                                 hid_warn(sc->hdev,
2786                                  "can't create sysfs bt_poll_interval attribute err: %d\n",
2787                                  ret);
2788                 }
2789
2790                 if (sc->quirks & DUALSHOCK4_DONGLE) {
2791                         INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2792                         sc->hotplug_worker_initialized = 1;
2793                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2794                 }
2795
2796                 sony_init_output_report(sc, dualshock4_send_output_report);
2797         } else if (sc->quirks & NSG_MRXU_REMOTE) {
2798                 /*
2799                  * The NSG-MRxU touchpad supports 2 touches and has a
2800                  * resolution of 1667x1868
2801                  */
2802                 ret = sony_register_touchpad(sc, 2,
2803                         NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2804                 if (ret) {
2805                         hid_err(sc->hdev,
2806                         "Unable to initialize multi-touch slots: %d\n",
2807                         ret);
2808                         goto err_stop;
2809                 }
2810
2811         } else if (sc->quirks & MOTION_CONTROLLER) {
2812                 sony_init_output_report(sc, motion_send_output_report);
2813         } else {
2814                 ret = 0;
2815         }
2816
2817         if (sc->quirks & SONY_LED_SUPPORT) {
2818                 ret = sony_leds_init(sc);
2819                 if (ret < 0)
2820                         goto err_stop;
2821         }
2822
2823         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2824                 ret = sony_battery_probe(sc, append_dev_id);
2825                 if (ret < 0)
2826                         goto err_stop;
2827
2828                 /* Open the device to receive reports with battery info */
2829                 ret = hid_hw_open(hdev);
2830                 if (ret < 0) {
2831                         hid_err(hdev, "hw open failed\n");
2832                         goto err_stop;
2833                 }
2834         }
2835
2836         if (sc->quirks & SONY_FF_SUPPORT) {
2837                 ret = sony_init_ff(sc);
2838                 if (ret < 0)
2839                         goto err_close;
2840         }
2841
2842         return 0;
2843 err_close:
2844         hid_hw_close(hdev);
2845 err_stop:
2846         /* Piggy back on the default ds4_bt_ poll_interval to determine
2847          * if we need to remove the file as we don't know for sure if we
2848          * executed that logic.
2849          */
2850         if (sc->ds4_bt_poll_interval)
2851                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2852         if (sc->fw_version)
2853                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2854         if (sc->hw_version)
2855                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2856         sony_cancel_work_sync(sc);
2857         sony_remove_dev_list(sc);
2858         sony_release_device_id(sc);
2859         return ret;
2860 }
2861
2862 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2863 {
2864         int ret;
2865         unsigned long quirks = id->driver_data;
2866         struct sony_sc *sc;
2867         unsigned int connect_mask = HID_CONNECT_DEFAULT;
2868
2869         if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2870                 quirks |= FUTUREMAX_DANCE_MAT;
2871
2872         if (!strcmp(hdev->name, "SHANWAN PS3 GamePad"))
2873                 quirks |= SHANWAN_GAMEPAD;
2874
2875         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2876         if (sc == NULL) {
2877                 hid_err(hdev, "can't alloc sony descriptor\n");
2878                 return -ENOMEM;
2879         }
2880
2881         spin_lock_init(&sc->lock);
2882
2883         sc->quirks = quirks;
2884         hid_set_drvdata(hdev, sc);
2885         sc->hdev = hdev;
2886
2887         ret = hid_parse(hdev);
2888         if (ret) {
2889                 hid_err(hdev, "parse failed\n");
2890                 return ret;
2891         }
2892
2893         if (sc->quirks & VAIO_RDESC_CONSTANT)
2894                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2895         else if (sc->quirks & SIXAXIS_CONTROLLER)
2896                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2897
2898         /* Patch the hw version on DS3/4 compatible devices, so applications can
2899          * distinguish between the default HID mappings and the mappings defined
2900          * by the Linux game controller spec. This is important for the SDL2
2901          * library, which has a game controller database, which uses device ids
2902          * in combination with version as a key.
2903          */
2904         if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
2905                 hdev->version |= 0x8000;
2906
2907         ret = hid_hw_start(hdev, connect_mask);
2908         if (ret) {
2909                 hid_err(hdev, "hw start failed\n");
2910                 return ret;
2911         }
2912
2913         /* sony_input_configured can fail, but this doesn't result
2914          * in hid_hw_start failures (intended). Check whether
2915          * the HID layer claimed the device else fail.
2916          * We don't know the actual reason for the failure, most
2917          * likely it is due to EEXIST in case of double connection
2918          * of USB and Bluetooth, but could have been due to ENOMEM
2919          * or other reasons as well.
2920          */
2921         if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2922                 hid_err(hdev, "failed to claim input\n");
2923                 hid_hw_stop(hdev);
2924                 return -ENODEV;
2925         }
2926
2927         return ret;
2928 }
2929
2930 static void sony_remove(struct hid_device *hdev)
2931 {
2932         struct sony_sc *sc = hid_get_drvdata(hdev);
2933
2934         hid_hw_close(hdev);
2935
2936         if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2937                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2938
2939         if (sc->fw_version)
2940                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2941
2942         if (sc->hw_version)
2943                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2944
2945         sony_cancel_work_sync(sc);
2946
2947         sony_remove_dev_list(sc);
2948
2949         sony_release_device_id(sc);
2950
2951         hid_hw_stop(hdev);
2952 }
2953
2954 #ifdef CONFIG_PM
2955
2956 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2957 {
2958 #ifdef CONFIG_SONY_FF
2959
2960         /* On suspend stop any running force-feedback events */
2961         if (SONY_FF_SUPPORT) {
2962                 struct sony_sc *sc = hid_get_drvdata(hdev);
2963
2964                 sc->left = sc->right = 0;
2965                 sony_send_output_report(sc);
2966         }
2967
2968 #endif
2969         return 0;
2970 }
2971
2972 static int sony_resume(struct hid_device *hdev)
2973 {
2974         struct sony_sc *sc = hid_get_drvdata(hdev);
2975
2976         /*
2977          * The Sixaxis and navigation controllers on USB need to be
2978          * reinitialized on resume or they won't behave properly.
2979          */
2980         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2981                 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2982                 sixaxis_set_operational_usb(sc->hdev);
2983                 sc->defer_initialization = 1;
2984         }
2985
2986         return 0;
2987 }
2988
2989 #endif
2990
2991 static const struct hid_device_id sony_devices[] = {
2992         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2993                 .driver_data = SIXAXIS_CONTROLLER_USB },
2994         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2995                 .driver_data = NAVIGATION_CONTROLLER_USB },
2996         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2997                 .driver_data = NAVIGATION_CONTROLLER_BT },
2998         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2999                 .driver_data = MOTION_CONTROLLER_USB },
3000         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
3001                 .driver_data = MOTION_CONTROLLER_BT },
3002         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3003                 .driver_data = SIXAXIS_CONTROLLER_BT },
3004         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
3005                 .driver_data = VAIO_RDESC_CONSTANT },
3006         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
3007                 .driver_data = VAIO_RDESC_CONSTANT },
3008         /*
3009          * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
3010          * Logitech joystick from the device descriptor.
3011          */
3012         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
3013                 .driver_data = BUZZ_CONTROLLER },
3014         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
3015                 .driver_data = BUZZ_CONTROLLER },
3016         /* PS3 BD Remote Control */
3017         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
3018                 .driver_data = PS3REMOTE },
3019         /* Logitech Harmony Adapter for PS3 */
3020         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
3021                 .driver_data = PS3REMOTE },
3022         /* SMK-Link PS3 BD Remote Control */
3023         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
3024                 .driver_data = PS3REMOTE },
3025         /* Sony Dualshock 4 controllers for PS4 */
3026         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3027                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3028         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3029                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3030         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3031                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3032         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3033                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3034         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
3035                 .driver_data = DUALSHOCK4_DONGLE },
3036         /* Nyko Core Controller for PS3 */
3037         { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
3038                 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
3039         /* SMK-Link NSG-MR5U Remote Control */
3040         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3041                 .driver_data = NSG_MR5U_REMOTE_BT },
3042         /* SMK-Link NSG-MR7U Remote Control */
3043         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3044                 .driver_data = NSG_MR7U_REMOTE_BT },
3045         { }
3046 };
3047 MODULE_DEVICE_TABLE(hid, sony_devices);
3048
3049 static struct hid_driver sony_driver = {
3050         .name             = "sony",
3051         .id_table         = sony_devices,
3052         .input_mapping    = sony_mapping,
3053         .input_configured = sony_input_configured,
3054         .probe            = sony_probe,
3055         .remove           = sony_remove,
3056         .report_fixup     = sony_report_fixup,
3057         .raw_event        = sony_raw_event,
3058
3059 #ifdef CONFIG_PM
3060         .suspend          = sony_suspend,
3061         .resume           = sony_resume,
3062         .reset_resume     = sony_resume,
3063 #endif
3064 };
3065
3066 static int __init sony_init(void)
3067 {
3068         dbg_hid("Sony:%s\n", __func__);
3069
3070         return hid_register_driver(&sony_driver);
3071 }
3072
3073 static void __exit sony_exit(void)
3074 {
3075         dbg_hid("Sony:%s\n", __func__);
3076
3077         hid_unregister_driver(&sony_driver);
3078         ida_destroy(&sony_device_id_allocator);
3079 }
3080 module_init(sony_init);
3081 module_exit(sony_exit);
3082
3083 MODULE_LICENSE("GPL");