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