drivers/hid/hid-sony.c

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