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