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 17
 806 #define SIXAXIS_REPORT_0xF5_SIZE 8
 807
 808 static spinlock_t sony_dev_list_lock;
 809 static LIST_HEAD(sony_device_list);
 810 static DEFINE_IDA(sony_device_id_allocator);
 811
 812 struct sony_sc {
 813         spinlock_t lock;
 814         struct list_head list_node;
 815         struct hid_device *hdev;
 816         struct led_classdev *leds[MAX_LEDS];
 817         unsigned long quirks;
 818         struct work_struct state_worker;
 819         struct power_supply battery;
 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         const int buf_size =
1135                 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1136         __u8 *buf;
1137         int ret;
1138
1139         buf = kmalloc(buf_size, GFP_KERNEL);
1140         if (!buf)
1141                 return -ENOMEM;
1142
1143         ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1144                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1145         if (ret < 0) {
1146                 hid_err(hdev, "can't set operational mode: step 1\n");
1147                 goto out;
1148         }
1149
1150         /*
1151          * Some compatible controllers like the Speedlink Strike FX and
1152          * Gasia need another query plus an USB interrupt to get operational.
1153          */
1154         ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1155                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1156         if (ret < 0) {
1157                 hid_err(hdev, "can't set operational mode: step 2\n");
1158                 goto out;
1159         }
1160
1161         ret = hid_hw_output_report(hdev, buf, 1);
1162         if (ret < 0)
1163                 hid_err(hdev, "can't set operational mode: step 3\n");
1164
1165 out:
1166         kfree(buf);
1167
1168         return ret;
1169 }
1170
1171 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1172 {
1173         static const __u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1174         __u8 *buf;
1175         int ret;
1176
1177         buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1178         if (!buf)
1179                 return -ENOMEM;
1180
1181         ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1182                                   HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1183
1184         kfree(buf);
1185
1186         return ret;
1187 }
1188
1189 /*
1190  * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1191  * controller so that it sends full input reports of type 0x11.
1192  */
1193 static int dualshock4_set_operational_bt(struct hid_device *hdev)
1194 {
1195         __u8 *buf;
1196         int ret;
1197
1198         buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1199         if (!buf)
1200                 return -ENOMEM;
1201
1202         ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
1203                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1204
1205         kfree(buf);
1206
1207         return ret;
1208 }
1209
1210 static void sixaxis_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1211 {
1212         static const __u8 sixaxis_leds[10][4] = {
1213                                 { 0x01, 0x00, 0x00, 0x00 },
1214                                 { 0x00, 0x01, 0x00, 0x00 },
1215                                 { 0x00, 0x00, 0x01, 0x00 },
1216                                 { 0x00, 0x00, 0x00, 0x01 },
1217                                 { 0x01, 0x00, 0x00, 0x01 },
1218                                 { 0x00, 0x01, 0x00, 0x01 },
1219                                 { 0x00, 0x00, 0x01, 0x01 },
1220                                 { 0x01, 0x00, 0x01, 0x01 },
1221                                 { 0x00, 0x01, 0x01, 0x01 },
1222                                 { 0x01, 0x01, 0x01, 0x01 }
1223         };
1224
1225         BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1226
1227         if (id < 0)
1228                 return;
1229
1230         id %= 10;
1231         memcpy(values, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1232 }
1233
1234 static void dualshock4_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1235 {
1236         /* The first 4 color/index entries match what the PS4 assigns */
1237         static const __u8 color_code[7][3] = {
1238                         /* Blue   */    { 0x00, 0x00, 0x01 },
1239                         /* Red    */    { 0x01, 0x00, 0x00 },
1240                         /* Green  */    { 0x00, 0x01, 0x00 },
1241                         /* Pink   */    { 0x02, 0x00, 0x01 },
1242                         /* Orange */    { 0x02, 0x01, 0x00 },
1243                         /* Teal   */    { 0x00, 0x01, 0x01 },
1244                         /* White  */    { 0x01, 0x01, 0x01 }
1245         };
1246
1247         BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1248
1249         if (id < 0)
1250                 return;
1251
1252         id %= 7;
1253         memcpy(values, color_code[id], sizeof(color_code[id]));
1254 }
1255
1256 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1257 {
1258         struct list_head *report_list =
1259                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1260         struct hid_report *report = list_entry(report_list->next,
1261                 struct hid_report, list);
1262         __s32 *value = report->field[0]->value;
1263
1264         value[0] = 0x00;
1265         value[1] = leds[0] ? 0xff : 0x00;
1266         value[2] = leds[1] ? 0xff : 0x00;
1267         value[3] = leds[2] ? 0xff : 0x00;
1268         value[4] = leds[3] ? 0xff : 0x00;
1269         value[5] = 0x00;
1270         value[6] = 0x00;
1271         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1272 }
1273
1274 static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count)
1275 {
1276         int n;
1277
1278         BUG_ON(count > MAX_LEDS);
1279
1280         if (sc->quirks & BUZZ_CONTROLLER && count == 4) {
1281                 buzz_set_leds(sc->hdev, leds);
1282         } else {
1283                 for (n = 0; n < count; n++)
1284                         sc->led_state[n] = leds[n];
1285                 schedule_work(&sc->state_worker);
1286         }
1287 }
1288
1289 static void sony_led_set_brightness(struct led_classdev *led,
1290                                     enum led_brightness value)
1291 {
1292         struct device *dev = led->dev->parent;
1293         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1294         struct sony_sc *drv_data;
1295
1296         int n;
1297         int force_update;
1298
1299         drv_data = hid_get_drvdata(hdev);
1300         if (!drv_data) {
1301                 hid_err(hdev, "No device data\n");
1302                 return;
1303         }
1304
1305         /*
1306          * The Sixaxis on USB will override any LED settings sent to it
1307          * and keep flashing all of the LEDs until the PS button is pressed.
1308          * Updates, even if redundant, must be always be sent to the
1309          * controller to avoid having to toggle the state of an LED just to
1310          * stop the flashing later on.
1311          */
1312         force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1313
1314         for (n = 0; n < drv_data->led_count; n++) {
1315                 if (led == drv_data->leds[n] && (force_update ||
1316                         (value != drv_data->led_state[n] ||
1317                         drv_data->led_delay_on[n] ||
1318                         drv_data->led_delay_off[n]))) {
1319
1320                         drv_data->led_state[n] = value;
1321
1322                         /* Setting the brightness stops the blinking */
1323                         drv_data->led_delay_on[n] = 0;
1324                         drv_data->led_delay_off[n] = 0;
1325
1326                         sony_set_leds(drv_data, drv_data->led_state,
1327                                         drv_data->led_count);
1328                         break;
1329                 }
1330         }
1331 }
1332
1333 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1334 {
1335         struct device *dev = led->dev->parent;
1336         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1337         struct sony_sc *drv_data;
1338
1339         int n;
1340
1341         drv_data = hid_get_drvdata(hdev);
1342         if (!drv_data) {
1343                 hid_err(hdev, "No device data\n");
1344                 return LED_OFF;
1345         }
1346
1347         for (n = 0; n < drv_data->led_count; n++) {
1348                 if (led == drv_data->leds[n])
1349                         return drv_data->led_state[n];
1350         }
1351
1352         return LED_OFF;
1353 }
1354
1355 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1356                                 unsigned long *delay_off)
1357 {
1358         struct device *dev = led->dev->parent;
1359         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1360         struct sony_sc *drv_data = hid_get_drvdata(hdev);
1361         int n;
1362         __u8 new_on, new_off;
1363
1364         if (!drv_data) {
1365                 hid_err(hdev, "No device data\n");
1366                 return -EINVAL;
1367         }
1368
1369         /* Max delay is 255 deciseconds or 2550 milliseconds */
1370         if (*delay_on > 2550)
1371                 *delay_on = 2550;
1372         if (*delay_off > 2550)
1373                 *delay_off = 2550;
1374
1375         /* Blink at 1 Hz if both values are zero */
1376         if (!*delay_on && !*delay_off)
1377                 *delay_on = *delay_off = 500;
1378
1379         new_on = *delay_on / 10;
1380         new_off = *delay_off / 10;
1381
1382         for (n = 0; n < drv_data->led_count; n++) {
1383                 if (led == drv_data->leds[n])
1384                         break;
1385         }
1386
1387         /* This LED is not registered on this device */
1388         if (n >= drv_data->led_count)
1389                 return -EINVAL;
1390
1391         /* Don't schedule work if the values didn't change */
1392         if (new_on != drv_data->led_delay_on[n] ||
1393                 new_off != drv_data->led_delay_off[n]) {
1394                 drv_data->led_delay_on[n] = new_on;
1395                 drv_data->led_delay_off[n] = new_off;
1396                 schedule_work(&drv_data->state_worker);
1397         }
1398
1399         return 0;
1400 }
1401
1402 static void sony_leds_remove(struct sony_sc *sc)
1403 {
1404         struct led_classdev *led;
1405         int n;
1406
1407         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1408
1409         for (n = 0; n < sc->led_count; n++) {
1410                 led = sc->leds[n];
1411                 sc->leds[n] = NULL;
1412                 if (!led)
1413                         continue;
1414                 led_classdev_unregister(led);
1415                 kfree(led);
1416         }
1417
1418         sc->led_count = 0;
1419 }
1420
1421 static int sony_leds_init(struct sony_sc *sc)
1422 {
1423         struct hid_device *hdev = sc->hdev;
1424         int n, ret = 0;
1425         int use_ds4_names;
1426         struct led_classdev *led;
1427         size_t name_sz;
1428         char *name;
1429         size_t name_len;
1430         const char *name_fmt;
1431         static const char * const ds4_name_str[] = { "red", "green", "blue",
1432                                                   "global" };
1433         __u8 initial_values[MAX_LEDS] = { 0 };
1434         __u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1435         __u8 use_hw_blink[MAX_LEDS] = { 0 };
1436
1437         BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1438
1439         if (sc->quirks & BUZZ_CONTROLLER) {
1440                 sc->led_count = 4;
1441                 use_ds4_names = 0;
1442                 name_len = strlen("::buzz#");
1443                 name_fmt = "%s::buzz%d";
1444                 /* Validate expected report characteristics. */
1445                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1446                         return -ENODEV;
1447         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1448                 dualshock4_set_leds_from_id(sc->device_id, initial_values);
1449                 initial_values[3] = 1;
1450                 sc->led_count = 4;
1451                 memset(max_brightness, 255, 3);
1452                 use_hw_blink[3] = 1;
1453                 use_ds4_names = 1;
1454                 name_len = 0;
1455                 name_fmt = "%s:%s";
1456         } else {
1457                 sixaxis_set_leds_from_id(sc->device_id, initial_values);
1458                 sc->led_count = 4;
1459                 memset(use_hw_blink, 1, 4);
1460                 use_ds4_names = 0;
1461                 name_len = strlen("::sony#");
1462                 name_fmt = "%s::sony%d";
1463         }
1464
1465         /*
1466          * Clear LEDs as we have no way of reading their initial state. This is
1467          * only relevant if the driver is loaded after somebody actively set the
1468          * LEDs to on
1469          */
1470         sony_set_leds(sc, initial_values, sc->led_count);
1471
1472         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1473
1474         for (n = 0; n < sc->led_count; n++) {
1475
1476                 if (use_ds4_names)
1477                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1478
1479                 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1480                 if (!led) {
1481                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1482                         ret = -ENOMEM;
1483                         goto error_leds;
1484                 }
1485
1486                 name = (void *)(&led[1]);
1487                 if (use_ds4_names)
1488                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1489                         ds4_name_str[n]);
1490                 else
1491                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1492                 led->name = name;
1493                 led->brightness = initial_values[n];
1494                 led->max_brightness = max_brightness[n];
1495                 led->brightness_get = sony_led_get_brightness;
1496                 led->brightness_set = sony_led_set_brightness;
1497
1498                 if (use_hw_blink[n])
1499                         led->blink_set = sony_led_blink_set;
1500
1501                 sc->leds[n] = led;
1502
1503                 ret = led_classdev_register(&hdev->dev, led);
1504                 if (ret) {
1505                         hid_err(hdev, "Failed to register LED %d\n", n);
1506                         sc->leds[n] = NULL;
1507                         kfree(led);
1508                         goto error_leds;
1509                 }
1510         }
1511
1512         return ret;
1513
1514 error_leds:
1515         sony_leds_remove(sc);
1516
1517         return ret;
1518 }
1519
1520 static void sixaxis_state_worker(struct work_struct *work)
1521 {
1522         static const union sixaxis_output_report_01 default_report = {
1523                 .buf = {
1524                         0x01,
1525                         0x00, 0xff, 0x00, 0xff, 0x00,
1526                         0x00, 0x00, 0x00, 0x00, 0x00,
1527                         0xff, 0x27, 0x10, 0x00, 0x32,
1528                         0xff, 0x27, 0x10, 0x00, 0x32,
1529                         0xff, 0x27, 0x10, 0x00, 0x32,
1530                         0xff, 0x27, 0x10, 0x00, 0x32,
1531                         0x00, 0x00, 0x00, 0x00, 0x00
1532                 }
1533         };
1534         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1535         struct sixaxis_output_report *report =
1536                 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1537         int n;
1538
1539         /* Initialize the report with default values */
1540         memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1541
1542 #ifdef CONFIG_SONY_FF
1543         report->rumble.right_motor_on = sc->right ? 1 : 0;
1544         report->rumble.left_motor_force = sc->left;
1545 #endif
1546
1547         report->leds_bitmap |= sc->led_state[0] << 1;
1548         report->leds_bitmap |= sc->led_state[1] << 2;
1549         report->leds_bitmap |= sc->led_state[2] << 3;
1550         report->leds_bitmap |= sc->led_state[3] << 4;
1551
1552         /* Set flag for all leds off, required for 3rd party INTEC controller */
1553         if ((report->leds_bitmap & 0x1E) == 0)
1554                 report->leds_bitmap |= 0x20;
1555
1556         /*
1557          * The LEDs in the report are indexed in reverse order to their
1558          * corresponding light on the controller.
1559          * Index 0 = LED 4, index 1 = LED 3, etc...
1560          *
1561          * In the case of both delay values being zero (blinking disabled) the
1562          * default report values should be used or the controller LED will be
1563          * always off.
1564          */
1565         for (n = 0; n < 4; n++) {
1566                 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1567                         report->led[3 - n].duty_off = sc->led_delay_off[n];
1568                         report->led[3 - n].duty_on = sc->led_delay_on[n];
1569                 }
1570         }
1571
1572         hid_hw_raw_request(sc->hdev, report->report_id, (__u8 *)report,
1573                         sizeof(struct sixaxis_output_report),
1574                         HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1575 }
1576
1577 static void dualshock4_state_worker(struct work_struct *work)
1578 {
1579         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1580         struct hid_device *hdev = sc->hdev;
1581         __u8 *buf = sc->output_report_dmabuf;
1582         int offset;
1583
1584         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1585                 memset(buf, 0, DS4_REPORT_0x05_SIZE);
1586                 buf[0] = 0x05;
1587                 buf[1] = 0xFF;
1588                 offset = 4;
1589         } else {
1590                 memset(buf, 0, DS4_REPORT_0x11_SIZE);
1591                 buf[0] = 0x11;
1592                 buf[1] = 0xB0;
1593                 buf[3] = 0x0F;
1594                 offset = 6;
1595         }
1596
1597 #ifdef CONFIG_SONY_FF
1598         buf[offset++] = sc->right;
1599         buf[offset++] = sc->left;
1600 #else
1601         offset += 2;
1602 #endif
1603
1604         /* LED 3 is the global control */
1605         if (sc->led_state[3]) {
1606                 buf[offset++] = sc->led_state[0];
1607                 buf[offset++] = sc->led_state[1];
1608                 buf[offset++] = sc->led_state[2];
1609         } else {
1610                 offset += 3;
1611         }
1612
1613         /* If both delay values are zero the DualShock 4 disables blinking. */
1614         buf[offset++] = sc->led_delay_on[3];
1615         buf[offset++] = sc->led_delay_off[3];
1616
1617         if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1618                 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
1619         else
1620                 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
1621                                 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1622 }
1623
1624 static int sony_allocate_output_report(struct sony_sc *sc)
1625 {
1626         if (sc->quirks & SIXAXIS_CONTROLLER)
1627                 sc->output_report_dmabuf =
1628                         kmalloc(sizeof(union sixaxis_output_report_01),
1629                                 GFP_KERNEL);
1630         else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1631                 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1632                                                 GFP_KERNEL);
1633         else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1634                 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1635                                                 GFP_KERNEL);
1636         else
1637                 return 0;
1638
1639         if (!sc->output_report_dmabuf)
1640                 return -ENOMEM;
1641
1642         return 0;
1643 }
1644
1645 #ifdef CONFIG_SONY_FF
1646 static int sony_play_effect(struct input_dev *dev, void *data,
1647                             struct ff_effect *effect)
1648 {
1649         struct hid_device *hid = input_get_drvdata(dev);
1650         struct sony_sc *sc = hid_get_drvdata(hid);
1651
1652         if (effect->type != FF_RUMBLE)
1653                 return 0;
1654
1655         sc->left = effect->u.rumble.strong_magnitude / 256;
1656         sc->right = effect->u.rumble.weak_magnitude / 256;
1657
1658         schedule_work(&sc->state_worker);
1659         return 0;
1660 }
1661
1662 static int sony_init_ff(struct sony_sc *sc)
1663 {
1664         struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1665                                                 struct hid_input, list);
1666         struct input_dev *input_dev = hidinput->input;
1667
1668         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1669         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1670 }
1671
1672 #else
1673 static int sony_init_ff(struct sony_sc *sc)
1674 {
1675         return 0;
1676 }
1677
1678 #endif
1679
1680 static int sony_battery_get_property(struct power_supply *psy,
1681                                      enum power_supply_property psp,
1682                                      union power_supply_propval *val)
1683 {
1684         struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1685         unsigned long flags;
1686         int ret = 0;
1687         u8 battery_charging, battery_capacity, cable_state;
1688
1689         spin_lock_irqsave(&sc->lock, flags);
1690         battery_charging = sc->battery_charging;
1691         battery_capacity = sc->battery_capacity;
1692         cable_state = sc->cable_state;
1693         spin_unlock_irqrestore(&sc->lock, flags);
1694
1695         switch (psp) {
1696         case POWER_SUPPLY_PROP_PRESENT:
1697                 val->intval = 1;
1698                 break;
1699         case POWER_SUPPLY_PROP_SCOPE:
1700                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1701                 break;
1702         case POWER_SUPPLY_PROP_CAPACITY:
1703                 val->intval = battery_capacity;
1704                 break;
1705         case POWER_SUPPLY_PROP_STATUS:
1706                 if (battery_charging)
1707                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
1708                 else
1709                         if (battery_capacity == 100 && cable_state)
1710                                 val->intval = POWER_SUPPLY_STATUS_FULL;
1711                         else
1712                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1713                 break;
1714         default:
1715                 ret = -EINVAL;
1716                 break;
1717         }
1718         return ret;
1719 }
1720
1721 static int sony_battery_probe(struct sony_sc *sc)
1722 {
1723         struct hid_device *hdev = sc->hdev;
1724         int ret;
1725
1726         /*
1727          * Set the default battery level to 100% to avoid low battery warnings
1728          * if the battery is polled before the first device report is received.
1729          */
1730         sc->battery_capacity = 100;
1731
1732         sc->battery.properties = sony_battery_props;
1733         sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1734         sc->battery.get_property = sony_battery_get_property;
1735         sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1736         sc->battery.use_for_apm = 0;
1737         sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR",
1738                                      sc->mac_address);
1739         if (!sc->battery.name)
1740                 return -ENOMEM;
1741
1742         ret = power_supply_register(&hdev->dev, &sc->battery);
1743         if (ret) {
1744                 hid_err(hdev, "Unable to register battery device\n");
1745                 goto err_free;
1746         }
1747
1748         power_supply_powers(&sc->battery, &hdev->dev);
1749         return 0;
1750
1751 err_free:
1752         kfree(sc->battery.name);
1753         sc->battery.name = NULL;
1754         return ret;
1755 }
1756
1757 static void sony_battery_remove(struct sony_sc *sc)
1758 {
1759         if (!sc->battery.name)
1760                 return;
1761
1762         power_supply_unregister(&sc->battery);
1763         kfree(sc->battery.name);
1764         sc->battery.name = NULL;
1765 }
1766
1767 /*
1768  * If a controller is plugged in via USB while already connected via Bluetooth
1769  * it will show up as two devices. A global list of connected controllers and
1770  * their MAC addresses is maintained to ensure that a device is only connected
1771  * once.
1772  */
1773 static int sony_check_add_dev_list(struct sony_sc *sc)
1774 {
1775         struct sony_sc *entry;
1776         unsigned long flags;
1777         int ret;
1778
1779         spin_lock_irqsave(&sony_dev_list_lock, flags);
1780
1781         list_for_each_entry(entry, &sony_device_list, list_node) {
1782                 ret = memcmp(sc->mac_address, entry->mac_address,
1783                                 sizeof(sc->mac_address));
1784                 if (!ret) {
1785                         ret = -EEXIST;
1786                         hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1787                                 sc->mac_address);
1788                         goto unlock;
1789                 }
1790         }
1791
1792         ret = 0;
1793         list_add(&(sc->list_node), &sony_device_list);
1794
1795 unlock:
1796         spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1797         return ret;
1798 }
1799
1800 static void sony_remove_dev_list(struct sony_sc *sc)
1801 {
1802         unsigned long flags;
1803
1804         if (sc->list_node.next) {
1805                 spin_lock_irqsave(&sony_dev_list_lock, flags);
1806                 list_del(&(sc->list_node));
1807                 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1808         }
1809 }
1810
1811 static int sony_get_bt_devaddr(struct sony_sc *sc)
1812 {
1813         int ret;
1814
1815         /* HIDP stores the device MAC address as a string in the uniq field. */
1816         ret = strlen(sc->hdev->uniq);
1817         if (ret != 17)
1818                 return -EINVAL;
1819
1820         ret = sscanf(sc->hdev->uniq,
1821                 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1822                 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1823                 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1824
1825         if (ret != 6)
1826                 return -EINVAL;
1827
1828         return 0;
1829 }
1830
1831 static int sony_check_add(struct sony_sc *sc)
1832 {
1833         __u8 *buf = NULL;
1834         int n, ret;
1835
1836         if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1837             (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1838                 /*
1839                  * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1840                  * address from the uniq string where HIDP stores it.
1841                  * As uniq cannot be guaranteed to be a MAC address in all cases
1842                  * a failure of this function should not prevent the connection.
1843                  */
1844                 if (sony_get_bt_devaddr(sc) < 0) {
1845                         hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1846                         return 0;
1847                 }
1848         } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1849                 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
1850                 if (!buf)
1851                         return -ENOMEM;
1852
1853                 /*
1854                  * The MAC address of a DS4 controller connected via USB can be
1855                  * retrieved with feature report 0x81. The address begins at
1856                  * offset 1.
1857                  */
1858                 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
1859                                 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
1860                                 HID_REQ_GET_REPORT);
1861
1862                 if (ret != DS4_REPORT_0x81_SIZE) {
1863                         hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1864                         ret = ret < 0 ? ret : -EINVAL;
1865                         goto out_free;
1866                 }
1867
1868                 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1869         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1870                 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1871                 if (!buf)
1872                         return -ENOMEM;
1873
1874                 /*
1875                  * The MAC address of a Sixaxis controller connected via USB can
1876                  * be retrieved with feature report 0xf2. The address begins at
1877                  * offset 4.
1878                  */
1879                 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1880                                 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1881                                 HID_REQ_GET_REPORT);
1882
1883                 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1884                         hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1885                         ret = ret < 0 ? ret : -EINVAL;
1886                         goto out_free;
1887                 }
1888
1889                 /*
1890                  * The Sixaxis device MAC in the report is big-endian and must
1891                  * be byte-swapped.
1892                  */
1893                 for (n = 0; n < 6; n++)
1894                         sc->mac_address[5-n] = buf[4+n];
1895         } else {
1896                 return 0;
1897         }
1898
1899         ret = sony_check_add_dev_list(sc);
1900
1901 out_free:
1902
1903         kfree(buf);
1904
1905         return ret;
1906 }
1907
1908 static int sony_set_device_id(struct sony_sc *sc)
1909 {
1910         int ret;
1911
1912         /*
1913          * Only DualShock 4 or Sixaxis controllers get an id.
1914          * All others are set to -1.
1915          */
1916         if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1917             (sc->quirks & DUALSHOCK4_CONTROLLER)) {
1918                 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1919                                         GFP_KERNEL);
1920                 if (ret < 0) {
1921                         sc->device_id = -1;
1922                         return ret;
1923                 }
1924                 sc->device_id = ret;
1925         } else {
1926                 sc->device_id = -1;
1927         }
1928
1929         return 0;
1930 }
1931
1932 static void sony_release_device_id(struct sony_sc *sc)
1933 {
1934         if (sc->device_id >= 0) {
1935                 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1936                 sc->device_id = -1;
1937         }
1938 }
1939
1940 static inline void sony_init_work(struct sony_sc *sc,
1941                                         void (*worker)(struct work_struct *))
1942 {
1943         if (!sc->worker_initialized)
1944                 INIT_WORK(&sc->state_worker, worker);
1945
1946         sc->worker_initialized = 1;
1947 }
1948
1949 static inline void sony_cancel_work_sync(struct sony_sc *sc)
1950 {
1951         if (sc->worker_initialized)
1952                 cancel_work_sync(&sc->state_worker);
1953 }
1954
1955 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1956 {
1957         int ret;
1958         unsigned long quirks = id->driver_data;
1959         struct sony_sc *sc;
1960         unsigned int connect_mask = HID_CONNECT_DEFAULT;
1961
1962         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1963         if (sc == NULL) {
1964                 hid_err(hdev, "can't alloc sony descriptor\n");
1965                 return -ENOMEM;
1966         }
1967
1968         sc->quirks = quirks;
1969         hid_set_drvdata(hdev, sc);
1970         sc->hdev = hdev;
1971
1972         ret = hid_parse(hdev);
1973         if (ret) {
1974                 hid_err(hdev, "parse failed\n");
1975                 return ret;
1976         }
1977
1978         if (sc->quirks & VAIO_RDESC_CONSTANT)
1979                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1980         else if (sc->quirks & SIXAXIS_CONTROLLER)
1981                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1982
1983         ret = hid_hw_start(hdev, connect_mask);
1984         if (ret) {
1985                 hid_err(hdev, "hw start failed\n");
1986                 return ret;
1987         }
1988
1989         ret = sony_allocate_output_report(sc);
1990         if (ret < 0) {
1991                 hid_err(hdev, "failed to allocate the output report buffer\n");
1992                 goto err_stop;
1993         }
1994
1995         ret = sony_set_device_id(sc);
1996         if (ret < 0) {
1997                 hid_err(hdev, "failed to allocate the device id\n");
1998                 goto err_stop;
1999         }
2000
2001         if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2002                 /*
2003                  * The Sony Sixaxis does not handle HID Output Reports on the
2004                  * Interrupt EP like it could, so we need to force HID Output
2005                  * Reports to use HID_REQ_SET_REPORT on the Control EP.
2006                  *
2007                  * There is also another issue about HID Output Reports via USB,
2008                  * the Sixaxis does not want the report_id as part of the data
2009                  * packet, so we have to discard buf[0] when sending the actual
2010                  * control message, even for numbered reports, humpf!
2011                  */
2012                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2013                 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2014                 ret = sixaxis_set_operational_usb(hdev);
2015                 sony_init_work(sc, sixaxis_state_worker);
2016         } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2017                 /*
2018                  * The Sixaxis wants output reports sent on the ctrl endpoint
2019                  * when connected via Bluetooth.
2020                  */
2021                 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2022                 ret = sixaxis_set_operational_bt(hdev);
2023                 sony_init_work(sc, sixaxis_state_worker);
2024         } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2025                 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2026                         /*
2027                          * The DualShock 4 wants output reports sent on the ctrl
2028                          * endpoint when connected via Bluetooth.
2029                          */
2030                         hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2031                         ret = dualshock4_set_operational_bt(hdev);
2032                         if (ret < 0) {
2033                                 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2034                                 goto err_stop;
2035                         }
2036                 }
2037
2038                 sony_init_work(sc, dualshock4_state_worker);
2039         } else {
2040                 ret = 0;
2041         }
2042
2043         if (ret < 0)
2044                 goto err_stop;
2045
2046         ret = sony_check_add(sc);
2047         if (ret < 0)
2048                 goto err_stop;
2049
2050         if (sc->quirks & SONY_LED_SUPPORT) {
2051                 ret = sony_leds_init(sc);
2052                 if (ret < 0)
2053                         goto err_stop;
2054         }
2055
2056         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2057                 ret = sony_battery_probe(sc);
2058                 if (ret < 0)
2059                         goto err_stop;
2060
2061                 /* Open the device to receive reports with battery info */
2062                 ret = hid_hw_open(hdev);
2063                 if (ret < 0) {
2064                         hid_err(hdev, "hw open failed\n");
2065                         goto err_stop;
2066                 }
2067         }
2068
2069         if (sc->quirks & SONY_FF_SUPPORT) {
2070                 ret = sony_init_ff(sc);
2071                 if (ret < 0)
2072                         goto err_close;
2073         }
2074
2075         return 0;
2076 err_close:
2077         hid_hw_close(hdev);
2078 err_stop:
2079         if (sc->quirks & SONY_LED_SUPPORT)
2080                 sony_leds_remove(sc);
2081         if (sc->quirks & SONY_BATTERY_SUPPORT)
2082                 sony_battery_remove(sc);
2083         sony_cancel_work_sync(sc);
2084         kfree(sc->output_report_dmabuf);
2085         sony_remove_dev_list(sc);
2086         sony_release_device_id(sc);
2087         hid_hw_stop(hdev);
2088         return ret;
2089 }
2090
2091 static void sony_remove(struct hid_device *hdev)
2092 {
2093         struct sony_sc *sc = hid_get_drvdata(hdev);
2094
2095         if (sc->quirks & SONY_LED_SUPPORT)
2096                 sony_leds_remove(sc);
2097
2098         if (sc->quirks & SONY_BATTERY_SUPPORT) {
2099                 hid_hw_close(hdev);
2100                 sony_battery_remove(sc);
2101         }
2102
2103         sony_cancel_work_sync(sc);
2104
2105         kfree(sc->output_report_dmabuf);
2106
2107         sony_remove_dev_list(sc);
2108
2109         sony_release_device_id(sc);
2110
2111         hid_hw_stop(hdev);
2112 }
2113
2114 static const struct hid_device_id sony_devices[] = {
2115         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2116                 .driver_data = SIXAXIS_CONTROLLER_USB },
2117         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2118                 .driver_data = SIXAXIS_CONTROLLER_USB },
2119         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2120                 .driver_data = SIXAXIS_CONTROLLER_BT },
2121         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2122                 .driver_data = VAIO_RDESC_CONSTANT },
2123         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2124                 .driver_data = VAIO_RDESC_CONSTANT },
2125         /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2126          * Logitech joystick from the device descriptor. */
2127         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2128                 .driver_data = BUZZ_CONTROLLER },
2129         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2130                 .driver_data = BUZZ_CONTROLLER },
2131         /* PS3 BD Remote Control */
2132         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2133                 .driver_data = PS3REMOTE },
2134         /* Logitech Harmony Adapter for PS3 */
2135         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2136                 .driver_data = PS3REMOTE },
2137         /* SMK-Link PS3 BD Remote Control */
2138         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2139                 .driver_data = PS3REMOTE },
2140         /* Sony Dualshock 4 controllers for PS4 */
2141         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2142                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2143         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2144                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2145         { }
2146 };
2147 MODULE_DEVICE_TABLE(hid, sony_devices);
2148
2149 static struct hid_driver sony_driver = {
2150         .name             = "sony",
2151         .id_table         = sony_devices,
2152         .input_mapping    = sony_mapping,
2153         .input_configured = sony_input_configured,
2154         .probe            = sony_probe,
2155         .remove           = sony_remove,
2156         .report_fixup     = sony_report_fixup,
2157         .raw_event        = sony_raw_event
2158 };
2159
2160 static int __init sony_init(void)
2161 {
2162         dbg_hid("Sony:%s\n", __func__);
2163
2164         return hid_register_driver(&sony_driver);
2165 }
2166
2167 static void __exit sony_exit(void)
2168 {
2169         dbg_hid("Sony:%s\n", __func__);
2170
2171         ida_destroy(&sony_device_id_allocator);
2172         hid_unregister_driver(&sony_driver);
2173 }
2174 module_init(sony_init);
2175 module_exit(sony_exit);
2176
2177 MODULE_LICENSE("GPL");