drivers/hid/hid-sony.c

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