drivers/hid/hid-sony.c

   1 /*
   2  *  HID driver for Sony / PS2 / PS3 / PS4 BD devices.
   3  *
   4  *  Copyright (c) 1999 Andreas Gal
   5  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
   6  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
   7  *  Copyright (c) 2008 Jiri Slaby
   8  *  Copyright (c) 2012 David Dillow <dave@thedillows.org>
   9  *  Copyright (c) 2006-2013 Jiri Kosina
  10  *  Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
  11  *  Copyright (c) 2014 Frank Praznik <frank.praznik@gmail.com>
  12  */
  13
  14 /*
  15  * This program is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License as published by the Free
  17  * Software Foundation; either version 2 of the License, or (at your option)
  18  * any later version.
  19  */
  20
  21 /*
  22  * NOTE: in order for the Sony PS3 BD Remote Control to be found by
  23  * a Bluetooth host, the key combination Start+Enter has to be kept pressed
  24  * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
  25  *
  26  * There will be no PIN request from the device.
  27  */
  28
  29 #include <linux/device.h>
  30 #include <linux/hid.h>
  31 #include <linux/module.h>
  32 #include <linux/slab.h>
  33 #include <linux/leds.h>
  34 #include <linux/power_supply.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/list.h>
  37 #include <linux/idr.h>
  38 #include <linux/input/mt.h>
  39
  40 #include "hid-ids.h"
  41
  42 #define VAIO_RDESC_CONSTANT       BIT(0)
  43 #define SIXAXIS_CONTROLLER_USB    BIT(1)
  44 #define SIXAXIS_CONTROLLER_BT     BIT(2)
  45 #define BUZZ_CONTROLLER           BIT(3)
  46 #define PS3REMOTE                 BIT(4)
  47 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
  48 #define DUALSHOCK4_CONTROLLER_BT  BIT(6)
  49
  50 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
  51 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
  52                                 DUALSHOCK4_CONTROLLER_BT)
  53 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
  54                                 DUALSHOCK4_CONTROLLER)
  55 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
  56 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
  57
  58 #define MAX_LEDS 4
  59
  60 static __u8 sixaxis_rdesc[] = {
  61         0x05, 0x01,         /*  Usage Page (Desktop),               */
  62         0x09, 0x04,         /*  Usage (Joystik),                    */
  63         0xA1, 0x01,         /*  Collection (Application),           */
  64         0xA1, 0x02,         /*      Collection (Logical),           */
  65         0x85, 0x01,         /*          Report ID (1),              */
  66         0x75, 0x08,         /*          Report Size (8),            */
  67         0x95, 0x01,         /*          Report Count (1),           */
  68         0x15, 0x00,         /*          Logical Minimum (0),        */
  69         0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
  70         0x81, 0x03,         /*          Input (Constant, Variable), */
  71         0x75, 0x01,         /*          Report Size (1),            */
  72         0x95, 0x13,         /*          Report Count (19),          */
  73         0x15, 0x00,         /*          Logical Minimum (0),        */
  74         0x25, 0x01,         /*          Logical Maximum (1),        */
  75         0x35, 0x00,         /*          Physical Minimum (0),       */
  76         0x45, 0x01,         /*          Physical Maximum (1),       */
  77         0x05, 0x09,         /*          Usage Page (Button),        */
  78         0x19, 0x01,         /*          Usage Minimum (01h),        */
  79         0x29, 0x13,         /*          Usage Maximum (13h),        */
  80         0x81, 0x02,         /*          Input (Variable),           */
  81         0x75, 0x01,         /*          Report Size (1),            */
  82         0x95, 0x0D,         /*          Report Count (13),          */
  83         0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
  84         0x81, 0x03,         /*          Input (Constant, Variable), */
  85         0x15, 0x00,         /*          Logical Minimum (0),        */
  86         0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
  87         0x05, 0x01,         /*          Usage Page (Desktop),       */
  88         0x09, 0x01,         /*          Usage (Pointer),            */
  89         0xA1, 0x00,         /*          Collection (Physical),      */
  90         0x75, 0x08,         /*              Report Size (8),        */
  91         0x95, 0x04,         /*              Report Count (4),       */
  92         0x35, 0x00,         /*              Physical Minimum (0),   */
  93         0x46, 0xFF, 0x00,   /*              Physical Maximum (255), */
  94         0x09, 0x30,         /*              Usage (X),              */
  95         0x09, 0x31,         /*              Usage (Y),              */
  96         0x09, 0x32,         /*              Usage (Z),              */
  97         0x09, 0x35,         /*              Usage (Rz),             */
  98         0x81, 0x02,         /*              Input (Variable),       */
  99         0xC0,               /*          End Collection,             */
 100         0x05, 0x01,         /*          Usage Page (Desktop),       */
 101         0x95, 0x13,         /*          Report Count (19),          */
 102         0x09, 0x01,         /*          Usage (Pointer),            */
 103         0x81, 0x02,         /*          Input (Variable),           */
 104         0x95, 0x0C,         /*          Report Count (12),          */
 105         0x81, 0x01,         /*          Input (Constant),           */
 106         0x75, 0x10,         /*          Report Size (16),           */
 107         0x95, 0x04,         /*          Report Count (4),           */
 108         0x26, 0xFF, 0x03,   /*          Logical Maximum (1023),     */
 109         0x46, 0xFF, 0x03,   /*          Physical Maximum (1023),    */
 110         0x09, 0x01,         /*          Usage (Pointer),            */
 111         0x81, 0x02,         /*          Input (Variable),           */
 112         0xC0,               /*      End Collection,                 */
 113         0xA1, 0x02,         /*      Collection (Logical),           */
 114         0x85, 0x02,         /*          Report ID (2),              */
 115         0x75, 0x08,         /*          Report Size (8),            */
 116         0x95, 0x30,         /*          Report Count (48),          */
 117         0x09, 0x01,         /*          Usage (Pointer),            */
 118         0xB1, 0x02,         /*          Feature (Variable),         */
 119         0xC0,               /*      End Collection,                 */
 120         0xA1, 0x02,         /*      Collection (Logical),           */
 121         0x85, 0xEE,         /*          Report ID (238),            */
 122         0x75, 0x08,         /*          Report Size (8),            */
 123         0x95, 0x30,         /*          Report Count (48),          */
 124         0x09, 0x01,         /*          Usage (Pointer),            */
 125         0xB1, 0x02,         /*          Feature (Variable),         */
 126         0xC0,               /*      End Collection,                 */
 127         0xA1, 0x02,         /*      Collection (Logical),           */
 128         0x85, 0xEF,         /*          Report ID (239),            */
 129         0x75, 0x08,         /*          Report Size (8),            */
 130         0x95, 0x30,         /*          Report Count (48),          */
 131         0x09, 0x01,         /*          Usage (Pointer),            */
 132         0xB1, 0x02,         /*          Feature (Variable),         */
 133         0xC0,               /*      End Collection,                 */
 134         0xC0                /*  End Collection                      */
 135 };
 136
 137 /*
 138  * The default descriptor doesn't provide mapping for the accelerometers
 139  * or orientation sensors.  This fixed descriptor maps the accelerometers
 140  * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
 141  * to usage values 0x43, 0x44 and 0x45.
 142  */
 143 static u8 dualshock4_usb_rdesc[] = {
 144         0x05, 0x01,         /*  Usage Page (Desktop),               */
 145         0x09, 0x05,         /*  Usage (Gamepad),                    */
 146         0xA1, 0x01,         /*  Collection (Application),           */
 147         0x85, 0x01,         /*      Report ID (1),                  */
 148         0x09, 0x30,         /*      Usage (X),                      */
 149         0x09, 0x31,         /*      Usage (Y),                      */
 150         0x09, 0x32,         /*      Usage (Z),                      */
 151         0x09, 0x35,         /*      Usage (Rz),                     */
 152         0x15, 0x00,         /*      Logical Minimum (0),            */
 153         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 154         0x75, 0x08,         /*      Report Size (8),                */
 155         0x95, 0x04,         /*      Report Count (4),               */
 156         0x81, 0x02,         /*      Input (Variable),               */
 157         0x09, 0x39,         /*      Usage (Hat Switch),             */
 158         0x15, 0x00,         /*      Logical Minimum (0),            */
 159         0x25, 0x07,         /*      Logical Maximum (7),            */
 160         0x35, 0x00,         /*      Physical Minimum (0),           */
 161         0x46, 0x3B, 0x01,   /*      Physical Maximum (315),         */
 162         0x65, 0x14,         /*      Unit (Degrees),                 */
 163         0x75, 0x04,         /*      Report Size (4),                */
 164         0x95, 0x01,         /*      Report Count (1),               */
 165         0x81, 0x42,         /*      Input (Variable, Null State),   */
 166         0x65, 0x00,         /*      Unit,                           */
 167         0x05, 0x09,         /*      Usage Page (Button),            */
 168         0x19, 0x01,         /*      Usage Minimum (01h),            */
 169         0x29, 0x0E,         /*      Usage Maximum (0Eh),            */
 170         0x15, 0x00,         /*      Logical Minimum (0),            */
 171         0x25, 0x01,         /*      Logical Maximum (1),            */
 172         0x75, 0x01,         /*      Report Size (1),                */
 173         0x95, 0x0E,         /*      Report Count (14),              */
 174         0x81, 0x02,         /*      Input (Variable),               */
 175         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 176         0x09, 0x20,         /*      Usage (20h),                    */
 177         0x75, 0x06,         /*      Report Size (6),                */
 178         0x95, 0x01,         /*      Report Count (1),               */
 179         0x15, 0x00,         /*      Logical Minimum (0),            */
 180         0x25, 0x3F,         /*      Logical Maximum (63),           */
 181         0x81, 0x02,         /*      Input (Variable),               */
 182         0x05, 0x01,         /*      Usage Page (Desktop),           */
 183         0x09, 0x33,         /*      Usage (Rx),                     */
 184         0x09, 0x34,         /*      Usage (Ry),                     */
 185         0x15, 0x00,         /*      Logical Minimum (0),            */
 186         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 187         0x75, 0x08,         /*      Report Size (8),                */
 188         0x95, 0x02,         /*      Report Count (2),               */
 189         0x81, 0x02,         /*      Input (Variable),               */
 190         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 191         0x09, 0x21,         /*      Usage (21h),                    */
 192         0x95, 0x03,         /*      Report Count (3),               */
 193         0x81, 0x02,         /*      Input (Variable),               */
 194         0x05, 0x01,         /*      Usage Page (Desktop),           */
 195         0x19, 0x40,         /*      Usage Minimum (40h),            */
 196         0x29, 0x42,         /*      Usage Maximum (42h),            */
 197         0x16, 0x00, 0x80,   /*      Logical Minimum (-32768),       */
 198         0x26, 0x00, 0x7F,   /*      Logical Maximum (32767),        */
 199         0x75, 0x10,         /*      Report Size (16),               */
 200         0x95, 0x03,         /*      Report Count (3),               */
 201         0x81, 0x02,         /*      Input (Variable),               */
 202         0x19, 0x43,         /*      Usage Minimum (43h),            */
 203         0x29, 0x45,         /*      Usage Maximum (45h),            */
 204         0x16, 0x00, 0xE0,   /*      Logical Minimum (-8192),        */
 205         0x26, 0xFF, 0x1F,   /*      Logical Maximum (8191),         */
 206         0x95, 0x03,         /*      Report Count (3),               */
 207         0x81, 0x02,         /*      Input (Variable),               */
 208         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 209         0x09, 0x21,         /*      Usage (21h),                    */
 210         0x15, 0x00,         /*      Logical Minimum (0),            */
 211         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 212         0x75, 0x08,         /*      Report Size (8),                */
 213         0x95, 0x27,         /*      Report Count (39),              */
 214         0x81, 0x02,         /*      Input (Variable),               */
 215         0x85, 0x05,         /*      Report ID (5),                  */
 216         0x09, 0x22,         /*      Usage (22h),                    */
 217         0x95, 0x1F,         /*      Report Count (31),              */
 218         0x91, 0x02,         /*      Output (Variable),              */
 219         0x85, 0x04,         /*      Report ID (4),                  */
 220         0x09, 0x23,         /*      Usage (23h),                    */
 221         0x95, 0x24,         /*      Report Count (36),              */
 222         0xB1, 0x02,         /*      Feature (Variable),             */
 223         0x85, 0x02,         /*      Report ID (2),                  */
 224         0x09, 0x24,         /*      Usage (24h),                    */
 225         0x95, 0x24,         /*      Report Count (36),              */
 226         0xB1, 0x02,         /*      Feature (Variable),             */
 227         0x85, 0x08,         /*      Report ID (8),                  */
 228         0x09, 0x25,         /*      Usage (25h),                    */
 229         0x95, 0x03,         /*      Report Count (3),               */
 230         0xB1, 0x02,         /*      Feature (Variable),             */
 231         0x85, 0x10,         /*      Report ID (16),                 */
 232         0x09, 0x26,         /*      Usage (26h),                    */
 233         0x95, 0x04,         /*      Report Count (4),               */
 234         0xB1, 0x02,         /*      Feature (Variable),             */
 235         0x85, 0x11,         /*      Report ID (17),                 */
 236         0x09, 0x27,         /*      Usage (27h),                    */
 237         0x95, 0x02,         /*      Report Count (2),               */
 238         0xB1, 0x02,         /*      Feature (Variable),             */
 239         0x85, 0x12,         /*      Report ID (18),                 */
 240         0x06, 0x02, 0xFF,   /*      Usage Page (FF02h),             */
 241         0x09, 0x21,         /*      Usage (21h),                    */
 242         0x95, 0x0F,         /*      Report Count (15),              */
 243         0xB1, 0x02,         /*      Feature (Variable),             */
 244         0x85, 0x13,         /*      Report ID (19),                 */
 245         0x09, 0x22,         /*      Usage (22h),                    */
 246         0x95, 0x16,         /*      Report Count (22),              */
 247         0xB1, 0x02,         /*      Feature (Variable),             */
 248         0x85, 0x14,         /*      Report ID (20),                 */
 249         0x06, 0x05, 0xFF,   /*      Usage Page (FF05h),             */
 250         0x09, 0x20,         /*      Usage (20h),                    */
 251         0x95, 0x10,         /*      Report Count (16),              */
 252         0xB1, 0x02,         /*      Feature (Variable),             */
 253         0x85, 0x15,         /*      Report ID (21),                 */
 254         0x09, 0x21,         /*      Usage (21h),                    */
 255         0x95, 0x2C,         /*      Report Count (44),              */
 256         0xB1, 0x02,         /*      Feature (Variable),             */
 257         0x06, 0x80, 0xFF,   /*      Usage Page (FF80h),             */
 258         0x85, 0x80,         /*      Report ID (128),                */
 259         0x09, 0x20,         /*      Usage (20h),                    */
 260         0x95, 0x06,         /*      Report Count (6),               */
 261         0xB1, 0x02,         /*      Feature (Variable),             */
 262         0x85, 0x81,         /*      Report ID (129),                */
 263         0x09, 0x21,         /*      Usage (21h),                    */
 264         0x95, 0x06,         /*      Report Count (6),               */
 265         0xB1, 0x02,         /*      Feature (Variable),             */
 266         0x85, 0x82,         /*      Report ID (130),                */
 267         0x09, 0x22,         /*      Usage (22h),                    */
 268         0x95, 0x05,         /*      Report Count (5),               */
 269         0xB1, 0x02,         /*      Feature (Variable),             */
 270         0x85, 0x83,         /*      Report ID (131),                */
 271         0x09, 0x23,         /*      Usage (23h),                    */
 272         0x95, 0x01,         /*      Report Count (1),               */
 273         0xB1, 0x02,         /*      Feature (Variable),             */
 274         0x85, 0x84,         /*      Report ID (132),                */
 275         0x09, 0x24,         /*      Usage (24h),                    */
 276         0x95, 0x04,         /*      Report Count (4),               */
 277         0xB1, 0x02,         /*      Feature (Variable),             */
 278         0x85, 0x85,         /*      Report ID (133),                */
 279         0x09, 0x25,         /*      Usage (25h),                    */
 280         0x95, 0x06,         /*      Report Count (6),               */
 281         0xB1, 0x02,         /*      Feature (Variable),             */
 282         0x85, 0x86,         /*      Report ID (134),                */
 283         0x09, 0x26,         /*      Usage (26h),                    */
 284         0x95, 0x06,         /*      Report Count (6),               */
 285         0xB1, 0x02,         /*      Feature (Variable),             */
 286         0x85, 0x87,         /*      Report ID (135),                */
 287         0x09, 0x27,         /*      Usage (27h),                    */
 288         0x95, 0x23,         /*      Report Count (35),              */
 289         0xB1, 0x02,         /*      Feature (Variable),             */
 290         0x85, 0x88,         /*      Report ID (136),                */
 291         0x09, 0x28,         /*      Usage (28h),                    */
 292         0x95, 0x22,         /*      Report Count (34),              */
 293         0xB1, 0x02,         /*      Feature (Variable),             */
 294         0x85, 0x89,         /*      Report ID (137),                */
 295         0x09, 0x29,         /*      Usage (29h),                    */
 296         0x95, 0x02,         /*      Report Count (2),               */
 297         0xB1, 0x02,         /*      Feature (Variable),             */
 298         0x85, 0x90,         /*      Report ID (144),                */
 299         0x09, 0x30,         /*      Usage (30h),                    */
 300         0x95, 0x05,         /*      Report Count (5),               */
 301         0xB1, 0x02,         /*      Feature (Variable),             */
 302         0x85, 0x91,         /*      Report ID (145),                */
 303         0x09, 0x31,         /*      Usage (31h),                    */
 304         0x95, 0x03,         /*      Report Count (3),               */
 305         0xB1, 0x02,         /*      Feature (Variable),             */
 306         0x85, 0x92,         /*      Report ID (146),                */
 307         0x09, 0x32,         /*      Usage (32h),                    */
 308         0x95, 0x03,         /*      Report Count (3),               */
 309         0xB1, 0x02,         /*      Feature (Variable),             */
 310         0x85, 0x93,         /*      Report ID (147),                */
 311         0x09, 0x33,         /*      Usage (33h),                    */
 312         0x95, 0x0C,         /*      Report Count (12),              */
 313         0xB1, 0x02,         /*      Feature (Variable),             */
 314         0x85, 0xA0,         /*      Report ID (160),                */
 315         0x09, 0x40,         /*      Usage (40h),                    */
 316         0x95, 0x06,         /*      Report Count (6),               */
 317         0xB1, 0x02,         /*      Feature (Variable),             */
 318         0x85, 0xA1,         /*      Report ID (161),                */
 319         0x09, 0x41,         /*      Usage (41h),                    */
 320         0x95, 0x01,         /*      Report Count (1),               */
 321         0xB1, 0x02,         /*      Feature (Variable),             */
 322         0x85, 0xA2,         /*      Report ID (162),                */
 323         0x09, 0x42,         /*      Usage (42h),                    */
 324         0x95, 0x01,         /*      Report Count (1),               */
 325         0xB1, 0x02,         /*      Feature (Variable),             */
 326         0x85, 0xA3,         /*      Report ID (163),                */
 327         0x09, 0x43,         /*      Usage (43h),                    */
 328         0x95, 0x30,         /*      Report Count (48),              */
 329         0xB1, 0x02,         /*      Feature (Variable),             */
 330         0x85, 0xA4,         /*      Report ID (164),                */
 331         0x09, 0x44,         /*      Usage (44h),                    */
 332         0x95, 0x0D,         /*      Report Count (13),              */
 333         0xB1, 0x02,         /*      Feature (Variable),             */
 334         0x85, 0xA5,         /*      Report ID (165),                */
 335         0x09, 0x45,         /*      Usage (45h),                    */
 336         0x95, 0x15,         /*      Report Count (21),              */
 337         0xB1, 0x02,         /*      Feature (Variable),             */
 338         0x85, 0xA6,         /*      Report ID (166),                */
 339         0x09, 0x46,         /*      Usage (46h),                    */
 340         0x95, 0x15,         /*      Report Count (21),              */
 341         0xB1, 0x02,         /*      Feature (Variable),             */
 342         0x85, 0xF0,         /*      Report ID (240),                */
 343         0x09, 0x47,         /*      Usage (47h),                    */
 344         0x95, 0x3F,         /*      Report Count (63),              */
 345         0xB1, 0x02,         /*      Feature (Variable),             */
 346         0x85, 0xF1,         /*      Report ID (241),                */
 347         0x09, 0x48,         /*      Usage (48h),                    */
 348         0x95, 0x3F,         /*      Report Count (63),              */
 349         0xB1, 0x02,         /*      Feature (Variable),             */
 350         0x85, 0xF2,         /*      Report ID (242),                */
 351         0x09, 0x49,         /*      Usage (49h),                    */
 352         0x95, 0x0F,         /*      Report Count (15),              */
 353         0xB1, 0x02,         /*      Feature (Variable),             */
 354         0x85, 0xA7,         /*      Report ID (167),                */
 355         0x09, 0x4A,         /*      Usage (4Ah),                    */
 356         0x95, 0x01,         /*      Report Count (1),               */
 357         0xB1, 0x02,         /*      Feature (Variable),             */
 358         0x85, 0xA8,         /*      Report ID (168),                */
 359         0x09, 0x4B,         /*      Usage (4Bh),                    */
 360         0x95, 0x01,         /*      Report Count (1),               */
 361         0xB1, 0x02,         /*      Feature (Variable),             */
 362         0x85, 0xA9,         /*      Report ID (169),                */
 363         0x09, 0x4C,         /*      Usage (4Ch),                    */
 364         0x95, 0x08,         /*      Report Count (8),               */
 365         0xB1, 0x02,         /*      Feature (Variable),             */
 366         0x85, 0xAA,         /*      Report ID (170),                */
 367         0x09, 0x4E,         /*      Usage (4Eh),                    */
 368         0x95, 0x01,         /*      Report Count (1),               */
 369         0xB1, 0x02,         /*      Feature (Variable),             */
 370         0x85, 0xAB,         /*      Report ID (171),                */
 371         0x09, 0x4F,         /*      Usage (4Fh),                    */
 372         0x95, 0x39,         /*      Report Count (57),              */
 373         0xB1, 0x02,         /*      Feature (Variable),             */
 374         0x85, 0xAC,         /*      Report ID (172),                */
 375         0x09, 0x50,         /*      Usage (50h),                    */
 376         0x95, 0x39,         /*      Report Count (57),              */
 377         0xB1, 0x02,         /*      Feature (Variable),             */
 378         0x85, 0xAD,         /*      Report ID (173),                */
 379         0x09, 0x51,         /*      Usage (51h),                    */
 380         0x95, 0x0B,         /*      Report Count (11),              */
 381         0xB1, 0x02,         /*      Feature (Variable),             */
 382         0x85, 0xAE,         /*      Report ID (174),                */
 383         0x09, 0x52,         /*      Usage (52h),                    */
 384         0x95, 0x01,         /*      Report Count (1),               */
 385         0xB1, 0x02,         /*      Feature (Variable),             */
 386         0x85, 0xAF,         /*      Report ID (175),                */
 387         0x09, 0x53,         /*      Usage (53h),                    */
 388         0x95, 0x02,         /*      Report Count (2),               */
 389         0xB1, 0x02,         /*      Feature (Variable),             */
 390         0x85, 0xB0,         /*      Report ID (176),                */
 391         0x09, 0x54,         /*      Usage (54h),                    */
 392         0x95, 0x3F,         /*      Report Count (63),              */
 393         0xB1, 0x02,         /*      Feature (Variable),             */
 394         0xC0                /*  End Collection                      */
 395 };
 396
 397 /*
 398  * The default behavior of the Dualshock 4 is to send reports using report
 399  * type 1 when running over Bluetooth. However, when feature report 2 is
 400  * requested during the controller initialization it starts sending input
 401  * reports in report 17.  Since report 17 is undefined in the default HID
 402  * descriptor the button and axis definitions must be moved to report 17 or
 403  * the HID layer won't process the received input.
 404  */
 405 static u8 dualshock4_bt_rdesc[] = {
 406         0x05, 0x01,         /*  Usage Page (Desktop),               */
 407         0x09, 0x05,         /*  Usage (Gamepad),                    */
 408         0xA1, 0x01,         /*  Collection (Application),           */
 409         0x85, 0x01,         /*      Report ID (1),                  */
 410         0x75, 0x08,         /*      Report Size (8),                */
 411         0x95, 0x0A,         /*      Report Count (9),               */
 412         0x81, 0x02,         /*      Input (Variable),               */
 413         0x06, 0x04, 0xFF,   /*      Usage Page (FF04h),             */
 414         0x85, 0x02,         /*      Report ID (2),                  */
 415         0x09, 0x24,         /*      Usage (24h),                    */
 416         0x95, 0x24,         /*      Report Count (36),              */
 417         0xB1, 0x02,         /*      Feature (Variable),             */
 418         0x85, 0xA3,         /*      Report ID (163),                */
 419         0x09, 0x25,         /*      Usage (25h),                    */
 420         0x95, 0x30,         /*      Report Count (48),              */
 421         0xB1, 0x02,         /*      Feature (Variable),             */
 422         0x85, 0x05,         /*      Report ID (5),                  */
 423         0x09, 0x26,         /*      Usage (26h),                    */
 424         0x95, 0x28,         /*      Report Count (40),              */
 425         0xB1, 0x02,         /*      Feature (Variable),             */
 426         0x85, 0x06,         /*      Report ID (6),                  */
 427         0x09, 0x27,         /*      Usage (27h),                    */
 428         0x95, 0x34,         /*      Report Count (52),              */
 429         0xB1, 0x02,         /*      Feature (Variable),             */
 430         0x85, 0x07,         /*      Report ID (7),                  */
 431         0x09, 0x28,         /*      Usage (28h),                    */
 432         0x95, 0x30,         /*      Report Count (48),              */
 433         0xB1, 0x02,         /*      Feature (Variable),             */
 434         0x85, 0x08,         /*      Report ID (8),                  */
 435         0x09, 0x29,         /*      Usage (29h),                    */
 436         0x95, 0x2F,         /*      Report Count (47),              */
 437         0xB1, 0x02,         /*      Feature (Variable),             */
 438         0x06, 0x03, 0xFF,   /*      Usage Page (FF03h),             */
 439         0x85, 0x03,         /*      Report ID (3),                  */
 440         0x09, 0x21,         /*      Usage (21h),                    */
 441         0x95, 0x26,         /*      Report Count (38),              */
 442         0xB1, 0x02,         /*      Feature (Variable),             */
 443         0x85, 0x04,         /*      Report ID (4),                  */
 444         0x09, 0x22,         /*      Usage (22h),                    */
 445         0x95, 0x2E,         /*      Report Count (46),              */
 446         0xB1, 0x02,         /*      Feature (Variable),             */
 447         0x85, 0xF0,         /*      Report ID (240),                */
 448         0x09, 0x47,         /*      Usage (47h),                    */
 449         0x95, 0x3F,         /*      Report Count (63),              */
 450         0xB1, 0x02,         /*      Feature (Variable),             */
 451         0x85, 0xF1,         /*      Report ID (241),                */
 452         0x09, 0x48,         /*      Usage (48h),                    */
 453         0x95, 0x3F,         /*      Report Count (63),              */
 454         0xB1, 0x02,         /*      Feature (Variable),             */
 455         0x85, 0xF2,         /*      Report ID (242),                */
 456         0x09, 0x49,         /*      Usage (49h),                    */
 457         0x95, 0x0F,         /*      Report Count (15),              */
 458         0xB1, 0x02,         /*      Feature (Variable),             */
 459         0x85, 0x11,         /*      Report ID (17),                 */
 460         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 461         0x09, 0x20,         /*      Usage (20h),                    */
 462         0x95, 0x02,         /*      Report Count (2),               */
 463         0x81, 0x02,         /*      Input (Variable),               */
 464         0x05, 0x01,         /*      Usage Page (Desktop),           */
 465         0x09, 0x30,         /*      Usage (X),                      */
 466         0x09, 0x31,         /*      Usage (Y),                      */
 467         0x09, 0x32,         /*      Usage (Z),                      */
 468         0x09, 0x35,         /*      Usage (Rz),                     */
 469         0x15, 0x00,         /*      Logical Minimum (0),            */
 470         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 471         0x75, 0x08,         /*      Report Size (8),                */
 472         0x95, 0x04,         /*      Report Count (4),               */
 473         0x81, 0x02,         /*      Input (Variable),               */
 474         0x09, 0x39,         /*      Usage (Hat Switch),             */
 475         0x15, 0x00,         /*      Logical Minimum (0),            */
 476         0x25, 0x07,         /*      Logical Maximum (7),            */
 477         0x75, 0x04,         /*      Report Size (4),                */
 478         0x95, 0x01,         /*      Report Count (1),               */
 479         0x81, 0x42,         /*      Input (Variable, Null State),   */
 480         0x05, 0x09,         /*      Usage Page (Button),            */
 481         0x19, 0x01,         /*      Usage Minimum (01h),            */
 482         0x29, 0x0E,         /*      Usage Maximum (0Eh),            */
 483         0x15, 0x00,         /*      Logical Minimum (0),            */
 484         0x25, 0x01,         /*      Logical Maximum (1),            */
 485         0x75, 0x01,         /*      Report Size (1),                */
 486         0x95, 0x0E,         /*      Report Count (14),              */
 487         0x81, 0x02,         /*      Input (Variable),               */
 488         0x75, 0x06,         /*      Report Size (6),                */
 489         0x95, 0x01,         /*      Report Count (1),               */
 490         0x81, 0x01,         /*      Input (Constant),               */
 491         0x05, 0x01,         /*      Usage Page (Desktop),           */
 492         0x09, 0x33,         /*      Usage (Rx),                     */
 493         0x09, 0x34,         /*      Usage (Ry),                     */
 494         0x15, 0x00,         /*      Logical Minimum (0),            */
 495         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 496         0x75, 0x08,         /*      Report Size (8),                */
 497         0x95, 0x02,         /*      Report Count (2),               */
 498         0x81, 0x02,         /*      Input (Variable),               */
 499         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 500         0x09, 0x20,         /*      Usage (20h),                    */
 501         0x95, 0x03,         /*      Report Count (3),               */
 502         0x81, 0x02,         /*      Input (Variable),               */
 503         0x05, 0x01,         /*      Usage Page (Desktop),           */
 504         0x19, 0x40,         /*      Usage Minimum (40h),            */
 505         0x29, 0x42,         /*      Usage Maximum (42h),            */
 506         0x16, 0x00, 0x80,   /*      Logical Minimum (-32768),       */
 507         0x26, 0x00, 0x7F,   /*      Logical Maximum (32767),        */
 508         0x75, 0x10,         /*      Report Size (16),               */
 509         0x95, 0x03,         /*      Report Count (3),               */
 510         0x81, 0x02,         /*      Input (Variable),               */
 511         0x19, 0x43,         /*      Usage Minimum (43h),            */
 512         0x29, 0x45,         /*      Usage Maximum (45h),            */
 513         0x16, 0x00, 0xE0,   /*      Logical Minimum (-8192),        */
 514         0x26, 0xFF, 0x1F,   /*      Logical Maximum (8191),         */
 515         0x95, 0x03,         /*      Report Count (3),               */
 516         0x81, 0x02,         /*      Input (Variable),               */
 517         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 518         0x09, 0x20,         /*      Usage (20h),                    */
 519         0x15, 0x00,         /*      Logical Minimum (0),            */
 520         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 521         0x75, 0x08,         /*      Report Size (8),                */
 522         0x95, 0x31,         /*      Report Count (51),              */
 523         0x81, 0x02,         /*      Input (Variable),               */
 524         0x09, 0x21,         /*      Usage (21h),                    */
 525         0x75, 0x08,         /*      Report Size (8),                */
 526         0x95, 0x4D,         /*      Report Count (77),              */
 527         0x91, 0x02,         /*      Output (Variable),              */
 528         0x85, 0x12,         /*      Report ID (18),                 */
 529         0x09, 0x22,         /*      Usage (22h),                    */
 530         0x95, 0x8D,         /*      Report Count (141),             */
 531         0x81, 0x02,         /*      Input (Variable),               */
 532         0x09, 0x23,         /*      Usage (23h),                    */
 533         0x91, 0x02,         /*      Output (Variable),              */
 534         0x85, 0x13,         /*      Report ID (19),                 */
 535         0x09, 0x24,         /*      Usage (24h),                    */
 536         0x95, 0xCD,         /*      Report Count (205),             */
 537         0x81, 0x02,         /*      Input (Variable),               */
 538         0x09, 0x25,         /*      Usage (25h),                    */
 539         0x91, 0x02,         /*      Output (Variable),              */
 540         0x85, 0x14,         /*      Report ID (20),                 */
 541         0x09, 0x26,         /*      Usage (26h),                    */
 542         0x96, 0x0D, 0x01,   /*      Report Count (269),             */
 543         0x81, 0x02,         /*      Input (Variable),               */
 544         0x09, 0x27,         /*      Usage (27h),                    */
 545         0x91, 0x02,         /*      Output (Variable),              */
 546         0x85, 0x15,         /*      Report ID (21),                 */
 547         0x09, 0x28,         /*      Usage (28h),                    */
 548         0x96, 0x4D, 0x01,   /*      Report Count (333),             */
 549         0x81, 0x02,         /*      Input (Variable),               */
 550         0x09, 0x29,         /*      Usage (29h),                    */
 551         0x91, 0x02,         /*      Output (Variable),              */
 552         0x85, 0x16,         /*      Report ID (22),                 */
 553         0x09, 0x2A,         /*      Usage (2Ah),                    */
 554         0x96, 0x8D, 0x01,   /*      Report Count (397),             */
 555         0x81, 0x02,         /*      Input (Variable),               */
 556         0x09, 0x2B,         /*      Usage (2Bh),                    */
 557         0x91, 0x02,         /*      Output (Variable),              */
 558         0x85, 0x17,         /*      Report ID (23),                 */
 559         0x09, 0x2C,         /*      Usage (2Ch),                    */
 560         0x96, 0xCD, 0x01,   /*      Report Count (461),             */
 561         0x81, 0x02,         /*      Input (Variable),               */
 562         0x09, 0x2D,         /*      Usage (2Dh),                    */
 563         0x91, 0x02,         /*      Output (Variable),              */
 564         0x85, 0x18,         /*      Report ID (24),                 */
 565         0x09, 0x2E,         /*      Usage (2Eh),                    */
 566         0x96, 0x0D, 0x02,   /*      Report Count (525),             */
 567         0x81, 0x02,         /*      Input (Variable),               */
 568         0x09, 0x2F,         /*      Usage (2Fh),                    */
 569         0x91, 0x02,         /*      Output (Variable),              */
 570         0x85, 0x19,         /*      Report ID (25),                 */
 571         0x09, 0x30,         /*      Usage (30h),                    */
 572         0x96, 0x22, 0x02,   /*      Report Count (546),             */
 573         0x81, 0x02,         /*      Input (Variable),               */
 574         0x09, 0x31,         /*      Usage (31h),                    */
 575         0x91, 0x02,         /*      Output (Variable),              */
 576         0x06, 0x80, 0xFF,   /*      Usage Page (FF80h),             */
 577         0x85, 0x82,         /*      Report ID (130),                */
 578         0x09, 0x22,         /*      Usage (22h),                    */
 579         0x95, 0x3F,         /*      Report Count (63),              */
 580         0xB1, 0x02,         /*      Feature (Variable),             */
 581         0x85, 0x83,         /*      Report ID (131),                */
 582         0x09, 0x23,         /*      Usage (23h),                    */
 583         0xB1, 0x02,         /*      Feature (Variable),             */
 584         0x85, 0x84,         /*      Report ID (132),                */
 585         0x09, 0x24,         /*      Usage (24h),                    */
 586         0xB1, 0x02,         /*      Feature (Variable),             */
 587         0x85, 0x90,         /*      Report ID (144),                */
 588         0x09, 0x30,         /*      Usage (30h),                    */
 589         0xB1, 0x02,         /*      Feature (Variable),             */
 590         0x85, 0x91,         /*      Report ID (145),                */
 591         0x09, 0x31,         /*      Usage (31h),                    */
 592         0xB1, 0x02,         /*      Feature (Variable),             */
 593         0x85, 0x92,         /*      Report ID (146),                */
 594         0x09, 0x32,         /*      Usage (32h),                    */
 595         0xB1, 0x02,         /*      Feature (Variable),             */
 596         0x85, 0x93,         /*      Report ID (147),                */
 597         0x09, 0x33,         /*      Usage (33h),                    */
 598         0xB1, 0x02,         /*      Feature (Variable),             */
 599         0x85, 0xA0,         /*      Report ID (160),                */
 600         0x09, 0x40,         /*      Usage (40h),                    */
 601         0xB1, 0x02,         /*      Feature (Variable),             */
 602         0x85, 0xA4,         /*      Report ID (164),                */
 603         0x09, 0x44,         /*      Usage (44h),                    */
 604         0xB1, 0x02,         /*      Feature (Variable),             */
 605         0xC0                /*  End Collection                      */
 606 };
 607
 608 static __u8 ps3remote_rdesc[] = {
 609         0x05, 0x01,          /* GUsagePage Generic Desktop */
 610         0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
 611         0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
 612
 613          /* Use collection 1 for joypad buttons */
 614          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 615
 616           /* Ignore the 1st byte, maybe it is used for a controller
 617            * number but it's not needed for correct operation */
 618           0x75, 0x08,        /* GReportSize 0x08 [8] */
 619           0x95, 0x01,        /* GReportCount 0x01 [1] */
 620           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 621
 622           /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
 623            * buttons multiple keypresses are allowed */
 624           0x05, 0x09,        /* GUsagePage Button */
 625           0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
 626           0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
 627           0x14,              /* GLogicalMinimum [0] */
 628           0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
 629           0x75, 0x01,        /* GReportSize 0x01 [1] */
 630           0x95, 0x18,        /* GReportCount 0x18 [24] */
 631           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 632
 633           0xC0,              /* MEndCollection */
 634
 635          /* Use collection 2 for remote control buttons */
 636          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 637
 638           /* 5th byte is used for remote control buttons */
 639           0x05, 0x09,        /* GUsagePage Button */
 640           0x18,              /* LUsageMinimum [No button pressed] */
 641           0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
 642           0x14,              /* GLogicalMinimum [0] */
 643           0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
 644           0x75, 0x08,        /* GReportSize 0x08 [8] */
 645           0x95, 0x01,        /* GReportCount 0x01 [1] */
 646           0x80,              /* MInput  */
 647
 648           /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
 649            * 0xff and 11th is for press indication */
 650           0x75, 0x08,        /* GReportSize 0x08 [8] */
 651           0x95, 0x06,        /* GReportCount 0x06 [6] */
 652           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 653
 654           /* 12th byte is for battery strength */
 655           0x05, 0x06,        /* GUsagePage Generic Device Controls */
 656           0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
 657           0x14,              /* GLogicalMinimum [0] */
 658           0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
 659           0x75, 0x08,        /* GReportSize 0x08 [8] */
 660           0x95, 0x01,        /* GReportCount 0x01 [1] */
 661           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 662
 663           0xC0,              /* MEndCollection */
 664
 665          0xC0                /* MEndCollection [Game Pad] */
 666 };
 667
 668 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
 669         [0x01] = KEY_SELECT,
 670         [0x02] = BTN_THUMBL,            /* L3 */
 671         [0x03] = BTN_THUMBR,            /* R3 */
 672         [0x04] = BTN_START,
 673         [0x05] = KEY_UP,
 674         [0x06] = KEY_RIGHT,
 675         [0x07] = KEY_DOWN,
 676         [0x08] = KEY_LEFT,
 677         [0x09] = BTN_TL2,               /* L2 */
 678         [0x0a] = BTN_TR2,               /* R2 */
 679         [0x0b] = BTN_TL,                /* L1 */
 680         [0x0c] = BTN_TR,                /* R1 */
 681         [0x0d] = KEY_OPTION,            /* options/triangle */
 682         [0x0e] = KEY_BACK,              /* back/circle */
 683         [0x0f] = BTN_0,                 /* cross */
 684         [0x10] = KEY_SCREEN,            /* view/square */
 685         [0x11] = KEY_HOMEPAGE,          /* PS button */
 686         [0x14] = KEY_ENTER,
 687 };
 688 static const unsigned int ps3remote_keymap_remote_buttons[] = {
 689         [0x00] = KEY_1,
 690         [0x01] = KEY_2,
 691         [0x02] = KEY_3,
 692         [0x03] = KEY_4,
 693         [0x04] = KEY_5,
 694         [0x05] = KEY_6,
 695         [0x06] = KEY_7,
 696         [0x07] = KEY_8,
 697         [0x08] = KEY_9,
 698         [0x09] = KEY_0,
 699         [0x0e] = KEY_ESC,               /* return */
 700         [0x0f] = KEY_CLEAR,
 701         [0x16] = KEY_EJECTCD,
 702         [0x1a] = KEY_MENU,              /* top menu */
 703         [0x28] = KEY_TIME,
 704         [0x30] = KEY_PREVIOUS,
 705         [0x31] = KEY_NEXT,
 706         [0x32] = KEY_PLAY,
 707         [0x33] = KEY_REWIND,            /* scan back */
 708         [0x34] = KEY_FORWARD,           /* scan forward */
 709         [0x38] = KEY_STOP,
 710         [0x39] = KEY_PAUSE,
 711         [0x40] = KEY_CONTEXT_MENU,      /* pop up/menu */
 712         [0x60] = KEY_FRAMEBACK,         /* slow/step back */
 713         [0x61] = KEY_FRAMEFORWARD,      /* slow/step forward */
 714         [0x63] = KEY_SUBTITLE,
 715         [0x64] = KEY_AUDIO,
 716         [0x65] = KEY_ANGLE,
 717         [0x70] = KEY_INFO,              /* display */
 718         [0x80] = KEY_BLUE,
 719         [0x81] = KEY_RED,
 720         [0x82] = KEY_GREEN,
 721         [0x83] = KEY_YELLOW,
 722 };
 723
 724 static const unsigned int buzz_keymap[] = {
 725         /*
 726          * The controller has 4 remote buzzers, each with one LED and 5
 727          * buttons.
 728          *
 729          * We use the mapping chosen by the controller, which is:
 730          *
 731          * Key          Offset
 732          * -------------------
 733          * Buzz              1
 734          * Blue              5
 735          * Orange            4
 736          * Green             3
 737          * Yellow            2
 738          *
 739          * So, for example, the orange button on the third buzzer is mapped to
 740          * BTN_TRIGGER_HAPPY14
 741          */
 742         [ 1] = BTN_TRIGGER_HAPPY1,
 743         [ 2] = BTN_TRIGGER_HAPPY2,
 744         [ 3] = BTN_TRIGGER_HAPPY3,
 745         [ 4] = BTN_TRIGGER_HAPPY4,
 746         [ 5] = BTN_TRIGGER_HAPPY5,
 747         [ 6] = BTN_TRIGGER_HAPPY6,
 748         [ 7] = BTN_TRIGGER_HAPPY7,
 749         [ 8] = BTN_TRIGGER_HAPPY8,
 750         [ 9] = BTN_TRIGGER_HAPPY9,
 751         [10] = BTN_TRIGGER_HAPPY10,
 752         [11] = BTN_TRIGGER_HAPPY11,
 753         [12] = BTN_TRIGGER_HAPPY12,
 754         [13] = BTN_TRIGGER_HAPPY13,
 755         [14] = BTN_TRIGGER_HAPPY14,
 756         [15] = BTN_TRIGGER_HAPPY15,
 757         [16] = BTN_TRIGGER_HAPPY16,
 758         [17] = BTN_TRIGGER_HAPPY17,
 759         [18] = BTN_TRIGGER_HAPPY18,
 760         [19] = BTN_TRIGGER_HAPPY19,
 761         [20] = BTN_TRIGGER_HAPPY20,
 762 };
 763
 764 static enum power_supply_property sony_battery_props[] = {
 765         POWER_SUPPLY_PROP_PRESENT,
 766         POWER_SUPPLY_PROP_CAPACITY,
 767         POWER_SUPPLY_PROP_SCOPE,
 768         POWER_SUPPLY_PROP_STATUS,
 769 };
 770
 771 struct sixaxis_led {
 772         __u8 time_enabled; /* the total time the led is active (0xff means forever) */
 773         __u8 duty_length;  /* how long a cycle is in deciseconds (0 means "really fast") */
 774         __u8 enabled;
 775         __u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
 776         __u8 duty_on;  /* % of duty_length the led is on (0xff mean 100%) */
 777 } __packed;
 778
 779 struct sixaxis_rumble {
 780         __u8 padding;
 781         __u8 right_duration; /* Right motor duration (0xff means forever) */
 782         __u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
 783         __u8 left_duration;    /* Left motor duration (0xff means forever) */
 784         __u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
 785 } __packed;
 786
 787 struct sixaxis_output_report {
 788         __u8 report_id;
 789         struct sixaxis_rumble rumble;
 790         __u8 padding[4];
 791         __u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
 792         struct sixaxis_led led[4];    /* LEDx at (4 - x) */
 793         struct sixaxis_led _reserved; /* LED5, not actually soldered */
 794 } __packed;
 795
 796 union sixaxis_output_report_01 {
 797         struct sixaxis_output_report data;
 798         __u8 buf[36];
 799 };
 800
 801 #define DS4_REPORT_0x02_SIZE 37
 802 #define DS4_REPORT_0x05_SIZE 32
 803 #define DS4_REPORT_0x11_SIZE 78
 804 #define DS4_REPORT_0x81_SIZE 7
 805 #define SIXAXIS_REPORT_0xF2_SIZE 18
 806
 807 static spinlock_t sony_dev_list_lock;
 808 static LIST_HEAD(sony_device_list);
 809 static DEFINE_IDA(sony_device_id_allocator);
 810
 811 struct sony_sc {
 812         spinlock_t lock;
 813         struct list_head list_node;
 814         struct hid_device *hdev;
 815         struct led_classdev *leds[MAX_LEDS];
 816         unsigned long quirks;
 817         struct work_struct state_worker;
 818         struct power_supply battery;
 819         int device_id;
 820         __u8 *output_report_dmabuf;
 821
 822 #ifdef CONFIG_SONY_FF
 823         __u8 left;
 824         __u8 right;
 825 #endif
 826
 827         __u8 mac_address[6];
 828         __u8 worker_initialized;
 829         __u8 cable_state;
 830         __u8 battery_charging;
 831         __u8 battery_capacity;
 832         __u8 led_state[MAX_LEDS];
 833         __u8 led_delay_on[MAX_LEDS];
 834         __u8 led_delay_off[MAX_LEDS];
 835         __u8 led_count;
 836 };
 837
 838 static __u8 *sixaxis_fixup(struct hid_device *hdev, __u8 *rdesc,
 839                              unsigned int *rsize)
 840 {
 841         *rsize = sizeof(sixaxis_rdesc);
 842         return sixaxis_rdesc;
 843 }
 844
 845 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
 846                              unsigned int *rsize)
 847 {
 848         *rsize = sizeof(ps3remote_rdesc);
 849         return ps3remote_rdesc;
 850 }
 851
 852 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
 853                              struct hid_field *field, struct hid_usage *usage,
 854                              unsigned long **bit, int *max)
 855 {
 856         unsigned int key = usage->hid & HID_USAGE;
 857
 858         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 859                 return -1;
 860
 861         switch (usage->collection_index) {
 862         case 1:
 863                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
 864                         return -1;
 865
 866                 key = ps3remote_keymap_joypad_buttons[key];
 867                 if (!key)
 868                         return -1;
 869                 break;
 870         case 2:
 871                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
 872                         return -1;
 873
 874                 key = ps3remote_keymap_remote_buttons[key];
 875                 if (!key)
 876                         return -1;
 877                 break;
 878         default:
 879                 return -1;
 880         }
 881
 882         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 883         return 1;
 884 }
 885
 886 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 887                 unsigned int *rsize)
 888 {
 889         struct sony_sc *sc = hid_get_drvdata(hdev);
 890
 891         /*
 892          * Some Sony RF receivers wrongly declare the mouse pointer as a
 893          * a constant non-data variable.
 894          */
 895         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
 896             /* usage page: generic desktop controls */
 897             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
 898             /* usage: mouse */
 899             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
 900             /* input (usage page for x,y axes): constant, variable, relative */
 901             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
 902                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
 903                 /* input: data, variable, relative */
 904                 rdesc[55] = 0x06;
 905         }
 906
 907         /*
 908          * The default Dualshock 4 USB descriptor doesn't assign
 909          * the gyroscope values to corresponding axes so we need a
 910          * modified one.
 911          */
 912         if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
 913                 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
 914                 rdesc = dualshock4_usb_rdesc;
 915                 *rsize = sizeof(dualshock4_usb_rdesc);
 916         } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
 917                 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
 918                 rdesc = dualshock4_bt_rdesc;
 919                 *rsize = sizeof(dualshock4_bt_rdesc);
 920         }
 921
 922         if (sc->quirks & SIXAXIS_CONTROLLER)
 923                 return sixaxis_fixup(hdev, rdesc, rsize);
 924
 925         if (sc->quirks & PS3REMOTE)
 926                 return ps3remote_fixup(hdev, rdesc, rsize);
 927
 928         return rdesc;
 929 }
 930
 931 static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
 932 {
 933         static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
 934         unsigned long flags;
 935         __u8 cable_state, battery_capacity, battery_charging;
 936
 937         /*
 938          * The sixaxis is charging if the battery value is 0xee
 939          * and it is fully charged if the value is 0xef.
 940          * It does not report the actual level while charging so it
 941          * is set to 100% while charging is in progress.
 942          */
 943         if (rd[30] >= 0xee) {
 944                 battery_capacity = 100;
 945                 battery_charging = !(rd[30] & 0x01);
 946                 cable_state = 1;
 947         } else {
 948                 __u8 index = rd[30] <= 5 ? rd[30] : 5;
 949                 battery_capacity = sixaxis_battery_capacity[index];
 950                 battery_charging = 0;
 951                 cable_state = 0;
 952         }
 953
 954         spin_lock_irqsave(&sc->lock, flags);
 955         sc->cable_state = cable_state;
 956         sc->battery_capacity = battery_capacity;
 957         sc->battery_charging = battery_charging;
 958         spin_unlock_irqrestore(&sc->lock, flags);
 959 }
 960
 961 static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
 962 {
 963         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
 964                                                 struct hid_input, list);
 965         struct input_dev *input_dev = hidinput->input;
 966         unsigned long flags;
 967         int n, offset;
 968         __u8 cable_state, battery_capacity, battery_charging;
 969
 970         /*
 971          * Battery and touchpad data starts at byte 30 in the USB report and
 972          * 32 in Bluetooth report.
 973          */
 974         offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
 975
 976         /*
 977          * The lower 4 bits of byte 30 contain the battery level
 978          * and the 5th bit contains the USB cable state.
 979          */
 980         cable_state = (rd[offset] >> 4) & 0x01;
 981         battery_capacity = rd[offset] & 0x0F;
 982
 983         /*
 984          * When a USB power source is connected the battery level ranges from
 985          * 0 to 10, and when running on battery power it ranges from 0 to 9.
 986          * A battery level above 10 when plugged in means charge completed.
 987          */
 988         if (!cable_state || battery_capacity > 10)
 989                 battery_charging = 0;
 990         else
 991                 battery_charging = 1;
 992
 993         if (!cable_state)
 994                 battery_capacity++;
 995         if (battery_capacity > 10)
 996                 battery_capacity = 10;
 997
 998         battery_capacity *= 10;
 999
