drivers/hid/hid-sony.c

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