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-2021 Pascal Giard <pascal.giard@etsmtl.ca>
  15  *  Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
  16  *  Copyright (c) 2021 Daniel Nguyen <daniel.nguyen.1@ens.etsmtl.ca>
  17  */
  18
  19 /*
  20  */
  21
  22 /*
  23  * NOTE: in order for the Sony PS3 BD Remote Control to be found by
  24  * a Bluetooth host, the key combination Start+Enter has to be kept pressed
  25  * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
  26  *
  27  * There will be no PIN request from the device.
  28  */
  29
  30 #include <linux/device.h>
  31 #include <linux/hid.h>
  32 #include <linux/module.h>
  33 #include <linux/slab.h>
  34 #include <linux/leds.h>
  35 #include <linux/power_supply.h>
  36 #include <linux/spinlock.h>
  37 #include <linux/list.h>
  38 #include <linux/idr.h>
  39 #include <linux/input/mt.h>
  40 #include <linux/crc32.h>
  41 #include <linux/usb.h>
  42 #include <linux/timer.h>
  43 #include <asm/unaligned.h>
  44
  45 #include "hid-ids.h"
  46
  47 #define VAIO_RDESC_CONSTANT       BIT(0)
  48 #define SIXAXIS_CONTROLLER_USB    BIT(1)
  49 #define SIXAXIS_CONTROLLER_BT     BIT(2)
  50 #define BUZZ_CONTROLLER           BIT(3)
  51 #define PS3REMOTE                 BIT(4)
  52 #define MOTION_CONTROLLER_USB     BIT(5)
  53 #define MOTION_CONTROLLER_BT      BIT(6)
  54 #define NAVIGATION_CONTROLLER_USB BIT(7)
  55 #define NAVIGATION_CONTROLLER_BT  BIT(8)
  56 #define SINO_LITE_CONTROLLER      BIT(9)
  57 #define FUTUREMAX_DANCE_MAT       BIT(10)
  58 #define NSG_MR5U_REMOTE_BT        BIT(11)
  59 #define NSG_MR7U_REMOTE_BT        BIT(12)
  60 #define SHANWAN_GAMEPAD           BIT(13)
  61 #define GH_GUITAR_CONTROLLER      BIT(14)
  62 #define GHL_GUITAR_PS3WIIU        BIT(15)
  63 #define GHL_GUITAR_PS4            BIT(16)
  64
  65 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
  66 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
  67 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
  68                                 NAVIGATION_CONTROLLER_BT)
  69 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
  70                                 MOTION_CONTROLLER | NAVIGATION_CONTROLLER)
  71 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
  72 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER)
  73 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
  74 #define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
  75
  76 #define MAX_LEDS 4
  77 #define NSG_MRXU_MAX_X 1667
  78 #define NSG_MRXU_MAX_Y 1868
  79
  80 /* The PS3/Wii U dongles require a poke every 10 seconds, but the PS4
  81  * requires one every 8 seconds. Using 8 seconds for all for simplicity.
  82  */
  83 #define GHL_GUITAR_POKE_INTERVAL 8 /* In seconds */
  84 #define GUITAR_TILT_USAGE 44
  85
  86 /* Magic data taken from GHLtarUtility:
  87  * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
  88  * Note: The Wii U and PS3 dongles happen to share the same!
  89  */
  90 static const char ghl_ps3wiiu_magic_data[] = {
  91         0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
  92 };
  93
  94 /* Magic data for the PS4 dongles sniffed with a USB protocol
  95  * analyzer.
  96  */
  97 static const char ghl_ps4_magic_data[] = {
  98         0x30, 0x02, 0x08, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00
  99 };
 100
 101 /* PS/3 Motion controller */
 102 static u8 motion_rdesc[] = {
 103         0x05, 0x01,         /*  Usage Page (Desktop),               */
 104         0x09, 0x04,         /*  Usage (Joystick),                   */
 105         0xA1, 0x01,         /*  Collection (Application),           */
 106         0xA1, 0x02,         /*      Collection (Logical),           */
 107         0x85, 0x01,         /*          Report ID (1),              */
 108         0x75, 0x01,         /*          Report Size (1),            */
 109         0x95, 0x15,         /*          Report Count (21),          */
 110         0x15, 0x00,         /*          Logical Minimum (0),        */
 111         0x25, 0x01,         /*          Logical Maximum (1),        */
 112         0x35, 0x00,         /*          Physical Minimum (0),       */
 113         0x45, 0x01,         /*          Physical Maximum (1),       */
 114         0x05, 0x09,         /*          Usage Page (Button),        */
 115         0x19, 0x01,         /*          Usage Minimum (01h),        */
 116         0x29, 0x15,         /*          Usage Maximum (15h),        */
 117         0x81, 0x02,         /*          Input (Variable),           * Buttons */
 118         0x95, 0x0B,         /*          Report Count (11),          */
 119         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 120         0x81, 0x03,         /*          Input (Constant, Variable), * Padding */
 121         0x15, 0x00,         /*          Logical Minimum (0),        */
 122         0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
 123         0x05, 0x01,         /*          Usage Page (Desktop),       */
 124         0xA1, 0x00,         /*          Collection (Physical),      */
 125         0x75, 0x08,         /*              Report Size (8),        */
 126         0x95, 0x01,         /*              Report Count (1),       */
 127         0x35, 0x00,         /*              Physical Minimum (0),   */
 128         0x46, 0xFF, 0x00,   /*              Physical Maximum (255), */
 129         0x09, 0x30,         /*              Usage (X),              */
 130         0x81, 0x02,         /*              Input (Variable),       * Trigger */
 131         0xC0,               /*          End Collection,             */
 132         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 133         0x75, 0x08,         /*          Report Size (8),            */
 134         0x95, 0x07,         /*          Report Count (7),           * skip 7 bytes */
 135         0x81, 0x02,         /*          Input (Variable),           */
 136         0x05, 0x01,         /*          Usage Page (Desktop),       */
 137         0x75, 0x10,         /*          Report Size (16),           */
 138         0x46, 0xFF, 0xFF,   /*          Physical Maximum (65535),   */
 139         0x27, 0xFF, 0xFF, 0x00, 0x00, /*      Logical Maximum (65535),    */
 140         0x95, 0x03,         /*          Report Count (3),           * 3x Accels */
 141         0x09, 0x33,         /*              Usage (rX),             */
 142         0x09, 0x34,         /*              Usage (rY),             */
 143         0x09, 0x35,         /*              Usage (rZ),             */
 144         0x81, 0x02,         /*          Input (Variable),           */
 145         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 146         0x95, 0x03,         /*          Report Count (3),           * Skip Accels 2nd frame */
 147         0x81, 0x02,         /*          Input (Variable),           */
 148         0x05, 0x01,         /*          Usage Page (Desktop),       */
 149         0x09, 0x01,         /*          Usage (Pointer),            */
 150         0x95, 0x03,         /*          Report Count (3),           * 3x Gyros */
 151         0x81, 0x02,         /*          Input (Variable),           */
 152         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
 153         0x95, 0x03,         /*          Report Count (3),           * Skip Gyros 2nd frame */
 154         0x81, 0x02,         /*          Input (Variable),           */
 155         0x75, 0x0C,         /*          Report Size (12),           */
 156         0x46, 0xFF, 0x0F,   /*          Physical Maximum (4095),    */
 157         0x26, 0xFF, 0x0F,   /*          Logical Maximum (4095),     */
 158         0x95, 0x04,         /*          Report Count (4),           * Skip Temp and Magnetometers */
 159         0x81, 0x02,         /*          Input (Variable),           */
 160         0x75, 0x08,         /*          Report Size (8),            */
 161         0x46, 0xFF, 0x00,   /*          Physical Maximum (255),     */
 162         0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
 163         0x95, 0x06,         /*          Report Count (6),           * Skip Timestamp and Extension Bytes */
 164         0x81, 0x02,         /*          Input (Variable),           */
 165         0x75, 0x08,         /*          Report Size (8),            */
 166         0x95, 0x30,         /*          Report Count (48),          */
 167         0x09, 0x01,         /*          Usage (Pointer),            */
 168         0x91, 0x02,         /*          Output (Variable),          */
 169         0x75, 0x08,         /*          Report Size (8),            */
 170         0x95, 0x30,         /*          Report Count (48),          */
 171         0x09, 0x01,         /*          Usage (Pointer),            */
 172         0xB1, 0x02,         /*          Feature (Variable),         */
 173         0xC0,               /*      End Collection,                 */
 174         0xA1, 0x02,         /*      Collection (Logical),           */
 175         0x85, 0x02,         /*          Report ID (2),              */
 176         0x75, 0x08,         /*          Report Size (8),            */
 177         0x95, 0x30,         /*          Report Count (48),          */
 178         0x09, 0x01,         /*          Usage (Pointer),            */
 179         0xB1, 0x02,         /*          Feature (Variable),         */
 180         0xC0,               /*      End Collection,                 */
 181         0xA1, 0x02,         /*      Collection (Logical),           */
 182         0x85, 0xEE,         /*          Report ID (238),            */
 183         0x75, 0x08,         /*          Report Size (8),            */
 184         0x95, 0x30,         /*          Report Count (48),          */
 185         0x09, 0x01,         /*          Usage (Pointer),            */
 186         0xB1, 0x02,         /*          Feature (Variable),         */
 187         0xC0,               /*      End Collection,                 */
 188         0xA1, 0x02,         /*      Collection (Logical),           */
 189         0x85, 0xEF,         /*          Report ID (239),            */
 190         0x75, 0x08,         /*          Report Size (8),            */
 191         0x95, 0x30,         /*          Report Count (48),          */
 192         0x09, 0x01,         /*          Usage (Pointer),            */
 193         0xB1, 0x02,         /*          Feature (Variable),         */
 194         0xC0,               /*      End Collection,                 */
 195         0xC0                /*  End Collection                      */
 196 };
 197
 198 static u8 ps3remote_rdesc[] = {
 199         0x05, 0x01,          /* GUsagePage Generic Desktop */
 200         0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
 201         0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
 202
 203          /* Use collection 1 for joypad buttons */
 204          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 205
 206           /*
 207            * Ignore the 1st byte, maybe it is used for a controller
 208            * number but it's not needed for correct operation
 209            */
 210           0x75, 0x08,        /* GReportSize 0x08 [8] */
 211           0x95, 0x01,        /* GReportCount 0x01 [1] */
 212           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 213
 214           /*
 215            * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
 216            * buttons multiple keypresses are allowed
 217            */
 218           0x05, 0x09,        /* GUsagePage Button */
 219           0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
 220           0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
 221           0x14,              /* GLogicalMinimum [0] */
 222           0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
 223           0x75, 0x01,        /* GReportSize 0x01 [1] */
 224           0x95, 0x18,        /* GReportCount 0x18 [24] */
 225           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 226
 227           0xC0,              /* MEndCollection */
 228
 229          /* Use collection 2 for remote control buttons */
 230          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 231
 232           /* 5th byte is used for remote control buttons */
 233           0x05, 0x09,        /* GUsagePage Button */
 234           0x18,              /* LUsageMinimum [No button pressed] */
 235           0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
 236           0x14,              /* GLogicalMinimum [0] */
 237           0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
 238           0x75, 0x08,        /* GReportSize 0x08 [8] */
 239           0x95, 0x01,        /* GReportCount 0x01 [1] */
 240           0x80,              /* MInput  */
 241
 242           /*
 243            * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
 244            * 0xff and 11th is for press indication
 245            */
 246           0x75, 0x08,        /* GReportSize 0x08 [8] */
 247           0x95, 0x06,        /* GReportCount 0x06 [6] */
 248           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 249
 250           /* 12th byte is for battery strength */
 251           0x05, 0x06,        /* GUsagePage Generic Device Controls */
 252           0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
 253           0x14,              /* GLogicalMinimum [0] */
 254           0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
 255           0x75, 0x08,        /* GReportSize 0x08 [8] */
 256           0x95, 0x01,        /* GReportCount 0x01 [1] */
 257           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 258
 259           0xC0,              /* MEndCollection */
 260
 261          0xC0                /* MEndCollection [Game Pad] */
 262 };
 263
 264 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
 265         [0x01] = KEY_SELECT,
 266         [0x02] = BTN_THUMBL,            /* L3 */
 267         [0x03] = BTN_THUMBR,            /* R3 */
 268         [0x04] = BTN_START,
 269         [0x05] = KEY_UP,
 270         [0x06] = KEY_RIGHT,
 271         [0x07] = KEY_DOWN,
 272         [0x08] = KEY_LEFT,
 273         [0x09] = BTN_TL2,               /* L2 */
 274         [0x0a] = BTN_TR2,               /* R2 */
 275         [0x0b] = BTN_TL,                /* L1 */
 276         [0x0c] = BTN_TR,                /* R1 */
 277         [0x0d] = KEY_OPTION,            /* options/triangle */
 278         [0x0e] = KEY_BACK,              /* back/circle */
 279         [0x0f] = BTN_0,                 /* cross */
 280         [0x10] = KEY_SCREEN,            /* view/square */
 281         [0x11] = KEY_HOMEPAGE,          /* PS button */
 282         [0x14] = KEY_ENTER,
 283 };
 284 static const unsigned int ps3remote_keymap_remote_buttons[] = {
 285         [0x00] = KEY_1,
 286         [0x01] = KEY_2,
 287         [0x02] = KEY_3,
 288         [0x03] = KEY_4,
 289         [0x04] = KEY_5,
 290         [0x05] = KEY_6,
 291         [0x06] = KEY_7,
 292         [0x07] = KEY_8,
 293         [0x08] = KEY_9,
 294         [0x09] = KEY_0,
 295         [0x0e] = KEY_ESC,               /* return */
 296         [0x0f] = KEY_CLEAR,
 297         [0x16] = KEY_EJECTCD,
 298         [0x1a] = KEY_MENU,              /* top menu */
 299         [0x28] = KEY_TIME,
 300         [0x30] = KEY_PREVIOUS,
 301         [0x31] = KEY_NEXT,
 302         [0x32] = KEY_PLAY,
 303         [0x33] = KEY_REWIND,            /* scan back */
 304         [0x34] = KEY_FORWARD,           /* scan forward */
 305         [0x38] = KEY_STOP,
 306         [0x39] = KEY_PAUSE,
 307         [0x40] = KEY_CONTEXT_MENU,      /* pop up/menu */
 308         [0x60] = KEY_FRAMEBACK,         /* slow/step back */
 309         [0x61] = KEY_FRAMEFORWARD,      /* slow/step forward */
 310         [0x63] = KEY_SUBTITLE,
 311         [0x64] = KEY_AUDIO,
 312         [0x65] = KEY_ANGLE,
 313         [0x70] = KEY_INFO,              /* display */
 314         [0x80] = KEY_BLUE,
 315         [0x81] = KEY_RED,
 316         [0x82] = KEY_GREEN,
 317         [0x83] = KEY_YELLOW,
 318 };
 319
 320 static const unsigned int buzz_keymap[] = {
 321         /*
 322          * The controller has 4 remote buzzers, each with one LED and 5
 323          * buttons.
 324          *
 325          * We use the mapping chosen by the controller, which is:
 326          *
 327          * Key          Offset
 328          * -------------------
 329          * Buzz              1
 330          * Blue              5
 331          * Orange            4
 332          * Green             3
 333          * Yellow            2
 334          *
 335          * So, for example, the orange button on the third buzzer is mapped to
 336          * BTN_TRIGGER_HAPPY14
 337          */
 338          [1] = BTN_TRIGGER_HAPPY1,
 339          [2] = BTN_TRIGGER_HAPPY2,
 340          [3] = BTN_TRIGGER_HAPPY3,
 341          [4] = BTN_TRIGGER_HAPPY4,
 342          [5] = BTN_TRIGGER_HAPPY5,
 343          [6] = BTN_TRIGGER_HAPPY6,
 344          [7] = BTN_TRIGGER_HAPPY7,
 345          [8] = BTN_TRIGGER_HAPPY8,
 346          [9] = BTN_TRIGGER_HAPPY9,
 347         [10] = BTN_TRIGGER_HAPPY10,
 348         [11] = BTN_TRIGGER_HAPPY11,
 349         [12] = BTN_TRIGGER_HAPPY12,
 350         [13] = BTN_TRIGGER_HAPPY13,
 351         [14] = BTN_TRIGGER_HAPPY14,
 352         [15] = BTN_TRIGGER_HAPPY15,
 353         [16] = BTN_TRIGGER_HAPPY16,
 354         [17] = BTN_TRIGGER_HAPPY17,
 355         [18] = BTN_TRIGGER_HAPPY18,
 356         [19] = BTN_TRIGGER_HAPPY19,
 357         [20] = BTN_TRIGGER_HAPPY20,
 358 };
 359
 360 /* The Navigation controller is a partial DS3 and uses the same HID report
 361  * and hence the same keymap indices, however not all axes/buttons
 362  * are physically present. We use the same axis and button mapping as
 363  * the DS3, which uses the Linux gamepad spec.
 364  */
 365 static const unsigned int navigation_absmap[] = {
 366         [0x30] = ABS_X,
 367         [0x31] = ABS_Y,
 368         [0x33] = ABS_Z, /* L2 */
 369 };
 370
 371 /* Buttons not physically available on the device, but still available
 372  * in the reports are explicitly set to 0 for documentation purposes.
 373  */
 374 static const unsigned int navigation_keymap[] = {
 375         [0x01] = 0, /* Select */
 376         [0x02] = BTN_THUMBL, /* L3 */
 377         [0x03] = 0, /* R3 */
 378         [0x04] = 0, /* Start */
 379         [0x05] = BTN_DPAD_UP, /* Up */
 380         [0x06] = BTN_DPAD_RIGHT, /* Right */
 381         [0x07] = BTN_DPAD_DOWN, /* Down */
 382         [0x08] = BTN_DPAD_LEFT, /* Left */
 383         [0x09] = BTN_TL2, /* L2 */
 384         [0x0a] = 0, /* R2 */
 385         [0x0b] = BTN_TL, /* L1 */
 386         [0x0c] = 0, /* R1 */
 387         [0x0d] = BTN_NORTH, /* Triangle */
 388         [0x0e] = BTN_EAST, /* Circle */
 389         [0x0f] = BTN_SOUTH, /* Cross */
 390         [0x10] = BTN_WEST, /* Square */
 391         [0x11] = BTN_MODE, /* PS */
 392 };
 393
 394 static const unsigned int sixaxis_absmap[] = {
 395         [0x30] = ABS_X,
 396         [0x31] = ABS_Y,
 397         [0x32] = ABS_RX, /* right stick X */
 398         [0x35] = ABS_RY, /* right stick Y */
 399 };
 400
 401 static const unsigned int sixaxis_keymap[] = {
 402         [0x01] = BTN_SELECT, /* Select */
 403         [0x02] = BTN_THUMBL, /* L3 */
 404         [0x03] = BTN_THUMBR, /* R3 */
 405         [0x04] = BTN_START, /* Start */
 406         [0x05] = BTN_DPAD_UP, /* Up */
 407         [0x06] = BTN_DPAD_RIGHT, /* Right */
 408         [0x07] = BTN_DPAD_DOWN, /* Down */
 409         [0x08] = BTN_DPAD_LEFT, /* Left */
 410         [0x09] = BTN_TL2, /* L2 */
 411         [0x0a] = BTN_TR2, /* R2 */
 412         [0x0b] = BTN_TL, /* L1 */
 413         [0x0c] = BTN_TR, /* R1 */
 414         [0x0d] = BTN_NORTH, /* Triangle */
 415         [0x0e] = BTN_EAST, /* Circle */
 416         [0x0f] = BTN_SOUTH, /* Cross */
 417         [0x10] = BTN_WEST, /* Square */
 418         [0x11] = BTN_MODE, /* PS */
 419 };
 420
 421 static enum power_supply_property sony_battery_props[] = {
 422         POWER_SUPPLY_PROP_PRESENT,
 423         POWER_SUPPLY_PROP_CAPACITY,
 424         POWER_SUPPLY_PROP_SCOPE,
 425         POWER_SUPPLY_PROP_STATUS,
 426 };
 427
 428 struct sixaxis_led {
 429         u8 time_enabled; /* the total time the led is active (0xff means forever) */
 430         u8 duty_length;  /* how long a cycle is in deciseconds (0 means "really fast") */
 431         u8 enabled;
 432         u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
 433         u8 duty_on;  /* % of duty_length the led is on (0xff mean 100%) */
 434 } __packed;
 435
 436 struct sixaxis_rumble {
 437         u8 padding;
 438         u8 right_duration; /* Right motor duration (0xff means forever) */
 439         u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
 440         u8 left_duration;    /* Left motor duration (0xff means forever) */
 441         u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
 442 } __packed;
 443
 444 struct sixaxis_output_report {
 445         u8 report_id;
 446         struct sixaxis_rumble rumble;
 447         u8 padding[4];
 448         u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
 449         struct sixaxis_led led[4];    /* LEDx at (4 - x) */
 450         struct sixaxis_led _reserved; /* LED5, not actually soldered */
 451 } __packed;
 452
 453 union sixaxis_output_report_01 {
 454         struct sixaxis_output_report data;
 455         u8 buf[36];
 456 };
 457
 458 struct motion_output_report_02 {
 459         u8 type, zero;
 460         u8 r, g, b;
 461         u8 zero2;
 462         u8 rumble;
 463 };
 464
 465 #define SIXAXIS_REPORT_0xF2_SIZE 17
 466 #define SIXAXIS_REPORT_0xF5_SIZE 8
 467 #define MOTION_REPORT_0x02_SIZE 49
 468
 469 #define SENSOR_SUFFIX " Motion Sensors"
 470 #define TOUCHPAD_SUFFIX " Touchpad"
 471
 472 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
 473 #define SIXAXIS_ACC_RES_PER_G 113
 474
 475 static DEFINE_SPINLOCK(sony_dev_list_lock);
 476 static LIST_HEAD(sony_device_list);
 477 static DEFINE_IDA(sony_device_id_allocator);
 478
 479 enum sony_worker {
 480         SONY_WORKER_STATE
 481 };
 482
 483 struct sony_sc {
 484         spinlock_t lock;
 485         struct list_head list_node;
 486         struct hid_device *hdev;
 487         struct input_dev *touchpad;
 488         struct input_dev *sensor_dev;
 489         struct led_classdev *leds[MAX_LEDS];
 490         unsigned long quirks;
 491         struct work_struct state_worker;
 492         void (*send_output_report)(struct sony_sc *);
 493         struct power_supply *battery;
 494         struct power_supply_desc battery_desc;
 495         int device_id;
 496         u8 *output_report_dmabuf;
 497
 498 #ifdef CONFIG_SONY_FF
 499         u8 left;
 500         u8 right;
 501 #endif
 502
 503         u8 mac_address[6];
 504         u8 state_worker_initialized;
 505         u8 defer_initialization;
 506         u8 battery_capacity;
 507         int battery_status;
 508         u8 led_state[MAX_LEDS];
 509         u8 led_delay_on[MAX_LEDS];
 510         u8 led_delay_off[MAX_LEDS];
 511         u8 led_count;
 512
 513         /* GH Live */
 514         struct urb *ghl_urb;
 515         struct timer_list ghl_poke_timer;
 516 };
 517
 518 static void sony_set_leds(struct sony_sc *sc);
 519
 520 static inline void sony_schedule_work(struct sony_sc *sc,
 521                                       enum sony_worker which)
 522 {
 523         unsigned long flags;
 524
 525         switch (which) {
 526         case SONY_WORKER_STATE:
 527                 spin_lock_irqsave(&sc->lock, flags);
 528                 if (!sc->defer_initialization && sc->state_worker_initialized)
 529                         schedule_work(&sc->state_worker);
 530                 spin_unlock_irqrestore(&sc->lock, flags);
 531                 break;
 532         }
 533 }
 534
 535 static void ghl_magic_poke_cb(struct urb *urb)
 536 {
 537         struct sony_sc *sc = urb->context;
 538
 539         if (urb->status < 0)
 540                 hid_err(sc->hdev, "URB transfer failed : %d", urb->status);
 541
 542         mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
 543 }
 544
 545 static void ghl_magic_poke(struct timer_list *t)
 546 {
 547         int ret;
 548         struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
 549
 550         ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC);
 551         if (ret < 0)
 552                 hid_err(sc->hdev, "usb_submit_urb failed: %d", ret);
 553 }
 554
 555 static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev,
 556                                            const char ghl_magic_data[], u16 poke_size)
 557 {
 558         struct usb_ctrlrequest *cr;
 559         u8 *databuf;
 560         unsigned int pipe;
 561         u16 ghl_magic_value = (((HID_OUTPUT_REPORT + 1) << 8) | ghl_magic_data[0]);
 562
 563         pipe = usb_sndctrlpipe(usbdev, 0);
 564
 565         cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
 566         if (cr == NULL)
 567                 return -ENOMEM;
 568
 569         databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
 570         if (databuf == NULL)
 571                 return -ENOMEM;
 572
 573         cr->bRequestType =
 574                 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
 575         cr->bRequest = USB_REQ_SET_CONFIGURATION;
 576         cr->wValue = cpu_to_le16(ghl_magic_value);
 577         cr->wIndex = 0;
 578         cr->wLength = cpu_to_le16(poke_size);
 579         memcpy(databuf, ghl_magic_data, poke_size);
 580         usb_fill_control_urb(
 581                 sc->ghl_urb, usbdev, pipe,
 582                 (unsigned char *) cr, databuf, poke_size,
 583                 ghl_magic_poke_cb, sc);
 584         return 0;
 585 }
 586
 587 static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
 588                           struct hid_field *field, struct hid_usage *usage,
 589                           unsigned long **bit, int *max)
 590 {
 591         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
 592                 unsigned int abs = usage->hid & HID_USAGE;
 593
 594                 if (abs == GUITAR_TILT_USAGE) {
 595                         hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
 596                         return 1;
 597                 }
 598         }
 599         return 0;
 600 }
 601
 602 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
 603                              unsigned int *rsize)
 604 {
 605         *rsize = sizeof(motion_rdesc);
 606         return motion_rdesc;
 607 }
 608
 609 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
 610                              unsigned int *rsize)
 611 {
 612         *rsize = sizeof(ps3remote_rdesc);
 613         return ps3remote_rdesc;
 614 }
 615
 616 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
 617                              struct hid_field *field, struct hid_usage *usage,
 618                              unsigned long **bit, int *max)
 619 {
 620         unsigned int key = usage->hid & HID_USAGE;
 621
 622         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 623                 return -1;
 624
 625         switch (usage->collection_index) {
 626         case 1:
 627                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
 628                         return -1;
 629
 630                 key = ps3remote_keymap_joypad_buttons[key];
 631                 if (!key)
 632                         return -1;
 633                 break;
 634         case 2:
 635                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
 636                         return -1;
 637
 638                 key = ps3remote_keymap_remote_buttons[key];
 639                 if (!key)
 640                         return -1;
 641                 break;
 642         default:
 643                 return -1;
 644         }
 645
 646         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 647         return 1;
 648 }
 649
 650 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
 651                           struct hid_field *field, struct hid_usage *usage,
 652                           unsigned long **bit, int *max)
 653 {
 654         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
 655                 unsigned int key = usage->hid & HID_USAGE;
 656
 657                 if (key >= ARRAY_SIZE(sixaxis_keymap))
 658                         return -1;
 659
 660                 key = navigation_keymap[key];
 661                 if (!key)
 662                         return -1;
 663
 664                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 665                 return 1;
 666         } else if (usage->hid == HID_GD_POINTER) {
 667                 /* See comment in sixaxis_mapping, basically the L2 (and R2)
 668                  * triggers are reported through GD Pointer.
 669                  * In addition we ignore any analog button 'axes' and only
 670                  * support digital buttons.
 671                  */
 672                 switch (usage->usage_index) {
 673                 case 8: /* L2 */
 674                         usage->hid = HID_GD_Z;
 675                         break;
 676                 default:
 677                         return -1;
 678                 }
 679
 680                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
 681                 return 1;
 682         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
 683                 unsigned int abs = usage->hid & HID_USAGE;
 684
 685                 if (abs >= ARRAY_SIZE(navigation_absmap))
 686                         return -1;
 687
 688                 abs = navigation_absmap[abs];
 689
 690                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
 691                 return 1;
 692         }
 693
 694         return -1;
 695 }
 696
 697
 698 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
 699                           struct hid_field *field, struct hid_usage *usage,
 700                           unsigned long **bit, int *max)
 701 {
 702         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
 703                 unsigned int key = usage->hid & HID_USAGE;
 704
 705                 if (key >= ARRAY_SIZE(sixaxis_keymap))
 706                         return -1;
 707
 708                 key = sixaxis_keymap[key];
 709                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 710                 return 1;
 711         } else if (usage->hid == HID_GD_POINTER) {
 712                 /* The DS3 provides analog values for most buttons and even
 713                  * for HAT axes through GD Pointer. L2 and R2 are reported
 714                  * among these as well instead of as GD Z / RZ. Remap L2
 715                  * and R2 and ignore other analog 'button axes' as there is
 716                  * no good way for reporting them.
 717                  */
 718                 switch (usage->usage_index) {
 719                 case 8: /* L2 */
 720                         usage->hid = HID_GD_Z;
 721                         break;
 722                 case 9: /* R2 */
 723                         usage->hid = HID_GD_RZ;
 724                         break;
 725                 default:
 726                         return -1;
 727                 }
 728
 729                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
 730                 return 1;
 731         } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
 732                 unsigned int abs = usage->hid & HID_USAGE;
 733
 734                 if (abs >= ARRAY_SIZE(sixaxis_absmap))
 735                         return -1;
 736
 737                 abs = sixaxis_absmap[abs];
 738
 739                 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
 740                 return 1;
 741         }
 742
 743         return -1;
 744 }
 745
 746 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
 747                 unsigned int *rsize)
 748 {
 749         struct sony_sc *sc = hid_get_drvdata(hdev);
 750
 751         if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
 752                 return rdesc;
 753
 754         /*
 755          * Some Sony RF receivers wrongly declare the mouse pointer as a
 756          * a constant non-data variable.
 757          */
 758         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
 759             /* usage page: generic desktop controls */
 760             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
 761             /* usage: mouse */
 762             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
 763             /* input (usage page for x,y axes): constant, variable, relative */
 764             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
 765                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
 766                 /* input: data, variable, relative */
 767                 rdesc[55] = 0x06;
 768         }
 769
 770         if (sc->quirks & MOTION_CONTROLLER)
 771                 return motion_fixup(hdev, rdesc, rsize);
 772
 773         if (sc->quirks & PS3REMOTE)
 774                 return ps3remote_fixup(hdev, rdesc, rsize);
 775
 776         /*
 777          * Some knock-off USB dongles incorrectly report their button count
 778          * as 13 instead of 16 causing three non-functional buttons.
 779          */
 780         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
 781                 /* Report Count (13) */
 782                 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
 783                 /* Usage Maximum (13) */
 784                 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
 785                 /* Report Count (3) */
 786                 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
 787                 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
 788                 rdesc[24] = 0x10;
 789                 rdesc[38] = 0x10;
 790                 rdesc[44] = 0x00;
 791         }
 792
 793         return rdesc;
 794 }
 795
 796 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
 797 {
 798         static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
 799         unsigned long flags;
 800         int offset;
 801         u8 battery_capacity;
 802         int battery_status;
 803
 804         /*
 805          * The sixaxis is charging if the battery value is 0xee
 806          * and it is fully charged if the value is 0xef.
 807          * It does not report the actual level while charging so it
 808          * is set to 100% while charging is in progress.
 809          */
 810         offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
 811
 812         if (rd[offset] >= 0xee) {
 813                 battery_capacity = 100;
 814                 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
 815         } else {
 816                 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
 817                 battery_capacity = sixaxis_battery_capacity[index];
 818                 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
 819         }
 820
 821         spin_lock_irqsave(&sc->lock, flags);
 822         sc->battery_capacity = battery_capacity;
 823         sc->battery_status = battery_status;
 824         spin_unlock_irqrestore(&sc->lock, flags);
 825
 826         if (sc->quirks & SIXAXIS_CONTROLLER) {
 827                 int val;
 828
 829                 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
 830                 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
 831                 input_report_abs(sc->sensor_dev, ABS_X, val);
 832
 833                 /* Y and Z are swapped and inversed */
 834                 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
 835                 input_report_abs(sc->sensor_dev, ABS_Y, val);
 836
 837                 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
 838                 input_report_abs(sc->sensor_dev, ABS_Z, val);
 839
 840                 input_sync(sc->sensor_dev);
 841         }
 842 }
 843
 844 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
 845 {
 846         int n, offset, relx, rely;
 847         u8 active;
 848
 849         /*
 850          * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
 851          *   the touch-related data starts at offset 2.
 852          * For the first byte, bit 0 is set when touchpad button is pressed.
 853          * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
 854          * This drag key is mapped to BTN_LEFT.  It is operational only when a
 855          *   touch point is active.
 856          * Bit 4 is set when only the first touch point is active.
 857          * Bit 6 is set when only the second touch point is active.
 858          * Bits 5 and 7 are set when both touch points are active.
 859          * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
 860          * The following byte, offset 5, has the touch width and length.
 861          *   Bits 0-4=X (width), bits 5-7=Y (length).
 862          * A signed relative X coordinate is at offset 6.
 863          * The bytes at offset 7-9 are the second touch X/Y coordinates.
 864          * Offset 10 has the second touch width and length.
 865          * Offset 11 has the relative Y coordinate.
 866          */
 867         offset = 1;
 868
 869         input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
 870         active = (rd[offset] >> 4);
 871         relx = (s8) rd[offset+5];
 872         rely = ((s8) rd[offset+10]) * -1;
 873
 874         offset++;
 875
 876         for (n = 0; n < 2; n++) {
 877                 u16 x, y;
 878                 u8 contactx, contacty;
 879
 880                 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
 881                 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
 882
 883                 input_mt_slot(sc->touchpad, n);
 884                 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
 885
 886                 if (active & 0x03) {
 887                         contactx = rd[offset+3] & 0x0F;
 888                         contacty = rd[offset+3] >> 4;
 889                         input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
 890                                 max(contactx, contacty));
 891                         input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
 892                                 min(contactx, contacty));
 893                         input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
 894                                 (bool) (contactx > contacty));
 895                         input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
 896                         input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
 897                                 NSG_MRXU_MAX_Y - y);
 898                         /*
 899                          * The relative coordinates belong to the first touch
 900                          * point, when present, or to the second touch point
 901                          * when the first is not active.
 902                          */
 903                         if ((n == 0) || ((n == 1) && (active & 0x01))) {
 904                                 input_report_rel(sc->touchpad, REL_X, relx);
 905                                 input_report_rel(sc->touchpad, REL_Y, rely);
 906                         }
 907                 }
 908
 909                 offset += 5;
 910                 active >>= 2;
 911         }
 912
 913         input_mt_sync_frame(sc->touchpad);
 914
 915         input_sync(sc->touchpad);
 916 }
 917
 918 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
 919                 u8 *rd, int size)
 920 {
 921         struct sony_sc *sc = hid_get_drvdata(hdev);
 922
 923         /*
 924          * Sixaxis HID report has acclerometers/gyro with MSByte first, this
 925          * has to be BYTE_SWAPPED before passing up to joystick interface
 926          */
 927         if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
 928                 /*
 929                  * When connected via Bluetooth the Sixaxis occasionally sends
 930                  * a report with the second byte 0xff and the rest zeroed.
 931                  *
 932                  * This report does not reflect the actual state of the
 933                  * controller must be ignored to avoid generating false input
 934                  * events.
 935                  */
 936                 if (rd[1] == 0xff)
 937                         return -EINVAL;
 938
 939                 swap(rd[41], rd[42]);
 940                 swap(rd[43], rd[44]);
 941                 swap(rd[45], rd[46]);
 942                 swap(rd[47], rd[48]);
 943
 944                 sixaxis_parse_report(sc, rd, size);
 945         } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
 946                 sixaxis_parse_report(sc, rd, size);
 947         } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
 948                         size == 49) {
 949                 sixaxis_parse_report(sc, rd, size);
 950         } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
 951                 nsg_mrxu_parse_report(sc, rd, size);
 952                 return 1;
 953         }
 954
 955         if (sc->defer_initialization) {
 956                 sc->defer_initialization = 0;
 957                 sony_schedule_work(sc, SONY_WORKER_STATE);
 958         }
 959
 960         return 0;
 961 }
 962
 963 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
 964                         struct hid_field *field, struct hid_usage *usage,
 965                         unsigned long **bit, int *max)
 966 {
 967         struct sony_sc *sc = hid_get_drvdata(hdev);
 968
 969         if (sc->quirks & BUZZ_CONTROLLER) {
 970                 unsigned int key = usage->hid & HID_USAGE;
 971
 972                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 973                         return -1;
 974
 975                 switch (usage->collection_index) {
 976                 case 1:
 977                         if (key >= ARRAY_SIZE(buzz_keymap))
 978                                 return -1;
 979
 980                         key = buzz_keymap[key];
 981                         if (!key)
 982                                 return -1;
 983                         break;
 984                 default:
 985                         return -1;
 986                 }
 987
 988                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 989                 return 1;
 990         }
 991
 992         if (sc->quirks & PS3REMOTE)
 993                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
 994
 995         if (sc->quirks & NAVIGATION_CONTROLLER)
 996                 return navigation_mapping(hdev, hi, field, usage, bit, max);
 997
 998         if (sc->quirks & SIXAXIS_CONTROLLER)
 999                 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1000
1001         if (sc->quirks & GH_GUITAR_CONTROLLER)
1002                 return guitar_mapping(hdev, hi, field, usage, bit, max);
1003
1004         /* Let hid-core decide for the others */
1005         return 0;
1006 }
1007
1008 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1009                 int w, int h, int touch_major, int touch_minor, int orientation)
1010 {
1011         size_t name_sz;
1012         char *name;
1013         int ret;
1014
1015         sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1016         if (!sc->touchpad)
1017                 return -ENOMEM;
1018
1019         input_set_drvdata(sc->touchpad, sc);
1020         sc->touchpad->dev.parent = &sc->hdev->dev;
1021         sc->touchpad->phys = sc->hdev->phys;
1022         sc->touchpad->uniq = sc->hdev->uniq;
1023         sc->touchpad->id.bustype = sc->hdev->bus;
1024         sc->touchpad->id.vendor = sc->hdev->vendor;
1025         sc->touchpad->id.product = sc->hdev->product;
1026         sc->touchpad->id.version = sc->hdev->version;
1027
1028         /* This suffix was originally apended when hid-sony also
1029          * supported DS4 devices. The DS4 was implemented using multiple
1030          * evdev nodes and hence had the need to separete them out using
1031          * a suffix. Other devices which were added later like Sony TV remotes
1032          * inhirited this suffix.
1033          */
1034         name_sz = strlen(sc->hdev->name) + sizeof(TOUCHPAD_SUFFIX);
1035         name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1036         if (!name)
1037                 return -ENOMEM;
1038         snprintf(name, name_sz, "%s" TOUCHPAD_SUFFIX, sc->hdev->name);
1039         sc->touchpad->name = name;
1040
1041         /* We map the button underneath the touchpad to BTN_LEFT. */
1042         __set_bit(EV_KEY, sc->touchpad->evbit);
1043         __set_bit(BTN_LEFT, sc->touchpad->keybit);
1044         __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1045
1046         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1047         input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1048
1049         if (touch_major > 0) {
1050                 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1051                         0, touch_major, 0, 0);
1052                 if (touch_minor > 0)
1053                         input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1054                                 0, touch_minor, 0, 0);
1055                 if (orientation > 0)
1056                         input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1057                                 0, orientation, 0, 0);
1058         }
1059
1060         if (sc->quirks & NSG_MRXU_REMOTE) {
1061                 __set_bit(EV_REL, sc->touchpad->evbit);
1062         }
1063
1064         ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1065         if (ret < 0)
1066                 return ret;
1067
1068         ret = input_register_device(sc->touchpad);
1069         if (ret < 0)
1070                 return ret;
1071
1072         return 0;
1073 }
1074
1075 static int sony_register_sensors(struct sony_sc *sc)
1076 {
1077         size_t name_sz;
1078         char *name;
1079         int ret;
1080
1081         sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1082         if (!sc->sensor_dev)
1083                 return -ENOMEM;
1084
1085         input_set_drvdata(sc->sensor_dev, sc);
1086         sc->sensor_dev->dev.parent = &sc->hdev->dev;
1087         sc->sensor_dev->phys = sc->hdev->phys;
1088         sc->sensor_dev->uniq = sc->hdev->uniq;
1089         sc->sensor_dev->id.bustype = sc->hdev->bus;
1090         sc->sensor_dev->id.vendor = sc->hdev->vendor;
1091         sc->sensor_dev->id.product = sc->hdev->product;
1092         sc->sensor_dev->id.version = sc->hdev->version;
1093
1094         /* Append a suffix to the controller name as there are various
1095          * DS4 compatible non-Sony devices with different names.
1096          */
1097         name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1098         name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1099         if (!name)
1100                 return -ENOMEM;
1101         snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1102         sc->sensor_dev->name = name;
1103
1104         if (sc->quirks & SIXAXIS_CONTROLLER) {
1105                 /* For the DS3 we only support the accelerometer, which works
1106                  * quite well even without calibration. The device also has
1107                  * a 1-axis gyro, but it is very difficult to manage from within
1108                  * the driver even to get data, the sensor is inaccurate and
1109                  * the behavior is very different between hardware revisions.
1110                  */
1111                 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1112                 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1113                 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1114                 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1115                 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1116                 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1117         }
1118
1119         __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1120
1121         ret = input_register_device(sc->sensor_dev);
1122         if (ret < 0)
1123                 return ret;
1124
1125         return 0;
1126 }
1127
1128 /*
1129  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1130  * to "operational".  Without this, the ps3 controller will not report any
1131  * events.
1132  */
1133 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1134 {
1135         struct sony_sc *sc = hid_get_drvdata(hdev);
1136         const int buf_size =
1137                 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1138         u8 *buf;
1139         int ret;
1140
1141         buf = kmalloc(buf_size, GFP_KERNEL);
1142         if (!buf)
1143                 return -ENOMEM;
1144
1145         ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1146                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1147         if (ret < 0) {
1148                 hid_err(hdev, "can't set operational mode: step 1\n");
1149                 goto out;
1150         }
1151
1152         /*
1153          * Some compatible controllers like the Speedlink Strike FX and
1154          * Gasia need another query plus an USB interrupt to get operational.
1155          */
1156         ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1157                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1158         if (ret < 0) {
1159                 hid_err(hdev, "can't set operational mode: step 2\n");
1160                 goto out;
1161         }
1162
1163         /*
1164          * But the USB interrupt would cause SHANWAN controllers to
1165          * start rumbling non-stop, so skip step 3 for these controllers.
1166          */
1167         if (sc->quirks & SHANWAN_GAMEPAD)
1168                 goto out;
1169
1170         ret = hid_hw_output_report(hdev, buf, 1);
1171         if (ret < 0) {
1172                 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1173                 ret = 0;
1174         }
1175
1176 out:
1177         kfree(buf);
1178
1179         return ret;
1180 }
1181
1182 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1183 {
1184         static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1185         u8 *buf;
1186         int ret;
1187
1188         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1189         if (!buf)
1190                 return -ENOMEM;
1191
1192         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1193                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1194
1195         kfree(buf);
1196
1197         return ret;
1198 }
1199
1200 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1201 {
1202         static const u8 sixaxis_leds[10][4] = {
1203                                 { 0x01, 0x00, 0x00, 0x00 },
1204                                 { 0x00, 0x01, 0x00, 0x00 },
1205                                 { 0x00, 0x00, 0x01, 0x00 },
1206                                 { 0x00, 0x00, 0x00, 0x01 },
1207                                 { 0x01, 0x00, 0x00, 0x01 },
1208                                 { 0x00, 0x01, 0x00, 0x01 },
1209                                 { 0x00, 0x00, 0x01, 0x01 },
1210                                 { 0x01, 0x00, 0x01, 0x01 },
1211                                 { 0x00, 0x01, 0x01, 0x01 },
1212                                 { 0x01, 0x01, 0x01, 0x01 }
1213         };
1214
1215         int id = sc->device_id;
1216
1217         BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1218
1219         if (id < 0)
1220                 return;
1221
1222         id %= 10;
1223         memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1224 }
1225
1226 static void buzz_set_leds(struct sony_sc *sc)
1227 {
1228         struct hid_device *hdev = sc->hdev;
1229         struct list_head *report_list =
1230                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1231         struct hid_report *report = list_entry(report_list->next,
1232                 struct hid_report, list);
1233         s32 *value = report->field[0]->value;
1234
1235         BUILD_BUG_ON(MAX_LEDS < 4);
1236
1237         value[0] = 0x00;
1238         value[1] = sc->led_state[0] ? 0xff : 0x00;
1239         value[2] = sc->led_state[1] ? 0xff : 0x00;
1240         value[3] = sc->led_state[2] ? 0xff : 0x00;
1241         value[4] = sc->led_state[3] ? 0xff : 0x00;
1242         value[5] = 0x00;
1243         value[6] = 0x00;
1244         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1245 }
1246
1247 static void sony_set_leds(struct sony_sc *sc)
1248 {
1249         if (!(sc->quirks & BUZZ_CONTROLLER))
1250                 sony_schedule_work(sc, SONY_WORKER_STATE);
1251         else
1252                 buzz_set_leds(sc);
1253 }
1254
1255 static void sony_led_set_brightness(struct led_classdev *led,
1256                                     enum led_brightness value)
1257 {
1258         struct device *dev = led->dev->parent;
1259         struct hid_device *hdev = to_hid_device(dev);
1260         struct sony_sc *drv_data;
1261
1262         int n;
1263         int force_update;
1264
1265         drv_data = hid_get_drvdata(hdev);
1266         if (!drv_data) {
1267                 hid_err(hdev, "No device data\n");
1268                 return;
1269         }
1270
1271         /*
1272          * The Sixaxis on USB will override any LED settings sent to it
1273          * and keep flashing all of the LEDs until the PS button is pressed.
1274          * Updates, even if redundant, must be always be sent to the
1275          * controller to avoid having to toggle the state of an LED just to
1276          * stop the flashing later on.
1277          */
1278         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1279
1280         for (n = 0; n < drv_data->led_count; n++) {
1281                 if (led == drv_data->leds[n] && (force_update ||
1282                         (value != drv_data->led_state[n] ||
1283                         drv_data->led_delay_on[n] ||
1284                         drv_data->led_delay_off[n]))) {
1285
1286                         drv_data->led_state[n] = value;
1287
1288                         /* Setting the brightness stops the blinking */
1289                         drv_data->led_delay_on[n] = 0;
1290                         drv_data->led_delay_off[n] = 0;
1291
1292                         sony_set_leds(drv_data);
1293                         break;
1294                 }
1295         }
1296 }
1297
1298 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1299 {
1300         struct device *dev = led->dev->parent;
1301         struct hid_device *hdev = to_hid_device(dev);
1302         struct sony_sc *drv_data;
1303
1304         int n;
1305
1306         drv_data = hid_get_drvdata(hdev);
1307         if (!drv_data) {
1308                 hid_err(hdev, "No device data\n");
1309                 return LED_OFF;
1310         }
1311
1312         for (n = 0; n < drv_data->led_count; n++) {
1313                 if (led == drv_data->leds[n])
1314                         return drv_data->led_state[n];
1315         }
1316
1317         return LED_OFF;
1318 }
1319
1320 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1321                                 unsigned long *delay_off)
1322 {
1323         struct device *dev = led->dev->parent;
1324         struct hid_device *hdev = to_hid_device(dev);
1325         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1326         int n;
1327         u8 new_on, new_off;
1328
1329         if (!drv_data) {
1330                 hid_err(hdev, "No device data\n");
1331                 return -EINVAL;
1332         }
1333
1334         /* Max delay is 255 deciseconds or 2550 milliseconds */
1335         if (*delay_on > 2550)
1336                 *delay_on = 2550;
1337         if (*delay_off > 2550)
1338                 *delay_off = 2550;
1339
1340         /* Blink at 1 Hz if both values are zero */
1341         if (!*delay_on && !*delay_off)
1342                 *delay_on = *delay_off = 500;
1343
1344         new_on = *delay_on / 10;
1345         new_off = *delay_off / 10;
1346
1347         for (n = 0; n < drv_data->led_count; n++) {
1348                 if (led == drv_data->leds[n])
1349                         break;
1350         }
1351
1352         /* This LED is not registered on this device */
1353         if (n >= drv_data->led_count)
1354                 return -EINVAL;
1355
1356         /* Don't schedule work if the values didn't change */
1357         if (new_on != drv_data->led_delay_on[n] ||
1358                 new_off != drv_data->led_delay_off[n]) {
1359                 drv_data->led_delay_on[n] = new_on;
1360                 drv_data->led_delay_off[n] = new_off;
1361                 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1362         }
1363
1364         return 0;
1365 }
1366
1367 static int sony_leds_init(struct sony_sc *sc)
1368 {
1369         struct hid_device *hdev = sc->hdev;
1370         int n, ret = 0;
1371         int use_color_names;
1372         struct led_classdev *led;
1373         size_t name_sz;
1374         char *name;
1375         size_t name_len;
1376         const char *name_fmt;
1377         static const char * const color_name_str[] = { "red", "green", "blue",
1378                                                   "global" };
1379         u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1380         u8 use_hw_blink[MAX_LEDS] = { 0 };
1381
1382         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1383
1384         if (sc->quirks & BUZZ_CONTROLLER) {
1385                 sc->led_count = 4;
1386                 use_color_names = 0;
1387                 name_len = strlen("::buzz#");
1388                 name_fmt = "%s::buzz%d";
1389                 /* Validate expected report characteristics. */
1390                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1391                         return -ENODEV;
1392         } else if (sc->quirks & MOTION_CONTROLLER) {
1393                 sc->led_count = 3;
1394                 memset(max_brightness, 255, 3);
1395                 use_color_names = 1;
1396                 name_len = 0;
1397                 name_fmt = "%s:%s";
1398         } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1399                 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1400
1401                 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1402                 sc->led_count = 1;
1403                 memset(use_hw_blink, 1, 4);
1404                 use_color_names = 0;
1405                 name_len = strlen("::sony#");
1406                 name_fmt = "%s::sony%d";
1407         } else {
1408                 sixaxis_set_leds_from_id(sc);
1409                 sc->led_count = 4;
1410                 memset(use_hw_blink, 1, 4);
1411                 use_color_names = 0;
1412                 name_len = strlen("::sony#");
1413                 name_fmt = "%s::sony%d";
1414         }
1415
1416         /*
1417          * Clear LEDs as we have no way of reading their initial state. This is
1418          * only relevant if the driver is loaded after somebody actively set the
1419          * LEDs to on
1420          */
1421         sony_set_leds(sc);
1422
1423         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1424
1425         for (n = 0; n < sc->led_count; n++) {
1426
1427                 if (use_color_names)
1428                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_name_str[n]) + 2;
1429
1430                 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1431                 if (!led) {
1432                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1433                         return -ENOMEM;
1434                 }
1435
1436                 name = (void *)(&led[1]);
1437                 if (use_color_names)
1438                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1439                         color_name_str[n]);
1440                 else
1441                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1442                 led->name = name;
1443                 led->brightness = sc->led_state[n];
1444                 led->max_brightness = max_brightness[n];
1445                 led->flags = LED_CORE_SUSPENDRESUME;
1446                 led->brightness_get = sony_led_get_brightness;
1447                 led->brightness_set = sony_led_set_brightness;
1448
1449                 if (use_hw_blink[n])
1450                         led->blink_set = sony_led_blink_set;
1451
1452                 sc->leds[n] = led;
1453
1454                 ret = devm_led_classdev_register(&hdev->dev, led);
1455                 if (ret) {
1456                         hid_err(hdev, "Failed to register LED %d\n", n);
1457                         return ret;
1458                 }
1459         }
1460
1461         return 0;
1462 }
1463
1464 static void sixaxis_send_output_report(struct sony_sc *sc)
1465 {
1466         static const union sixaxis_output_report_01 default_report = {
1467                 .buf = {
1468                         0x01,
1469                         0x01, 0xff, 0x00, 0xff, 0x00,
1470                         0x00, 0x00, 0x00, 0x00, 0x00,
1471                         0xff, 0x27, 0x10, 0x00, 0x32,
1472                         0xff, 0x27, 0x10, 0x00, 0x32,
1473                         0xff, 0x27, 0x10, 0x00, 0x32,
1474                         0xff, 0x27, 0x10, 0x00, 0x32,
1475                         0x00, 0x00, 0x00, 0x00, 0x00
1476                 }
1477         };
1478         struct sixaxis_output_report *report =
1479                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1480         int n;
1481
1482         /* Initialize the report with default values */
1483         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1484
1485 #ifdef CONFIG_SONY_FF
1486         report->rumble.right_motor_on = sc->right ? 1 : 0;
1487         report->rumble.left_motor_force = sc->left;
1488 #endif
1489
1490         report->leds_bitmap |= sc->led_state[0] << 1;
1491         report->leds_bitmap |= sc->led_state[1] << 2;
1492         report->leds_bitmap |= sc->led_state[2] << 3;
1493         report->leds_bitmap |= sc->led_state[3] << 4;
1494
1495         /* Set flag for all leds off, required for 3rd party INTEC controller */
1496         if ((report->leds_bitmap & 0x1E) == 0)
1497                 report->leds_bitmap |= 0x20;
1498
1499         /*
1500          * The LEDs in the report are indexed in reverse order to their
1501          * corresponding light on the controller.
1502          * Index 0 = LED 4, index 1 = LED 3, etc...
1503          *
1504          * In the case of both delay values being zero (blinking disabled) the
1505          * default report values should be used or the controller LED will be
1506          * always off.
1507          */
1508         for (n = 0; n < 4; n++) {
1509                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1510                         report->led[3 - n].duty_off = sc->led_delay_off[n];
1511                         report->led[3 - n].duty_on = sc->led_delay_on[n];
1512                 }
1513         }
1514
1515         /* SHANWAN controllers require output reports via intr channel */
1516         if (sc->quirks & SHANWAN_GAMEPAD)
1517                 hid_hw_output_report(sc->hdev, (u8 *)report,
1518                                 sizeof(struct sixaxis_output_report));
1519         else
1520                 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
1521                                 sizeof(struct sixaxis_output_report),
1522                                 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1523 }
1524
1525 static void motion_send_output_report(struct sony_sc *sc)
1526 {
1527         struct hid_device *hdev = sc->hdev;
1528         struct motion_output_report_02 *report =
1529                 (struct motion_output_report_02 *)sc->output_report_dmabuf;
1530
1531         memset(report, 0, MOTION_REPORT_0x02_SIZE);
1532
1533         report->type = 0x02; /* set leds */
1534         report->r = sc->led_state[0];
1535         report->g = sc->led_state[1];
1536         report->b = sc->led_state[2];
1537
1538 #ifdef CONFIG_SONY_FF
1539         report->rumble = max(sc->right, sc->left);
1540 #endif
1541
1542         hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
1543 }
1544
1545 #ifdef CONFIG_SONY_FF
1546 static inline void sony_send_output_report(struct sony_sc *sc)
1547 {
1548         if (sc->send_output_report)
1549                 sc->send_output_report(sc);
1550 }
1551 #endif
1552
1553 static void sony_state_worker(struct work_struct *work)
1554 {
1555         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1556
1557         sc->send_output_report(sc);
1558 }
1559
1560 static int sony_allocate_output_report(struct sony_sc *sc)
1561 {
1562         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1563                         (sc->quirks & NAVIGATION_CONTROLLER))
1564                 sc->output_report_dmabuf =
1565                         devm_kmalloc(&sc->hdev->dev,
1566                                 sizeof(union sixaxis_output_report_01),
1567                                 GFP_KERNEL);
1568         else if (sc->quirks & MOTION_CONTROLLER)
1569                 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
1570                                                 MOTION_REPORT_0x02_SIZE,
1571                                                 GFP_KERNEL);
1572         else
1573                 return 0;
1574
1575         if (!sc->output_report_dmabuf)
1576                 return -ENOMEM;
1577
1578         return 0;
1579 }
1580
1581 #ifdef CONFIG_SONY_FF
1582 static int sony_play_effect(struct input_dev *dev, void *data,
1583                             struct ff_effect *effect)
1584 {
1585         struct hid_device *hid = input_get_drvdata(dev);
1586         struct sony_sc *sc = hid_get_drvdata(hid);
1587
1588         if (effect->type != FF_RUMBLE)
1589                 return 0;
1590
1591         sc->left = effect->u.rumble.strong_magnitude / 256;
1592         sc->right = effect->u.rumble.weak_magnitude / 256;
1593
1594         sony_schedule_work(sc, SONY_WORKER_STATE);
1595         return 0;
1596 }
1597
1598 static int sony_init_ff(struct sony_sc *sc)
1599 {
1600         struct hid_input *hidinput;
1601         struct input_dev *input_dev;
1602
1603         if (list_empty(&sc->hdev->inputs)) {
1604                 hid_err(sc->hdev, "no inputs found\n");
1605                 return -ENODEV;
1606         }
1607         hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
1608         input_dev = hidinput->input;
1609
1610         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1611         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1612 }
1613
1614 #else
1615 static int sony_init_ff(struct sony_sc *sc)
1616 {
1617         return 0;
1618 }
1619
1620 #endif
1621
1622 static int sony_battery_get_property(struct power_supply *psy,
1623                                      enum power_supply_property psp,
1624                                      union power_supply_propval *val)
1625 {
1626         struct sony_sc *sc = power_supply_get_drvdata(psy);
1627         unsigned long flags;
1628         int ret = 0;
1629         u8 battery_capacity;
1630         int battery_status;
1631
1632         spin_lock_irqsave(&sc->lock, flags);
1633         battery_capacity = sc->battery_capacity;
1634         battery_status = sc->battery_status;
1635         spin_unlock_irqrestore(&sc->lock, flags);
1636
1637         switch (psp) {
1638         case POWER_SUPPLY_PROP_PRESENT:
1639                 val->intval = 1;
1640                 break;
1641         case POWER_SUPPLY_PROP_SCOPE:
1642                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1643                 break;
1644         case POWER_SUPPLY_PROP_CAPACITY:
1645                 val->intval = battery_capacity;
1646                 break;
1647         case POWER_SUPPLY_PROP_STATUS:
1648                 val->intval = battery_status;
1649                 break;
1650         default:
1651                 ret = -EINVAL;
1652                 break;
1653         }
1654         return ret;
1655 }
1656
1657 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
1658 {
1659         const char *battery_str_fmt = append_dev_id ?
1660                 "sony_controller_battery_%pMR_%i" :
1661                 "sony_controller_battery_%pMR";
1662         struct power_supply_config psy_cfg = { .drv_data = sc, };
1663         struct hid_device *hdev = sc->hdev;
1664         int ret;
1665
1666         /*
1667          * Set the default battery level to 100% to avoid low battery warnings
1668          * if the battery is polled before the first device report is received.
1669          */
1670         sc->battery_capacity = 100;
1671
1672         sc->battery_desc.properties = sony_battery_props;
1673         sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
1674         sc->battery_desc.get_property = sony_battery_get_property;
1675         sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
1676         sc->battery_desc.use_for_apm = 0;
1677         sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
1678                                           battery_str_fmt, sc->mac_address, sc->device_id);
1679         if (!sc->battery_desc.name)
1680                 return -ENOMEM;
1681
1682         sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
1683                                             &psy_cfg);
1684         if (IS_ERR(sc->battery)) {
1685                 ret = PTR_ERR(sc->battery);
1686                 hid_err(hdev, "Unable to register battery device\n");
1687                 return ret;
1688         }
1689
1690         power_supply_powers(sc->battery, &hdev->dev);
1691         return 0;
1692 }
1693
1694 /*
1695  * If a controller is plugged in via USB while already connected via Bluetooth
1696  * it will show up as two devices. A global list of connected controllers and
1697  * their MAC addresses is maintained to ensure that a device is only connected
1698  * once.
1699  *
1700  * Some USB-only devices masquerade as Sixaxis controllers and all have the
1701  * same dummy Bluetooth address, so a comparison of the connection type is
1702  * required.  Devices are only rejected in the case where two devices have
1703  * matching Bluetooth addresses on different bus types.
1704  */
1705 static inline int sony_compare_connection_type(struct sony_sc *sc0,
1706                                                 struct sony_sc *sc1)
1707 {
1708         const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
1709         const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
1710
1711         return sc0_not_bt == sc1_not_bt;
1712 }
1713
1714 static int sony_check_add_dev_list(struct sony_sc *sc)
1715 {
1716         struct sony_sc *entry;
1717         unsigned long flags;
1718         int ret;
1719
1720         spin_lock_irqsave(&sony_dev_list_lock, flags);
1721
1722         list_for_each_entry(entry, &sony_device_list, list_node) {
1723                 ret = memcmp(sc->mac_address, entry->mac_address,
1724                                 sizeof(sc->mac_address));
1725                 if (!ret) {
1726                         if (sony_compare_connection_type(sc, entry)) {
1727                                 ret = 1;
1728                         } else {
1729                                 ret = -EEXIST;
1730                                 hid_info(sc->hdev,
1731                                 "controller with MAC address %pMR already connected\n",
1732                                 sc->mac_address);
1733                         }
1734                         goto unlock;
1735                 }
1736         }
1737
1738         ret = 0;
1739         list_add(&(sc->list_node), &sony_device_list);
1740
1741 unlock:
1742         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1743         return ret;
1744 }
1745
1746 static void sony_remove_dev_list(struct sony_sc *sc)
1747 {
1748         unsigned long flags;
1749
1750         if (sc->list_node.next) {
1751                 spin_lock_irqsave(&sony_dev_list_lock, flags);
1752                 list_del(&(sc->list_node));
1753                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1754         }
1755 }
1756
1757 static int sony_get_bt_devaddr(struct sony_sc *sc)
1758 {
1759         int ret;
1760
1761         /* HIDP stores the device MAC address as a string in the uniq field. */
1762         ret = strlen(sc->hdev->uniq);
1763         if (ret != 17)
1764                 return -EINVAL;
1765
1766         ret = sscanf(sc->hdev->uniq,
1767                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1768                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1769                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1770
1771         if (ret != 6)
1772                 return -EINVAL;
1773
1774         return 0;
1775 }
1776
1777 static int sony_check_add(struct sony_sc *sc)
1778 {
1779         u8 *buf = NULL;
1780         int n, ret;
1781
1782         if ((sc->quirks & MOTION_CONTROLLER_BT) ||
1783             (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
1784             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1785                 /*
1786                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1787                  * address from the uniq string where HIDP stores it.
1788                  * As uniq cannot be guaranteed to be a MAC address in all cases
1789                  * a failure of this function should not prevent the connection.
1790                  */
1791                 if (sony_get_bt_devaddr(sc) < 0) {
1792                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1793                         return 0;
1794                 }
1795         } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
1796                         (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
1797                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1798                 if (!buf)
1799                         return -ENOMEM;
1800
1801                 /*
1802                  * The MAC address of a Sixaxis controller connected via USB can
1803                  * be retrieved with feature report 0xf2. The address begins at
1804                  * offset 4.
1805                  */
1806                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1807                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1808                                 HID_REQ_GET_REPORT);
1809
1810                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1811                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1812                         ret = ret < 0 ? ret : -EINVAL;
1813                         goto out_free;
1814                 }
1815
1816                 /*
1817                  * The Sixaxis device MAC in the report is big-endian and must
1818                  * be byte-swapped.
1819                  */
1820                 for (n = 0; n < 6; n++)
1821                         sc->mac_address[5-n] = buf[4+n];
1822
1823                 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
1824                          "%pMR", sc->mac_address);
1825         } else {
1826                 return 0;
1827         }
1828
1829         ret = sony_check_add_dev_list(sc);
1830
1831 out_free:
1832
1833         kfree(buf);
1834
1835         return ret;
1836 }
1837
1838 static int sony_set_device_id(struct sony_sc *sc)
1839 {
1840         int ret;
1841
1842         /*
1843          * Only Sixaxis controllers get an id.
1844          * All others are set to -1.
1845          */
1846         if (sc->quirks & SIXAXIS_CONTROLLER) {
1847                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1848                                         GFP_KERNEL);
1849                 if (ret < 0) {
1850                         sc->device_id = -1;
1851                         return ret;
1852                 }
1853                 sc->device_id = ret;
1854         } else {
1855                 sc->device_id = -1;
1856         }
1857
1858         return 0;
1859 }
1860
1861 static void sony_release_device_id(struct sony_sc *sc)
1862 {
1863         if (sc->device_id >= 0) {
1864                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1865                 sc->device_id = -1;
1866         }
1867 }
1868
1869 static inline void sony_init_output_report(struct sony_sc *sc,
1870                                 void (*send_output_report)(struct sony_sc *))
1871 {
1872         sc->send_output_report = send_output_report;
1873
1874         if (!sc->state_worker_initialized)
1875                 INIT_WORK(&sc->state_worker, sony_state_worker);
1876
1877         sc->state_worker_initialized = 1;
1878 }
1879
1880 static inline void sony_cancel_work_sync(struct sony_sc *sc)
1881 {
1882         unsigned long flags;
1883
1884         if (sc->state_worker_initialized) {
1885                 spin_lock_irqsave(&sc->lock, flags);
1886                 sc->state_worker_initialized = 0;
1887                 spin_unlock_irqrestore(&sc->lock, flags);
1888                 cancel_work_sync(&sc->state_worker);
1889         }
1890 }
1891
1892 static int sony_input_configured(struct hid_device *hdev,
1893                                         struct hid_input *hidinput)
1894 {
1895         struct sony_sc *sc = hid_get_drvdata(hdev);
1896         int append_dev_id;
1897         int ret;
1898
1899         ret = sony_set_device_id(sc);
1900         if (ret < 0) {
1901                 hid_err(hdev, "failed to allocate the device id\n");
1902                 goto err_stop;
1903         }
1904
1905         ret = append_dev_id = sony_check_add(sc);
1906         if (ret < 0)
1907                 goto err_stop;
1908
1909         ret = sony_allocate_output_report(sc);
1910         if (ret < 0) {
1911                 hid_err(hdev, "failed to allocate the output report buffer\n");
1912                 goto err_stop;
1913         }
1914
1915         if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
1916                 /*
1917                  * The Sony Sixaxis does not handle HID Output Reports on the
1918                  * Interrupt EP like it could, so we need to force HID Output
1919                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
1920                  *
1921                  * There is also another issue about HID Output Reports via USB,
1922                  * the Sixaxis does not want the report_id as part of the data
1923                  * packet, so we have to discard buf[0] when sending the actual
1924                  * control message, even for numbered reports, humpf!
1925                  *
1926                  * Additionally, the Sixaxis on USB isn't properly initialized
1927                  * until the PS logo button is pressed and as such won't retain
1928                  * any state set by an output report, so the initial
1929                  * configuration report is deferred until the first input
1930                  * report arrives.
1931                  */
1932                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1933                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1934                 sc->defer_initialization = 1;
1935
1936                 ret = sixaxis_set_operational_usb(hdev);
1937                 if (ret < 0) {
1938                         hid_err(hdev, "Failed to set controller into operational mode\n");
1939                         goto err_stop;
1940                 }
1941
1942                 sony_init_output_report(sc, sixaxis_send_output_report);
1943         } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
1944                 /*
1945                  * The Navigation controller wants output reports sent on the ctrl
1946                  * endpoint when connected via Bluetooth.
1947                  */
1948                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1949
1950                 ret = sixaxis_set_operational_bt(hdev);
1951                 if (ret < 0) {
1952                         hid_err(hdev, "Failed to set controller into operational mode\n");
1953                         goto err_stop;
1954                 }
1955
1956                 sony_init_output_report(sc, sixaxis_send_output_report);
1957         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1958                 /*
1959                  * The Sony Sixaxis does not handle HID Output Reports on the
1960                  * Interrupt EP and the device only becomes active when the
1961                  * PS button is pressed. See comment for Navigation controller
1962                  * above for more details.
1963                  */
1964                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1965                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1966                 sc->defer_initialization = 1;
1967
1968                 ret = sixaxis_set_operational_usb(hdev);
1969                 if (ret < 0) {
1970                         hid_err(hdev, "Failed to set controller into operational mode\n");
1971                         goto err_stop;
1972                 }
1973
1974                 ret = sony_register_sensors(sc);
1975                 if (ret) {
1976                         hid_err(sc->hdev,
1977                         "Unable to initialize motion sensors: %d\n", ret);
1978                         goto err_stop;
1979                 }
1980
1981                 sony_init_output_report(sc, sixaxis_send_output_report);
1982         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1983                 /*
1984                  * The Sixaxis wants output reports sent on the ctrl endpoint
1985                  * when connected via Bluetooth.
1986                  */
1987                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1988
1989                 ret = sixaxis_set_operational_bt(hdev);
1990                 if (ret < 0) {
1991                         hid_err(hdev, "Failed to set controller into operational mode\n");
1992                         goto err_stop;
1993                 }
1994
1995                 ret = sony_register_sensors(sc);
1996                 if (ret) {
1997                         hid_err(sc->hdev,
1998                         "Unable to initialize motion sensors: %d\n", ret);
1999                         goto err_stop;
2000                 }
2001
2002                 sony_init_output_report(sc, sixaxis_send_output_report);
2003         } else if (sc->quirks & NSG_MRXU_REMOTE) {
2004                 /*
2005                  * The NSG-MRxU touchpad supports 2 touches and has a
2006                  * resolution of 1667x1868
2007                  */
2008                 ret = sony_register_touchpad(sc, 2,
2009                         NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2010                 if (ret) {
2011                         hid_err(sc->hdev,
2012                         "Unable to initialize multi-touch slots: %d\n",
2013                         ret);
2014                         goto err_stop;
2015                 }
2016
2017         } else if (sc->quirks & MOTION_CONTROLLER) {
2018                 sony_init_output_report(sc, motion_send_output_report);
2019         } else {
2020                 ret = 0;
2021         }
2022
2023         if (sc->quirks & SONY_LED_SUPPORT) {
2024                 ret = sony_leds_init(sc);
2025                 if (ret < 0)
2026                         goto err_stop;
2027         }
2028
2029         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2030                 ret = sony_battery_probe(sc, append_dev_id);
2031                 if (ret < 0)
2032                         goto err_stop;
2033
2034                 /* Open the device to receive reports with battery info */
2035                 ret = hid_hw_open(hdev);
2036                 if (ret < 0) {
2037                         hid_err(hdev, "hw open failed\n");
2038                         goto err_stop;
2039                 }
2040         }
2041
2042         if (sc->quirks & SONY_FF_SUPPORT) {
2043                 ret = sony_init_ff(sc);
2044                 if (ret < 0)
2045                         goto err_close;
2046         }
2047
2048         return 0;
2049 err_close:
2050         hid_hw_close(hdev);
2051 err_stop:
2052         sony_cancel_work_sync(sc);
2053         sony_remove_dev_list(sc);
2054         sony_release_device_id(sc);
2055         return ret;
2056 }
2057
2058 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2059 {
2060         int ret;
2061         unsigned long quirks = id->driver_data;
2062         struct sony_sc *sc;
2063         struct usb_device *usbdev;
2064         unsigned int connect_mask = HID_CONNECT_DEFAULT;
2065
2066         if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2067                 quirks |= FUTUREMAX_DANCE_MAT;
2068
2069         if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") ||
2070             !strcmp(hdev->name, "ShanWan PS(R) Ga`epad"))
2071                 quirks |= SHANWAN_GAMEPAD;
2072
2073         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2074         if (sc == NULL) {
2075                 hid_err(hdev, "can't alloc sony descriptor\n");
2076                 return -ENOMEM;
2077         }
2078
2079         spin_lock_init(&sc->lock);
2080
2081         sc->quirks = quirks;
2082         hid_set_drvdata(hdev, sc);
2083         sc->hdev = hdev;
2084
2085         ret = hid_parse(hdev);
2086         if (ret) {
2087                 hid_err(hdev, "parse failed\n");
2088                 return ret;
2089         }
2090
2091         if (sc->quirks & VAIO_RDESC_CONSTANT)
2092                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2093         else if (sc->quirks & SIXAXIS_CONTROLLER)
2094                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2095
2096         /* Patch the hw version on DS3 compatible devices, so applications can
2097          * distinguish between the default HID mappings and the mappings defined
2098          * by the Linux game controller spec. This is important for the SDL2
2099          * library, which has a game controller database, which uses device ids
2100          * in combination with version as a key.
2101          */
2102         if (sc->quirks & SIXAXIS_CONTROLLER)
2103                 hdev->version |= 0x8000;
2104
2105         ret = hid_hw_start(hdev, connect_mask);
2106         if (ret) {
2107                 hid_err(hdev, "hw start failed\n");
2108                 return ret;
2109         }
2110
2111         /* sony_input_configured can fail, but this doesn't result
2112          * in hid_hw_start failures (intended). Check whether
2113          * the HID layer claimed the device else fail.
2114          * We don't know the actual reason for the failure, most
2115          * likely it is due to EEXIST in case of double connection
2116          * of USB and Bluetooth, but could have been due to ENOMEM
2117          * or other reasons as well.
2118          */
2119         if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2120                 hid_err(hdev, "failed to claim input\n");
2121                 ret = -ENODEV;
2122                 goto err;
2123         }
2124
2125         if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
2126                 if (!hid_is_usb(hdev)) {
2127                         ret = -EINVAL;
2128                         goto err;
2129                 }
2130
2131                 usbdev = to_usb_device(sc->hdev->dev.parent->parent);
2132
2133                 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
2134                 if (!sc->ghl_urb) {
2135                         ret = -ENOMEM;
2136                         goto err;
2137                 }
2138
2139                 if (sc->quirks & GHL_GUITAR_PS3WIIU)
2140                         ret = ghl_init_urb(sc, usbdev, ghl_ps3wiiu_magic_data,
2141                                                            ARRAY_SIZE(ghl_ps3wiiu_magic_data));
2142                 else if (sc->quirks & GHL_GUITAR_PS4)
2143                         ret = ghl_init_urb(sc, usbdev, ghl_ps4_magic_data,
2144                                                            ARRAY_SIZE(ghl_ps4_magic_data));
2145                 if (ret) {
2146                         hid_err(hdev, "error preparing URB\n");
2147                         goto err;
2148                 }
2149
2150                 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
2151                 mod_timer(&sc->ghl_poke_timer,
2152                           jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
2153         }
2154
2155         return ret;
2156
2157 err:
2158         usb_free_urb(sc->ghl_urb);
2159
2160         hid_hw_stop(hdev);
2161         return ret;
2162 }
2163
2164 static void sony_remove(struct hid_device *hdev)
2165 {
2166         struct sony_sc *sc = hid_get_drvdata(hdev);
2167
2168         if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
2169                 del_timer_sync(&sc->ghl_poke_timer);
2170                 usb_free_urb(sc->ghl_urb);
2171         }
2172
2173         hid_hw_close(hdev);
2174
2175         sony_cancel_work_sync(sc);
2176
2177         sony_remove_dev_list(sc);
2178
2179         sony_release_device_id(sc);
2180
2181         hid_hw_stop(hdev);
2182 }
2183
2184 #ifdef CONFIG_PM
2185
2186 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2187 {
2188 #ifdef CONFIG_SONY_FF
2189
2190         /* On suspend stop any running force-feedback events */
2191         if (SONY_FF_SUPPORT) {
2192                 struct sony_sc *sc = hid_get_drvdata(hdev);
2193
2194                 sc->left = sc->right = 0;
2195                 sony_send_output_report(sc);
2196         }
2197
2198 #endif
2199         return 0;
2200 }
2201
2202 static int sony_resume(struct hid_device *hdev)
2203 {
2204         struct sony_sc *sc = hid_get_drvdata(hdev);
2205
2206         /*
2207          * The Sixaxis and navigation controllers on USB need to be
2208          * reinitialized on resume or they won't behave properly.
2209          */
2210         if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2211                 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2212                 sixaxis_set_operational_usb(sc->hdev);
2213                 sc->defer_initialization = 1;
2214         }
2215
2216         return 0;
2217 }
2218
2219 #endif
2220
2221 static const struct hid_device_id sony_devices[] = {
2222         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2223                 .driver_data = SIXAXIS_CONTROLLER_USB },
2224         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2225                 .driver_data = NAVIGATION_CONTROLLER_USB },
2226         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2227                 .driver_data = NAVIGATION_CONTROLLER_BT },
2228         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2229                 .driver_data = MOTION_CONTROLLER_USB },
2230         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2231                 .driver_data = MOTION_CONTROLLER_BT },
2232         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2233                 .driver_data = SIXAXIS_CONTROLLER_BT },
2234         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2235                 .driver_data = VAIO_RDESC_CONSTANT },
2236         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2237                 .driver_data = VAIO_RDESC_CONSTANT },
2238         /*
2239          * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2240          * Logitech joystick from the device descriptor.
2241          */
2242         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2243                 .driver_data = BUZZ_CONTROLLER },
2244         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2245                 .driver_data = BUZZ_CONTROLLER },
2246         /* PS3 BD Remote Control */
2247         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2248                 .driver_data = PS3REMOTE },
2249         /* Logitech Harmony Adapter for PS3 */
2250         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2251                 .driver_data = PS3REMOTE },
2252         /* SMK-Link PS3 BD Remote Control */
2253         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2254                 .driver_data = PS3REMOTE },
2255         /* Nyko Core Controller for PS3 */
2256         { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2257                 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2258         /* SMK-Link NSG-MR5U Remote Control */
2259         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
2260                 .driver_data = NSG_MR5U_REMOTE_BT },
2261         /* SMK-Link NSG-MR7U Remote Control */
2262         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
2263                 .driver_data = NSG_MR7U_REMOTE_BT },
2264         /* Guitar Hero Live PS3 and Wii U guitar dongles */
2265         { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
2266                 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
2267         /* Guitar Hero PC Guitar Dongle */
2268         { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_GUITAR_DONGLE),
2269                 .driver_data = GH_GUITAR_CONTROLLER },
2270         /* Guitar Hero PS3 World Tour Guitar Dongle */
2271         { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
2272                 .driver_data = GH_GUITAR_CONTROLLER },
2273         /* Guitar Hero Live PS4 guitar dongles */
2274         { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_PS4_GHLIVE_DONGLE),
2275                 .driver_data = GHL_GUITAR_PS4 | GH_GUITAR_CONTROLLER },
2276         { }
2277 };
2278 MODULE_DEVICE_TABLE(hid, sony_devices);
2279
2280 static struct hid_driver sony_driver = {
2281         .name             = "sony",
2282         .id_table         = sony_devices,
2283         .input_mapping    = sony_mapping,
2284         .input_configured = sony_input_configured,
2285         .probe            = sony_probe,
2286         .remove           = sony_remove,
2287         .report_fixup     = sony_report_fixup,
2288         .raw_event        = sony_raw_event,
2289
2290 #ifdef CONFIG_PM
2291         .suspend          = sony_suspend,
2292         .resume           = sony_resume,
2293         .reset_resume     = sony_resume,
2294 #endif
2295 };
2296
2297 static int __init sony_init(void)
2298 {
2299         dbg_hid("Sony:%s\n", __func__);
2300
2301         return hid_register_driver(&sony_driver);
2302 }
2303
2304 static void __exit sony_exit(void)
2305 {
2306         dbg_hid("Sony:%s\n", __func__);
2307
2308         hid_unregister_driver(&sony_driver);
2309         ida_destroy(&sony_device_id_allocator);
2310 }
2311 module_init(sony_init);
2312 module_exit(sony_exit);
2313
2314 MODULE_LICENSE("GPL");