1000         spin_lock_irqsave(&sc->lock, flags);
1001         sc->cable_state = cable_state;
1002         sc->battery_capacity = battery_capacity;
1003         sc->battery_charging = battery_charging;
1004         spin_unlock_irqrestore(&sc->lock, flags);
1005
1006         offset += 5;
1007
1008         /*
1009          * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
1010          * and 37 on Bluetooth.
1011          * The first 7 bits of the first byte is a counter and bit 8 is a touch
1012          * indicator that is 0 when pressed and 1 when not pressed.
1013          * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1014          * The data for the second touch is in the same format and immediatly
1015          * follows the data for the first.
1016          */
1017         for (n = 0; n < 2; n++) {
1018                 __u16 x, y;
1019
1020                 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1021                 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1022
1023                 input_mt_slot(input_dev, n);
1024                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
1025                                         !(rd[offset] >> 7));
1026                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1027                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1028
1029                 offset += 4;
1030         }
1031 }
1032
1033 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1034                 __u8 *rd, int size)
1035 {
1036         struct sony_sc *sc = hid_get_drvdata(hdev);
1037
1038         /*
1039          * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1040          * has to be BYTE_SWAPPED before passing up to joystick interface
1041          */
1042         if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1043                 swap(rd[41], rd[42]);
1044                 swap(rd[43], rd[44]);
1045                 swap(rd[45], rd[46]);
1046                 swap(rd[47], rd[48]);
1047
1048                 sixaxis_parse_report(sc, rd, size);
1049         } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1050                         size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1051                         && rd[0] == 0x11 && size == 78)) {
1052                 dualshock4_parse_report(sc, rd, size);
1053         }
1054
1055         return 0;
1056 }
1057
1058 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1059                         struct hid_field *field, struct hid_usage *usage,
1060                         unsigned long **bit, int *max)
1061 {
1062         struct sony_sc *sc = hid_get_drvdata(hdev);
1063
1064         if (sc->quirks & BUZZ_CONTROLLER) {
1065                 unsigned int key = usage->hid & HID_USAGE;
1066
1067                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1068                         return -1;
1069
1070                 switch (usage->collection_index) {
1071                 case 1:
1072                         if (key >= ARRAY_SIZE(buzz_keymap))
1073                                 return -1;
1074
1075                         key = buzz_keymap[key];
1076                         if (!key)
1077                                 return -1;
1078                         break;
1079                 default:
1080                         return -1;
1081                 }
1082
1083                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1084                 return 1;
1085         }
1086
1087         if (sc->quirks & PS3REMOTE)
1088                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1089
1090         /* Let hid-core decide for the others */
1091         return 0;
1092 }
1093
1094 static int sony_register_touchpad(struct hid_input *hi, int touch_count,
1095                                         int w, int h)
1096 {
1097         struct input_dev *input_dev = hi->input;
1098         int ret;
1099
1100         ret = input_mt_init_slots(input_dev, touch_count, 0);
1101         if (ret < 0)
1102                 return ret;
1103
1104         input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1105         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1106
1107         return 0;
1108 }
1109
1110 static void sony_input_configured(struct hid_device *hdev,
1111                                         struct hid_input *hidinput)
1112 {
1113         struct sony_sc *sc = hid_get_drvdata(hdev);
1114
1115         /*
1116          * The Dualshock 4 touchpad supports 2 touches and has a
1117          * resolution of 1920x942 (44.86 dots/mm).
1118          */
1119         if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1120                 if (sony_register_touchpad(hidinput, 2, 1920, 942) != 0)
1121                         hid_err(sc->hdev,
1122                                 "Unable to initialize multi-touch slots\n");
1123         }
1124 }
1125
1126 /*
1127  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1128  * to "operational".  Without this, the ps3 controller will not report any
1129  * events.
1130  */
1131 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1132 {
1133         int ret;
1134         char *buf = kmalloc(18, GFP_KERNEL);
1135
1136         if (!buf)
1137                 return -ENOMEM;
1138
1139         ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1140                                  HID_REQ_GET_REPORT);
1141
1142         if (ret < 0)
1143                 hid_err(hdev, "can't set operational mode\n");
1144
1145         kfree(buf);
1146
1147         return ret;
1148 }
1149
1150 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1151 {
1152         static const __u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1153         __u8 *buf;
1154         int ret;
1155
1156         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1157         if (!buf)
1158                 return -ENOMEM;
1159
1160         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1161                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1162
1163         kfree(buf);
1164
1165         return ret;
1166 }
1167
1168 /*
1169  * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1170  * controller so that it sends full input reports of type 0x11.
1171  */
1172 static int dualshock4_set_operational_bt(struct hid_device *hdev)
1173 {
1174         __u8 *buf;
1175         int ret;
1176
1177         buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1178         if (!buf)
1179                 return -ENOMEM;
1180
1181         ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
1182                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1183
1184         kfree(buf);
1185
1186         return ret;
1187 }
1188
1189 static void sixaxis_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1190 {
1191         static const __u8 sixaxis_leds[10][4] = {
1192                                 { 0x01, 0x00, 0x00, 0x00 },
1193                                 { 0x00, 0x01, 0x00, 0x00 },
1194                                 { 0x00, 0x00, 0x01, 0x00 },
1195                                 { 0x00, 0x00, 0x00, 0x01 },
1196                                 { 0x01, 0x00, 0x00, 0x01 },
1197                                 { 0x00, 0x01, 0x00, 0x01 },
1198                                 { 0x00, 0x00, 0x01, 0x01 },
1199                                 { 0x01, 0x00, 0x01, 0x01 },
1200                                 { 0x00, 0x01, 0x01, 0x01 },
1201                                 { 0x01, 0x01, 0x01, 0x01 }
1202         };
1203
1204         BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1205
1206         if (id < 0)
1207                 return;
1208
1209         id %= 10;
1210         memcpy(values, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1211 }
1212
1213 static void dualshock4_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1214 {
1215         /* The first 4 color/index entries match what the PS4 assigns */
1216         static const __u8 color_code[7][3] = {
1217                         /* Blue   */    { 0x00, 0x00, 0x01 },
1218                         /* Red    */    { 0x01, 0x00, 0x00 },
1219                         /* Green  */    { 0x00, 0x01, 0x00 },
1220                         /* Pink   */    { 0x02, 0x00, 0x01 },
1221                         /* Orange */    { 0x02, 0x01, 0x00 },
1222                         /* Teal   */    { 0x00, 0x01, 0x01 },
1223                         /* White  */    { 0x01, 0x01, 0x01 }
1224         };
1225
1226         BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1227
1228         if (id < 0)
1229                 return;
1230
1231         id %= 7;
1232         memcpy(values, color_code[id], sizeof(color_code[id]));
1233 }
1234
1235 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1236 {
1237         struct list_head *report_list =
1238                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1239         struct hid_report *report = list_entry(report_list->next,
1240                 struct hid_report, list);
1241         __s32 *value = report->field[0]->value;
1242
1243         value[0] = 0x00;
1244         value[1] = leds[0] ? 0xff : 0x00;
1245         value[2] = leds[1] ? 0xff : 0x00;
1246         value[3] = leds[2] ? 0xff : 0x00;
1247         value[4] = leds[3] ? 0xff : 0x00;
1248         value[5] = 0x00;
1249         value[6] = 0x00;
1250         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1251 }
1252
1253 static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count)
1254 {
1255         int n;
1256
1257         BUG_ON(count > MAX_LEDS);
1258
1259         if (sc->quirks & BUZZ_CONTROLLER && count == 4) {
1260                 buzz_set_leds(sc->hdev, leds);
1261         } else {
1262                 for (n = 0; n < count; n++)
1263                         sc->led_state[n] = leds[n];
1264                 schedule_work(&sc->state_worker);
1265         }
1266 }
1267
1268 static void sony_led_set_brightness(struct led_classdev *led,
1269                                     enum led_brightness value)
1270 {
1271         struct device *dev = led->dev->parent;
1272         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1273         struct sony_sc *drv_data;
1274
1275         int n;
1276         int force_update;
1277
1278         drv_data = hid_get_drvdata(hdev);
1279         if (!drv_data) {
1280                 hid_err(hdev, "No device data\n");
1281                 return;
1282         }
1283
1284         /*
1285          * The Sixaxis on USB will override any LED settings sent to it
1286          * and keep flashing all of the LEDs until the PS button is pressed.
1287          * Updates, even if redundant, must be always be sent to the
1288          * controller to avoid having to toggle the state of an LED just to
1289          * stop the flashing later on.
1290          */
1291         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1292
1293         for (n = 0; n < drv_data->led_count; n++) {
1294                 if (led == drv_data->leds[n] && (force_update ||
1295                         (value != drv_data->led_state[n] ||
1296                         drv_data->led_delay_on[n] ||
1297                         drv_data->led_delay_off[n]))) {
1298
1299                         drv_data->led_state[n] = value;
1300
1301                         /* Setting the brightness stops the blinking */
1302                         drv_data->led_delay_on[n] = 0;
1303                         drv_data->led_delay_off[n] = 0;
1304
1305                         sony_set_leds(drv_data, drv_data->led_state,
1306                                         drv_data->led_count);
1307                         break;
1308                 }
1309         }
1310 }
1311
1312 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1313 {
1314         struct device *dev = led->dev->parent;
1315         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1316         struct sony_sc *drv_data;
1317
1318         int n;
1319
1320         drv_data = hid_get_drvdata(hdev);
1321         if (!drv_data) {
1322                 hid_err(hdev, "No device data\n");
1323                 return LED_OFF;
1324         }
1325
1326         for (n = 0; n < drv_data->led_count; n++) {
1327                 if (led == drv_data->leds[n])
1328                         return drv_data->led_state[n];
1329         }
1330
1331         return LED_OFF;
1332 }
1333
1334 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1335                                 unsigned long *delay_off)
1336 {
1337         struct device *dev = led->dev->parent;
1338         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1339         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1340         int n;
1341         __u8 new_on, new_off;
1342
1343         if (!drv_data) {
1344                 hid_err(hdev, "No device data\n");
1345                 return -EINVAL;
1346         }
1347
1348         /* Max delay is 255 deciseconds or 2550 milliseconds */
1349         if (*delay_on > 2550)
1350                 *delay_on = 2550;
1351         if (*delay_off > 2550)
1352                 *delay_off = 2550;
1353
1354         /* Blink at 1 Hz if both values are zero */
1355         if (!*delay_on && !*delay_off)
1356                 *delay_on = *delay_off = 500;
1357
1358         new_on = *delay_on / 10;
1359         new_off = *delay_off / 10;
1360
1361         for (n = 0; n < drv_data->led_count; n++) {
1362                 if (led == drv_data->leds[n])
1363                         break;
1364         }
1365
1366         /* This LED is not registered on this device */
1367         if (n >= drv_data->led_count)
1368                 return -EINVAL;
1369
1370         /* Don't schedule work if the values didn't change */
1371         if (new_on != drv_data->led_delay_on[n] ||
1372                 new_off != drv_data->led_delay_off[n]) {
1373                 drv_data->led_delay_on[n] = new_on;
1374                 drv_data->led_delay_off[n] = new_off;
1375                 schedule_work(&drv_data->state_worker);
1376         }
1377
1378         return 0;
1379 }
1380
1381 static void sony_leds_remove(struct sony_sc *sc)
1382 {
1383         struct led_classdev *led;
1384         int n;
1385
1386         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1387
1388         for (n = 0; n < sc->led_count; n++) {
1389                 led = sc->leds[n];
1390                 sc->leds[n] = NULL;
1391                 if (!led)
1392                         continue;
1393                 led_classdev_unregister(led);
1394                 kfree(led);
1395         }
1396
1397         sc->led_count = 0;
1398 }
1399
1400 static int sony_leds_init(struct sony_sc *sc)
1401 {
1402         struct hid_device *hdev = sc->hdev;
1403         int n, ret = 0;
1404         int use_ds4_names;
1405         struct led_classdev *led;
1406         size_t name_sz;
1407         char *name;
1408         size_t name_len;
1409         const char *name_fmt;
1410         static const char * const ds4_name_str[] = { "red", "green", "blue",
1411                                                   "global" };
1412         __u8 initial_values[MAX_LEDS] = { 0 };
1413         __u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1414         __u8 use_hw_blink[MAX_LEDS] = { 0 };
1415
1416         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1417
1418         if (sc->quirks & BUZZ_CONTROLLER) {
1419                 sc->led_count = 4;
1420                 use_ds4_names = 0;
1421                 name_len = strlen("::buzz#");
1422                 name_fmt = "%s::buzz%d";
1423                 /* Validate expected report characteristics. */
1424                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1425                         return -ENODEV;
1426         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1427                 dualshock4_set_leds_from_id(sc->device_id, initial_values);
1428                 initial_values[3] = 1;
1429                 sc->led_count = 4;
1430                 memset(max_brightness, 255, 3);
1431                 use_hw_blink[3] = 1;
1432                 use_ds4_names = 1;
1433                 name_len = 0;
1434                 name_fmt = "%s:%s";
1435         } else {
1436                 sixaxis_set_leds_from_id(sc->device_id, initial_values);
1437                 sc->led_count = 4;
1438                 memset(use_hw_blink, 1, 4);
1439                 use_ds4_names = 0;
1440                 name_len = strlen("::sony#");
1441                 name_fmt = "%s::sony%d";
1442         }
1443
1444         /*
1445          * Clear LEDs as we have no way of reading their initial state. This is
1446          * only relevant if the driver is loaded after somebody actively set the
1447          * LEDs to on
1448          */
1449         sony_set_leds(sc, initial_values, sc->led_count);
1450
1451         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1452
1453         for (n = 0; n < sc->led_count; n++) {
1454
1455                 if (use_ds4_names)
1456                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1457
1458                 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1459                 if (!led) {
1460                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1461                         ret = -ENOMEM;
1462                         goto error_leds;
1463                 }
1464
1465                 name = (void *)(&led[1]);
1466                 if (use_ds4_names)
1467                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1468                         ds4_name_str[n]);
1469                 else
1470                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1471                 led->name = name;
1472                 led->brightness = initial_values[n];
1473                 led->max_brightness = max_brightness[n];
1474                 led->brightness_get = sony_led_get_brightness;
1475                 led->brightness_set = sony_led_set_brightness;
1476
1477                 if (use_hw_blink[n])
1478                         led->blink_set = sony_led_blink_set;
1479
1480                 sc->leds[n] = led;
1481
1482                 ret = led_classdev_register(&hdev->dev, led);
1483                 if (ret) {
1484                         hid_err(hdev, "Failed to register LED %d\n", n);
1485                         sc->leds[n] = NULL;
1486                         kfree(led);
1487                         goto error_leds;
1488                 }
1489         }
1490
1491         return ret;
1492
1493 error_leds:
1494         sony_leds_remove(sc);
1495
1496         return ret;
1497 }
1498
1499 static void sixaxis_state_worker(struct work_struct *work)
1500 {
1501         static const union sixaxis_output_report_01 default_report = {
1502                 .buf = {
1503                         0x01,
1504                         0x00, 0xff, 0x00, 0xff, 0x00,
1505                         0x00, 0x00, 0x00, 0x00, 0x00,
1506                         0xff, 0x27, 0x10, 0x00, 0x32,
1507                         0xff, 0x27, 0x10, 0x00, 0x32,
1508                         0xff, 0x27, 0x10, 0x00, 0x32,
1509                         0xff, 0x27, 0x10, 0x00, 0x32,
1510                         0x00, 0x00, 0x00, 0x00, 0x00
1511                 }
1512         };
1513         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1514         struct sixaxis_output_report *report =
1515                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1516         int n;
1517
1518         /* Initialize the report with default values */
1519         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1520
1521 #ifdef CONFIG_SONY_FF
1522         report->rumble.right_motor_on = sc->right ? 1 : 0;
1523         report->rumble.left_motor_force = sc->left;
1524 #endif
1525
1526         report->leds_bitmap |= sc->led_state[0] << 1;
1527         report->leds_bitmap |= sc->led_state[1] << 2;
1528         report->leds_bitmap |= sc->led_state[2] << 3;
1529         report->leds_bitmap |= sc->led_state[3] << 4;
1530
1531         /* Set flag for all leds off, required for 3rd party INTEC controller */
1532         if ((report->leds_bitmap & 0x1E) == 0)
1533                 report->leds_bitmap |= 0x20;
1534
1535         /*
1536          * The LEDs in the report are indexed in reverse order to their
1537          * corresponding light on the controller.
1538          * Index 0 = LED 4, index 1 = LED 3, etc...
1539          *
1540          * In the case of both delay values being zero (blinking disabled) the
1541          * default report values should be used or the controller LED will be
1542          * always off.
1543          */
1544         for (n = 0; n < 4; n++) {
1545                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1546                         report->led[3 - n].duty_off = sc->led_delay_off[n];
1547                         report->led[3 - n].duty_on = sc->led_delay_on[n];
1548                 }
1549         }
1550
1551         hid_hw_raw_request(sc->hdev, report->report_id, (__u8 *)report,
1552                         sizeof(struct sixaxis_output_report),
1553                         HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1554 }
1555
1556 static void dualshock4_state_worker(struct work_struct *work)
1557 {
1558         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1559         struct hid_device *hdev = sc->hdev;
1560         __u8 *buf = sc->output_report_dmabuf;
1561         int offset;
1562
1563         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1564                 memset(buf, 0, DS4_REPORT_0x05_SIZE);
1565                 buf[0] = 0x05;
1566                 buf[1] = 0xFF;
1567                 offset = 4;
1568         } else {
1569                 memset(buf, 0, DS4_REPORT_0x11_SIZE);
1570                 buf[0] = 0x11;
1571                 buf[1] = 0xB0;
1572                 buf[3] = 0x0F;
1573                 offset = 6;
1574         }
1575
1576 #ifdef CONFIG_SONY_FF
1577         buf[offset++] = sc->right;
1578         buf[offset++] = sc->left;
1579 #else
1580         offset += 2;
1581 #endif
1582
1583         /* LED 3 is the global control */
1584         if (sc->led_state[3]) {
1585                 buf[offset++] = sc->led_state[0];
1586                 buf[offset++] = sc->led_state[1];
1587                 buf[offset++] = sc->led_state[2];
1588         } else {
1589                 offset += 3;
1590         }
1591
1592         /* If both delay values are zero the DualShock 4 disables blinking. */
1593         buf[offset++] = sc->led_delay_on[3];
1594         buf[offset++] = sc->led_delay_off[3];
1595
1596         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1597                 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
1598         else
1599                 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
1600                                 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1601 }
1602
1603 static int sony_allocate_output_report(struct sony_sc *sc)
1604 {
1605         if (sc->quirks & SIXAXIS_CONTROLLER)
1606                 sc->output_report_dmabuf =
1607                         kmalloc(sizeof(union sixaxis_output_report_01),
1608                                 GFP_KERNEL);
1609         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1610                 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1611                                                 GFP_KERNEL);
1612         else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1613                 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1614                                                 GFP_KERNEL);
1615         else
1616                 return 0;
1617
1618         if (!sc->output_report_dmabuf)
1619                 return -ENOMEM;
1620
1621         return 0;
1622 }
1623
1624 #ifdef CONFIG_SONY_FF
1625 static int sony_play_effect(struct input_dev *dev, void *data,
1626                             struct ff_effect *effect)
1627 {
1628         struct hid_device *hid = input_get_drvdata(dev);
1629         struct sony_sc *sc = hid_get_drvdata(hid);
1630
1631         if (effect->type != FF_RUMBLE)
1632                 return 0;
1633
1634         sc->left = effect->u.rumble.strong_magnitude / 256;
1635         sc->right = effect->u.rumble.weak_magnitude / 256;
1636
1637         schedule_work(&sc->state_worker);
1638         return 0;
1639 }
1640
1641 static int sony_init_ff(struct sony_sc *sc)
1642 {
1643         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1644                                                 struct hid_input, list);
1645         struct input_dev *input_dev = hidinput->input;
1646
1647         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1648         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1649 }
1650
1651 #else
1652 static int sony_init_ff(struct sony_sc *sc)
1653 {
1654         return 0;
1655 }
1656
1657 #endif
1658
1659 static int sony_battery_get_property(struct power_supply *psy,
1660                                      enum power_supply_property psp,
1661                                      union power_supply_propval *val)
1662 {
1663         struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1664         unsigned long flags;
1665         int ret = 0;
1666         u8 battery_charging, battery_capacity, cable_state;
1667
1668         spin_lock_irqsave(&sc->lock, flags);
1669         battery_charging = sc->battery_charging;
1670         battery_capacity = sc->battery_capacity;
1671         cable_state = sc->cable_state;
1672         spin_unlock_irqrestore(&sc->lock, flags);
1673
1674         switch (psp) {
1675         case POWER_SUPPLY_PROP_PRESENT:
1676                 val->intval = 1;
1677                 break;
1678         case POWER_SUPPLY_PROP_SCOPE:
1679                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1680                 break;
1681         case POWER_SUPPLY_PROP_CAPACITY:
1682                 val->intval = battery_capacity;
1683                 break;
1684         case POWER_SUPPLY_PROP_STATUS:
1685                 if (battery_charging)
1686                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
1687                 else
1688                         if (battery_capacity == 100 && cable_state)
1689                                 val->intval = POWER_SUPPLY_STATUS_FULL;
1690                         else
1691                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1692                 break;
1693         default:
1694                 ret = -EINVAL;
1695                 break;
1696         }
1697         return ret;
1698 }
1699
1700 static int sony_battery_probe(struct sony_sc *sc)
1701 {
1702         struct hid_device *hdev = sc->hdev;
1703         int ret;
1704
1705         /*
1706          * Set the default battery level to 100% to avoid low battery warnings
1707          * if the battery is polled before the first device report is received.
1708          */
1709         sc->battery_capacity = 100;
1710
1711         sc->battery.properties = sony_battery_props;
1712         sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1713         sc->battery.get_property = sony_battery_get_property;
1714         sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1715         sc->battery.use_for_apm = 0;
1716         sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR",
1717                                      sc->mac_address);
1718         if (!sc->battery.name)
1719                 return -ENOMEM;
1720
1721         ret = power_supply_register(&hdev->dev, &sc->battery);
1722         if (ret) {
1723                 hid_err(hdev, "Unable to register battery device\n");
1724                 goto err_free;
1725         }
1726
1727         power_supply_powers(&sc->battery, &hdev->dev);
1728         return 0;
1729
1730 err_free:
1731         kfree(sc->battery.name);
1732         sc->battery.name = NULL;
1733         return ret;
1734 }
1735
1736 static void sony_battery_remove(struct sony_sc *sc)
1737 {
1738         if (!sc->battery.name)
1739                 return;
1740
1741         power_supply_unregister(&sc->battery);
1742         kfree(sc->battery.name);
1743         sc->battery.name = NULL;
1744 }
1745
1746 /*
1747  * If a controller is plugged in via USB while already connected via Bluetooth
1748  * it will show up as two devices. A global list of connected controllers and
1749  * their MAC addresses is maintained to ensure that a device is only connected
1750  * once.
1751  */
1752 static int sony_check_add_dev_list(struct sony_sc *sc)
1753 {
1754         struct sony_sc *entry;
1755         unsigned long flags;
1756         int ret;
1757
1758         spin_lock_irqsave(&sony_dev_list_lock, flags);
1759
1760         list_for_each_entry(entry, &sony_device_list, list_node) {
1761                 ret = memcmp(sc->mac_address, entry->mac_address,
1762                                 sizeof(sc->mac_address));
1763                 if (!ret) {
1764                         ret = -EEXIST;
1765                         hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1766                                 sc->mac_address);
1767                         goto unlock;
1768                 }
1769         }
1770
1771         ret = 0;
1772         list_add(&(sc->list_node), &sony_device_list);
1773
1774 unlock:
1775         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1776         return ret;
1777 }
1778
1779 static void sony_remove_dev_list(struct sony_sc *sc)
1780 {
1781         unsigned long flags;
1782
1783         if (sc->list_node.next) {
1784                 spin_lock_irqsave(&sony_dev_list_lock, flags);
1785                 list_del(&(sc->list_node));
1786                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1787         }
1788 }
1789
1790 static int sony_get_bt_devaddr(struct sony_sc *sc)
1791 {
1792         int ret;
1793
1794         /* HIDP stores the device MAC address as a string in the uniq field. */
1795         ret = strlen(sc->hdev->uniq);
1796         if (ret != 17)
1797                 return -EINVAL;
1798
1799         ret = sscanf(sc->hdev->uniq,
1800                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1801                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1802                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1803
1804         if (ret != 6)
1805                 return -EINVAL;
1806
1807         return 0;
1808 }
1809
1810 static int sony_check_add(struct sony_sc *sc)
1811 {
1812         __u8 *buf = NULL;
1813         int n, ret;
1814
1815         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1816             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1817                 /*
1818                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1819                  * address from the uniq string where HIDP stores it.
1820                  * As uniq cannot be guaranteed to be a MAC address in all cases
1821                  * a failure of this function should not prevent the connection.
1822                  */
1823                 if (sony_get_bt_devaddr(sc) < 0) {
1824                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1825                         return 0;
1826                 }
1827         } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1828                 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
1829                 if (!buf)
1830                         return -ENOMEM;
1831
1832                 /*
1833                  * The MAC address of a DS4 controller connected via USB can be
1834                  * retrieved with feature report 0x81. The address begins at
1835                  * offset 1.
1836                  */
1837                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
1838                                 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
1839                                 HID_REQ_GET_REPORT);
1840
1841                 if (ret != DS4_REPORT_0x81_SIZE) {
1842                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1843                         ret = ret < 0 ? ret : -EINVAL;
1844                         goto out_free;
1845                 }
1846
1847                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1848         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1849                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1850                 if (!buf)
1851                         return -ENOMEM;
1852
1853                 /*
1854                  * The MAC address of a Sixaxis controller connected via USB can
1855                  * be retrieved with feature report 0xf2. The address begins at
1856                  * offset 4.
1857                  */
1858                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1859                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1860                                 HID_REQ_GET_REPORT);
1861
1862                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1863                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1864                         ret = ret < 0 ? ret : -EINVAL;
1865                         goto out_free;
1866                 }
1867
1868                 /*
1869                  * The Sixaxis device MAC in the report is big-endian and must
1870                  * be byte-swapped.
1871                  */
1872                 for (n = 0; n < 6; n++)
1873                         sc->mac_address[5-n] = buf[4+n];
1874         } else {
1875                 return 0;
1876         }
1877
1878         ret = sony_check_add_dev_list(sc);
1879
1880 out_free:
1881
1882         kfree(buf);
1883
1884         return ret;
1885 }
1886
1887 static int sony_set_device_id(struct sony_sc *sc)
1888 {
1889         int ret;
1890
1891         /*
1892          * Only DualShock 4 or Sixaxis controllers get an id.
1893          * All others are set to -1.
1894          */
1895         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1896             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
1897                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1898                                         GFP_KERNEL);
1899                 if (ret < 0) {
1900                         sc->device_id = -1;
1901                         return ret;
1902                 }
1903                 sc->device_id = ret;
1904         } else {
1905                 sc->device_id = -1;
1906         }
1907
1908         return 0;
1909 }
1910
1911 static void sony_release_device_id(struct sony_sc *sc)
1912 {
1913         if (sc->device_id >= 0) {
1914                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1915                 sc->device_id = -1;
1916         }
1917 }
1918
1919 static inline void sony_init_work(struct sony_sc *sc,
1920                                         void (*worker)(struct work_struct *))
1921 {
1922         if (!sc->worker_initialized)
1923                 INIT_WORK(&sc->state_worker, worker);
1924
1925         sc->worker_initialized = 1;
1926 }
1927
1928 static inline void sony_cancel_work_sync(struct sony_sc *sc)
1929 {
1930         if (sc->worker_initialized)
1931                 cancel_work_sync(&sc->state_worker);
1932 }
1933
1934 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1935 {
1936         int ret;
1937         unsigned long quirks = id->driver_data;
1938         struct sony_sc *sc;
1939         unsigned int connect_mask = HID_CONNECT_DEFAULT;
1940
1941         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1942         if (sc == NULL) {
1943                 hid_err(hdev, "can't alloc sony descriptor\n");
1944                 return -ENOMEM;
1945         }
1946
1947         sc->quirks = quirks;
1948         hid_set_drvdata(hdev, sc);
1949         sc->hdev = hdev;
1950
1951         ret = hid_parse(hdev);
1952         if (ret) {
1953                 hid_err(hdev, "parse failed\n");
1954                 return ret;
1955         }
1956
1957         if (sc->quirks & VAIO_RDESC_CONSTANT)
1958                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1959         else if (sc->quirks & SIXAXIS_CONTROLLER)
1960                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1961
1962         ret = hid_hw_start(hdev, connect_mask);
1963         if (ret) {
1964                 hid_err(hdev, "hw start failed\n");
1965                 return ret;
1966         }
1967
1968         ret = sony_allocate_output_report(sc);
1969         if (ret < 0) {
1970                 hid_err(hdev, "failed to allocate the output report buffer\n");
1971                 goto err_stop;
1972         }
1973
1974         ret = sony_set_device_id(sc);
1975         if (ret < 0) {
1976                 hid_err(hdev, "failed to allocate the device id\n");
1977                 goto err_stop;
1978         }
1979
1980         if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1981                 /*
1982                  * The Sony Sixaxis does not handle HID Output Reports on the
1983                  * Interrupt EP like it could, so we need to force HID Output
1984                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
1985                  *
1986                  * There is also another issue about HID Output Reports via USB,
1987                  * the Sixaxis does not want the report_id as part of the data
1988                  * packet, so we have to discard buf[0] when sending the actual
1989                  * control message, even for numbered reports, humpf!
1990                  */
1991                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1992                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1993                 ret = sixaxis_set_operational_usb(hdev);
1994                 sony_init_work(sc, sixaxis_state_worker);
1995         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1996                 /*
1997                  * The Sixaxis wants output reports sent on the ctrl endpoint
1998                  * when connected via Bluetooth.
1999                  */
2000                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2001                 ret = sixaxis_set_operational_bt(hdev);
2002                 sony_init_work(sc, sixaxis_state_worker);
2003         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2004                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2005                         /*
2006                          * The DualShock 4 wants output reports sent on the ctrl
2007                          * endpoint when connected via Bluetooth.
2008                          */
2009                         hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2010                         ret = dualshock4_set_operational_bt(hdev);
2011                         if (ret < 0) {
2012                                 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2013                                 goto err_stop;
2014                         }
2015                 }
2016
2017                 sony_init_work(sc, dualshock4_state_worker);
2018         } else {
2019                 ret = 0;
2020         }
2021
2022         if (ret < 0)
2023                 goto err_stop;
2024
2025         ret = sony_check_add(sc);
2026         if (ret < 0)
2027                 goto err_stop;
2028
2029         if (sc->quirks & SONY_LED_SUPPORT) {
2030                 ret = sony_leds_init(sc);
2031                 if (ret < 0)
2032                         goto err_stop;
2033         }
2034
2035         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2036                 ret = sony_battery_probe(sc);
2037                 if (ret < 0)
2038                         goto err_stop;
2039
2040                 /* Open the device to receive reports with battery info */
2041                 ret = hid_hw_open(hdev);
2042                 if (ret < 0) {
2043                         hid_err(hdev, "hw open failed\n");
2044                         goto err_stop;
2045                 }
2046         }
2047
2048         if (sc->quirks & SONY_FF_SUPPORT) {
2049                 ret = sony_init_ff(sc);
2050                 if (ret < 0)
2051                         goto err_close;
2052         }
2053
2054         return 0;
2055 err_close:
2056         hid_hw_close(hdev);
2057 err_stop:
2058         if (sc->quirks & SONY_LED_SUPPORT)
2059                 sony_leds_remove(sc);
2060         if (sc->quirks & SONY_BATTERY_SUPPORT)
2061                 sony_battery_remove(sc);
2062         sony_cancel_work_sync(sc);
2063         kfree(sc->output_report_dmabuf);
2064         sony_remove_dev_list(sc);
2065         sony_release_device_id(sc);
2066         hid_hw_stop(hdev);
2067         return ret;
2068 }
2069
2070 static void sony_remove(struct hid_device *hdev)
2071 {
2072         struct sony_sc *sc = hid_get_drvdata(hdev);
2073
2074         if (sc->quirks & SONY_LED_SUPPORT)
2075                 sony_leds_remove(sc);
2076
2077         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2078                 hid_hw_close(hdev);
2079                 sony_battery_remove(sc);
2080         }
2081
2082         sony_cancel_work_sync(sc);
2083
2084         kfree(sc->output_report_dmabuf);
2085
2086         sony_remove_dev_list(sc);
2087
2088         sony_release_device_id(sc);
2089
2090         hid_hw_stop(hdev);
2091 }
2092
2093 static const struct hid_device_id sony_devices[] = {
2094         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2095                 .driver_data = SIXAXIS_CONTROLLER_USB },
2096         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2097                 .driver_data = SIXAXIS_CONTROLLER_USB },
2098         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2099                 .driver_data = SIXAXIS_CONTROLLER_BT },
2100         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2101                 .driver_data = VAIO_RDESC_CONSTANT },
2102         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2103                 .driver_data = VAIO_RDESC_CONSTANT },
2104         /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2105          * Logitech joystick from the device descriptor. */
2106         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2107                 .driver_data = BUZZ_CONTROLLER },
2108         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2109                 .driver_data = BUZZ_CONTROLLER },
2110         /* PS3 BD Remote Control */
2111         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2112                 .driver_data = PS3REMOTE },
2113         /* Logitech Harmony Adapter for PS3 */
2114         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2115                 .driver_data = PS3REMOTE },
2116         /* SMK-Link PS3 BD Remote Control */
2117         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2118                 .driver_data = PS3REMOTE },
2119         /* Sony Dualshock 4 controllers for PS4 */
2120         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2121                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2122         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2123                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2124         { }
2125 };
2126 MODULE_DEVICE_TABLE(hid, sony_devices);
2127
2128 static struct hid_driver sony_driver = {
2129         .name             = "sony",
2130         .id_table         = sony_devices,
2131         .input_mapping    = sony_mapping,
2132         .input_configured = sony_input_configured,
2133         .probe            = sony_probe,
2134         .remove           = sony_remove,
2135         .report_fixup     = sony_report_fixup,
2136         .raw_event        = sony_raw_event
2137 };
2138
2139 static int __init sony_init(void)
2140 {
2141         dbg_hid("Sony:%s\n", __func__);
2142
2143         return hid_register_driver(&sony_driver);
2144 }
2145
2146 static void __exit sony_exit(void)
2147 {
2148         dbg_hid("Sony:%s\n", __func__);
2149
2150         ida_destroy(&sony_device_id_allocator);
2151         hid_unregister_driver(&sony_driver);
2152 }
2153 module_init(sony_init);
2154 module_exit(sony_exit);
2155
2156 MODULE_LICENSE("GPL");