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 DEFINE_SPINLOCK(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         struct power_supply_desc battery_desc;
 820         int device_id;
 821         __u8 *output_report_dmabuf;
 822
 823 #ifdef CONFIG_SONY_FF
 824         __u8 left;
 825         __u8 right;
 826 #endif
 827
 828         __u8 mac_address[6];
 829         __u8 worker_initialized;
 830         __u8 cable_state;
 831         __u8 battery_charging;
 832         __u8 battery_capacity;
 833         __u8 led_state[MAX_LEDS];
 834         __u8 led_delay_on[MAX_LEDS];
 835         __u8 led_delay_off[MAX_LEDS];
 836         __u8 led_count;
 837 };
 838
 839 static __u8 *sixaxis_fixup(struct hid_device *hdev, __u8 *rdesc,
 840                              unsigned int *rsize)
 841 {
 842         *rsize = sizeof(sixaxis_rdesc);
 843         return sixaxis_rdesc;
 844 }
 845
 846 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
 847                              unsigned int *rsize)
 848 {
 849         *rsize = sizeof(ps3remote_rdesc);
 850         return ps3remote_rdesc;
 851 }
 852
 853 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
 854                              struct hid_field *field, struct hid_usage *usage,
 855                              unsigned long **bit, int *max)
 856 {
 857         unsigned int key = usage->hid & HID_USAGE;
 858
 859         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 860                 return -1;
 861
 862         switch (usage->collection_index) {
 863         case 1:
 864                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
 865                         return -1;
 866
 867                 key = ps3remote_keymap_joypad_buttons[key];
 868                 if (!key)
 869                         return -1;
 870                 break;
 871         case 2:
 872                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
 873                         return -1;
 874
 875                 key = ps3remote_keymap_remote_buttons[key];
 876                 if (!key)
 877                         return -1;
 878                 break;
 879         default:
 880                 return -1;
 881         }
 882
 883         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 884         return 1;
 885 }
 886
 887 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 888                 unsigned int *rsize)
 889 {
 890         struct sony_sc *sc = hid_get_drvdata(hdev);
 891
 892         /*
 893          * Some Sony RF receivers wrongly declare the mouse pointer as a
 894          * a constant non-data variable.
 895          */
 896         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
 897             /* usage page: generic desktop controls */
 898             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
 899             /* usage: mouse */
 900             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
 901             /* input (usage page for x,y axes): constant, variable, relative */
 902             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
 903                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
 904                 /* input: data, variable, relative */
 905                 rdesc[55] = 0x06;
 906         }
 907
 908         /*
 909          * The default Dualshock 4 USB descriptor doesn't assign
 910          * the gyroscope values to corresponding axes so we need a
 911          * modified one.
 912          */
 913         if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
 914                 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
 915                 rdesc = dualshock4_usb_rdesc;
 916                 *rsize = sizeof(dualshock4_usb_rdesc);
 917         } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
 918                 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
 919                 rdesc = dualshock4_bt_rdesc;
 920                 *rsize = sizeof(dualshock4_bt_rdesc);
 921         }
 922
 923         if (sc->quirks & SIXAXIS_CONTROLLER)
 924                 return sixaxis_fixup(hdev, rdesc, rsize);
 925
 926         if (sc->quirks & PS3REMOTE)
 927                 return ps3remote_fixup(hdev, rdesc, rsize);
 928
 929         return rdesc;
 930 }
 931
 932 static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
 933 {
 934         static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
 935         unsigned long flags;
 936         __u8 cable_state, battery_capacity, battery_charging;
 937
 938         /*
 939          * The sixaxis is charging if the battery value is 0xee
 940          * and it is fully charged if the value is 0xef.
 941          * It does not report the actual level while charging so it
 942          * is set to 100% while charging is in progress.
 943          */
 944         if (rd[30] >= 0xee) {
 945                 battery_capacity = 100;
 946                 battery_charging = !(rd[30] & 0x01);
 947                 cable_state = 1;
 948         } else {
 949                 __u8 index = rd[30] <= 5 ? rd[30] : 5;
 950                 battery_capacity = sixaxis_battery_capacity[index];
 951                 battery_charging = 0;
 952                 cable_state = 0;
 953         }
 954
 955         spin_lock_irqsave(&sc->lock, flags);
 956         sc->cable_state = cable_state;
 957         sc->battery_capacity = battery_capacity;
 958         sc->battery_charging = battery_charging;
 959         spin_unlock_irqrestore(&sc->lock, flags);
 960 }
 961
 962 static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
 963 {
 964         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
 965                                                 struct hid_input, list);
 966         struct input_dev *input_dev = hidinput->input;
 967         unsigned long flags;
 968         int n, offset;
 969         __u8 cable_state, battery_capacity, battery_charging;
 970
 971         /*
 972          * Battery and touchpad data starts at byte 30 in the USB report and
 973          * 32 in Bluetooth report.
 974          */
 975         offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
 976
 977         /*
 978          * The lower 4 bits of byte 30 contain the battery level
 979          * and the 5th bit contains the USB cable state.
 980          */
 981         cable_state = (rd[offset] >> 4) & 0x01;
 982         battery_capacity = rd[offset] & 0x0F;
 983
 984         /*
 985          * When a USB power source is connected the battery level ranges from
 986          * 0 to 10, and when running on battery power it ranges from 0 to 9.
 987          * A battery level above 10 when plugged in means charge completed.
 988          */
 989         if (!cable_state || battery_capacity > 10)
 990                 battery_charging = 0;
 991         else
 992                 battery_charging = 1;
 993
 994         if (!cable_state)
 995                 battery_capacity++;
 996         if (battery_capacity > 10)
 997                 battery_capacity = 10;
 998
 999         battery_capacity *= 10;
