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 = devm_input_allocate_device(&sc->hdev->dev);
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 = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1374         if (!name)
1375                 return -ENOMEM;
1376         snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1377         sc->touchpad->name = name;
1378
1379         /* We map the button underneath the touchpad to BTN_LEFT. */
1380         __set_bit(EV_KEY, sc->touchpad->evbit);
1381         __set_bit(BTN_LEFT, sc->touchpad->keybit);
1382         __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1383
1384         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1385         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1386
1387         if (touch_major > 0) {
1388                 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1389                         0, touch_major, 0, 0);
1390                 if (touch_minor > 0)
1391                         input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1392                                 0, touch_minor, 0, 0);
1393                 if (orientation > 0)
1394                         input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1395                                 0, orientation, 0, 0);
1396         }
1397
1398         if (sc->quirks & NSG_MRXU_REMOTE) {
1399                 __set_bit(EV_REL, sc->touchpad->evbit);
1400         }
1401
1402         ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1403         if (ret < 0)
1404                 return ret;
1405
1406         ret = input_register_device(sc->touchpad);
1407         if (ret < 0)
1408                 return ret;
1409
1410         return 0;
1411 }
1412
1413 static int sony_register_sensors(struct sony_sc *sc)
1414 {
1415         size_t name_sz;
1416         char *name;
1417         int ret;
1418         int range;
1419
1420         sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1421         if (!sc->sensor_dev)
1422                 return -ENOMEM;
1423
1424         input_set_drvdata(sc->sensor_dev, sc);
1425         sc->sensor_dev->dev.parent = &sc->hdev->dev;
1426         sc->sensor_dev->phys = sc->hdev->phys;
1427         sc->sensor_dev->uniq = sc->hdev->uniq;
1428         sc->sensor_dev->id.bustype = sc->hdev->bus;
1429         sc->sensor_dev->id.vendor = sc->hdev->vendor;
1430         sc->sensor_dev->id.product = sc->hdev->product;
1431         sc->sensor_dev->id.version = sc->hdev->version;
1432
1433         /* Append a suffix to the controller name as there are various
1434          * DS4 compatible non-Sony devices with different names.
1435          */
1436         name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1437         name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1438         if (!name)
1439                 return -ENOMEM;
1440         snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1441         sc->sensor_dev->name = name;
1442
1443         if (sc->quirks & SIXAXIS_CONTROLLER) {
1444                 /* For the DS3 we only support the accelerometer, which works
1445                  * quite well even without calibration. The device also has
1446                  * a 1-axis gyro, but it is very difficult to manage from within
1447                  * the driver even to get data, the sensor is inaccurate and
1448                  * the behavior is very different between hardware revisions.
1449                  */
1450                 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1451                 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1452                 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1453                 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1454                 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1455                 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1456         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1457                 range = DS4_ACC_RES_PER_G*4;
1458                 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1459                 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1460                 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1461                 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1462                 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1463                 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1464
1465                 range = DS4_GYRO_RES_PER_DEG_S*2048;
1466                 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1467                 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1468                 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1469                 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1470                 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1471                 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1472
1473                 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1474                 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1475         }
1476
1477         __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1478
1479         ret = input_register_device(sc->sensor_dev);
1480         if (ret < 0)
1481                 return ret;
1482
1483         return 0;
1484 }
1485
1486 /*
1487  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1488  * to "operational".  Without this, the ps3 controller will not report any
1489  * events.
1490  */
1491 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1492 {
1493         const int buf_size =
1494                 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1495         u8 *buf;
1496         int ret;
1497
1498         buf = kmalloc(buf_size, GFP_KERNEL);
1499         if (!buf)
1500                 return -ENOMEM;
1501
1502         ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1503                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1504         if (ret < 0) {
1505                 hid_err(hdev, "can't set operational mode: step 1\n");
1506                 goto out;
1507         }
1508
1509         /*
1510          * Some compatible controllers like the Speedlink Strike FX and
1511          * Gasia need another query plus an USB interrupt to get operational.
1512          */
1513         ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1514                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1515         if (ret < 0) {
1516                 hid_err(hdev, "can't set operational mode: step 2\n");
1517                 goto out;
1518         }
1519
1520         /*
1521          * But the USB interrupt would cause SHANWAN controllers to
1522          * start rumbling non-stop.
1523          */
1524         if (strcmp(hdev->name, "SHANWAN PS3 GamePad")) {
1525                 ret = hid_hw_output_report(hdev, buf, 1);
1526                 if (ret < 0) {
1527                         hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1528                         ret = 0;
1529                 }
1530         }
1531
1532 out:
1533         kfree(buf);
1534
1535         return ret;
1536 }
1537
1538 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1539 {
1540         static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1541         u8 *buf;
1542         int ret;
1543
1544         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1545         if (!buf)
1546                 return -ENOMEM;
1547
1548         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1549                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1550
1551         kfree(buf);
1552
1553         return ret;
1554 }
1555
1556 /*
1557  * Request DS4 calibration data for the motion sensors.
1558  * For Bluetooth this also affects the operating mode (see below).
1559  */
1560 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1561 {
1562         u8 *buf;
1563         int ret;
1564         short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1565         short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1566         short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1567         short gyro_speed_plus, gyro_speed_minus;
1568         short acc_x_plus, acc_x_minus;
1569         short acc_y_plus, acc_y_minus;
1570         short acc_z_plus, acc_z_minus;
1571         int speed_2x;
1572         int range_2g;
1573
1574         /* For Bluetooth we use a different request, which supports CRC.
1575          * Note: in Bluetooth mode feature report 0x02 also changes the state
1576          * of the controller, so that it sends input reports of type 0x11.
1577          */
1578         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1579                 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1580                 if (!buf)
1581                         return -ENOMEM;
1582
1583                 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1584                                          DS4_FEATURE_REPORT_0x02_SIZE,
1585                                          HID_FEATURE_REPORT,
1586                                          HID_REQ_GET_REPORT);
1587                 if (ret < 0)
1588                         goto err_stop;
1589         } else {
1590                 u8 bthdr = 0xA3;
1591                 u32 crc;
1592                 u32 report_crc;
1593                 int retries;
1594
1595                 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1596                 if (!buf)
1597                         return -ENOMEM;
1598
1599                 for (retries = 0; retries < 3; retries++) {
1600                         ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1601                                                  DS4_FEATURE_REPORT_0x05_SIZE,
1602                                                  HID_FEATURE_REPORT,
1603                                                  HID_REQ_GET_REPORT);
1604                         if (ret < 0)
1605                                 goto err_stop;
1606
1607                         /* CRC check */
1608                         crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1609                         crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1610                         report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1611                         if (crc != report_crc) {
1612                                 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1613                                         report_crc, crc);
1614                                 if (retries < 2) {
1615                                         hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1616                                         continue;
1617                                 } else {
1618                                         ret = -EILSEQ;
1619                                         goto err_stop;
1620                                 }
1621                         } else {
1622                                 break;
1623                         }
1624                 }
1625         }
1626
1627         gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
1628         gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
1629         gyro_roll_bias   = get_unaligned_le16(&buf[5]);
1630         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1631                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1632                 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1633                 gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
1634                 gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
1635                 gyro_roll_plus   = get_unaligned_le16(&buf[15]);
1636                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1637         } else {
1638                 /* BT + Dongle */
1639                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1640                 gyro_yaw_plus    = get_unaligned_le16(&buf[9]);
1641                 gyro_roll_plus   = get_unaligned_le16(&buf[11]);
1642                 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1643                 gyro_yaw_minus   = get_unaligned_le16(&buf[15]);
1644                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1645         }
1646         gyro_speed_plus  = get_unaligned_le16(&buf[19]);
1647         gyro_speed_minus = get_unaligned_le16(&buf[21]);
1648         acc_x_plus       = get_unaligned_le16(&buf[23]);
1649         acc_x_minus      = get_unaligned_le16(&buf[25]);
1650         acc_y_plus       = get_unaligned_le16(&buf[27]);
1651         acc_y_minus      = get_unaligned_le16(&buf[29]);
1652         acc_z_plus       = get_unaligned_le16(&buf[31]);
1653         acc_z_minus      = get_unaligned_le16(&buf[33]);
1654
1655         /* Set gyroscope calibration and normalization parameters.
1656          * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1657          */
1658         speed_2x = (gyro_speed_plus + gyro_speed_minus);
1659         sc->ds4_calib_data[0].abs_code = ABS_RX;
1660         sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1661         sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1662         sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1663
1664         sc->ds4_calib_data[1].abs_code = ABS_RY;
1665         sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1666         sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1667         sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1668
1669         sc->ds4_calib_data[2].abs_code = ABS_RZ;
1670         sc->ds4_calib_data[2].bias = gyro_roll_bias;
1671         sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1672         sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1673
1674         /* Set accelerometer calibration and normalization parameters.
1675          * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1676          */
1677         range_2g = acc_x_plus - acc_x_minus;
1678         sc->ds4_calib_data[3].abs_code = ABS_X;
1679         sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1680         sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1681         sc->ds4_calib_data[3].sens_denom = range_2g;
1682
1683         range_2g = acc_y_plus - acc_y_minus;
1684         sc->ds4_calib_data[4].abs_code = ABS_Y;
1685         sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1686         sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1687         sc->ds4_calib_data[4].sens_denom = range_2g;
1688
1689         range_2g = acc_z_plus - acc_z_minus;
1690         sc->ds4_calib_data[5].abs_code = ABS_Z;
1691         sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1692         sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1693         sc->ds4_calib_data[5].sens_denom = range_2g;
1694
1695 err_stop:
1696         kfree(buf);
1697         return ret;
1698 }
1699
1700 static void dualshock4_calibration_work(struct work_struct *work)
1701 {
1702         struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1703         unsigned long flags;
1704         enum ds4_dongle_state dongle_state;
1705         int ret;
1706
1707         ret = dualshock4_get_calibration_data(sc);
1708         if (ret < 0) {
1709                 /* This call is very unlikely to fail for the dongle. When it
1710                  * fails we are probably in a very bad state, so mark the
1711                  * dongle as disabled. We will re-enable the dongle if a new
1712                  * DS4 hotplug is detect from sony_raw_event as any issues
1713                  * are likely resolved then (the dongle is quite stupid).
1714                  */
1715                 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1716                 dongle_state = DONGLE_DISABLED;
1717         } else {
1718                 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1719                 dongle_state = DONGLE_CONNECTED;
1720         }
1721
1722         spin_lock_irqsave(&sc->lock, flags);
1723         sc->ds4_dongle_state = dongle_state;
1724         spin_unlock_irqrestore(&sc->lock, flags);
1725 }
1726
1727 static int dualshock4_get_version_info(struct sony_sc *sc)
1728 {
1729         u8 *buf;
1730         int ret;
1731
1732         buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1733         if (!buf)
1734                 return -ENOMEM;
1735
1736         ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1737                                  DS4_FEATURE_REPORT_0xA3_SIZE,
1738                                  HID_FEATURE_REPORT,
1739                                  HID_REQ_GET_REPORT);
1740         if (ret < 0) {
1741                 kfree(buf);
1742                 return ret;
1743         }
1744
1745         sc->hw_version = get_unaligned_le16(&buf[35]);
1746         sc->fw_version = get_unaligned_le16(&buf[41]);
1747
1748         kfree(buf);
1749         return 0;
1750 }
1751
1752 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1753 {
1754         static const u8 sixaxis_leds[10][4] = {
1755                                 { 0x01, 0x00, 0x00, 0x00 },
1756                                 { 0x00, 0x01, 0x00, 0x00 },
1757                                 { 0x00, 0x00, 0x01, 0x00 },
1758                                 { 0x00, 0x00, 0x00, 0x01 },
1759                                 { 0x01, 0x00, 0x00, 0x01 },
1760                                 { 0x00, 0x01, 0x00, 0x01 },
1761                                 { 0x00, 0x00, 0x01, 0x01 },
1762                                 { 0x01, 0x00, 0x01, 0x01 },
1763                                 { 0x00, 0x01, 0x01, 0x01 },
1764                                 { 0x01, 0x01, 0x01, 0x01 }
1765         };
1766
1767         int id = sc->device_id;
1768
1769         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1770
1771         if (id < 0)
1772                 return;
1773
1774         id %= 10;
1775         memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1776 }
1777
1778 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1779 {
1780         /* The first 4 color/index entries match what the PS4 assigns */
1781         static const u8 color_code[7][3] = {
1782                         /* Blue   */    { 0x00, 0x00, 0x40 },
1783                         /* Red    */    { 0x40, 0x00, 0x00 },
1784                         /* Green  */    { 0x00, 0x40, 0x00 },
1785                         /* Pink   */    { 0x20, 0x00, 0x20 },
1786                         /* Orange */    { 0x02, 0x01, 0x00 },
1787                         /* Teal   */    { 0x00, 0x01, 0x01 },
1788                         /* White  */    { 0x01, 0x01, 0x01 }
1789         };
1790
1791         int id = sc->device_id;
1792
1793         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1794
1795         if (id < 0)
1796                 return;
1797
1798         id %= 7;
1799         memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1800 }
1801
1802 static void buzz_set_leds(struct sony_sc *sc)
1803 {
1804         struct hid_device *hdev = sc->hdev;
1805         struct list_head *report_list =
1806                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1807         struct hid_report *report = list_entry(report_list->next,
1808                 struct hid_report, list);
1809         s32 *value = report->field[0]->value;
1810
1811         BUILD_BUG_ON(MAX_LEDS < 4);
1812
1813         value[0] = 0x00;
1814         value[1] = sc->led_state[0] ? 0xff : 0x00;
1815         value[2] = sc->led_state[1] ? 0xff : 0x00;
1816         value[3] = sc->led_state[2] ? 0xff : 0x00;
1817         value[4] = sc->led_state[3] ? 0xff : 0x00;
1818         value[5] = 0x00;
1819         value[6] = 0x00;
1820         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1821 }
1822
1823 static void sony_set_leds(struct sony_sc *sc)
1824 {
1825         if (!(sc->quirks & BUZZ_CONTROLLER))
1826                 sony_schedule_work(sc, SONY_WORKER_STATE);
1827         else
1828                 buzz_set_leds(sc);
1829 }
1830
1831 static void sony_led_set_brightness(struct led_classdev *led,
1832                                     enum led_brightness value)
1833 {
1834         struct device *dev = led->dev->parent;
1835         struct hid_device *hdev = to_hid_device(dev);
1836         struct sony_sc *drv_data;
1837
1838         int n;
1839         int force_update;
1840
1841         drv_data = hid_get_drvdata(hdev);
1842         if (!drv_data) {
1843                 hid_err(hdev, "No device data\n");
1844                 return;
1845         }
1846
1847         /*
1848          * The Sixaxis on USB will override any LED settings sent to it
1849          * and keep flashing all of the LEDs until the PS button is pressed.
1850          * Updates, even if redundant, must be always be sent to the
1851          * controller to avoid having to toggle the state of an LED just to
1852          * stop the flashing later on.
1853          */
1854         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1855
1856         for (n = 0; n < drv_data->led_count; n++) {
1857                 if (led == drv_data->leds[n] && (force_update ||
1858                         (value != drv_data->led_state[n] ||
1859                         drv_data->led_delay_on[n] ||
1860                         drv_data->led_delay_off[n]))) {
1861
1862                         drv_data->led_state[n] = value;
1863
1864                         /* Setting the brightness stops the blinking */
1865                         drv_data->led_delay_on[n] = 0;
1866                         drv_data->led_delay_off[n] = 0;
1867
1868                         sony_set_leds(drv_data);
1869                         break;
1870                 }
1871         }
1872 }
1873
1874 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1875 {
1876         struct device *dev = led->dev->parent;
1877         struct hid_device *hdev = to_hid_device(dev);
1878         struct sony_sc *drv_data;
1879
1880         int n;
1881
1882         drv_data = hid_get_drvdata(hdev);
1883         if (!drv_data) {
1884                 hid_err(hdev, "No device data\n");
1885                 return LED_OFF;
1886         }
1887
1888         for (n = 0; n < drv_data->led_count; n++) {
1889                 if (led == drv_data->leds[n])
1890                         return drv_data->led_state[n];
1891         }
1892
1893         return LED_OFF;
1894 }
1895
1896 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1897                                 unsigned long *delay_off)
1898 {
1899         struct device *dev = led->dev->parent;
1900         struct hid_device *hdev = to_hid_device(dev);
1901         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1902         int n;
1903         u8 new_on, new_off;
1904
1905         if (!drv_data) {
1906                 hid_err(hdev, "No device data\n");
1907                 return -EINVAL;
1908         }
1909
1910         /* Max delay is 255 deciseconds or 2550 milliseconds */
1911         if (*delay_on > 2550)
1912                 *delay_on = 2550;
1913         if (*delay_off > 2550)
1914                 *delay_off = 2550;
1915
1916         /* Blink at 1 Hz if both values are zero */
1917         if (!*delay_on && !*delay_off)
1918                 *delay_on = *delay_off = 500;
1919
1920         new_on = *delay_on / 10;
1921         new_off = *delay_off / 10;
1922
1923         for (n = 0; n < drv_data->led_count; n++) {
1924                 if (led == drv_data->leds[n])
1925                         break;
1926         }
1927
1928         /* This LED is not registered on this device */
1929         if (n >= drv_data->led_count)
1930                 return -EINVAL;
1931
1932         /* Don't schedule work if the values didn't change */
1933         if (new_on != drv_data->led_delay_on[n] ||
1934                 new_off != drv_data->led_delay_off[n]) {
1935                 drv_data->led_delay_on[n] = new_on;
1936                 drv_data->led_delay_off[n] = new_off;
1937                 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1938         }
1939
1940         return 0;
1941 }
1942
1943 static int sony_leds_init(struct sony_sc *sc)
1944 {
1945         struct hid_device *hdev = sc->hdev;
1946         int n, ret = 0;
1947         int use_ds4_names;
1948         struct led_classdev *led;
1949         size_t name_sz;
1950         char *name;
1951         size_t name_len;
1952         const char *name_fmt;
1953         static const char * const ds4_name_str[] = { "red", "green", "blue",
1954                                                   "global" };
1955         u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1956         u8 use_hw_blink[MAX_LEDS] = { 0 };
1957
1958         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1959
1960         if (sc->quirks & BUZZ_CONTROLLER) {
1961                 sc->led_count = 4;
1962                 use_ds4_names = 0;
1963                 name_len = strlen("::buzz#");
1964                 name_fmt = "%s::buzz%d";
1965                 /* Validate expected report characteristics. */
1966                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1967                         return -ENODEV;
1968         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1969                 dualshock4_set_leds_from_id(sc);
1970                 sc->led_state[3] = 1;
1971                 sc->led_count = 4;
1972                 memset(max_brightness, 255, 3);
1973                 use_hw_blink[3] = 1;
1974                 use_ds4_names = 1;
1975                 name_len = 0;
1976                 name_fmt = "%s:%s";
1977         } else if (sc->quirks & MOTION_CONTROLLER) {
1978                 sc->led_count = 3;
1979                 memset(max_brightness, 255, 3);
1980                 use_ds4_names = 1;
1981                 name_len = 0;
1982                 name_fmt = "%s:%s";
1983         } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1984                 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1985
1986                 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1987                 sc->led_count = 1;
1988                 memset(use_hw_blink, 1, 4);
1989                 use_ds4_names = 0;
1990                 name_len = strlen("::sony#");
1991                 name_fmt = "%s::sony%d";
1992         } else {
1993                 sixaxis_set_leds_from_id(sc);
1994                 sc->led_count = 4;
1995                 memset(use_hw_blink, 1, 4);
1996                 use_ds4_names = 0;
1997                 name_len = strlen("::sony#");
1998                 name_fmt = "%s::sony%d";
1999         }
2000
2001         /*
2002          * Clear LEDs as we have no way of reading their initial state. This is
2003          * only relevant if the driver is loaded after somebody actively set the
2004          * LEDs to on
2005          */
2006         sony_set_leds(sc);
2007
2008         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2009
2010         for (n = 0; n < sc->led_count; n++) {
2011
2012                 if (use_ds4_names)
2013                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2014
2015                 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2016                 if (!led) {
2017                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2018                         return -ENOMEM;
2019                 }
2020
2021                 name = (void *)(&led[1]);
2022                 if (use_ds4_names)
2023                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2024                         ds4_name_str[n]);
2025                 else
2026                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2027                 led->name = name;
2028                 led->brightness = sc->led_state[n];
2029                 led->max_brightness = max_brightness[n];
2030                 led->flags = LED_CORE_SUSPENDRESUME;
2031                 led->brightness_get = sony_led_get_brightness;
2032                 led->brightness_set = sony_led_set_brightness;
2033
2034                 if (use_hw_blink[n])
2035                         led->blink_set = sony_led_blink_set;
2036
2037                 sc->leds[n] = led;
2038
2039                 ret = devm_led_classdev_register(&hdev->dev, led);
2040                 if (ret) {
2041                         hid_err(hdev, "Failed to register LED %d\n", n);
2042                         return ret;
2043                 }
2044         }
2045
2046         return 0;
2047 }
2048
2049 static void sixaxis_send_output_report(struct sony_sc *sc)
2050 {
2051         static const union sixaxis_output_report_01 default_report = {
2052                 .buf = {
2053                         0x01,
2054                         0x01, 0xff, 0x00, 0xff, 0x00,
2055                         0x00, 0x00, 0x00, 0x00, 0x00,
2056                         0xff, 0x27, 0x10, 0x00, 0x32,
2057                         0xff, 0x27, 0x10, 0x00, 0x32,
2058                         0xff, 0x27, 0x10, 0x00, 0x32,
2059                         0xff, 0x27, 0x10, 0x00, 0x32,
2060                         0x00, 0x00, 0x00, 0x00, 0x00
2061                 }
2062         };
2063         struct sixaxis_output_report *report =
2064                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2065         int n;
2066
2067         /* Initialize the report with default values */
2068         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2069
2070 #ifdef CONFIG_SONY_FF
2071         report->rumble.right_motor_on = sc->right ? 1 : 0;
2072         report->rumble.left_motor_force = sc->left;
2073 #endif
2074
2075         report->leds_bitmap |= sc->led_state[0] << 1;
2076         report->leds_bitmap |= sc->led_state[1] << 2;
2077         report->leds_bitmap |= sc->led_state[2] << 3;
2078         report->leds_bitmap |= sc->led_state[3] << 4;
2079
2080         /* Set flag for all leds off, required for 3rd party INTEC controller */
2081         if ((report->leds_bitmap & 0x1E) == 0)
2082                 report->leds_bitmap |= 0x20;
2083
2084         /*
2085          * The LEDs in the report are indexed in reverse order to their
2086          * corresponding light on the controller.
2087          * Index 0 = LED 4, index 1 = LED 3, etc...
2088          *
2089          * In the case of both delay values being zero (blinking disabled) the
2090          * default report values should be used or the controller LED will be
2091          * always off.
2092          */
2093         for (n = 0; n < 4; n++) {
2094                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2095                         report->led[3 - n].duty_off = sc->led_delay_off[n];
2096                         report->led[3 - n].duty_on = sc->led_delay_on[n];
2097                 }
2098         }
2099
2100         hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2101                         sizeof(struct sixaxis_output_report),
2102                         HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2103 }
2104
2105 static void dualshock4_send_output_report(struct sony_sc *sc)
2106 {
2107         struct hid_device *hdev = sc->hdev;
2108         u8 *buf = sc->output_report_dmabuf;
2109         int offset;
2110
2111         /*
2112          * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2113          * control the interval at which Dualshock 4 reports data:
2114          * 0x00 - 1ms
2115          * 0x01 - 1ms
2116          * 0x02 - 2ms
2117          * 0x3E - 62ms
2118          * 0x3F - disabled
2119          */
2120         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2121                 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2122                 buf[0] = 0x05;
2123                 buf[1] = 0x07; /* blink + LEDs + motor */
2124                 offset = 4;
2125         } else {
2126                 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2127                 buf[0] = 0x11;
2128                 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2129                 buf[3] = 0x07; /* blink + LEDs + motor */
2130                 offset = 6;
2131         }
2132
2133 #ifdef CONFIG_SONY_FF
2134         buf[offset++] = sc->right;
2135         buf[offset++] = sc->left;
2136 #else
2137         offset += 2;
2138 #endif
2139
2140         /* LED 3 is the global control */
2141         if (sc->led_state[3]) {
2142                 buf[offset++] = sc->led_state[0];
2143                 buf[offset++] = sc->led_state[1];
2144                 buf[offset++] = sc->led_state[2];
2145         } else {
2146                 offset += 3;
2147         }
2148
2149         /* If both delay values are zero the DualShock 4 disables blinking. */
2150         buf[offset++] = sc->led_delay_on[3];
2151         buf[offset++] = sc->led_delay_off[3];
2152
2153         if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2154                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2155         else {
2156                 /* CRC generation */
2157                 u8 bthdr = 0xA2;
2158                 u32 crc;
2159
2160                 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2161                 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2162                 put_unaligned_le32(crc, &buf[74]);
2163                 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2164         }
2165 }
2166
2167 static void motion_send_output_report(struct sony_sc *sc)
2168 {
2169         struct hid_device *hdev = sc->hdev;
2170         struct motion_output_report_02 *report =
2171                 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2172
2173         memset(report, 0, MOTION_REPORT_0x02_SIZE);
2174
2175         report->type = 0x02; /* set leds */
2176         report->r = sc->led_state[0];
2177         report->g = sc->led_state[1];
2178         report->b = sc->led_state[2];
2179
2180 #ifdef CONFIG_SONY_FF
2181         report->rumble = max(sc->right, sc->left);
2182 #endif
2183
2184         hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2185 }
2186
2187 static inline void sony_send_output_report(struct sony_sc *sc)
2188 {
2189         if (sc->send_output_report)
2190                 sc->send_output_report(sc);
2191 }
2192
2193 static void sony_state_worker(struct work_struct *work)
2194 {
2195         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2196
2197         sc->send_output_report(sc);
2198 }
2199
2200 static int sony_allocate_output_report(struct sony_sc *sc)
2201 {
2202         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2203                         (sc->quirks & NAVIGATION_CONTROLLER))
2204                 sc->output_report_dmabuf =
2205                         devm_kmalloc(&sc->hdev->dev,
2206                                 sizeof(union sixaxis_output_report_01),
2207                                 GFP_KERNEL);
2208         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2209                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2210                                                 DS4_OUTPUT_REPORT_0x11_SIZE,
2211                                                 GFP_KERNEL);
2212         else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2213                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2214                                                 DS4_OUTPUT_REPORT_0x05_SIZE,
2215                                                 GFP_KERNEL);
2216         else if (sc->quirks & MOTION_CONTROLLER)
2217                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2218                                                 MOTION_REPORT_0x02_SIZE,
2219                                                 GFP_KERNEL);
2220         else
2221                 return 0;
2222
2223         if (!sc->output_report_dmabuf)
2224                 return -ENOMEM;
2225
2226         return 0;
2227 }
2228
2229 #ifdef CONFIG_SONY_FF
2230 static int sony_play_effect(struct input_dev *dev, void *data,
2231                             struct ff_effect *effect)
2232 {
2233         struct hid_device *hid = input_get_drvdata(dev);
2234         struct sony_sc *sc = hid_get_drvdata(hid);
2235
2236         if (effect->type != FF_RUMBLE)
2237                 return 0;
2238
2239         sc->left = effect->u.rumble.strong_magnitude / 256;
2240         sc->right = effect->u.rumble.weak_magnitude / 256;
2241
2242         sony_schedule_work(sc, SONY_WORKER_STATE);
2243         return 0;
2244 }
2245
2246 static int sony_init_ff(struct sony_sc *sc)
2247 {
2248         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
2249                                                 struct hid_input, list);
2250         struct input_dev *input_dev = hidinput->input;
2251
2252         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2253         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2254 }
2255
2256 #else
2257 static int sony_init_ff(struct sony_sc *sc)
2258 {
2259         return 0;
2260 }
2261
2262 #endif
2263
2264 static int sony_battery_get_property(struct power_supply *psy,
2265                                      enum power_supply_property psp,
2266                                      union power_supply_propval *val)
2267 {
2268         struct sony_sc *sc = power_supply_get_drvdata(psy);
2269         unsigned long flags;
2270         int ret = 0;
2271         u8 battery_charging, battery_capacity, cable_state;
2272
2273         spin_lock_irqsave(&sc->lock, flags);
2274         battery_charging = sc->battery_charging;
2275         battery_capacity = sc->battery_capacity;
2276         cable_state = sc->cable_state;
2277         spin_unlock_irqrestore(&sc->lock, flags);
2278
2279         switch (psp) {
2280         case POWER_SUPPLY_PROP_PRESENT:
2281                 val->intval = 1;
2282                 break;
2283         case POWER_SUPPLY_PROP_SCOPE:
2284                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2285                 break;
2286         case POWER_SUPPLY_PROP_CAPACITY:
2287                 val->intval = battery_capacity;
2288                 break;
2289         case POWER_SUPPLY_PROP_STATUS:
2290                 if (battery_charging)
2291                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
2292                 else
2293                         if (battery_capacity == 100 && cable_state)
2294                                 val->intval = POWER_SUPPLY_STATUS_FULL;
2295                         else
2296                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2297                 break;
2298         default:
2299                 ret = -EINVAL;
2300                 break;
2301         }
2302         return ret;
2303 }
2304
2305 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2306 {
2307         const char *battery_str_fmt = append_dev_id ?
2308                 "sony_controller_battery_%pMR_%i" :
2309                 "sony_controller_battery_%pMR";
2310         struct power_supply_config psy_cfg = { .drv_data = sc, };
2311         struct hid_device *hdev = sc->hdev;
2312         int ret;
2313
2314         /*
2315          * Set the default battery level to 100% to avoid low battery warnings
2316          * if the battery is polled before the first device report is received.
2317          */
2318         sc->battery_capacity = 100;
2319
2320         sc->battery_desc.properties = sony_battery_props;
2321         sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2322         sc->battery_desc.get_property = sony_battery_get_property;
2323         sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2324         sc->battery_desc.use_for_apm = 0;
2325         sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2326                                           battery_str_fmt, sc->mac_address, sc->device_id);
2327         if (!sc->battery_desc.name)
2328                 return -ENOMEM;
2329
2330         sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2331                                             &psy_cfg);
2332         if (IS_ERR(sc->battery)) {
2333                 ret = PTR_ERR(sc->battery);
2334                 hid_err(hdev, "Unable to register battery device\n");
2335                 return ret;
2336         }
2337
2338         power_supply_powers(sc->battery, &hdev->dev);
2339         return 0;
2340 }
2341
2342 /*
2343  * If a controller is plugged in via USB while already connected via Bluetooth
2344  * it will show up as two devices. A global list of connected controllers and
2345  * their MAC addresses is maintained to ensure that a device is only connected
2346  * once.
2347  *
2348  * Some USB-only devices masquerade as Sixaxis controllers and all have the
2349  * same dummy Bluetooth address, so a comparison of the connection type is
2350  * required.  Devices are only rejected in the case where two devices have
2351  * matching Bluetooth addresses on different bus types.
2352  */
2353 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2354                                                 struct sony_sc *sc1)
2355 {
2356         const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2357         const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2358
2359         return sc0_not_bt == sc1_not_bt;
2360 }
2361
2362 static int sony_check_add_dev_list(struct sony_sc *sc)
2363 {
2364         struct sony_sc *entry;
2365         unsigned long flags;
2366         int ret;
2367
2368         spin_lock_irqsave(&sony_dev_list_lock, flags);
2369
2370         list_for_each_entry(entry, &sony_device_list, list_node) {
2371                 ret = memcmp(sc->mac_address, entry->mac_address,
2372                                 sizeof(sc->mac_address));
2373                 if (!ret) {
2374                         if (sony_compare_connection_type(sc, entry)) {
2375                                 ret = 1;
2376                         } else {
2377                                 ret = -EEXIST;
2378                                 hid_info(sc->hdev,
2379                                 "controller with MAC address %pMR already connected\n",
2380                                 sc->mac_address);
2381                         }
2382                         goto unlock;
2383                 }
2384         }
2385
2386         ret = 0;
2387         list_add(&(sc->list_node), &sony_device_list);
2388
2389 unlock:
2390         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2391         return ret;
2392 }
2393
2394 static void sony_remove_dev_list(struct sony_sc *sc)
2395 {
2396         unsigned long flags;
2397
2398         if (sc->list_node.next) {
2399                 spin_lock_irqsave(&sony_dev_list_lock, flags);
2400                 list_del(&(sc->list_node));
2401                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2402         }
2403 }
2404
2405 static int sony_get_bt_devaddr(struct sony_sc *sc)
2406 {
2407         int ret;
2408
2409         /* HIDP stores the device MAC address as a string in the uniq field. */
2410         ret = strlen(sc->hdev->uniq);
2411         if (ret != 17)
2412                 return -EINVAL;
2413
2414         ret = sscanf(sc->hdev->uniq,
2415                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2416                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2417                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2418
2419         if (ret != 6)
2420                 return -EINVAL;
2421
2422         return 0;
2423 }
2424
2425 static int sony_check_add(struct sony_sc *sc)
2426 {
2427         u8 *buf = NULL;
2428         int n, ret;
2429
2430         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2431             (sc->quirks & MOTION_CONTROLLER_BT) ||
2432             (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2433             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2434                 /*
2435                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2436                  * address from the uniq string where HIDP stores it.
2437                  * As uniq cannot be guaranteed to be a MAC address in all cases
2438                  * a failure of this function should not prevent the connection.
2439                  */
2440                 if (sony_get_bt_devaddr(sc) < 0) {
2441                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2442                         return 0;
2443                 }
2444         } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2445                 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2446                 if (!buf)
2447                         return -ENOMEM;
2448
2449                 /*
2450                  * The MAC address of a DS4 controller connected via USB can be
2451                  * retrieved with feature report 0x81. The address begins at
2452                  * offset 1.
2453                  */
2454                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2455                                 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2456                                 HID_REQ_GET_REPORT);
2457
2458                 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2459                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2460                         ret = ret < 0 ? ret : -EINVAL;
2461                         goto out_free;
2462                 }
2463
2464                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2465
2466                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2467                          "%pMR", sc->mac_address);
2468         } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2469                         (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2470                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2471                 if (!buf)
2472                         return -ENOMEM;
2473
2474                 /*
2475                  * The MAC address of a Sixaxis controller connected via USB can
2476                  * be retrieved with feature report 0xf2. The address begins at
2477                  * offset 4.
2478                  */
2479                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2480                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2481                                 HID_REQ_GET_REPORT);
2482
2483                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2484                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2485                         ret = ret < 0 ? ret : -EINVAL;
2486                         goto out_free;
2487                 }
2488
2489                 /*
2490                  * The Sixaxis device MAC in the report is big-endian and must
2491                  * be byte-swapped.
2492                  */
2493                 for (n = 0; n < 6; n++)
2494                         sc->mac_address[5-n] = buf[4+n];
2495
2496                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2497                          "%pMR", sc->mac_address);
2498         } else {
2499                 return 0;
2500         }
2501
2502         ret = sony_check_add_dev_list(sc);
2503
2504 out_free:
2505
2506         kfree(buf);
2507
2508         return ret;
2509 }
2510
2511 static int sony_set_device_id(struct sony_sc *sc)
2512 {
2513         int ret;
2514
2515         /*
2516          * Only DualShock 4 or Sixaxis controllers get an id.
2517          * All others are set to -1.
2518          */
2519         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2520             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2521                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2522                                         GFP_KERNEL);
2523                 if (ret < 0) {
2524                         sc->device_id = -1;
2525                         return ret;
2526                 }
2527                 sc->device_id = ret;
2528         } else {
2529                 sc->device_id = -1;
2530         }
2531
2532         return 0;
2533 }
2534
2535 static void sony_release_device_id(struct sony_sc *sc)
2536 {
2537         if (sc->device_id >= 0) {
2538                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2539                 sc->device_id = -1;
2540         }
2541 }
2542
2543 static inline void sony_init_output_report(struct sony_sc *sc,
2544                                 void (*send_output_report)(struct sony_sc *))
2545 {
2546         sc->send_output_report = send_output_report;
2547
2548         if (!sc->state_worker_initialized)
2549                 INIT_WORK(&sc->state_worker, sony_state_worker);
2550
2551         sc->state_worker_initialized = 1;
2552 }
2553
2554 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2555 {
2556         if (sc->hotplug_worker_initialized)
2557                 cancel_work_sync(&sc->hotplug_worker);
2558         if (sc->state_worker_initialized)
2559                 cancel_work_sync(&sc->state_worker);
2560 }
2561
2562
2563 static int sony_input_configured(struct hid_device *hdev,
2564                                         struct hid_input *hidinput)
2565 {
2566         struct sony_sc *sc = hid_get_drvdata(hdev);
2567         int append_dev_id;
2568         int ret;
2569
2570         ret = sony_set_device_id(sc);
2571         if (ret < 0) {
2572                 hid_err(hdev, "failed to allocate the device id\n");
2573                 goto err_stop;
2574         }
2575
2576         ret = append_dev_id = sony_check_add(sc);
2577         if (ret < 0)
2578                 goto err_stop;
2579
2580         ret = sony_allocate_output_report(sc);
2581         if (ret < 0) {
2582                 hid_err(hdev, "failed to allocate the output report buffer\n");
2583                 goto err_stop;
2584         }
2585
2586         if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2587                 /*
2588                  * The Sony Sixaxis does not handle HID Output Reports on the
2589                  * Interrupt EP like it could, so we need to force HID Output
2590                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
2591                  *
2592                  * There is also another issue about HID Output Reports via USB,
2593                  * the Sixaxis does not want the report_id as part of the data
2594                  * packet, so we have to discard buf[0] when sending the actual
2595                  * control message, even for numbered reports, humpf!
2596                  *
2597                  * Additionally, the Sixaxis on USB isn't properly initialized
2598                  * until the PS logo button is pressed and as such won't retain
2599                  * any state set by an output report, so the initial
2600                  * configuration report is deferred until the first input
2601                  * report arrives.
2602                  */
2603                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2604                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2605                 sc->defer_initialization = 1;
2606
2607                 ret = sixaxis_set_operational_usb(hdev);
2608                 if (ret < 0) {
2609                         hid_err(hdev, "Failed to set controller into operational mode\n");
2610                         goto err_stop;
2611                 }
2612
2613                 sony_init_output_report(sc, sixaxis_send_output_report);
2614         } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2615                 /*
2616                  * The Navigation controller wants output reports sent on the ctrl
2617                  * endpoint when connected via Bluetooth.
2618                  */
2619                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2620
2621                 ret = sixaxis_set_operational_bt(hdev);
2622                 if (ret < 0) {
2623                         hid_err(hdev, "Failed to set controller into operational mode\n");
2624                         goto err_stop;
2625                 }
2626
2627                 sony_init_output_report(sc, sixaxis_send_output_report);
2628         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2629                 /*
2630                  * The Sony Sixaxis does not handle HID Output Reports on the
2631                  * Interrupt EP and the device only becomes active when the
2632                  * PS button is pressed. See comment for Navigation controller
2633                  * above for more details.
2634                  */
2635                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2636                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2637                 sc->defer_initialization = 1;
2638
2639                 ret = sixaxis_set_operational_usb(hdev);
2640                 if (ret < 0) {
2641                         hid_err(hdev, "Failed to set controller into operational mode\n");
2642                         goto err_stop;
2643                 }
2644
2645                 ret = sony_register_sensors(sc);
2646                 if (ret) {
2647                         hid_err(sc->hdev,
2648                         "Unable to initialize motion sensors: %d\n", ret);
2649                         goto err_stop;
2650                 }
2651
2652                 sony_init_output_report(sc, sixaxis_send_output_report);
2653         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2654                 /*
2655                  * The Sixaxis wants output reports sent on the ctrl endpoint
2656                  * when connected via Bluetooth.
2657                  */
2658                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2659
2660                 ret = sixaxis_set_operational_bt(hdev);
2661                 if (ret < 0) {
2662                         hid_err(hdev, "Failed to set controller into operational mode\n");
2663                         goto err_stop;
2664                 }
2665
2666                 ret = sony_register_sensors(sc);
2667                 if (ret) {
2668                         hid_err(sc->hdev,
2669                         "Unable to initialize motion sensors: %d\n", ret);
2670                         goto err_stop;
2671                 }
2672
2673                 sony_init_output_report(sc, sixaxis_send_output_report);
2674         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2675                 ret = dualshock4_get_calibration_data(sc);
2676                 if (ret < 0) {
2677                         hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2678                         goto err_stop;
2679                 }
2680
2681                 ret = dualshock4_get_version_info(sc);
2682                 if (ret < 0) {
2683                         hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2684                         goto err_stop;
2685                 }
2686
2687                 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2688                 if (ret) {
2689                         /* Make zero for cleanup reasons of sysfs entries. */
2690                         sc->fw_version = 0;
2691                         sc->hw_version = 0;
2692                         hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2693                         goto err_stop;
2694                 }
2695
2696                 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2697                 if (ret) {
2698                         sc->hw_version = 0;
2699                         hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2700                         goto err_stop;
2701                 }
2702
2703                 /*
2704                  * The Dualshock 4 touchpad supports 2 touches and has a
2705                  * resolution of 1920x942 (44.86 dots/mm).
2706                  */
2707                 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2708                 if (ret) {
2709                         hid_err(sc->hdev,
2710                         "Unable to initialize multi-touch slots: %d\n",
2711                         ret);
2712                         goto err_stop;
2713                 }
2714
2715                 ret = sony_register_sensors(sc);
2716                 if (ret) {
2717                         hid_err(sc->hdev,
2718                         "Unable to initialize motion sensors: %d\n", ret);
2719                         goto err_stop;
2720                 }
2721
2722                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2723                         sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2724                         ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2725                         if (ret)
2726                                 hid_warn(sc->hdev,
2727                                  "can't create sysfs bt_poll_interval attribute err: %d\n",
2728                                  ret);
2729                 }
2730
2731                 if (sc->quirks & DUALSHOCK4_DONGLE) {
2732                         INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2733                         sc->hotplug_worker_initialized = 1;
2734                         sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2735                 }
2736
2737                 sony_init_output_report(sc, dualshock4_send_output_report);
2738         } else if (sc->quirks & NSG_MRXU_REMOTE) {
2739                 /*
2740                  * The NSG-MRxU touchpad supports 2 touches and has a
2741                  * resolution of 1667x1868
2742                  */
2743                 ret = sony_register_touchpad(sc, 2,
2744                         NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2745                 if (ret) {
2746                         hid_err(sc->hdev,
2747                         "Unable to initialize multi-touch slots: %d\n",
2748                         ret);
2749                         goto err_stop;
2750                 }
2751
2752         } else if (sc->quirks & MOTION_CONTROLLER) {
2753                 sony_init_output_report(sc, motion_send_output_report);
2754         } else {
2755                 ret = 0;
2756         }
2757
2758         if (sc->quirks & SONY_LED_SUPPORT) {
2759                 ret = sony_leds_init(sc);
2760                 if (ret < 0)
2761                         goto err_stop;
2762         }
2763
2764         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2765                 ret = sony_battery_probe(sc, append_dev_id);
2766                 if (ret < 0)
2767                         goto err_stop;
2768
2769                 /* Open the device to receive reports with battery info */
2770                 ret = hid_hw_open(hdev);
2771                 if (ret < 0) {
2772                         hid_err(hdev, "hw open failed\n");
2773                         goto err_stop;
2774                 }
2775         }
2776
2777         if (sc->quirks & SONY_FF_SUPPORT) {
2778                 ret = sony_init_ff(sc);
2779                 if (ret < 0)
2780                         goto err_close;
2781         }
2782
2783         return 0;
2784 err_close:
2785         hid_hw_close(hdev);
2786 err_stop:
2787         /* Piggy back on the default ds4_bt_ poll_interval to determine
2788          * if we need to remove the file as we don't know for sure if we
2789          * executed that logic.
2790          */
2791         if (sc->ds4_bt_poll_interval)
2792                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2793         if (sc->fw_version)
2794                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2795         if (sc->hw_version)
2796                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2797         sony_cancel_work_sync(sc);
2798         sony_remove_dev_list(sc);
2799         sony_release_device_id(sc);
2800         hid_hw_stop(hdev);
2801         return ret;
2802 }
2803
2804 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2805 {
2806         int ret;
2807         unsigned long quirks = id->driver_data;
2808         struct sony_sc *sc;
2809         unsigned int connect_mask = HID_CONNECT_DEFAULT;
2810
2811         if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2812                 quirks |= FUTUREMAX_DANCE_MAT;
2813
2814         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2815         if (sc == NULL) {
2816                 hid_err(hdev, "can't alloc sony descriptor\n");
2817                 return -ENOMEM;
2818         }
2819
2820         spin_lock_init(&sc->lock);
2821
2822         sc->quirks = quirks;
2823         hid_set_drvdata(hdev, sc);
2824         sc->hdev = hdev;
2825
2826         ret = hid_parse(hdev);
2827         if (ret) {
2828                 hid_err(hdev, "parse failed\n");
2829                 return ret;
2830         }
2831
2832         if (sc->quirks & VAIO_RDESC_CONSTANT)
2833                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2834         else if (sc->quirks & SIXAXIS_CONTROLLER)
2835                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2836
2837         /* Patch the hw version on DS3/4 compatible devices, so applications can
2838          * distinguish between the default HID mappings and the mappings defined
2839          * by the Linux game controller spec. This is important for the SDL2
2840          * library, which has a game controller database, which uses device ids
2841          * in combination with version as a key.
2842          */
2843         if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
2844                 hdev->version |= 0x8000;
2845
2846         ret = hid_hw_start(hdev, connect_mask);
2847         if (ret) {
2848                 hid_err(hdev, "hw start failed\n");
2849                 return ret;
2850         }
2851
2852         /* sony_input_configured can fail, but this doesn't result
2853          * in hid_hw_start failures (intended). Check whether
2854          * the HID layer claimed the device else fail.
2855          * We don't know the actual reason for the failure, most
2856          * likely it is due to EEXIST in case of double connection
2857          * of USB and Bluetooth, but could have been due to ENOMEM
2858          * or other reasons as well.
2859          */
2860         if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2861                 hid_err(hdev, "failed to claim input\n");
2862                 return -ENODEV;
2863         }
2864
2865         return ret;
2866 }
2867
2868 static void sony_remove(struct hid_device *hdev)
2869 {
2870         struct sony_sc *sc = hid_get_drvdata(hdev);
2871
2872         hid_hw_close(hdev);
2873
2874         if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2875                 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2876
2877         if (sc->fw_version)
2878                 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2879
2880         if (sc->hw_version)
2881                 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2882
2883         sony_cancel_work_sync(sc);
2884
2885         sony_remove_dev_list(sc);
2886
2887         sony_release_device_id(sc);
2888
2889         hid_hw_stop(hdev);
2890 }
2891
2892 #ifdef CONFIG_PM
2893
2894 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2895 {
2896 #ifdef CONFIG_SONY_FF
2897
2898         /* On suspend stop any running force-feedback events */
2899         if (SONY_FF_SUPPORT) {
2900                 struct sony_sc *sc = hid_get_drvdata(hdev);
2901
2902                 sc->left = sc->right = 0;
2903                 sony_send_output_report(sc);
2904         }
2905
2906 #endif
2907         return 0;
2908 }
2909
2910 static int sony_resume(struct hid_device *hdev)
2911 {
2912         struct sony_sc *sc = hid_get_drvdata(hdev);
2913
2914         /*
2915          * The Sixaxis and navigation controllers on USB need to be
2916          * reinitialized on resume or they won't behave properly.
2917          */
2918         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2919                 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2920                 sixaxis_set_operational_usb(sc->hdev);
2921                 sc->defer_initialization = 1;
2922         }
2923
2924         return 0;
2925 }
2926
2927 #endif
2928
2929 static const struct hid_device_id sony_devices[] = {
2930         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2931                 .driver_data = SIXAXIS_CONTROLLER_USB },
2932         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2933                 .driver_data = NAVIGATION_CONTROLLER_USB },
2934         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2935                 .driver_data = NAVIGATION_CONTROLLER_BT },
2936         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2937                 .driver_data = MOTION_CONTROLLER_USB },
2938         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2939                 .driver_data = MOTION_CONTROLLER_BT },
2940         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2941                 .driver_data = SIXAXIS_CONTROLLER_BT },
2942         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2943                 .driver_data = VAIO_RDESC_CONSTANT },
2944         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2945                 .driver_data = VAIO_RDESC_CONSTANT },
2946         /*
2947          * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2948          * Logitech joystick from the device descriptor.
2949          */
2950         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2951                 .driver_data = BUZZ_CONTROLLER },
2952         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2953                 .driver_data = BUZZ_CONTROLLER },
2954         /* PS3 BD Remote Control */
2955         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2956                 .driver_data = PS3REMOTE },
2957         /* Logitech Harmony Adapter for PS3 */
2958         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2959                 .driver_data = PS3REMOTE },
2960         /* SMK-Link PS3 BD Remote Control */
2961         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2962                 .driver_data = PS3REMOTE },
2963         /* Sony Dualshock 4 controllers for PS4 */
2964         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2965                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2966         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2967                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2968         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2969                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2970         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2971                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2972         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
2973                 .driver_data = DUALSHOCK4_DONGLE },
2974         /* Nyko Core Controller for PS3 */
2975         { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2976                 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2977         /* SMK-Link NSG-MR5U Remote Control */
2978         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
2979                 .driver_data = NSG_MR5U_REMOTE_BT },
2980         /* SMK-Link NSG-MR7U Remote Control */
2981         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
2982                 .driver_data = NSG_MR7U_REMOTE_BT },
2983         { }
2984 };
2985 MODULE_DEVICE_TABLE(hid, sony_devices);
2986
2987 static struct hid_driver sony_driver = {
2988         .name             = "sony",
2989         .id_table         = sony_devices,
2990         .input_mapping    = sony_mapping,
2991         .input_configured = sony_input_configured,
2992         .probe            = sony_probe,
2993         .remove           = sony_remove,
2994         .report_fixup     = sony_report_fixup,
2995         .raw_event        = sony_raw_event,
2996
2997 #ifdef CONFIG_PM
2998         .suspend          = sony_suspend,
2999         .resume           = sony_resume,
3000         .reset_resume     = sony_resume,
3001 #endif
3002 };
3003
3004 static int __init sony_init(void)
3005 {
3006         dbg_hid("Sony:%s\n", __func__);
3007
3008         return hid_register_driver(&sony_driver);
3009 }
3010
3011 static void __exit sony_exit(void)
3012 {
3013         dbg_hid("Sony:%s\n", __func__);
3014
3015         hid_unregister_driver(&sony_driver);
3016         ida_destroy(&sony_device_id_allocator);
3017 }
3018 module_init(sony_init);
3019 module_exit(sony_exit);
3020
3021 MODULE_LICENSE("GPL");