drivers/hid/hid-sony.c

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