1000
1001         spin_lock_irqsave(&sc->lock, flags);
1002         sc->cable_state = cable_state;
1003         sc->battery_capacity = battery_capacity;
1004         sc->battery_charging = battery_charging;
1005         spin_unlock_irqrestore(&sc->lock, flags);
1006
1007         offset += 5;
1008
1009         /*
1010          * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
1011          * and 37 on Bluetooth.
1012          * The first 7 bits of the first byte is a counter and bit 8 is a touch
1013          * indicator that is 0 when pressed and 1 when not pressed.
1014          * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1015          * The data for the second touch is in the same format and immediatly
1016          * follows the data for the first.
1017          */
1018         for (n = 0; n < 2; n++) {
1019                 __u16 x, y;
1020
1021                 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1022                 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1023
1024                 input_mt_slot(input_dev, n);
1025                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
1026                                         !(rd[offset] >> 7));
1027                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1028                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1029
1030                 offset += 4;
1031         }
1032 }
1033
1034 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1035                 __u8 *rd, int size)
1036 {
1037         struct sony_sc *sc = hid_get_drvdata(hdev);
1038
1039         /*
1040          * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1041          * has to be BYTE_SWAPPED before passing up to joystick interface
1042          */
1043         if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1044                 swap(rd[41], rd[42]);
1045                 swap(rd[43], rd[44]);
1046                 swap(rd[45], rd[46]);
1047                 swap(rd[47], rd[48]);
1048
1049                 sixaxis_parse_report(sc, rd, size);
1050         } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1051                         size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1052                         && rd[0] == 0x11 && size == 78)) {
1053                 dualshock4_parse_report(sc, rd, size);
1054         }
1055
1056         return 0;
1057 }
1058
1059 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1060                         struct hid_field *field, struct hid_usage *usage,
1061                         unsigned long **bit, int *max)
1062 {
1063         struct sony_sc *sc = hid_get_drvdata(hdev);
1064
1065         if (sc->quirks & BUZZ_CONTROLLER) {
1066                 unsigned int key = usage->hid & HID_USAGE;
1067
1068                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1069                         return -1;
1070
1071                 switch (usage->collection_index) {
1072                 case 1:
1073                         if (key >= ARRAY_SIZE(buzz_keymap))
1074                                 return -1;
1075
1076                         key = buzz_keymap[key];
1077                         if (!key)
1078                                 return -1;
1079                         break;
1080                 default:
1081                         return -1;
1082                 }
1083
1084                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1085                 return 1;
1086         }
1087
1088         if (sc->quirks & PS3REMOTE)
1089                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1090
1091         /* Let hid-core decide for the others */
1092         return 0;
1093 }
1094
1095 static int sony_register_touchpad(struct hid_input *hi, int touch_count,
1096                                         int w, int h)
1097 {
1098         struct input_dev *input_dev = hi->input;
1099         int ret;
1100
1101         ret = input_mt_init_slots(input_dev, touch_count, 0);
1102         if (ret < 0)
1103                 return ret;
1104
1105         input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1106         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1107
1108         return 0;
1109 }
1110
1111 static void sony_input_configured(struct hid_device *hdev,
1112                                         struct hid_input *hidinput)
1113 {
1114         struct sony_sc *sc = hid_get_drvdata(hdev);
1115
1116         /*
1117          * The Dualshock 4 touchpad supports 2 touches and has a
1118          * resolution of 1920x942 (44.86 dots/mm).
1119          */
1120         if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1121                 if (sony_register_touchpad(hidinput, 2, 1920, 942) != 0)
1122                         hid_err(sc->hdev,
1123                                 "Unable to initialize multi-touch slots\n");
1124         }
1125 }
1126
1127 /*
1128  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1129  * to "operational".  Without this, the ps3 controller will not report any
1130  * events.
1131  */
1132 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1133 {
1134         int ret;
1135         char *buf = kmalloc(18, GFP_KERNEL);
1136
1137         if (!buf)
1138                 return -ENOMEM;
1139
1140         ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1141                                  HID_REQ_GET_REPORT);
1142
1143         if (ret < 0)
1144                 hid_err(hdev, "can't set operational mode\n");
1145
1146         kfree(buf);
1147
1148         return ret;
1149 }
1150
1151 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1152 {
1153         static const __u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1154         __u8 *buf;
1155         int ret;
1156
1157         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1158         if (!buf)
1159                 return -ENOMEM;
1160
1161         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1162                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1163
1164         kfree(buf);
1165
1166         return ret;
1167 }
1168
1169 /*
1170  * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1171  * controller so that it sends full input reports of type 0x11.
1172  */
1173 static int dualshock4_set_operational_bt(struct hid_device *hdev)
1174 {
1175         __u8 *buf;
1176         int ret;
1177
1178         buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1179         if (!buf)
1180                 return -ENOMEM;
1181
1182         ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
1183                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1184
1185         kfree(buf);
1186
1187         return ret;
1188 }
1189
1190 static void sixaxis_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1191 {
1192         static const __u8 sixaxis_leds[10][4] = {
1193                                 { 0x01, 0x00, 0x00, 0x00 },
1194                                 { 0x00, 0x01, 0x00, 0x00 },
1195                                 { 0x00, 0x00, 0x01, 0x00 },
1196                                 { 0x00, 0x00, 0x00, 0x01 },
1197                                 { 0x01, 0x00, 0x00, 0x01 },
1198                                 { 0x00, 0x01, 0x00, 0x01 },
1199                                 { 0x00, 0x00, 0x01, 0x01 },
1200                                 { 0x01, 0x00, 0x01, 0x01 },
1201                                 { 0x00, 0x01, 0x01, 0x01 },
1202                                 { 0x01, 0x01, 0x01, 0x01 }
1203         };
1204
1205         BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1206
1207         if (id < 0)
1208                 return;
1209
1210         id %= 10;
1211         memcpy(values, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1212 }
1213
1214 static void dualshock4_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1215 {
1216         /* The first 4 color/index entries match what the PS4 assigns */
1217         static const __u8 color_code[7][3] = {
1218                         /* Blue   */    { 0x00, 0x00, 0x01 },
1219                         /* Red    */    { 0x01, 0x00, 0x00 },
1220                         /* Green  */    { 0x00, 0x01, 0x00 },
1221                         /* Pink   */    { 0x02, 0x00, 0x01 },
1222                         /* Orange */    { 0x02, 0x01, 0x00 },
1223                         /* Teal   */    { 0x00, 0x01, 0x01 },
1224                         /* White  */    { 0x01, 0x01, 0x01 }
1225         };
1226
1227         BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1228
1229         if (id < 0)
1230                 return;
1231
1232         id %= 7;
1233         memcpy(values, color_code[id], sizeof(color_code[id]));
1234 }
1235
1236 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1237 {
1238         struct list_head *report_list =
1239                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1240         struct hid_report *report = list_entry(report_list->next,
1241                 struct hid_report, list);
1242         __s32 *value = report->field[0]->value;
1243
1244         value[0] = 0x00;
1245         value[1] = leds[0] ? 0xff : 0x00;
1246         value[2] = leds[1] ? 0xff : 0x00;
1247         value[3] = leds[2] ? 0xff : 0x00;
1248         value[4] = leds[3] ? 0xff : 0x00;
1249         value[5] = 0x00;
1250         value[6] = 0x00;
1251         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1252 }
1253
1254 static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count)
1255 {
1256         int n;
1257
1258         BUG_ON(count > MAX_LEDS);
1259
1260         if (sc->quirks & BUZZ_CONTROLLER && count == 4) {
1261                 buzz_set_leds(sc->hdev, leds);
1262         } else {
1263                 for (n = 0; n < count; n++)
1264                         sc->led_state[n] = leds[n];
1265                 schedule_work(&sc->state_worker);
1266         }
1267 }
1268
1269 static void sony_led_set_brightness(struct led_classdev *led,
1270                                     enum led_brightness value)
1271 {
1272         struct device *dev = led->dev->parent;
1273         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1274         struct sony_sc *drv_data;
1275
1276         int n;
1277         int force_update;
1278
1279         drv_data = hid_get_drvdata(hdev);
1280         if (!drv_data) {
1281                 hid_err(hdev, "No device data\n");
1282                 return;
1283         }
1284
1285         /*
1286          * The Sixaxis on USB will override any LED settings sent to it
1287          * and keep flashing all of the LEDs until the PS button is pressed.
1288          * Updates, even if redundant, must be always be sent to the
1289          * controller to avoid having to toggle the state of an LED just to
1290          * stop the flashing later on.
1291          */
1292         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1293
1294         for (n = 0; n < drv_data->led_count; n++) {
1295                 if (led == drv_data->leds[n] && (force_update ||
1296                         (value != drv_data->led_state[n] ||
1297                         drv_data->led_delay_on[n] ||
1298                         drv_data->led_delay_off[n]))) {
1299
1300                         drv_data->led_state[n] = value;
1301
1302                         /* Setting the brightness stops the blinking */
1303                         drv_data->led_delay_on[n] = 0;
1304                         drv_data->led_delay_off[n] = 0;
1305
1306                         sony_set_leds(drv_data, drv_data->led_state,
1307                                         drv_data->led_count);
1308                         break;
1309                 }
1310         }
1311 }
1312
1313 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1314 {
1315         struct device *dev = led->dev->parent;
1316         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1317         struct sony_sc *drv_data;
1318
1319         int n;
1320
1321         drv_data = hid_get_drvdata(hdev);
1322         if (!drv_data) {
1323                 hid_err(hdev, "No device data\n");
1324                 return LED_OFF;
1325         }
1326
1327         for (n = 0; n < drv_data->led_count; n++) {
1328                 if (led == drv_data->leds[n])
1329                         return drv_data->led_state[n];
1330         }
1331
1332         return LED_OFF;
1333 }
1334
1335 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1336                                 unsigned long *delay_off)
1337 {
1338         struct device *dev = led->dev->parent;
1339         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1340         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1341         int n;
1342         __u8 new_on, new_off;
1343
1344         if (!drv_data) {
1345                 hid_err(hdev, "No device data\n");
1346                 return -EINVAL;
1347         }
1348
1349         /* Max delay is 255 deciseconds or 2550 milliseconds */
1350         if (*delay_on > 2550)
1351                 *delay_on = 2550;
1352         if (*delay_off > 2550)
1353                 *delay_off = 2550;
1354
1355         /* Blink at 1 Hz if both values are zero */
1356         if (!*delay_on && !*delay_off)
1357                 *delay_on = *delay_off = 500;
1358
1359         new_on = *delay_on / 10;
1360         new_off = *delay_off / 10;
1361
1362         for (n = 0; n < drv_data->led_count; n++) {
1363                 if (led == drv_data->leds[n])
1364                         break;
1365         }
1366
1367         /* This LED is not registered on this device */
1368         if (n >= drv_data->led_count)
1369                 return -EINVAL;
1370
1371         /* Don't schedule work if the values didn't change */
1372         if (new_on != drv_data->led_delay_on[n] ||
1373                 new_off != drv_data->led_delay_off[n]) {
1374                 drv_data->led_delay_on[n] = new_on;
1375                 drv_data->led_delay_off[n] = new_off;
1376                 schedule_work(&drv_data->state_worker);
1377         }
1378
1379         return 0;
1380 }
1381
1382 static void sony_leds_remove(struct sony_sc *sc)
1383 {
1384         struct led_classdev *led;
1385         int n;
1386
1387         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1388
1389         for (n = 0; n < sc->led_count; n++) {
1390                 led = sc->leds[n];
1391                 sc->leds[n] = NULL;
1392                 if (!led)
1393                         continue;
1394                 led_classdev_unregister(led);
1395                 kfree(led);
1396         }
1397
1398         sc->led_count = 0;
1399 }
1400
1401 static int sony_leds_init(struct sony_sc *sc)
1402 {
1403         struct hid_device *hdev = sc->hdev;
1404         int n, ret = 0;
1405         int use_ds4_names;
1406         struct led_classdev *led;
1407         size_t name_sz;
1408         char *name;
1409         size_t name_len;
1410         const char *name_fmt;
1411         static const char * const ds4_name_str[] = { "red", "green", "blue",
1412                                                   "global" };
1413         __u8 initial_values[MAX_LEDS] = { 0 };
1414         __u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1415         __u8 use_hw_blink[MAX_LEDS] = { 0 };
1416
1417         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1418
1419         if (sc->quirks & BUZZ_CONTROLLER) {
1420                 sc->led_count = 4;
1421                 use_ds4_names = 0;
1422                 name_len = strlen("::buzz#");
1423                 name_fmt = "%s::buzz%d";
1424                 /* Validate expected report characteristics. */
1425                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1426                         return -ENODEV;
1427         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1428                 dualshock4_set_leds_from_id(sc->device_id, initial_values);
1429                 initial_values[3] = 1;
1430                 sc->led_count = 4;
1431                 memset(max_brightness, 255, 3);
1432                 use_hw_blink[3] = 1;
1433                 use_ds4_names = 1;
1434                 name_len = 0;
1435                 name_fmt = "%s:%s";
1436         } else {
1437                 sixaxis_set_leds_from_id(sc->device_id, initial_values);
1438                 sc->led_count = 4;
1439                 memset(use_hw_blink, 1, 4);
1440                 use_ds4_names = 0;
1441                 name_len = strlen("::sony#");
1442                 name_fmt = "%s::sony%d";
1443         }
1444
1445         /*
1446          * Clear LEDs as we have no way of reading their initial state. This is
1447          * only relevant if the driver is loaded after somebody actively set the
1448          * LEDs to on
1449          */
1450         sony_set_leds(sc, initial_values, sc->led_count);
1451
1452         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1453
1454         for (n = 0; n < sc->led_count; n++) {
1455
1456                 if (use_ds4_names)
1457                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1458
1459                 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1460                 if (!led) {
1461                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1462                         ret = -ENOMEM;
1463                         goto error_leds;
1464                 }
1465
1466                 name = (void *)(&led[1]);
1467                 if (use_ds4_names)
1468                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1469                         ds4_name_str[n]);
1470                 else
1471                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1472                 led->name = name;
1473                 led->brightness = initial_values[n];
1474                 led->max_brightness = max_brightness[n];
1475                 led->brightness_get = sony_led_get_brightness;
1476                 led->brightness_set = sony_led_set_brightness;
1477
1478                 if (use_hw_blink[n])
1479                         led->blink_set = sony_led_blink_set;
1480
1481                 sc->leds[n] = led;
1482
1483                 ret = led_classdev_register(&hdev->dev, led);
1484                 if (ret) {
1485                         hid_err(hdev, "Failed to register LED %d\n", n);
1486                         sc->leds[n] = NULL;
1487                         kfree(led);
1488                         goto error_leds;
1489                 }
1490         }
1491
1492         return ret;
1493
1494 error_leds:
1495         sony_leds_remove(sc);
1496
1497         return ret;
1498 }
1499
1500 static void sixaxis_state_worker(struct work_struct *work)
1501 {
1502         static const union sixaxis_output_report_01 default_report = {
1503                 .buf = {
1504                         0x01,
1505                         0x00, 0xff, 0x00, 0xff, 0x00,
1506                         0x00, 0x00, 0x00, 0x00, 0x00,
1507                         0xff, 0x27, 0x10, 0x00, 0x32,
1508                         0xff, 0x27, 0x10, 0x00, 0x32,
1509                         0xff, 0x27, 0x10, 0x00, 0x32,
1510                         0xff, 0x27, 0x10, 0x00, 0x32,
1511                         0x00, 0x00, 0x00, 0x00, 0x00
1512                 }
1513         };
1514         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1515         struct sixaxis_output_report *report =
1516                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1517         int n;
1518
1519         /* Initialize the report with default values */
1520         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1521
1522 #ifdef CONFIG_SONY_FF
1523         report->rumble.right_motor_on = sc->right ? 1 : 0;
1524         report->rumble.left_motor_force = sc->left;
1525 #endif
1526
1527         report->leds_bitmap |= sc->led_state[0] << 1;
1528         report->leds_bitmap |= sc->led_state[1] << 2;
1529         report->leds_bitmap |= sc->led_state[2] << 3;
1530         report->leds_bitmap |= sc->led_state[3] << 4;
1531
1532         /* Set flag for all leds off, required for 3rd party INTEC controller */
1533         if ((report->leds_bitmap & 0x1E) == 0)
1534                 report->leds_bitmap |= 0x20;
1535
1536         /*
1537          * The LEDs in the report are indexed in reverse order to their
1538          * corresponding light on the controller.
1539          * Index 0 = LED 4, index 1 = LED 3, etc...
1540          *
1541          * In the case of both delay values being zero (blinking disabled) the
1542          * default report values should be used or the controller LED will be
1543          * always off.
1544          */
1545         for (n = 0; n < 4; n++) {
1546                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1547                         report->led[3 - n].duty_off = sc->led_delay_off[n];
1548                         report->led[3 - n].duty_on = sc->led_delay_on[n];
1549                 }
1550         }
1551
1552         hid_hw_raw_request(sc->hdev, report->report_id, (__u8 *)report,
1553                         sizeof(struct sixaxis_output_report),
1554                         HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1555 }
1556
1557 static void dualshock4_state_worker(struct work_struct *work)
1558 {
1559         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1560         struct hid_device *hdev = sc->hdev;
1561         __u8 *buf = sc->output_report_dmabuf;
1562         int offset;
1563
1564         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1565                 memset(buf, 0, DS4_REPORT_0x05_SIZE);
1566                 buf[0] = 0x05;
1567                 buf[1] = 0xFF;
1568                 offset = 4;
1569         } else {
1570                 memset(buf, 0, DS4_REPORT_0x11_SIZE);
1571                 buf[0] = 0x11;
1572                 buf[1] = 0xB0;
1573                 buf[3] = 0x0F;
1574                 offset = 6;
1575         }
1576
1577 #ifdef CONFIG_SONY_FF
1578         buf[offset++] = sc->right;
1579         buf[offset++] = sc->left;
1580 #else
1581         offset += 2;
1582 #endif
1583
1584         /* LED 3 is the global control */
1585         if (sc->led_state[3]) {
1586                 buf[offset++] = sc->led_state[0];
1587                 buf[offset++] = sc->led_state[1];
1588                 buf[offset++] = sc->led_state[2];
1589         } else {
1590                 offset += 3;
1591         }
1592
1593         /* If both delay values are zero the DualShock 4 disables blinking. */
1594         buf[offset++] = sc->led_delay_on[3];
1595         buf[offset++] = sc->led_delay_off[3];
1596
1597         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1598                 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
1599         else
1600                 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
1601                                 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1602 }
1603
1604 static int sony_allocate_output_report(struct sony_sc *sc)
1605 {
1606         if (sc->quirks & SIXAXIS_CONTROLLER)
1607                 sc->output_report_dmabuf =
1608                         kmalloc(sizeof(union sixaxis_output_report_01),
1609                                 GFP_KERNEL);
1610         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1611                 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1612                                                 GFP_KERNEL);
1613         else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1614                 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1615                                                 GFP_KERNEL);
1616         else
1617                 return 0;
1618
1619         if (!sc->output_report_dmabuf)
1620                 return -ENOMEM;
1621
1622         return 0;
1623 }
1624
1625 #ifdef CONFIG_SONY_FF
1626 static int sony_play_effect(struct input_dev *dev, void *data,
1627                             struct ff_effect *effect)
1628 {
1629         struct hid_device *hid = input_get_drvdata(dev);
1630         struct sony_sc *sc = hid_get_drvdata(hid);
1631
1632         if (effect->type != FF_RUMBLE)
1633                 return 0;
1634
1635         sc->left = effect->u.rumble.strong_magnitude / 256;
1636         sc->right = effect->u.rumble.weak_magnitude / 256;
1637
1638         schedule_work(&sc->state_worker);
1639         return 0;
1640 }
1641
1642 static int sony_init_ff(struct sony_sc *sc)
1643 {
1644         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1645                                                 struct hid_input, list);
1646         struct input_dev *input_dev = hidinput->input;
1647
1648         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1649         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1650 }
1651
1652 #else
1653 static int sony_init_ff(struct sony_sc *sc)
1654 {
1655         return 0;
1656 }
1657
1658 #endif
1659
1660 static int sony_battery_get_property(struct power_supply *psy,
1661                                      enum power_supply_property psp,
1662                                      union power_supply_propval *val)
1663 {
1664         struct sony_sc *sc = power_supply_get_drvdata(psy);
1665         unsigned long flags;
1666         int ret = 0;
1667         u8 battery_charging, battery_capacity, cable_state;
1668
1669         spin_lock_irqsave(&sc->lock, flags);
1670         battery_charging = sc->battery_charging;
1671         battery_capacity = sc->battery_capacity;
1672         cable_state = sc->cable_state;
1673         spin_unlock_irqrestore(&sc->lock, flags);
1674
1675         switch (psp) {
1676         case POWER_SUPPLY_PROP_PRESENT:
1677                 val->intval = 1;
1678                 break;
1679         case POWER_SUPPLY_PROP_SCOPE:
1680                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1681                 break;
1682         case POWER_SUPPLY_PROP_CAPACITY:
1683                 val->intval = battery_capacity;
1684                 break;
1685         case POWER_SUPPLY_PROP_STATUS:
1686                 if (battery_charging)
1687                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
1688                 else
1689                         if (battery_capacity == 100 && cable_state)
1690                                 val->intval = POWER_SUPPLY_STATUS_FULL;
1691                         else
1692                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1693                 break;
1694         default:
1695                 ret = -EINVAL;
1696                 break;
1697         }
1698         return ret;
1699 }
1700
1701 static int sony_battery_probe(struct sony_sc *sc)
1702 {
1703         struct power_supply_config psy_cfg = { .drv_data = sc, };
1704         struct hid_device *hdev = sc->hdev;
1705         int ret;
1706
1707         /*
1708          * Set the default battery level to 100% to avoid low battery warnings
1709          * if the battery is polled before the first device report is received.
1710          */
1711         sc->battery_capacity = 100;
1712
1713         sc->battery_desc.properties = sony_battery_props;
1714         sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
1715         sc->battery_desc.get_property = sony_battery_get_property;
1716         sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
1717         sc->battery_desc.use_for_apm = 0;
1718         sc->battery_desc.name = kasprintf(GFP_KERNEL,
1719                                           "sony_controller_battery_%pMR",
1720                                           sc->mac_address);
1721         if (!sc->battery_desc.name)
1722                 return -ENOMEM;
1723
1724         sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
1725                                             &psy_cfg);
1726         if (IS_ERR(sc->battery)) {
1727                 ret = PTR_ERR(sc->battery);
1728                 hid_err(hdev, "Unable to register battery device\n");
1729                 goto err_free;
1730         }
1731
1732         power_supply_powers(sc->battery, &hdev->dev);
1733         return 0;
1734
1735 err_free:
1736         kfree(sc->battery_desc.name);
1737         sc->battery_desc.name = NULL;
1738         return ret;
1739 }
1740
1741 static void sony_battery_remove(struct sony_sc *sc)
1742 {
1743         if (!sc->battery_desc.name)
1744                 return;
1745
1746         power_supply_unregister(sc->battery);
1747         kfree(sc->battery_desc.name);
1748         sc->battery_desc.name = NULL;
1749 }
1750
1751 /*
1752  * If a controller is plugged in via USB while already connected via Bluetooth
1753  * it will show up as two devices. A global list of connected controllers and
1754  * their MAC addresses is maintained to ensure that a device is only connected
1755  * once.
1756  */
1757 static int sony_check_add_dev_list(struct sony_sc *sc)
1758 {
1759         struct sony_sc *entry;
1760         unsigned long flags;
1761         int ret;
1762
1763         spin_lock_irqsave(&sony_dev_list_lock, flags);
1764
1765         list_for_each_entry(entry, &sony_device_list, list_node) {
1766                 ret = memcmp(sc->mac_address, entry->mac_address,
1767                                 sizeof(sc->mac_address));
1768                 if (!ret) {
1769                         ret = -EEXIST;
1770                         hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1771                                 sc->mac_address);
1772                         goto unlock;
1773                 }
1774         }
1775
1776         ret = 0;
1777         list_add(&(sc->list_node), &sony_device_list);
1778
1779 unlock:
1780         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1781         return ret;
1782 }
1783
1784 static void sony_remove_dev_list(struct sony_sc *sc)
1785 {
1786         unsigned long flags;
1787
1788         if (sc->list_node.next) {
1789                 spin_lock_irqsave(&sony_dev_list_lock, flags);
1790                 list_del(&(sc->list_node));
1791                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1792         }
1793 }
1794
1795 static int sony_get_bt_devaddr(struct sony_sc *sc)
1796 {
1797         int ret;
1798
1799         /* HIDP stores the device MAC address as a string in the uniq field. */
1800         ret = strlen(sc->hdev->uniq);
1801         if (ret != 17)
1802                 return -EINVAL;
1803
1804         ret = sscanf(sc->hdev->uniq,
1805                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1806                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1807                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1808
1809         if (ret != 6)
1810                 return -EINVAL;
1811
1812         return 0;
1813 }
1814
1815 static int sony_check_add(struct sony_sc *sc)
1816 {
1817         __u8 *buf = NULL;
1818         int n, ret;
1819
1820         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1821             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1822                 /*
1823                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1824                  * address from the uniq string where HIDP stores it.
1825                  * As uniq cannot be guaranteed to be a MAC address in all cases
1826                  * a failure of this function should not prevent the connection.
1827                  */
1828                 if (sony_get_bt_devaddr(sc) < 0) {
1829                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1830                         return 0;
1831                 }
1832         } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1833                 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
1834                 if (!buf)
1835                         return -ENOMEM;
1836
1837                 /*
1838                  * The MAC address of a DS4 controller connected via USB can be
1839                  * retrieved with feature report 0x81. The address begins at
1840                  * offset 1.
1841                  */
1842                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
1843                                 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
1844                                 HID_REQ_GET_REPORT);
1845
1846                 if (ret != DS4_REPORT_0x81_SIZE) {
1847                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1848                         ret = ret < 0 ? ret : -EINVAL;
1849                         goto out_free;
1850                 }
1851
1852                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1853         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1854                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1855                 if (!buf)
1856                         return -ENOMEM;
1857
1858                 /*
1859                  * The MAC address of a Sixaxis controller connected via USB can
1860                  * be retrieved with feature report 0xf2. The address begins at
1861                  * offset 4.
1862                  */
1863                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1864                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1865                                 HID_REQ_GET_REPORT);
1866
1867                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1868                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1869                         ret = ret < 0 ? ret : -EINVAL;
1870                         goto out_free;
1871                 }
1872
1873                 /*
1874                  * The Sixaxis device MAC in the report is big-endian and must
1875                  * be byte-swapped.
1876                  */
1877                 for (n = 0; n < 6; n++)
1878                         sc->mac_address[5-n] = buf[4+n];
1879         } else {
1880                 return 0;
1881         }
1882
1883         ret = sony_check_add_dev_list(sc);
1884
1885 out_free:
1886
1887         kfree(buf);
1888
1889         return ret;
1890 }
1891
1892 static int sony_set_device_id(struct sony_sc *sc)
1893 {
1894         int ret;
1895
1896         /*
1897          * Only DualShock 4 or Sixaxis controllers get an id.
1898          * All others are set to -1.
1899          */
1900         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1901             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
1902                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1903                                         GFP_KERNEL);
1904                 if (ret < 0) {
1905                         sc->device_id = -1;
1906                         return ret;
1907                 }
1908                 sc->device_id = ret;
1909         } else {
1910                 sc->device_id = -1;
1911         }
1912
1913         return 0;
1914 }
1915
1916 static void sony_release_device_id(struct sony_sc *sc)
1917 {
1918         if (sc->device_id >= 0) {
1919                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1920                 sc->device_id = -1;
1921         }
1922 }
1923
1924 static inline void sony_init_work(struct sony_sc *sc,
1925                                         void (*worker)(struct work_struct *))
1926 {
1927         if (!sc->worker_initialized)
1928                 INIT_WORK(&sc->state_worker, worker);
1929
1930         sc->worker_initialized = 1;
1931 }
1932
1933 static inline void sony_cancel_work_sync(struct sony_sc *sc)
1934 {
1935         if (sc->worker_initialized)
1936                 cancel_work_sync(&sc->state_worker);
1937 }
1938
1939 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1940 {
1941         int ret;
1942         unsigned long quirks = id->driver_data;
1943         struct sony_sc *sc;
1944         unsigned int connect_mask = HID_CONNECT_DEFAULT;
1945
1946         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1947         if (sc == NULL) {
1948                 hid_err(hdev, "can't alloc sony descriptor\n");
1949                 return -ENOMEM;
1950         }
1951
1952         spin_lock_init(&sc->lock);
1953
1954         sc->quirks = quirks;
1955         hid_set_drvdata(hdev, sc);
1956         sc->hdev = hdev;
1957
1958         ret = hid_parse(hdev);
1959         if (ret) {
1960                 hid_err(hdev, "parse failed\n");
1961                 return ret;
1962         }
1963
1964         if (sc->quirks & VAIO_RDESC_CONSTANT)
1965                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1966         else if (sc->quirks & SIXAXIS_CONTROLLER)
1967                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1968
1969         ret = hid_hw_start(hdev, connect_mask);
1970         if (ret) {
1971                 hid_err(hdev, "hw start failed\n");
1972                 return ret;
1973         }
1974
1975         ret = sony_allocate_output_report(sc);
1976         if (ret < 0) {
1977                 hid_err(hdev, "failed to allocate the output report buffer\n");
1978                 goto err_stop;
1979         }
1980
1981         ret = sony_set_device_id(sc);
1982         if (ret < 0) {
1983                 hid_err(hdev, "failed to allocate the device id\n");
1984                 goto err_stop;
1985         }
1986
1987         if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1988                 /*
1989                  * The Sony Sixaxis does not handle HID Output Reports on the
1990                  * Interrupt EP like it could, so we need to force HID Output
1991                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
1992                  *
1993                  * There is also another issue about HID Output Reports via USB,
1994                  * the Sixaxis does not want the report_id as part of the data
1995                  * packet, so we have to discard buf[0] when sending the actual
1996                  * control message, even for numbered reports, humpf!
1997                  */
1998                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1999                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2000                 ret = sixaxis_set_operational_usb(hdev);
2001                 sony_init_work(sc, sixaxis_state_worker);
2002         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2003                 /*
2004                  * The Sixaxis wants output reports sent on the ctrl endpoint
2005                  * when connected via Bluetooth.
2006                  */
2007                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2008                 ret = sixaxis_set_operational_bt(hdev);
2009                 sony_init_work(sc, sixaxis_state_worker);
2010         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2011                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2012                         /*
2013                          * The DualShock 4 wants output reports sent on the ctrl
2014                          * endpoint when connected via Bluetooth.
2015                          */
2016                         hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2017                         ret = dualshock4_set_operational_bt(hdev);
2018                         if (ret < 0) {
2019                                 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2020                                 goto err_stop;
2021                         }
2022                 }
2023
2024                 sony_init_work(sc, dualshock4_state_worker);
2025         } else {
2026                 ret = 0;
2027         }
2028
2029         if (ret < 0)
2030                 goto err_stop;
2031
2032         ret = sony_check_add(sc);
2033         if (ret < 0)
2034                 goto err_stop;
2035
2036         if (sc->quirks & SONY_LED_SUPPORT) {
2037                 ret = sony_leds_init(sc);
2038                 if (ret < 0)
2039                         goto err_stop;
2040         }
2041
2042         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2043                 ret = sony_battery_probe(sc);
2044                 if (ret < 0)
2045                         goto err_stop;
2046
2047                 /* Open the device to receive reports with battery info */
2048                 ret = hid_hw_open(hdev);
2049                 if (ret < 0) {
2050                         hid_err(hdev, "hw open failed\n");
2051                         goto err_stop;
2052                 }
2053         }
2054
2055         if (sc->quirks & SONY_FF_SUPPORT) {
2056                 ret = sony_init_ff(sc);
2057                 if (ret < 0)
2058                         goto err_close;
2059         }
2060
2061         return 0;
2062 err_close:
2063         hid_hw_close(hdev);
2064 err_stop:
2065         if (sc->quirks & SONY_LED_SUPPORT)
2066                 sony_leds_remove(sc);
2067         if (sc->quirks & SONY_BATTERY_SUPPORT)
2068                 sony_battery_remove(sc);
2069         sony_cancel_work_sync(sc);
2070         kfree(sc->output_report_dmabuf);
2071         sony_remove_dev_list(sc);
2072         sony_release_device_id(sc);
2073         hid_hw_stop(hdev);
2074         return ret;
2075 }
2076
2077 static void sony_remove(struct hid_device *hdev)
2078 {
2079         struct sony_sc *sc = hid_get_drvdata(hdev);
2080
2081         if (sc->quirks & SONY_LED_SUPPORT)
2082                 sony_leds_remove(sc);
2083
2084         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2085                 hid_hw_close(hdev);
2086                 sony_battery_remove(sc);
2087         }
2088
2089         sony_cancel_work_sync(sc);
2090
2091         kfree(sc->output_report_dmabuf);
2092
2093         sony_remove_dev_list(sc);
2094
2095         sony_release_device_id(sc);
2096
2097         hid_hw_stop(hdev);
2098 }
2099
2100 static const struct hid_device_id sony_devices[] = {
2101         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2102                 .driver_data = SIXAXIS_CONTROLLER_USB },
2103         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2104                 .driver_data = SIXAXIS_CONTROLLER_USB },
2105         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2106                 .driver_data = SIXAXIS_CONTROLLER_BT },
2107         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2108                 .driver_data = VAIO_RDESC_CONSTANT },
2109         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2110                 .driver_data = VAIO_RDESC_CONSTANT },
2111         /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2112          * Logitech joystick from the device descriptor. */
2113         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2114                 .driver_data = BUZZ_CONTROLLER },
2115         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2116                 .driver_data = BUZZ_CONTROLLER },
2117         /* PS3 BD Remote Control */
2118         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2119                 .driver_data = PS3REMOTE },
2120         /* Logitech Harmony Adapter for PS3 */
2121         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2122                 .driver_data = PS3REMOTE },
2123         /* SMK-Link PS3 BD Remote Control */
2124         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2125                 .driver_data = PS3REMOTE },
2126         /* Sony Dualshock 4 controllers for PS4 */
2127         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2128                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2129         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2130                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2131         { }
2132 };
2133 MODULE_DEVICE_TABLE(hid, sony_devices);
2134
2135 static struct hid_driver sony_driver = {
2136         .name             = "sony",
2137         .id_table         = sony_devices,
2138         .input_mapping    = sony_mapping,
2139         .input_configured = sony_input_configured,
2140         .probe            = sony_probe,
2141         .remove           = sony_remove,
2142         .report_fixup     = sony_report_fixup,
2143         .raw_event        = sony_raw_event
2144 };
2145
2146 static int __init sony_init(void)
2147 {
2148         dbg_hid("Sony:%s\n", __func__);
2149
2150         return hid_register_driver(&sony_driver);
2151 }
2152
2153 static void __exit sony_exit(void)
2154 {
2155         dbg_hid("Sony:%s\n", __func__);
2156
2157         hid_unregister_driver(&sony_driver);
2158         ida_destroy(&sony_device_id_allocator);
2159 }
2160 module_init(sony_init);
2161 module_exit(sony_exit);
2162
2163 MODULE_LICENSE("GPL");