drivers/hid/hid-sony.c

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