drivers/hid/hid-sony.c

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