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