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         return rdesc;
 871 }
 872
 873 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
 874 {
 875         static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
 876         unsigned long flags;
 877         int offset;
 878         u8 cable_state, battery_capacity, battery_charging;
 879
 880         /*
 881          * The sixaxis is charging if the battery value is 0xee
 882          * and it is fully charged if the value is 0xef.
 883          * It does not report the actual level while charging so it
 884          * is set to 100% while charging is in progress.
 885          */
 886         offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
 887
 888         if (rd[offset] >= 0xee) {
 889                 battery_capacity = 100;
 890                 battery_charging = !(rd[offset] & 0x01);
 891                 cable_state = 1;
 892         } else {
 893                 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
 894                 battery_capacity = sixaxis_battery_capacity[index];
 895                 battery_charging = 0;
 896                 cable_state = 0;
 897         }
 898
 899         spin_lock_irqsave(&sc->lock, flags);
 900         sc->cable_state = cable_state;
 901         sc->battery_capacity = battery_capacity;
 902         sc->battery_charging = battery_charging;
 903         spin_unlock_irqrestore(&sc->lock, flags);
 904
 905         if (sc->quirks & SIXAXIS_CONTROLLER) {
 906                 int val;
 907
 908                 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
 909                 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
 910                 input_report_abs(sc->sensor_dev, ABS_X, val);
 911
 912                 /* Y and Z are swapped and inversed */
 913                 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
 914                 input_report_abs(sc->sensor_dev, ABS_Y, val);
 915
 916                 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
 917                 input_report_abs(sc->sensor_dev, ABS_Z, val);
 918
 919                 input_sync(sc->sensor_dev);
 920         }
 921 }
 922
 923 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
 924 {
 925         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
 926                                                 struct hid_input, list);
 927         struct input_dev *input_dev = hidinput->input;
 928         unsigned long flags;
 929         int n, m, offset, num_touch_data, max_touch_data;
 930         u8 cable_state, battery_capacity, battery_charging;
 931         u16 timestamp;
 932
 933         /* When using Bluetooth the header is 2 bytes longer, so skip these. */
 934         int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
 935
 936         /* Second bit of third button byte is for the touchpad button. */
 937         offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
 938         input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
 939
 940         /*
 941          * The default behavior of the Dualshock 4 is to send reports using
 942          * report type 1 when running over Bluetooth. However, when feature
 943          * report 2 is requested during the controller initialization it starts
 944          * sending input reports in report 17. Since report 17 is undefined
 945          * in the default HID descriptor, the HID layer won't generate events.
 946          * While it is possible (and this was done before) to fixup the HID
 947          * descriptor to add this mapping, it was better to do this manually.
 948          * The reason is there were various pieces software both open and closed
 949          * source, relying on the descriptors to be the same across various
 950          * operating systems. If the descriptors wouldn't match some
 951          * applications e.g. games on Wine would not be able to function due
 952          * to different descriptors, which such applications are not parsing.
 953          */
 954         if (rd[0] == 17) {
 955                 int value;
 956
 957                 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
 958                 input_report_abs(input_dev, ABS_X, rd[offset]);
 959                 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
 960                 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
 961                 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
 962
 963                 value = rd[offset+4] & 0xf;
 964                 if (value > 7)
 965                         value = 8; /* Center 0, 0 */
 966                 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
 967                 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
 968
 969                 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
 970                 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
 971                 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
 972                 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
 973
 974                 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
 975                 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
 976                 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
 977                 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
 978                 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
 979                 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
 980                 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
 981                 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
 982
 983                 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
 984
 985                 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
 986                 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
 987
 988                 input_sync(input_dev);
 989         }
 990
 991         /* Convert timestamp (in 5.33us unit) to timestamp_us */
 992         offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
 993         timestamp = get_unaligned_le16(&rd[offset]);
 994         if (!sc->timestamp_initialized) {
 995                 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
 996                 sc->timestamp_initialized = true;
 997         } else {
 998                 u16 delta;
 999
1000                 if (sc->prev_timestamp > timestamp)
1001                         delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1002                 else
1003                         delta = timestamp - sc->prev_timestamp;
1004                 sc->timestamp_us += (delta * 16) / 3;
1005         }
1006         sc->prev_timestamp = timestamp;
1007         input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1008
1009         offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
1010         for (n = 0; n < 6; n++) {
1011                 /* Store data in int for more precision during mult_frac. */
1012                 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1013                 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1014
1015                 /* High precision is needed during calibration, but the
1016                  * calibrated values are within 32-bit.
1017                  * Note: we swap numerator 'x' and 'numer' in mult_frac for
1018                  *       precision reasons so we don't need 64-bit.
1019                  */
1020                 int calib_data = mult_frac(calib->sens_numer,
1021                                            raw_data - calib->bias,
1022                                            calib->sens_denom);
1023
1024                 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1025                 offset += 2;
1026         }
1027         input_sync(sc->sensor_dev);
1028
1029         /*
1030          * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1031          * and the 5th bit contains the USB cable state.
1032          */
1033         offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1034         cable_state = (rd[offset] >> 4) & 0x01;
1035         battery_capacity = rd[offset] & 0x0F;
1036
1037         /*
1038          * When a USB power source is connected the battery level ranges from
1039          * 0 to 10, and when running on battery power it ranges from 0 to 9.
1040          * A battery level above 10 when plugged in means charge completed.
1041          */
1042         if (!cable_state || battery_capacity > 10)
1043                 battery_charging = 0;
1044         else
1045                 battery_charging = 1;
1046
1047         if (!cable_state)
1048                 battery_capacity++;
1049         if (battery_capacity > 10)
1050                 battery_capacity = 10;
1051
1052         battery_capacity *= 10;
1053
1054         spin_lock_irqsave(&sc->lock, flags);
1055         sc->cable_state = cable_state;
1056         sc->battery_capacity = battery_capacity;
1057         sc->battery_charging = battery_charging;
1058         spin_unlock_irqrestore(&sc->lock, flags);
1059
1060         /*
1061          * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1062          * and 35 on Bluetooth.
1063          * The first byte indicates the number of touch data in the report.
1064          * Trackpad data starts 2 bytes later (e.g. 35 for USB).
1065          */
1066         offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1067         max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1068         if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1069                 num_touch_data = rd[offset];
1070         else
1071                 num_touch_data = 1;
1072         offset += 1;
1073
1074         for (m = 0; m < num_touch_data; m++) {
1075                 /* Skip past timestamp */
1076                 offset += 1;
1077
1078                 /*
1079                  * The first 7 bits of the first byte is a counter and bit 8 is
1080                  * a touch indicator that is 0 when pressed and 1 when not
1081                  * pressed.
1082                  * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1083                  * The data for the second touch is in the same format and
1084                  * immediately follows the data for the first.
1085                  */
1086                 for (n = 0; n < 2; n++) {
1087                         u16 x, y;
1088                         bool active;
1089
1090                         x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1091                         y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1092
1093                         active = !(rd[offset] >> 7);
1094                         input_mt_slot(sc->touchpad, n);
1095                         input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1096
1097                         if (active) {
1098                                 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1099                                 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1100                         }
1101
1102                         offset += 4;
1103                 }
1104                 input_mt_sync_frame(sc->touchpad);
1105                 input_sync(sc->touchpad);
1106         }
1107 }
1108
1109 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1110 {
1111         int n, offset, relx, rely;
1112         u8 active;
1113
1114         /*
1115          * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
1116          *   the touch-related data starts at offset 2.
1117          * For the first byte, bit 0 is set when touchpad button is pressed.
1118          * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
1119          * This drag key is mapped to BTN_LEFT.  It is operational only when a
1120          *   touch point is active.
1121          * Bit 4 is set when only the first touch point is active.
1122          * Bit 6 is set when only the second touch point is active.
1123          * Bits 5 and 7 are set when both touch points are active.
1124          * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
1125          * The following byte, offset 5, has the touch width and length.
1126          *   Bits 0-4=X (width), bits 5-7=Y (length).
1127          * A signed relative X coordinate is at offset 6.
1128          * The bytes at offset 7-9 are the second touch X/Y coordinates.
1129          * Offset 10 has the second touch width and length.
1130          * Offset 11 has the relative Y coordinate.
1131          */
1132         offset = 1;
1133
1134         input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1135         active = (rd[offset] >> 4);
1136         relx = (s8) rd[offset+5];
1137         rely = ((s8) rd[offset+10]) * -1;
1138
1139         offset++;
1140
1141         for (n = 0; n < 2; n++) {
1142                 u16 x, y;
1143                 u8 contactx, contacty;
1144
1145                 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1146                 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1147
1148                 input_mt_slot(sc->touchpad, n);
1149                 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1150
1151                 if (active & 0x03) {
1152                         contactx = rd[offset+3] & 0x0F;
1153                         contacty = rd[offset+3] >> 4;
1154                         input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1155                                 max(contactx, contacty));
1156                         input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1157                                 min(contactx, contacty));
1158                         input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1159                                 (bool) (contactx > contacty));
1160                         input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1161                         input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1162                                 NSG_MRXU_MAX_Y - y);
1163                         /*
1164                          * The relative coordinates belong to the first touch
1165                          * point, when present, or to the second touch point
1166                          * when the first is not active.
1167                          */
1168                         if ((n == 0) || ((n == 1) && (active & 0x01))) {
1169                                 input_report_rel(sc->touchpad, REL_X, relx);
1170                                 input_report_rel(sc->touchpad, REL_Y, rely);
1171                         }
1172                 }
1173
1174                 offset += 5;
1175                 active >>= 2;
1176         }
1177
1178         input_mt_sync_frame(sc->touchpad);
1179
1180         input_sync(sc->touchpad);
1181 }
1182
1183 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1184                 u8 *rd, int size)
1185 {
1186         struct sony_sc *sc = hid_get_drvdata(hdev);
1187
1188         /*
1189          * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1190          * has to be BYTE_SWAPPED before passing up to joystick interface
1191          */
1192         if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1193                 /*
1194                  * When connected via Bluetooth the Sixaxis occasionally sends
1195                  * a report with the second byte 0xff and the rest zeroed.
1196                  *
1197                  * This report does not reflect the actual state of the
1198                  * controller must be ignored to avoid generating false input
1199                  * events.
1200                  */
1201                 if (rd[1] == 0xff)
1202                         return -EINVAL;
1203
1204                 swap(rd[41], rd[42]);
1205                 swap(rd[43], rd[44]);
1206                 swap(rd[45], rd[46]);
1207                 swap(rd[47], rd[48]);
1208
1209                 sixaxis_parse_report(sc, rd, size);
1210         } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1211                 sixaxis_parse_report(sc, rd, size);
1212         } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1213                         size == 49) {
1214                 sixaxis_parse_report(sc, rd, size);
1215         } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1216                         size == 64) {
1217                 dualshock4_parse_report(sc, rd, size);
1218         } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1219                         size == 78)) {
1220                 /* CRC check */
1221                 u8 bthdr = 0xA1;
1222                 u32 crc;
1223                 u32 report_crc;
1224
1225                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1226                 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1227                 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1228                 if (crc != report_crc) {
1229                         hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1230                                 report_crc, crc);
1231                         return -EILSEQ;
1232                 }
1233
1234                 dualshock4_parse_report(sc, rd, size);
1235         } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1236                         size == 64) {
1237                 unsigned long flags;
1238                 enum ds4_dongle_state dongle_state;
1239
1240                 /*
1241                  * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1242                  * if a DS4 is actually connected (indicated by '0').
1243                  * For non-dongle, this bit is always 0 (connected).
1244                  */
1245                 bool connected = (rd[31] & 0x04) ? false : true;
1246
1247                 spin_lock_irqsave(&sc->lock, flags);
1248                 dongle_state = sc->ds4_dongle_state;
1249                 spin_unlock_irqrestore(&sc->lock, flags);
1250
1251                 /*
1252                  * The dongle always sends input reports even when no
1253                  * DS4 is attached. When a DS4 is connected, we need to
1254                  * obtain calibration data before we can use it.
1255                  * The code below tracks dongle state and kicks of
1256                  * calibration when needed and only allows us to process
1257                  * input if a DS4 is actually connected.
1258                  */
1259                 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1260                         hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1261                         sony_set_leds(sc);
1262
1263                         spin_lock_irqsave(&sc->lock, flags);
1264                         sc->ds4_dongle_state = DONGLE_CALIBRATING;
1265                         spin_unlock_irqrestore(&sc->lock, flags);
1266
1267                         sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1268
1269                         /* Don't process the report since we don't have
1270                          * calibration data, but let hidraw have it anyway.
1271                          */
1272                         return 0;
1273                 } else if ((dongle_state == DONGLE_CONNECTED ||
1274                             dongle_state == DONGLE_DISABLED) && !connected) {
1275                         hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1276
1277                         spin_lock_irqsave(&sc->lock, flags);
1278                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1279                         spin_unlock_irqrestore(&sc->lock, flags);
1280
1281                         /* Return 0, so hidraw can get the report. */
1282                         return 0;
1283                 } else if (dongle_state == DONGLE_CALIBRATING ||
1284                            dongle_state == DONGLE_DISABLED ||
1285                            dongle_state == DONGLE_DISCONNECTED) {
1286                         /* Return 0, so hidraw can get the report. */
1287                         return 0;
1288                 }
1289
1290                 dualshock4_parse_report(sc, rd, size);
1291
1292         } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1293                 nsg_mrxu_parse_report(sc, rd, size);
1294                 return 1;
1295         }
1296
1297         if (sc->defer_initialization) {
1298                 sc->defer_initialization = 0;
1299                 sony_schedule_work(sc, SONY_WORKER_STATE);
1300         }
1301
1302         return 0;
1303 }
1304
1305 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1306                         struct hid_field *field, struct hid_usage *usage,
1307                         unsigned long **bit, int *max)
1308 {
1309         struct sony_sc *sc = hid_get_drvdata(hdev);
1310
1311         if (sc->quirks & BUZZ_CONTROLLER) {
1312                 unsigned int key = usage->hid & HID_USAGE;
1313
1314                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1315                         return -1;
1316
1317                 switch (usage->collection_index) {
1318                 case 1:
1319                         if (key >= ARRAY_SIZE(buzz_keymap))
1320                                 return -1;
1321
1322                         key = buzz_keymap[key];
1323                         if (!key)
1324                                 return -1;
1325                         break;
1326                 default:
1327                         return -1;
1328                 }
1329
1330                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1331                 return 1;
1332         }
1333
1334         if (sc->quirks & PS3REMOTE)
1335                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1336
1337         if (sc->quirks & NAVIGATION_CONTROLLER)
1338                 return navigation_mapping(hdev, hi, field, usage, bit, max);
1339
1340         if (sc->quirks & SIXAXIS_CONTROLLER)
1341                 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1342
1343         if (sc->quirks & DUALSHOCK4_CONTROLLER)
1344                 return ds4_mapping(hdev, hi, field, usage, bit, max);
1345
1346
1347         /* Let hid-core decide for the others */
1348         return 0;
1349 }
1350
1351 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1352                 int w, int h, int touch_major, int touch_minor, int orientation)
1353 {
1354         size_t name_sz;
1355         char *name;
1356         int ret;
1357
1358         sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1359         if (!sc->touchpad)
1360                 return -ENOMEM;
1361
1362         input_set_drvdata(sc->touchpad, sc);
1363         sc->touchpad->dev.parent = &sc->hdev->dev;
1364         sc->touchpad->phys = sc->hdev->phys;
1365         sc->touchpad->uniq = sc->hdev->uniq;
1366         sc->touchpad->id.bustype = sc->hdev->bus;
1367         sc->touchpad->id.vendor = sc->hdev->vendor;
1368         sc->touchpad->id.product = sc->hdev->product;
1369         sc->touchpad->id.version = sc->hdev->version;
1370
1371         /* Append a suffix to the controller name as there are various
1372          * DS4 compatible non-Sony devices with different names.
1373          */
1374         name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1375         name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1376         if (!name)
1377                 return -ENOMEM;
1378         snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1379         sc->touchpad->name = name;
1380
1381         /* We map the button underneath the touchpad to BTN_LEFT. */
1382         __set_bit(EV_KEY, sc->touchpad->evbit);
1383         __set_bit(BTN_LEFT, sc->touchpad->keybit);
1384         __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1385
1386         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1387         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1388
1389         if (touch_major > 0) {
1390                 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1391                         0, touch_major, 0, 0);
1392                 if (touch_minor > 0)
1393                         input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1394                                 0, touch_minor, 0, 0);
1395                 if (orientation > 0)
1396                         input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1397                                 0, orientation, 0, 0);
1398         }
1399
1400         if (sc->quirks & NSG_MRXU_REMOTE) {
1401                 __set_bit(EV_REL, sc->touchpad->evbit);
1402         }
1403
1404         ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1405         if (ret < 0)
1406                 return ret;
1407
1408         ret = input_register_device(sc->touchpad);
1409         if (ret < 0)
1410                 return ret;
1411
1412         return 0;
1413 }
1414
1415 static int sony_register_sensors(struct sony_sc *sc)
1416 {
1417         size_t name_sz;
1418         char *name;
1419         int ret;
1420         int range;
1421
1422         sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1423         if (!sc->sensor_dev)
1424                 return -ENOMEM;
1425
1426         input_set_drvdata(sc->sensor_dev, sc);
1427         sc->sensor_dev->dev.parent = &sc->hdev->dev;
1428         sc->sensor_dev->phys = sc->hdev->phys;
1429         sc->sensor_dev->uniq = sc->hdev->uniq;
1430         sc->sensor_dev->id.bustype = sc->hdev->bus;
1431         sc->sensor_dev->id.vendor = sc->hdev->vendor;
1432         sc->sensor_dev->id.product = sc->hdev->product;
1433         sc->sensor_dev->id.version = sc->hdev->version;
1434
1435         /* Append a suffix to the controller name as there are various
1436          * DS4 compatible non-Sony devices with different names.
1437          */
1438         name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1439         name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1440         if (!name)
1441                 return -ENOMEM;
1442         snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1443         sc->sensor_dev->name = name;
1444
1445         if (sc->quirks & SIXAXIS_CONTROLLER) {
1446                 /* For the DS3 we only support the accelerometer, which works
1447                  * quite well even without calibration. The device also has
1448                  * a 1-axis gyro, but it is very difficult to manage from within
1449                  * the driver even to get data, the sensor is inaccurate and
1450                  * the behavior is very different between hardware revisions.
1451                  */
1452                 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1453                 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1454                 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1455                 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1456                 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1457                 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1458         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1459                 range = DS4_ACC_RES_PER_G*4;
1460                 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1461                 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1462                 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1463                 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1464                 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1465                 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1466
1467                 range = DS4_GYRO_RES_PER_DEG_S*2048;
1468                 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1469                 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1470                 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1471                 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1472                 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1473                 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1474
1475                 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1476                 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1477         }
1478
1479         __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1480
1481         ret = input_register_device(sc->sensor_dev);
1482         if (ret < 0)
1483                 return ret;
1484
1485         return 0;
1486 }
1487
1488 /*
1489  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1490  * to "operational".  Without this, the ps3 controller will not report any
1491  * events.
1492  */
1493 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1494 {
1495         struct sony_sc *sc = hid_get_drvdata(hdev);
1496         const int buf_size =
1497                 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1498         u8 *buf;
1499         int ret;
1500
1501         buf = kmalloc(buf_size, GFP_KERNEL);
1502         if (!buf)
1503                 return -ENOMEM;
1504
1505         ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1506                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1507         if (ret < 0) {
1508                 hid_err(hdev, "can't set operational mode: step 1\n");
1509                 goto out;
1510         }
1511
1512         /*
1513          * Some compatible controllers like the Speedlink Strike FX and
1514          * Gasia need another query plus an USB interrupt to get operational.
1515          */
1516         ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1517                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1518         if (ret < 0) {
1519                 hid_err(hdev, "can't set operational mode: step 2\n");
1520                 goto out;
1521         }
1522
1523         /*
1524          * But the USB interrupt would cause SHANWAN controllers to
1525          * start rumbling non-stop, so skip step 3 for these controllers.
1526          */
1527         if (sc->quirks & SHANWAN_GAMEPAD)
1528                 goto out;
1529
1530         ret = hid_hw_output_report(hdev, buf, 1);
1531         if (ret < 0) {
1532                 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1533                 ret = 0;
1534         }
1535
1536 out:
1537         kfree(buf);
1538
1539         return ret;
1540 }
1541
1542 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1543 {
1544         static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1545         u8 *buf;
1546         int ret;
1547
1548         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1549         if (!buf)
1550                 return -ENOMEM;
1551
1552         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1553                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1554
1555         kfree(buf);
1556
1557         return ret;
1558 }
1559
1560 /*
1561  * Request DS4 calibration data for the motion sensors.
1562  * For Bluetooth this also affects the operating mode (see below).
1563  */
1564 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1565 {
1566         u8 *buf;
1567         int ret;
1568         short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1569         short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1570         short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1571         short gyro_speed_plus, gyro_speed_minus;
1572         short acc_x_plus, acc_x_minus;
1573         short acc_y_plus, acc_y_minus;
1574         short acc_z_plus, acc_z_minus;
1575         int speed_2x;
1576         int range_2g;
1577
1578         /* For Bluetooth we use a different request, which supports CRC.
1579          * Note: in Bluetooth mode feature report 0x02 also changes the state
1580          * of the controller, so that it sends input reports of type 0x11.
1581          */
1582         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1583                 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1584                 if (!buf)
1585                         return -ENOMEM;
1586
1587                 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1588                                          DS4_FEATURE_REPORT_0x02_SIZE,
1589                                          HID_FEATURE_REPORT,
1590                                          HID_REQ_GET_REPORT);
1591                 if (ret < 0)
1592                         goto err_stop;
1593         } else {
1594                 u8 bthdr = 0xA3;
1595                 u32 crc;
1596                 u32 report_crc;
1597                 int retries;
1598
1599                 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1600                 if (!buf)
1601                         return -ENOMEM;
1602
1603                 for (retries = 0; retries < 3; retries++) {
1604                         ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1605                                                  DS4_FEATURE_REPORT_0x05_SIZE,
1606                                                  HID_FEATURE_REPORT,
1607                                                  HID_REQ_GET_REPORT);
1608                         if (ret < 0)
1609                                 goto err_stop;
1610
1611                         /* CRC check */
1612                         crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1613                         crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1614                         report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1615                         if (crc != report_crc) {
1616                                 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1617                                         report_crc, crc);
1618                                 if (retries < 2) {
1619                                         hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1620                                         continue;
1621                                 } else {
1622                                         ret = -EILSEQ;
1623                                         goto err_stop;
1624                                 }
1625                         } else {
1626                                 break;
1627                         }
1628                 }
1629         }
1630
1631         gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
1632         gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
1633         gyro_roll_bias   = get_unaligned_le16(&buf[5]);
1634         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1635                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1636                 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1637                 gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
1638                 gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
1639                 gyro_roll_plus   = get_unaligned_le16(&buf[15]);
1640                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1641         } else {
1642                 /* BT + Dongle */
1643                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1644                 gyro_yaw_plus    = get_unaligned_le16(&buf[9]);
1645                 gyro_roll_plus   = get_unaligned_le16(&buf[11]);
1646                 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1647                 gyro_yaw_minus   = get_unaligned_le16(&buf[15]);
1648                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1649         }
1650         gyro_speed_plus  = get_unaligned_le16(&buf[19]);
1651         gyro_speed_minus = get_unaligned_le16(&buf[21]);
1652         acc_x_plus       = get_unaligned_le16(&buf[23]);
1653         acc_x_minus      = get_unaligned_le16(&buf[25]);
1654         acc_y_plus       = get_unaligned_le16(&buf[27]);
1655         acc_y_minus      = get_unaligned_le16(&buf[29]);
1656         acc_z_plus       = get_unaligned_le16(&buf[31]);
1657         acc_z_minus      = get_unaligned_le16(&buf[33]);
1658
1659         /* Set gyroscope calibration and normalization parameters.
1660          * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1661          */
1662         speed_2x = (gyro_speed_plus + gyro_speed_minus);
1663         sc->ds4_calib_data[0].abs_code = ABS_RX;
1664         sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1665         sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1666         sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1667
1668         sc->ds4_calib_data[1].abs_code = ABS_RY;
1669         sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1670         sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1671         sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1672
1673         sc->ds4_calib_data[2].abs_code = ABS_RZ;
1674         sc->ds4_calib_data[2].bias = gyro_roll_bias;
1675         sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1676         sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1677
1678         /* Set accelerometer calibration and normalization parameters.
1679          * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1680          */
1681         range_2g = acc_x_plus - acc_x_minus;
1682         sc->ds4_calib_data[3].abs_code = ABS_X;
1683         sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1684         sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1685         sc->ds4_calib_data[3].sens_denom = range_2g;
1686
1687         range_2g = acc_y_plus - acc_y_minus;
1688         sc->ds4_calib_data[4].abs_code = ABS_Y;
1689         sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1690         sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1691         sc->ds4_calib_data[4].sens_denom = range_2g;
1692
1693         range_2g = acc_z_plus - acc_z_minus;
1694         sc->ds4_calib_data[5].abs_code = ABS_Z;
1695         sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1696         sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1697         sc->ds4_calib_data[5].sens_denom = range_2g;
1698
1699 err_stop:
1700         kfree(buf);
1701         return ret;
1702 }
1703
1704 static void dualshock4_calibration_work(struct work_struct *work)
1705 {
1706         struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1707         unsigned long flags;
1708         enum ds4_dongle_state dongle_state;
1709         int ret;
1710
1711         ret = dualshock4_get_calibration_data(sc);
1712         if (ret < 0) {
1713                 /* This call is very unlikely to fail for the dongle. When it
1714                  * fails we are probably in a very bad state, so mark the
1715                  * dongle as disabled. We will re-enable the dongle if a new
1716                  * DS4 hotplug is detect from sony_raw_event as any issues
1717                  * are likely resolved then (the dongle is quite stupid).
1718                  */
1719                 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1720                 dongle_state = DONGLE_DISABLED;
1721         } else {
1722                 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1723                 dongle_state = DONGLE_CONNECTED;
1724         }
1725
1726         spin_lock_irqsave(&sc->lock, flags);
1727         sc->ds4_dongle_state = dongle_state;
1728         spin_unlock_irqrestore(&sc->lock, flags);
1729 }
1730
1731 static int dualshock4_get_version_info(struct sony_sc *sc)
1732 {
1733         u8 *buf;
1734         int ret;
1735
1736         buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1737         if (!buf)
1738                 return -ENOMEM;
1739
1740         ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1741                                  DS4_FEATURE_REPORT_0xA3_SIZE,
1742                                  HID_FEATURE_REPORT,
1743                                  HID_REQ_GET_REPORT);
1744         if (ret < 0) {
1745                 kfree(buf);
1746                 return ret;
1747         }
1748
1749         sc->hw_version = get_unaligned_le16(&buf[35]);
1750         sc->fw_version = get_unaligned_le16(&buf[41]);
1751
1752         kfree(buf);
1753         return 0;
1754 }
1755
1756 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1757 {
1758         static const u8 sixaxis_leds[10][4] = {
1759                                 { 0x01, 0x00, 0x00, 0x00 },
1760                                 { 0x00, 0x01, 0x00, 0x00 },
1761                                 { 0x00, 0x00, 0x01, 0x00 },
1762                                 { 0x00, 0x00, 0x00, 0x01 },
1763                                 { 0x01, 0x00, 0x00, 0x01 },
1764                                 { 0x00, 0x01, 0x00, 0x01 },
1765                                 { 0x00, 0x00, 0x01, 0x01 },
1766                                 { 0x01, 0x00, 0x01, 0x01 },
1767                                 { 0x00, 0x01, 0x01, 0x01 },
1768                                 { 0x01, 0x01, 0x01, 0x01 }
1769         };
1770
1771         int id = sc->device_id;
1772
1773         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1774
1775         if (id < 0)
1776                 return;
1777
1778         id %= 10;
1779         memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1780 }
1781
1782 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1783 {
1784         /* The first 4 color/index entries match what the PS4 assigns */
1785         static const u8 color_code[7][3] = {
1786                         /* Blue   */    { 0x00, 0x00, 0x40 },
1787                         /* Red    */    { 0x40, 0x00, 0x00 },
1788                         /* Green  */    { 0x00, 0x40, 0x00 },
1789                         /* Pink   */    { 0x20, 0x00, 0x20 },
1790                         /* Orange */    { 0x02, 0x01, 0x00 },
1791                         /* Teal   */    { 0x00, 0x01, 0x01 },
1792                         /* White  */    { 0x01, 0x01, 0x01 }
1793         };
1794
1795         int id = sc->device_id;
1796
1797         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1798
1799         if (id < 0)
1800                 return;
1801
1802         id %= 7;
1803         memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1804 }
1805
1806 static void buzz_set_leds(struct sony_sc *sc)
1807 {
1808         struct hid_device *hdev = sc->hdev;
1809         struct list_head *report_list =
1810                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1811         struct hid_report *report = list_entry(report_list->next,
1812                 struct hid_report, list);
1813         s32 *value = report->field[0]->value;
1814
1815         BUILD_BUG_ON(MAX_LEDS < 4);
1816
1817         value[0] = 0x00;
1818         value[1] = sc->led_state[0] ? 0xff : 0x00;
1819         value[2] = sc->led_state[1] ? 0xff : 0x00;
1820         value[3] = sc->led_state[2] ? 0xff : 0x00;
1821         value[4] = sc->led_state[3] ? 0xff : 0x00;
1822         value[5] = 0x00;
1823         value[6] = 0x00;
1824         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1825 }
1826
1827 static void sony_set_leds(struct sony_sc *sc)
1828 {
1829         if (!(sc->quirks & BUZZ_CONTROLLER))
1830                 sony_schedule_work(sc, SONY_WORKER_STATE);
1831         else
1832                 buzz_set_leds(sc);
1833 }
1834
1835 static void sony_led_set_brightness(struct led_classdev *led,
1836                                     enum led_brightness value)
1837 {
1838         struct device *dev = led->dev->parent;
1839         struct hid_device *hdev = to_hid_device(dev);
1840         struct sony_sc *drv_data;
1841
1842         int n;
1843         int force_update;
1844
1845         drv_data = hid_get_drvdata(hdev);
1846         if (!drv_data) {
1847                 hid_err(hdev, "No device data\n");
1848                 return;
1849         }
1850
1851         /*
1852          * The Sixaxis on USB will override any LED settings sent to it
1853          * and keep flashing all of the LEDs until the PS button is pressed.
1854          * Updates, even if redundant, must be always be sent to the
1855          * controller to avoid having to toggle the state of an LED just to
1856          * stop the flashing later on.
1857          */
1858         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1859
1860         for (n = 0; n < drv_data->led_count; n++) {
1861                 if (led == drv_data->leds[n] && (force_update ||
1862                         (value != drv_data->led_state[n] ||
1863                         drv_data->led_delay_on[n] ||
1864                         drv_data->led_delay_off[n]))) {
1865
1866                         drv_data->led_state[n] = value;
1867
1868                         /* Setting the brightness stops the blinking */
1869                         drv_data->led_delay_on[n] = 0;
1870                         drv_data->led_delay_off[n] = 0;
1871
1872                         sony_set_leds(drv_data);
1873                         break;
1874                 }
1875         }
1876 }
1877
1878 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1879 {
1880         struct device *dev = led->dev->parent;
1881         struct hid_device *hdev = to_hid_device(dev);
1882         struct sony_sc *drv_data;
1883
1884         int n;
1885
1886         drv_data = hid_get_drvdata(hdev);
1887         if (!drv_data) {
1888                 hid_err(hdev, "No device data\n");
1889                 return LED_OFF;
1890         }
1891
1892         for (n = 0; n < drv_data->led_count; n++) {
1893                 if (led == drv_data->leds[n])
1894                         return drv_data->led_state[n];
1895         }
1896
1897         return LED_OFF;
1898 }
1899
1900 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1901                                 unsigned long *delay_off)
1902 {
1903         struct device *dev = led->dev->parent;
1904         struct hid_device *hdev = to_hid_device(dev);
1905         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1906         int n;
1907         u8 new_on, new_off;
1908
1909         if (!drv_data) {
1910                 hid_err(hdev, "No device data\n");
1911                 return -EINVAL;
1912         }
1913
1914         /* Max delay is 255 deciseconds or 2550 milliseconds */
1915         if (*delay_on > 2550)
1916                 *delay_on = 2550;
1917         if (*delay_off > 2550)
1918                 *delay_off = 2550;
1919
1920         /* Blink at 1 Hz if both values are zero */
1921         if (!*delay_on && !*delay_off)
1922                 *delay_on = *delay_off = 500;
1923
1924         new_on = *delay_on / 10;
1925         new_off = *delay_off / 10;
1926
1927         for (n = 0; n < drv_data->led_count; n++) {
1928                 if (led == drv_data->leds[n])
1929                         break;
1930         }
1931
1932         /* This LED is not registered on this device */
1933         if (n >= drv_data->led_count)
1934                 return -EINVAL;
1935
1936         /* Don't schedule work if the values didn't change */
1937         if (new_on != drv_data->led_delay_on[n] ||
1938                 new_off != drv_data->led_delay_off[n]) {
1939                 drv_data->led_delay_on[n] = new_on;
1940                 drv_data->led_delay_off[n] = new_off;
1941                 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1942         }
1943
1944         return 0;
1945 }
1946
1947 static int sony_leds_init(struct sony_sc *sc)
1948 {
1949         struct hid_device *hdev = sc->hdev;
1950         int n, ret = 0;
1951         int use_ds4_names;
1952         struct led_classdev *led;
1953         size_t name_sz;
1954         char *name;
1955         size_t name_len;
1956         const char *name_fmt;
1957         static const char * const ds4_name_str[] = { "red", "green", "blue",
1958                                                   "global" };
1959         u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1960         u8 use_hw_blink[MAX_LEDS] = { 0 };
1961
1962         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1963
1964         if (sc->quirks & BUZZ_CONTROLLER) {
1965                 sc->led_count = 4;
1966                 use_ds4_names = 0;
1967                 name_len = strlen("::buzz#");
1968                 name_fmt = "%s::buzz%d";
1969                 /* Validate expected report characteristics. */
1970                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1971                         return -ENODEV;
1972         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1973                 dualshock4_set_leds_from_id(sc);
1974                 sc->led_state[3] = 1;
1975                 sc->led_count = 4;
1976                 memset(max_brightness, 255, 3);
1977                 use_hw_blink[3] = 1;
1978                 use_ds4_names = 1;
1979                 name_len = 0;
1980                 name_fmt = "%s:%s";
1981         } else if (sc->quirks & MOTION_CONTROLLER) {
1982                 sc->led_count = 3;
1983                 memset(max_brightness, 255, 3);
1984                 use_ds4_names = 1;
1985                 name_len = 0;
1986                 name_fmt = "%s:%s";
1987         } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1988                 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1989
1990                 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1991                 sc->led_count = 1;
1992                 memset(use_hw_blink, 1, 4);
1993                 use_ds4_names = 0;
1994                 name_len = strlen("::sony#");
1995                 name_fmt = "%s::sony%d";
1996         } else {
1997                 sixaxis_set_leds_from_id(sc);
1998                 sc->led_count = 4;
1999                 memset(use_hw_blink, 1, 4);
2000                 use_ds4_names = 0;
2001                 name_len = strlen("::sony#");
2002                 name_fmt = "%s::sony%d";
2003         }
2004
2005         /*
2006          * Clear LEDs as we have no way of reading their initial state. This is
2007          * only relevant if the driver is loaded after somebody actively set the
2008          * LEDs to on
2009          */
2010         sony_set_leds(sc);
2011
2012         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2013
2014         for (n = 0; n < sc->led_count; n++) {
2015
2016                 if (use_ds4_names)
2017                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2018
2019                 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2020                 if (!led) {
2021                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2022                         return -ENOMEM;
2023                 }
2024
2025                 name = (void *)(&led[1]);
2026                 if (use_ds4_names)
2027                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2028                         ds4_name_str[n]);
2029                 else
2030                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2031                 led->name = name;
2032                 led->brightness = sc->led_state[n];
2033                 led->max_brightness = max_brightness[n];
2034                 led->flags = LED_CORE_SUSPENDRESUME;
2035                 led->brightness_get = sony_led_get_brightness;
2036                 led->brightness_set = sony_led_set_brightness;
2037
2038                 if (use_hw_blink[n])
2039                         led->blink_set = sony_led_blink_set;
2040
2041                 sc->leds[n] = led;
2042
2043                 ret = devm_led_classdev_register(&hdev->dev, led);
2044                 if (ret) {
2045                         hid_err(hdev, "Failed to register LED %d\n", n);
2046                         return ret;
2047                 }
2048         }
2049
2050         return 0;
2051 }
2052
2053 static void sixaxis_send_output_report(struct sony_sc *sc)
2054 {
2055         static const union sixaxis_output_report_01 default_report = {
2056                 .buf = {
2057                         0x01,
2058                         0x01, 0xff, 0x00, 0xff, 0x00,
2059                         0x00, 0x00, 0x00, 0x00, 0x00,
2060                         0xff, 0x27, 0x10, 0x00, 0x32,
2061                         0xff, 0x27, 0x10, 0x00, 0x32,
2062                         0xff, 0x27, 0x10, 0x00, 0x32,
2063                         0xff, 0x27, 0x10, 0x00, 0x32,
2064                         0x00, 0x00, 0x00, 0x00, 0x00
2065                 }
2066         };
2067         struct sixaxis_output_report *report =
2068                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2069         int n;
2070
2071         /* Initialize the report with default values */
2072         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2073
2074 #ifdef CONFIG_SONY_FF
2075         report->rumble.right_motor_on = sc->right ? 1 : 0;
2076         report->rumble.left_motor_force = sc->left;
2077 #endif
2078
2079         report->leds_bitmap |= sc->led_state[0] << 1;
2080         report->leds_bitmap |= sc->led_state[1] << 2;
2081         report->leds_bitmap |= sc->led_state[2] << 3;
2082         report->leds_bitmap |= sc->led_state[3] << 4;
2083
2084         /* Set flag for all leds off, required for 3rd party INTEC controller */
2085         if ((report->leds_bitmap & 0x1E) == 0)
2086                 report->leds_bitmap |= 0x20;
2087
2088         /*
2089          * The LEDs in the report are indexed in reverse order to their
2090          * corresponding light on the controller.
2091          * Index 0 = LED 4, index 1 = LED 3, etc...
2092          *
2093          * In the case of both delay values being zero (blinking disabled) the
2094          * default report values should be used or the controller LED will be
2095          * always off.
2096          */
2097         for (n = 0; n < 4; n++) {
2098                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2099                         report->led[3 - n].duty_off = sc->led_delay_off[n];
2100                         report->led[3 - n].duty_on = sc->led_delay_on[n];
2101                 }
2102         }
2103
2104         /* SHANWAN controllers require output reports via intr channel */
2105         if (sc->quirks & SHANWAN_GAMEPAD)
2106                 hid_hw_output_report(sc->hdev, (u8 *)report,
2107                                 sizeof(struct sixaxis_output_report));
2108         else
2109                 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2110                                 sizeof(struct sixaxis_output_report),
2111                                 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2112 }
2113
2114 static void dualshock4_send_output_report(struct sony_sc *sc)
2115 {
2116         struct hid_device *hdev = sc->hdev;
2117         u8 *buf = sc->output_report_dmabuf;
2118         int offset;
2119
2120         /*
2121          * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2122          * control the interval at which Dualshock 4 reports data:
2123          * 0x00 - 1ms
2124          * 0x01 - 1ms
2125          * 0x02 - 2ms
2126          * 0x3E - 62ms
2127          * 0x3F - disabled
2128          */
2129         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2130                 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2131                 buf[0] = 0x05;
2132                 buf[1] = 0x07; /* blink + LEDs + motor */
2133                 offset = 4;
2134         } else {
2135                 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2136                 buf[0] = 0x11;
2137                 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2138                 buf[3] = 0x07; /* blink + LEDs + motor */
2139                 offset = 6;
2140         }
2141
2142 #ifdef CONFIG_SONY_FF
2143         buf[offset++] = sc->right;
2144         buf[offset++] = sc->left;
2145 #else
2146         offset += 2;
2147 #endif
2148
2149         /* LED 3 is the global control */
2150         if (sc->led_state[3]) {
2151                 buf[offset++] = sc->led_state[0];
2152                 buf[offset++] = sc->led_state[1];
2153                 buf[offset++] = sc->led_state[2];
2154         } else {
2155                 offset += 3;
2156         }
2157
2158         /* If both delay values are zero the DualShock 4 disables blinking. */
2159         buf[offset++] = sc->led_delay_on[3];
2160         buf[offset++] = sc->led_delay_off[3];
2161
2162         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2163                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2164         else {
2165                 /* CRC generation */
2166                 u8 bthdr = 0xA2;
2167                 u32 crc;
2168
2169                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2170                 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2171                 put_unaligned_le32(crc, &buf[74]);
2172                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2173         }
2174 }
2175
2176 static void motion_send_output_report(struct sony_sc *sc)
2177 {
2178         struct hid_device *hdev = sc->hdev;
2179         struct motion_output_report_02 *report =
2180                 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2181
2182         memset(report, 0, MOTION_REPORT_0x02_SIZE);
2183
2184         report->type = 0x02; /* set leds */
2185         report->r = sc->led_state[0];
2186         report->g = sc->led_state[1];
2187         report->b = sc->led_state[2];
2188
2189 #ifdef CONFIG_SONY_FF
2190         report->rumble = max(sc->right, sc->left);
2191 #endif
2192
2193         hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2194 }
2195
2196 static inline void sony_send_output_report(struct sony_sc *sc)
2197 {
2198         if (sc->send_output_report)
2199                 sc->send_output_report(sc);
2200 }
2201
2202 static void sony_state_worker(struct work_struct *work)
2203 {
2204         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2205
2206         sc->send_output_report(sc);
2207 }
2208
2209 static int sony_allocate_output_report(struct sony_sc *sc)
2210 {
2211         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2212                         (sc->quirks & NAVIGATION_CONTROLLER))
2213                 sc->output_report_dmabuf =
2214                         devm_kmalloc(&sc->hdev->dev,
2215                                 sizeof(union sixaxis_output_report_01),
2216                                 GFP_KERNEL);
2217         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2218                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2219                                                 DS4_OUTPUT_REPORT_0x11_SIZE,
2220                                                 GFP_KERNEL);
2221         else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2222                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2223                                                 DS4_OUTPUT_REPORT_0x05_SIZE,
2224                                                 GFP_KERNEL);
2225         else if (sc->quirks & MOTION_CONTROLLER)
2226                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2227                                                 MOTION_REPORT_0x02_SIZE,
2228                                                 GFP_KERNEL);
2229         else
2230                 return 0;
2231
2232         if (!sc->output_report_dmabuf)
2233                 return -ENOMEM;
2234
2235         return 0;
2236 }
2237
2238 #ifdef CONFIG_SONY_FF
2239 static int sony_play_effect(struct input_dev *dev, void *data,
2240                             struct ff_effect *effect)
2241 {
2242         struct hid_device *hid = input_get_drvdata(dev);
2243         struct sony_sc *sc = hid_get_drvdata(hid);
2244
2245         if (effect->type != FF_RUMBLE)
2246                 return 0;
2247
2248         sc->left = effect->u.rumble.strong_magnitude / 256;
2249         sc->right = effect->u.rumble.weak_magnitude / 256;
2250
2251         sony_schedule_work(sc, SONY_WORKER_STATE);
2252         return 0;
2253 }
2254
2255 static int sony_init_ff(struct sony_sc *sc)
2256 {
2257         struct hid_input *hidinput;
2258         struct input_dev *input_dev;
2259
2260         if (list_empty(&sc->hdev->inputs)) {
2261                 hid_err(sc->hdev, "no inputs found\n");
2262                 return -ENODEV;
2263         }
2264         hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2265         input_dev = hidinput->input;
2266
2267         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2268         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2269 }
2270
2271 #else
2272 static int sony_init_ff(struct sony_sc *sc)
2273 {
2274         return 0;
2275 }
2276
2277 #endif
2278
2279 static int sony_battery_get_property(struct power_supply *psy,
2280                                      enum power_supply_property psp,
2281                                      union power_supply_propval *val)
2282 {
2283         struct sony_sc *sc = power_supply_get_drvdata(psy);
2284         unsigned long flags;
2285         int ret = 0;
2286         u8 battery_charging, battery_capacity, cable_state;
2287
2288         spin_lock_irqsave(&sc->lock, flags);
2289         battery_charging = sc->battery_charging;
2290         battery_capacity = sc->battery_capacity;
2291         cable_state = sc->cable_state;
2292         spin_unlock_irqrestore(&sc->lock, flags);
2293
2294         switch (psp) {
2295         case POWER_SUPPLY_PROP_PRESENT:
2296                 val->intval = 1;
2297                 break;
2298         case POWER_SUPPLY_PROP_SCOPE:
2299                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2300                 break;
2301         case POWER_SUPPLY_PROP_CAPACITY:
2302                 val->intval = battery_capacity;
2303                 break;
2304         case POWER_SUPPLY_PROP_STATUS:
2305                 if (battery_charging)
2306                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
2307                 else
2308                         if (battery_capacity == 100 && cable_state)
2309                                 val->intval = POWER_SUPPLY_STATUS_FULL;
2310                         else
2311                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2312                 break;
2313         default:
2314                 ret = -EINVAL;
2315                 break;
2316         }
2317         return ret;
2318 }
2319
2320 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2321 {
2322         const char *battery_str_fmt = append_dev_id ?
2323                 "sony_controller_battery_%pMR_%i" :
2324                 "sony_controller_battery_%pMR";
2325         struct power_supply_config psy_cfg = { .drv_data = sc, };
2326         struct hid_device *hdev = sc->hdev;
2327         int ret;
2328
2329         /*
2330          * Set the default battery level to 100% to avoid low battery warnings
2331          * if the battery is polled before the first device report is received.
2332          */
2333         sc->battery_capacity = 100;
2334
2335         sc->battery_desc.properties = sony_battery_props;
2336         sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2337         sc->battery_desc.get_property = sony_battery_get_property;
2338         sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2339         sc->battery_desc.use_for_apm = 0;
2340         sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2341                                           battery_str_fmt, sc->mac_address, sc->device_id);
2342         if (!sc->battery_desc.name)
2343                 return -ENOMEM;
2344
2345         sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2346                                             &psy_cfg);
2347         if (IS_ERR(sc->battery)) {
2348                 ret = PTR_ERR(sc->battery);
2349                 hid_err(hdev, "Unable to register battery device\n");
2350                 return ret;
2351         }
2352
2353         power_supply_powers(sc->battery, &hdev->dev);
2354         return 0;
2355 }
2356
2357 /*
2358  * If a controller is plugged in via USB while already connected via Bluetooth
2359  * it will show up as two devices. A global list of connected controllers and
2360  * their MAC addresses is maintained to ensure that a device is only connected
2361  * once.
2362  *
2363  * Some USB-only devices masquerade as Sixaxis controllers and all have the
2364  * same dummy Bluetooth address, so a comparison of the connection type is
2365  * required.  Devices are only rejected in the case where two devices have
2366  * matching Bluetooth addresses on different bus types.
2367  */
2368 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2369                                                 struct sony_sc *sc1)
2370 {
2371         const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2372         const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2373
2374         return sc0_not_bt == sc1_not_bt;
2375 }
2376
2377 static int sony_check_add_dev_list(struct sony_sc *sc)
2378 {
2379         struct sony_sc *entry;
2380         unsigned long flags;
2381         int ret;
2382
2383         spin_lock_irqsave(&sony_dev_list_lock, flags);
2384
2385         list_for_each_entry(entry, &sony_device_list, list_node) {
2386                 ret = memcmp(sc->mac_address, entry->mac_address,
2387                                 sizeof(sc->mac_address));
2388                 if (!ret) {
2389                         if (sony_compare_connection_type(sc, entry)) {
2390                                 ret = 1;
2391                         } else {
2392                                 ret = -EEXIST;
2393                                 hid_info(sc->hdev,
2394                                 "controller with MAC address %pMR already connected\n",
2395                                 sc->mac_address);
2396                         }
2397                         goto unlock;
2398                 }
2399         }
2400
2401         ret = 0;
2402         list_add(&(sc->list_node), &sony_device_list);
2403
2404 unlock:
2405         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2406         return ret;
2407 }
2408
2409 static void sony_remove_dev_list(struct sony_sc *sc)
2410 {
2411         unsigned long flags;
2412
2413         if (sc->list_node.next) {
2414                 spin_lock_irqsave(&sony_dev_list_lock, flags);
2415                 list_del(&(sc->list_node));
2416                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2417         }
2418 }
2419
2420 static int sony_get_bt_devaddr(struct sony_sc *sc)
2421 {
2422         int ret;
2423
2424         /* HIDP stores the device MAC address as a string in the uniq field. */
2425         ret = strlen(sc->hdev->uniq);
2426         if (ret != 17)
2427                 return -EINVAL;
2428
2429         ret = sscanf(sc->hdev->uniq,
2430                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2431                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2432                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2433
2434         if (ret != 6)
2435                 return -EINVAL;
2436
2437         return 0;
2438 }
2439
2440 static int sony_check_add(struct sony_sc *sc)
2441 {
2442         u8 *buf = NULL;
2443         int n, ret;
2444
2445         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2446             (sc->quirks & MOTION_CONTROLLER_BT) ||
2447             (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2448             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2449                 /*
2450                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2451                  * address from the uniq string where HIDP stores it.
2452                  * As uniq cannot be guaranteed to be a MAC address in all cases
2453                  * a failure of this function should not prevent the connection.
2454                  */
2455                 if (sony_get_bt_devaddr(sc) < 0) {
2456                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2457                         return 0;
2458                 }
2459         } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2460                 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2461                 if (!buf)
2462                         return -ENOMEM;
2463
2464                 /*
2465                  * The MAC address of a DS4 controller connected via USB can be
2466                  * retrieved with feature report 0x81. The address begins at
2467                  * offset 1.
2468                  */
2469                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2470                                 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2471                                 HID_REQ_GET_REPORT);
2472
2473                 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2474                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2475                         ret = ret < 0 ? ret : -EINVAL;
2476                         goto out_free;
2477                 }
2478
2479                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2480
2481                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2482                          "%pMR", sc->mac_address);
2483         } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2484                         (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2485                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2486                 if (!buf)
2487                         return -ENOMEM;
2488
2489                 /*
2490                  * The MAC address of a Sixaxis controller connected via USB can
2491                  * be retrieved with feature report 0xf2. The address begins at
2492                  * offset 4.
2493                  */
2494                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2495                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2496                                 HID_REQ_GET_REPORT);
2497
2498                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2499                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2500                         ret = ret < 0 ? ret : -EINVAL;
2501                         goto out_free;
2502                 }
2503
2504                 /*
2505                  * The Sixaxis device MAC in the report is big-endian and must
2506                  * be byte-swapped.
2507                  */
2508                 for (n = 0; n < 6; n++)
2509                         sc->mac_address[5-n] = buf[4+n];
2510
2511                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2512                          "%pMR", sc->mac_address);
2513         } else {
2514                 return 0;
2515         }
2516
2517         ret = sony_check_add_dev_list(sc);
2518
2519 out_free:
2520
2521         kfree(buf);
2522
2523         return ret;
2524 }
2525
2526 static int sony_set_device_id(struct sony_sc *sc)
2527 {
2528         int ret;
2529
2530         /*
2531          * Only DualShock 4 or Sixaxis controllers get an id.
2532          * All others are set to -1.
2533          */
2534         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2535             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2536                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2537                                         GFP_KERNEL);
2538                 if (ret < 0) {
2539                         sc->device_id = -1;
2540                         return ret;
2541                 }
2542                 sc->device_id = ret;
2543         } else {
2544                 sc->device_id = -1;
2545         }
2546
2547         return 0;
2548 }
2549
2550 static void sony_release_device_id(struct sony_sc *sc)
2551 {
2552         if (sc->device_id >= 0) {
2553                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2554                 sc->device_id = -1;
2555         }
2556 }
2557
2558 static inline void sony_init_output_report(struct sony_sc *sc,
2559                                 void (*send_output_report)(struct sony_sc *))
2560 {
2561         sc->send_output_report = send_output_report;
2562
2563         if (!sc->state_worker_initialized)
2564                 INIT_WORK(&sc->state_worker, sony_state_worker);
2565
2566         sc->state_worker_initialized = 1;
2567 }
2568
2569 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2570 {
2571         unsigned long flags;
2572
2573         if (sc->hotplug_worker_initialized)
2574                 cancel_work_sync(&sc->hotplug_worker);
2575         if (sc->state_worker_initialized) {
2576                 spin_lock_irqsave(&sc->lock, flags);
2577                 sc->state_worker_initialized = 0;
2578                 spin_unlock_irqrestore(&sc->lock, flags);
2579                 cancel_work_sync(&sc->state_worker);
2580         }
2581 }
2582
2583 static int sony_input_configured(struct hid_device *hdev,
2584                                         struct hid_input *hidinput)
2585 {
2586         struct sony_sc *sc = hid_get_drvdata(hdev);
2587         int append_dev_id;
2588         int ret;
2589
2590         ret = sony_set_device_id(sc);
2591         if (ret < 0) {
2592                 hid_err(hdev, "failed to allocate the device id\n");
2593                 goto err_stop;
2594         }
2595
2596         ret = append_dev_id = sony_check_add(sc);
2597         if (ret < 0)
2598                 goto err_stop;
2599
2600         ret = sony_allocate_output_report(sc);
2601         if (ret < 0) {
2602                 hid_err(hdev, "failed to allocate the output report buffer\n");
2603                 goto err_stop;
2604         }
2605
2606         if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2607                 /*
2608                  * The Sony Sixaxis does not handle HID Output Reports on the
2609                  * Interrupt EP like it could, so we need to force HID Output
2610                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
2611                  *
2612                  * There is also another issue about HID Output Reports via USB,
2613                  * the Sixaxis does not want the report_id as part of the data
2614                  * packet, so we have to discard buf[0] when sending the actual
2615                  * control message, even for numbered reports, humpf!
2616                  *
2617                  * Additionally, the Sixaxis on USB isn't properly initialized
2618                  * until the PS logo button is pressed and as such won't retain
2619                  * any state set by an output report, so the initial
2620                  * configuration report is deferred until the first input
2621                  * report arrives.
2622                  */
2623                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2624                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2625                 sc->defer_initialization = 1;
2626
2627                 ret = sixaxis_set_operational_usb(hdev);
2628                 if (ret < 0) {
2629                         hid_err(hdev, "Failed to set controller into operational mode\n");
2630                         goto err_stop;
2631                 }
2632
2633                 sony_init_output_report(sc, sixaxis_send_output_report);
2634         } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2635                 /*
2636                  * The Navigation controller wants output reports sent on the ctrl
2637                  * endpoint when connected via Bluetooth.
2638                  */
2639                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2640
2641                 ret = sixaxis_set_operational_bt(hdev);
2642                 if (ret < 0) {
2643                         hid_err(hdev, "Failed to set controller into operational mode\n");
2644                         goto err_stop;
2645                 }
2646
2647                 sony_init_output_report(sc, sixaxis_send_output_report);
2648         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2649                 /*
2650                  * The Sony Sixaxis does not handle HID Output Reports on the
2651                  * Interrupt EP and the device only becomes active when the
2652                  * PS button is pressed. See comment for Navigation controller
2653                  * above for more details.
2654                  */
2655                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2656                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2657                 sc->defer_initialization = 1;
2658
2659                 ret = sixaxis_set_operational_usb(hdev);
2660                 if (ret < 0) {
2661                         hid_err(hdev, "Failed to set controller into operational mode\n");
2662                         goto err_stop;
2663                 }
2664
2665                 ret = sony_register_sensors(sc);
2666                 if (ret) {
2667                         hid_err(sc->hdev,
2668                         "Unable to initialize motion sensors: %d\n", ret);
2669                         goto err_stop;
2670                 }
2671
2672                 sony_init_output_report(sc, sixaxis_send_output_report);
2673         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2674                 /*
2675                  * The Sixaxis wants output reports sent on the ctrl endpoint
2676                  * 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                 ret = sony_register_sensors(sc);
2687                 if (ret) {
2688                         hid_err(sc->hdev,
2689                         "Unable to initialize motion sensors: %d\n", ret);
2690                         goto err_stop;
2691                 }
2692
2693                 sony_init_output_report(sc, sixaxis_send_output_report);
2694         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2695                 ret = dualshock4_get_calibration_data(sc);
2696                 if (ret < 0) {
2697                         hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2698                         goto err_stop;
2699                 }
2700
2701                 ret = dualshock4_get_version_info(sc);
2702                 if (ret < 0) {
2703                         hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2704                         goto err_stop;
2705                 }
2706
2707                 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2708                 if (ret) {
2709                         /* Make zero for cleanup reasons of sysfs entries. */
2710                         sc->fw_version = 0;
2711                         sc->hw_version = 0;
2712                         hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2713                         goto err_stop;
2714                 }
2715
2716                 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2717                 if (ret) {
2718                         sc->hw_version = 0;
2719                         hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2720                         goto err_stop;
2721                 }
2722
2723                 /*
2724                  * The Dualshock 4 touchpad supports 2 touches and has a
2725                  * resolution of 1920x942 (44.86 dots/mm).
2726                  */
2727                 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2728                 if (ret) {
2729                         hid_err(sc->hdev,
2730                         "Unable to initialize multi-touch slots: %d\n",
2731                         ret);
2732                         goto err_stop;
2733                 }
2734
2735                 ret = sony_register_sensors(sc);
2736                 if (ret) {
2737                         hid_err(sc->hdev,
2738                         "Unable to initialize motion sensors: %d\n", ret);
2739                         goto err_stop;
2740                 }
2741
2742                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2743                         sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2744                         ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2745                         if (ret)
2746                                 hid_warn(sc->hdev,
2747                                  "can't create sysfs bt_poll_interval attribute err: %d\n",
2748                                  ret);
2749                 }
2750
2751                 if (sc->quirks & DUALSHOCK4_DONGLE) {
2752                         INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2753                         sc->hotplug_worker_initialized = 1;
2754                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2755                 }
2756
2757                 sony_init_output_report(sc, dualshock4_send_output_report);
2758         } else if (sc->quirks & NSG_MRXU_REMOTE) {
2759                 /*
2760                  * The NSG-MRxU touchpad supports 2 touches and has a
2761                  * resolution of 1667x1868
2762                  */
2763                 ret = sony_register_touchpad(sc, 2,
2764                         NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2765                 if (ret) {
2766                         hid_err(sc->hdev,
2767                         "Unable to initialize multi-touch slots: %d\n",
2768                         ret);
2769                         goto err_stop;
2770                 }
2771
2772         } else if (sc->quirks & MOTION_CONTROLLER) {
2773                 sony_init_output_report(sc, motion_send_output_report);
2774         } else {
2775                 ret = 0;
2776         }
2777
2778         if (sc->quirks & SONY_LED_SUPPORT) {
2779                 ret = sony_leds_init(sc);
2780                 if (ret < 0)
2781                         goto err_stop;
2782         }
2783
2784         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2785                 ret = sony_battery_probe(sc, append_dev_id);
2786                 if (ret < 0)
2787                         goto err_stop;
2788
2789                 /* Open the device to receive reports with battery info */
2790                 ret = hid_hw_open(hdev);
2791                 if (ret < 0) {
2792                         hid_err(hdev, "hw open failed\n");
2793                         goto err_stop;
2794                 }
2795         }
2796
2797         if (sc->quirks & SONY_FF_SUPPORT) {
2798                 ret = sony_init_ff(sc);
2799                 if (ret < 0)
2800                         goto err_close;
2801         }
2802
2803         return 0;
2804 err_close:
2805         hid_hw_close(hdev);
2806 err_stop:
2807         /* Piggy back on the default ds4_bt_ poll_interval to determine
2808          * if we need to remove the file as we don't know for sure if we
2809          * executed that logic.
2810          */
2811         if (sc->ds4_bt_poll_interval)
2812                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2813         if (sc->fw_version)
2814                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2815         if (sc->hw_version)
2816                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2817         sony_cancel_work_sync(sc);
2818         sony_remove_dev_list(sc);
2819         sony_release_device_id(sc);
2820         return ret;
2821 }
2822
2823 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2824 {
2825         int ret;
2826         unsigned long quirks = id->driver_data;
2827         struct sony_sc *sc;
2828         unsigned int connect_mask = HID_CONNECT_DEFAULT;
2829
2830         if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2831                 quirks |= FUTUREMAX_DANCE_MAT;
2832
2833         if (!strcmp(hdev->name, "SHANWAN PS3 GamePad"))
2834                 quirks |= SHANWAN_GAMEPAD;
2835
2836         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2837         if (sc == NULL) {
2838                 hid_err(hdev, "can't alloc sony descriptor\n");
2839                 return -ENOMEM;
2840         }
2841
2842         spin_lock_init(&sc->lock);
2843
2844         sc->quirks = quirks;
2845         hid_set_drvdata(hdev, sc);
2846         sc->hdev = hdev;
2847
2848         ret = hid_parse(hdev);
2849         if (ret) {
2850                 hid_err(hdev, "parse failed\n");
2851                 return ret;
2852         }
2853
2854         if (sc->quirks & VAIO_RDESC_CONSTANT)
2855                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2856         else if (sc->quirks & SIXAXIS_CONTROLLER)
2857                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2858
2859         /* Patch the hw version on DS3/4 compatible devices, so applications can
2860          * distinguish between the default HID mappings and the mappings defined
2861          * by the Linux game controller spec. This is important for the SDL2
2862          * library, which has a game controller database, which uses device ids
2863          * in combination with version as a key.
2864          */
2865         if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
2866                 hdev->version |= 0x8000;
2867
2868         ret = hid_hw_start(hdev, connect_mask);
2869         if (ret) {
2870                 hid_err(hdev, "hw start failed\n");
2871                 return ret;
2872         }
2873
2874         /* sony_input_configured can fail, but this doesn't result
2875          * in hid_hw_start failures (intended). Check whether
2876          * the HID layer claimed the device else fail.
2877          * We don't know the actual reason for the failure, most
2878          * likely it is due to EEXIST in case of double connection
2879          * of USB and Bluetooth, but could have been due to ENOMEM
2880          * or other reasons as well.
2881          */
2882         if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2883                 hid_err(hdev, "failed to claim input\n");
2884                 hid_hw_stop(hdev);
2885                 return -ENODEV;
2886         }
2887
2888         return ret;
2889 }
2890
2891 static void sony_remove(struct hid_device *hdev)
2892 {
2893         struct sony_sc *sc = hid_get_drvdata(hdev);
2894
2895         hid_hw_close(hdev);
2896
2897         if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2898                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2899
2900         if (sc->fw_version)
2901                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2902
2903         if (sc->hw_version)
2904                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2905
2906         sony_cancel_work_sync(sc);
2907
2908         sony_remove_dev_list(sc);
2909
2910         sony_release_device_id(sc);
2911
2912         hid_hw_stop(hdev);
2913 }
2914
2915 #ifdef CONFIG_PM
2916
2917 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2918 {
2919 #ifdef CONFIG_SONY_FF
2920
2921         /* On suspend stop any running force-feedback events */
2922         if (SONY_FF_SUPPORT) {
2923                 struct sony_sc *sc = hid_get_drvdata(hdev);
2924
2925                 sc->left = sc->right = 0;
2926                 sony_send_output_report(sc);
2927         }
2928
2929 #endif
2930         return 0;
2931 }
2932
2933 static int sony_resume(struct hid_device *hdev)
2934 {
2935         struct sony_sc *sc = hid_get_drvdata(hdev);
2936
2937         /*
2938          * The Sixaxis and navigation controllers on USB need to be
2939          * reinitialized on resume or they won't behave properly.
2940          */
2941         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2942                 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2943                 sixaxis_set_operational_usb(sc->hdev);
2944                 sc->defer_initialization = 1;
2945         }
2946
2947         return 0;
2948 }
2949
2950 #endif
2951
2952 static const struct hid_device_id sony_devices[] = {
2953         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2954                 .driver_data = SIXAXIS_CONTROLLER_USB },
2955         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2956                 .driver_data = NAVIGATION_CONTROLLER_USB },
2957         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2958                 .driver_data = NAVIGATION_CONTROLLER_BT },
2959         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2960                 .driver_data = MOTION_CONTROLLER_USB },
2961         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2962                 .driver_data = MOTION_CONTROLLER_BT },
2963         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2964                 .driver_data = SIXAXIS_CONTROLLER_BT },
2965         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2966                 .driver_data = VAIO_RDESC_CONSTANT },
2967         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2968                 .driver_data = VAIO_RDESC_CONSTANT },
2969         /*
2970          * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2971          * Logitech joystick from the device descriptor.
2972          */
2973         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2974                 .driver_data = BUZZ_CONTROLLER },
2975         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2976                 .driver_data = BUZZ_CONTROLLER },
2977         /* PS3 BD Remote Control */
2978         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2979                 .driver_data = PS3REMOTE },
2980         /* Logitech Harmony Adapter for PS3 */
2981         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2982                 .driver_data = PS3REMOTE },
2983         /* SMK-Link PS3 BD Remote Control */
2984         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2985                 .driver_data = PS3REMOTE },
2986         /* Sony Dualshock 4 controllers for PS4 */
2987         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2988                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2989         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2990                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2991         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2992                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2993         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2994                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2995         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
2996                 .driver_data = DUALSHOCK4_DONGLE },
2997         /* Nyko Core Controller for PS3 */
2998         { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2999                 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
3000         /* SMK-Link NSG-MR5U Remote Control */
3001         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3002                 .driver_data = NSG_MR5U_REMOTE_BT },
3003         /* SMK-Link NSG-MR7U Remote Control */
3004         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3005                 .driver_data = NSG_MR7U_REMOTE_BT },
3006         { }
3007 };
3008 MODULE_DEVICE_TABLE(hid, sony_devices);
3009
3010 static struct hid_driver sony_driver = {
3011         .name             = "sony",
3012         .id_table         = sony_devices,
3013         .input_mapping    = sony_mapping,
3014         .input_configured = sony_input_configured,
3015         .probe            = sony_probe,
3016         .remove           = sony_remove,
3017         .report_fixup     = sony_report_fixup,
3018         .raw_event        = sony_raw_event,
3019
3020 #ifdef CONFIG_PM
3021         .suspend          = sony_suspend,
3022         .resume           = sony_resume,
3023         .reset_resume     = sony_resume,
3024 #endif
3025 };
3026
3027 static int __init sony_init(void)
3028 {
3029         dbg_hid("Sony:%s\n", __func__);
3030
3031         return hid_register_driver(&sony_driver);
3032 }
3033
3034 static void __exit sony_exit(void)
3035 {
3036         dbg_hid("Sony:%s\n", __func__);
3037
3038         hid_unregister_driver(&sony_driver);
3039         ida_destroy(&sony_device_id_allocator);
3040 }
3041 module_init(sony_init);
3042 module_exit(sony_exit);
3043
3044 MODULE_LICENSE("GPL");