Pileus Git - ~andy/linux/blob - 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 /* NOTE: in order for the Sony PS3 BD Remote Control to be found by
  21  * a Bluetooth host, the key combination Start+Enter has to be kept pressed
  22  * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
  23  *
  24  * There will be no PIN request from the device.
  25  */
  26
  27 #include <linux/device.h>
  28 #include <linux/hid.h>
  29 #include <linux/module.h>
  30 #include <linux/slab.h>
  31 #include <linux/usb.h>
  32 #include <linux/leds.h>
  33
  34 #include "hid-ids.h"
  35
  36 #define VAIO_RDESC_CONSTANT       BIT(0)
  37 #define SIXAXIS_CONTROLLER_USB    BIT(1)
  38 #define SIXAXIS_CONTROLLER_BT     BIT(2)
  39 #define BUZZ_CONTROLLER           BIT(3)
  40 #define PS3REMOTE                 BIT(4)
  41 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
  42 #define DUALSHOCK4_CONTROLLER_BT  BIT(6)
  43
  44 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER_USB | BUZZ_CONTROLLER | DUALSHOCK4_CONTROLLER_USB)
  45 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER_USB | DUALSHOCK4_CONTROLLER_USB)
  46
  47 #define MAX_LEDS 4
  48
  49 static const u8 sixaxis_rdesc_fixup[] = {
  50         0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
  51         0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
  52         0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
  53 };
  54
  55 static const u8 sixaxis_rdesc_fixup2[] = {
  56         0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
  57         0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
  58         0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
  59         0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
  60         0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
  61         0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
  62         0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
  63         0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
  64         0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
  65         0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
  66         0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
  67         0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
  68         0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
  69         0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
  70         0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
  71         0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
  72         0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
  73         0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
  74         0xb1, 0x02, 0xc0, 0xc0,
  75 };
  76
  77 /* The default descriptor doesn't provide mapping for the accelerometers
  78  * or orientation sensors.  This fixed descriptor maps the accelerometers
  79  * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
  80  * to usage values 0x43, 0x44 and 0x45.
  81  */
  82 static u8 dualshock4_usb_rdesc[] = {
  83         0x05, 0x01,         /*  Usage Page (Desktop),               */
  84         0x09, 0x05,         /*  Usage (Gamepad),                    */
  85         0xA1, 0x01,         /*  Collection (Application),           */
  86         0x85, 0x01,         /*      Report ID (1),                  */
  87         0x09, 0x30,         /*      Usage (X),                      */
  88         0x09, 0x31,         /*      Usage (Y),                      */
  89         0x09, 0x32,         /*      Usage (Z),                      */
  90         0x09, 0x35,         /*      Usage (Rz),                     */
  91         0x15, 0x00,         /*      Logical Minimum (0),            */
  92         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
  93         0x75, 0x08,         /*      Report Size (8),                */
  94         0x95, 0x04,         /*      Report Count (4),               */
  95         0x81, 0x02,         /*      Input (Variable),               */
  96         0x09, 0x39,         /*      Usage (Hat Switch),             */
  97         0x15, 0x00,         /*      Logical Minimum (0),            */
  98         0x25, 0x07,         /*      Logical Maximum (7),            */
  99         0x35, 0x00,         /*      Physical Minimum (0),           */
 100         0x46, 0x3B, 0x01,   /*      Physical Maximum (315),         */
 101         0x65, 0x14,         /*      Unit (Degrees),                 */
 102         0x75, 0x04,         /*      Report Size (4),                */
 103         0x95, 0x01,         /*      Report Count (1),               */
 104         0x81, 0x42,         /*      Input (Variable, Null State),   */
 105         0x65, 0x00,         /*      Unit,                           */
 106         0x05, 0x09,         /*      Usage Page (Button),            */
 107         0x19, 0x01,         /*      Usage Minimum (01h),            */
 108         0x29, 0x0E,         /*      Usage Maximum (0Eh),            */
 109         0x15, 0x00,         /*      Logical Minimum (0),            */
 110         0x25, 0x01,         /*      Logical Maximum (1),            */
 111         0x75, 0x01,         /*      Report Size (1),                */
 112         0x95, 0x0E,         /*      Report Count (14),              */
 113         0x81, 0x02,         /*      Input (Variable),               */
 114         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 115         0x09, 0x20,         /*      Usage (20h),                    */
 116         0x75, 0x06,         /*      Report Size (6),                */
 117         0x95, 0x01,         /*      Report Count (1),               */
 118         0x15, 0x00,         /*      Logical Minimum (0),            */
 119         0x25, 0x7F,         /*      Logical Maximum (127),          */
 120         0x81, 0x02,         /*      Input (Variable),               */
 121         0x05, 0x01,         /*      Usage Page (Desktop),           */
 122         0x09, 0x33,         /*      Usage (Rx),                     */
 123         0x09, 0x34,         /*      Usage (Ry),                     */
 124         0x15, 0x00,         /*      Logical Minimum (0),            */
 125         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 126         0x75, 0x08,         /*      Report Size (8),                */
 127         0x95, 0x02,         /*      Report Count (2),               */
 128         0x81, 0x02,         /*      Input (Variable),               */
 129         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 130         0x09, 0x21,         /*      Usage (21h),                    */
 131         0x95, 0x03,         /*      Report Count (3),               */
 132         0x81, 0x02,         /*      Input (Variable),               */
 133         0x05, 0x01,         /*      Usage Page (Desktop),           */
 134         0x19, 0x40,         /*      Usage Minimum (40h),            */
 135         0x29, 0x42,         /*      Usage Maximum (42h),            */
 136         0x16, 0x00, 0x80,   /*      Logical Minimum (-32768),       */
 137         0x26, 0x00, 0x7F,   /*      Logical Maximum (32767),        */
 138         0x75, 0x10,         /*      Report Size (16),               */
 139         0x95, 0x03,         /*      Report Count (3),               */
 140         0x81, 0x02,         /*      Input (Variable),               */
 141         0x19, 0x43,         /*      Usage Minimum (43h),            */
 142         0x29, 0x45,         /*      Usage Maximum (45h),            */
 143         0x16, 0xFF, 0xBF,   /*      Logical Minimum (-16385),       */
 144         0x26, 0x00, 0x40,   /*      Logical Maximum (16384),        */
 145         0x95, 0x03,         /*      Report Count (3),               */
 146         0x81, 0x02,         /*      Input (Variable),               */
 147         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
 148         0x09, 0x21,         /*      Usage (21h),                    */
 149         0x15, 0x00,         /*      Logical Minimum (0),            */
 150         0x25, 0xFF,         /*      Logical Maximum (255),          */
 151         0x75, 0x08,         /*      Report Size (8),                */
 152         0x95, 0x27,         /*      Report Count (39),              */
 153         0x81, 0x02,         /*      Input (Variable),               */
 154         0x85, 0x05,         /*      Report ID (5),                  */
 155         0x09, 0x22,         /*      Usage (22h),                    */
 156         0x95, 0x1F,         /*      Report Count (31),              */
 157         0x91, 0x02,         /*      Output (Variable),              */
 158         0x85, 0x04,         /*      Report ID (4),                  */
 159         0x09, 0x23,         /*      Usage (23h),                    */
 160         0x95, 0x24,         /*      Report Count (36),              */
 161         0xB1, 0x02,         /*      Feature (Variable),             */
 162         0x85, 0x02,         /*      Report ID (2),                  */
 163         0x09, 0x24,         /*      Usage (24h),                    */
 164         0x95, 0x24,         /*      Report Count (36),              */
 165         0xB1, 0x02,         /*      Feature (Variable),             */
 166         0x85, 0x08,         /*      Report ID (8),                  */
 167         0x09, 0x25,         /*      Usage (25h),                    */
 168         0x95, 0x03,         /*      Report Count (3),               */
 169         0xB1, 0x02,         /*      Feature (Variable),             */
 170         0x85, 0x10,         /*      Report ID (16),                 */
 171         0x09, 0x26,         /*      Usage (26h),                    */
 172         0x95, 0x04,         /*      Report Count (4),               */
 173         0xB1, 0x02,         /*      Feature (Variable),             */
 174         0x85, 0x11,         /*      Report ID (17),                 */
 175         0x09, 0x27,         /*      Usage (27h),                    */
 176         0x95, 0x02,         /*      Report Count (2),               */
 177         0xB1, 0x02,         /*      Feature (Variable),             */
 178         0x85, 0x12,         /*      Report ID (18),                 */
 179         0x06, 0x02, 0xFF,   /*      Usage Page (FF02h),             */
 180         0x09, 0x21,         /*      Usage (21h),                    */
 181         0x95, 0x0F,         /*      Report Count (15),              */
 182         0xB1, 0x02,         /*      Feature (Variable),             */
 183         0x85, 0x13,         /*      Report ID (19),                 */
 184         0x09, 0x22,         /*      Usage (22h),                    */
 185         0x95, 0x16,         /*      Report Count (22),              */
 186         0xB1, 0x02,         /*      Feature (Variable),             */
 187         0x85, 0x14,         /*      Report ID (20),                 */
 188         0x06, 0x05, 0xFF,   /*      Usage Page (FF05h),             */
 189         0x09, 0x20,         /*      Usage (20h),                    */
 190         0x95, 0x10,         /*      Report Count (16),              */
 191         0xB1, 0x02,         /*      Feature (Variable),             */
 192         0x85, 0x15,         /*      Report ID (21),                 */
 193         0x09, 0x21,         /*      Usage (21h),                    */
 194         0x95, 0x2C,         /*      Report Count (44),              */
 195         0xB1, 0x02,         /*      Feature (Variable),             */
 196         0x06, 0x80, 0xFF,   /*      Usage Page (FF80h),             */
 197         0x85, 0x80,         /*      Report ID (128),                */
 198         0x09, 0x20,         /*      Usage (20h),                    */
 199         0x95, 0x06,         /*      Report Count (6),               */
 200         0xB1, 0x02,         /*      Feature (Variable),             */
 201         0x85, 0x81,         /*      Report ID (129),                */
 202         0x09, 0x21,         /*      Usage (21h),                    */
 203         0x95, 0x06,         /*      Report Count (6),               */
 204         0xB1, 0x02,         /*      Feature (Variable),             */
 205         0x85, 0x82,         /*      Report ID (130),                */
 206         0x09, 0x22,         /*      Usage (22h),                    */
 207         0x95, 0x05,         /*      Report Count (5),               */
 208         0xB1, 0x02,         /*      Feature (Variable),             */
 209         0x85, 0x83,         /*      Report ID (131),                */
 210         0x09, 0x23,         /*      Usage (23h),                    */
 211         0x95, 0x01,         /*      Report Count (1),               */
 212         0xB1, 0x02,         /*      Feature (Variable),             */
 213         0x85, 0x84,         /*      Report ID (132),                */
 214         0x09, 0x24,         /*      Usage (24h),                    */
 215         0x95, 0x04,         /*      Report Count (4),               */
 216         0xB1, 0x02,         /*      Feature (Variable),             */
 217         0x85, 0x85,         /*      Report ID (133),                */
 218         0x09, 0x25,         /*      Usage (25h),                    */
 219         0x95, 0x06,         /*      Report Count (6),               */
 220         0xB1, 0x02,         /*      Feature (Variable),             */
 221         0x85, 0x86,         /*      Report ID (134),                */
 222         0x09, 0x26,         /*      Usage (26h),                    */
 223         0x95, 0x06,         /*      Report Count (6),               */
 224         0xB1, 0x02,         /*      Feature (Variable),             */
 225         0x85, 0x87,         /*      Report ID (135),                */
 226         0x09, 0x27,         /*      Usage (27h),                    */
 227         0x95, 0x23,         /*      Report Count (35),              */
 228         0xB1, 0x02,         /*      Feature (Variable),             */
 229         0x85, 0x88,         /*      Report ID (136),                */
 230         0x09, 0x28,         /*      Usage (28h),                    */
 231         0x95, 0x22,         /*      Report Count (34),              */
 232         0xB1, 0x02,         /*      Feature (Variable),             */
 233         0x85, 0x89,         /*      Report ID (137),                */
 234         0x09, 0x29,         /*      Usage (29h),                    */
 235         0x95, 0x02,         /*      Report Count (2),               */
 236         0xB1, 0x02,         /*      Feature (Variable),             */
 237         0x85, 0x90,         /*      Report ID (144),                */
 238         0x09, 0x30,         /*      Usage (30h),                    */
 239         0x95, 0x05,         /*      Report Count (5),               */
 240         0xB1, 0x02,         /*      Feature (Variable),             */
 241         0x85, 0x91,         /*      Report ID (145),                */
 242         0x09, 0x31,         /*      Usage (31h),                    */
 243         0x95, 0x03,         /*      Report Count (3),               */
 244         0xB1, 0x02,         /*      Feature (Variable),             */
 245         0x85, 0x92,         /*      Report ID (146),                */
 246         0x09, 0x32,         /*      Usage (32h),                    */
 247         0x95, 0x03,         /*      Report Count (3),               */
 248         0xB1, 0x02,         /*      Feature (Variable),             */
 249         0x85, 0x93,         /*      Report ID (147),                */
 250         0x09, 0x33,         /*      Usage (33h),                    */
 251         0x95, 0x0C,         /*      Report Count (12),              */
 252         0xB1, 0x02,         /*      Feature (Variable),             */
 253         0x85, 0xA0,         /*      Report ID (160),                */
 254         0x09, 0x40,         /*      Usage (40h),                    */
 255         0x95, 0x06,         /*      Report Count (6),               */
 256         0xB1, 0x02,         /*      Feature (Variable),             */
 257         0x85, 0xA1,         /*      Report ID (161),                */
 258         0x09, 0x41,         /*      Usage (41h),                    */
 259         0x95, 0x01,         /*      Report Count (1),               */
 260         0xB1, 0x02,         /*      Feature (Variable),             */
 261         0x85, 0xA2,         /*      Report ID (162),                */
 262         0x09, 0x42,         /*      Usage (42h),                    */
 263         0x95, 0x01,         /*      Report Count (1),               */
 264         0xB1, 0x02,         /*      Feature (Variable),             */
 265         0x85, 0xA3,         /*      Report ID (163),                */
 266         0x09, 0x43,         /*      Usage (43h),                    */
 267         0x95, 0x30,         /*      Report Count (48),              */
 268         0xB1, 0x02,         /*      Feature (Variable),             */
 269         0x85, 0xA4,         /*      Report ID (164),                */
 270         0x09, 0x44,         /*      Usage (44h),                    */
 271         0x95, 0x0D,         /*      Report Count (13),              */
 272         0xB1, 0x02,         /*      Feature (Variable),             */
 273         0x85, 0xA5,         /*      Report ID (165),                */
 274         0x09, 0x45,         /*      Usage (45h),                    */
 275         0x95, 0x15,         /*      Report Count (21),              */
 276         0xB1, 0x02,         /*      Feature (Variable),             */
 277         0x85, 0xA6,         /*      Report ID (166),                */
 278         0x09, 0x46,         /*      Usage (46h),                    */
 279         0x95, 0x15,         /*      Report Count (21),              */
 280         0xB1, 0x02,         /*      Feature (Variable),             */
 281         0x85, 0xF0,         /*      Report ID (240),                */
 282         0x09, 0x47,         /*      Usage (47h),                    */
 283         0x95, 0x3F,         /*      Report Count (63),              */
 284         0xB1, 0x02,         /*      Feature (Variable),             */
 285         0x85, 0xF1,         /*      Report ID (241),                */
 286         0x09, 0x48,         /*      Usage (48h),                    */
 287         0x95, 0x3F,         /*      Report Count (63),              */
 288         0xB1, 0x02,         /*      Feature (Variable),             */
 289         0x85, 0xF2,         /*      Report ID (242),                */
 290         0x09, 0x49,         /*      Usage (49h),                    */
 291         0x95, 0x0F,         /*      Report Count (15),              */
 292         0xB1, 0x02,         /*      Feature (Variable),             */
 293         0x85, 0xA7,         /*      Report ID (167),                */
 294         0x09, 0x4A,         /*      Usage (4Ah),                    */
 295         0x95, 0x01,         /*      Report Count (1),               */
 296         0xB1, 0x02,         /*      Feature (Variable),             */
 297         0x85, 0xA8,         /*      Report ID (168),                */
 298         0x09, 0x4B,         /*      Usage (4Bh),                    */
 299         0x95, 0x01,         /*      Report Count (1),               */
 300         0xB1, 0x02,         /*      Feature (Variable),             */
 301         0x85, 0xA9,         /*      Report ID (169),                */
 302         0x09, 0x4C,         /*      Usage (4Ch),                    */
 303         0x95, 0x08,         /*      Report Count (8),               */
 304         0xB1, 0x02,         /*      Feature (Variable),             */
 305         0x85, 0xAA,         /*      Report ID (170),                */
 306         0x09, 0x4E,         /*      Usage (4Eh),                    */
 307         0x95, 0x01,         /*      Report Count (1),               */
 308         0xB1, 0x02,         /*      Feature (Variable),             */
 309         0x85, 0xAB,         /*      Report ID (171),                */
 310         0x09, 0x4F,         /*      Usage (4Fh),                    */
 311         0x95, 0x39,         /*      Report Count (57),              */
 312         0xB1, 0x02,         /*      Feature (Variable),             */
 313         0x85, 0xAC,         /*      Report ID (172),                */
 314         0x09, 0x50,         /*      Usage (50h),                    */
 315         0x95, 0x39,         /*      Report Count (57),              */
 316         0xB1, 0x02,         /*      Feature (Variable),             */
 317         0x85, 0xAD,         /*      Report ID (173),                */
 318         0x09, 0x51,         /*      Usage (51h),                    */
 319         0x95, 0x0B,         /*      Report Count (11),              */
 320         0xB1, 0x02,         /*      Feature (Variable),             */
 321         0x85, 0xAE,         /*      Report ID (174),                */
 322         0x09, 0x52,         /*      Usage (52h),                    */
 323         0x95, 0x01,         /*      Report Count (1),               */
 324         0xB1, 0x02,         /*      Feature (Variable),             */
 325         0x85, 0xAF,         /*      Report ID (175),                */
 326         0x09, 0x53,         /*      Usage (53h),                    */
 327         0x95, 0x02,         /*      Report Count (2),               */
 328         0xB1, 0x02,         /*      Feature (Variable),             */
 329         0x85, 0xB0,         /*      Report ID (176),                */
 330         0x09, 0x54,         /*      Usage (54h),                    */
 331         0x95, 0x3F,         /*      Report Count (63),              */
 332         0xB1, 0x02,         /*      Feature (Variable),             */
 333         0xC0                /*  End Collection                      */
 334 };
 335
 336 static __u8 ps3remote_rdesc[] = {
 337         0x05, 0x01,          /* GUsagePage Generic Desktop */
 338         0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
 339         0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
 340
 341          /* Use collection 1 for joypad buttons */
 342          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 343
 344           /* Ignore the 1st byte, maybe it is used for a controller
 345            * number but it's not needed for correct operation */
 346           0x75, 0x08,        /* GReportSize 0x08 [8] */
 347           0x95, 0x01,        /* GReportCount 0x01 [1] */
 348           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 349
 350           /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
 351            * buttons multiple keypresses are allowed */
 352           0x05, 0x09,        /* GUsagePage Button */
 353           0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
 354           0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
 355           0x14,              /* GLogicalMinimum [0] */
 356           0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
 357           0x75, 0x01,        /* GReportSize 0x01 [1] */
 358           0x95, 0x18,        /* GReportCount 0x18 [24] */
 359           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 360
 361           0xC0,              /* MEndCollection */
 362
 363          /* Use collection 2 for remote control buttons */
 364          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
 365
 366           /* 5th byte is used for remote control buttons */
 367           0x05, 0x09,        /* GUsagePage Button */
 368           0x18,              /* LUsageMinimum [No button pressed] */
 369           0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
 370           0x14,              /* GLogicalMinimum [0] */
 371           0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
 372           0x75, 0x08,        /* GReportSize 0x08 [8] */
 373           0x95, 0x01,        /* GReportCount 0x01 [1] */
 374           0x80,              /* MInput  */
 375
 376           /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
 377            * 0xff and 11th is for press indication */
 378           0x75, 0x08,        /* GReportSize 0x08 [8] */
 379           0x95, 0x06,        /* GReportCount 0x06 [6] */
 380           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
 381
 382           /* 12th byte is for battery strength */
 383           0x05, 0x06,        /* GUsagePage Generic Device Controls */
 384           0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
 385           0x14,              /* GLogicalMinimum [0] */
 386           0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
 387           0x75, 0x08,        /* GReportSize 0x08 [8] */
 388           0x95, 0x01,        /* GReportCount 0x01 [1] */
 389           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
 390
 391           0xC0,              /* MEndCollection */
 392
 393          0xC0                /* MEndCollection [Game Pad] */
 394 };
 395
 396 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
 397         [0x01] = KEY_SELECT,
 398         [0x02] = BTN_THUMBL,            /* L3 */
 399         [0x03] = BTN_THUMBR,            /* R3 */
 400         [0x04] = BTN_START,
 401         [0x05] = KEY_UP,
 402         [0x06] = KEY_RIGHT,
 403         [0x07] = KEY_DOWN,
 404         [0x08] = KEY_LEFT,
 405         [0x09] = BTN_TL2,               /* L2 */
 406         [0x0a] = BTN_TR2,               /* R2 */
 407         [0x0b] = BTN_TL,                /* L1 */
 408         [0x0c] = BTN_TR,                /* R1 */
 409         [0x0d] = KEY_OPTION,            /* options/triangle */
 410         [0x0e] = KEY_BACK,              /* back/circle */
 411         [0x0f] = BTN_0,                 /* cross */
 412         [0x10] = KEY_SCREEN,            /* view/square */
 413         [0x11] = KEY_HOMEPAGE,          /* PS button */
 414         [0x14] = KEY_ENTER,
 415 };
 416 static const unsigned int ps3remote_keymap_remote_buttons[] = {
 417         [0x00] = KEY_1,
 418         [0x01] = KEY_2,
 419         [0x02] = KEY_3,
 420         [0x03] = KEY_4,
 421         [0x04] = KEY_5,
 422         [0x05] = KEY_6,
 423         [0x06] = KEY_7,
 424         [0x07] = KEY_8,
 425         [0x08] = KEY_9,
 426         [0x09] = KEY_0,
 427         [0x0e] = KEY_ESC,               /* return */
 428         [0x0f] = KEY_CLEAR,
 429         [0x16] = KEY_EJECTCD,
 430         [0x1a] = KEY_MENU,              /* top menu */
 431         [0x28] = KEY_TIME,
 432         [0x30] = KEY_PREVIOUS,
 433         [0x31] = KEY_NEXT,
 434         [0x32] = KEY_PLAY,
 435         [0x33] = KEY_REWIND,            /* scan back */
 436         [0x34] = KEY_FORWARD,           /* scan forward */
 437         [0x38] = KEY_STOP,
 438         [0x39] = KEY_PAUSE,
 439         [0x40] = KEY_CONTEXT_MENU,      /* pop up/menu */
 440         [0x60] = KEY_FRAMEBACK,         /* slow/step back */
 441         [0x61] = KEY_FRAMEFORWARD,      /* slow/step forward */
 442         [0x63] = KEY_SUBTITLE,
 443         [0x64] = KEY_AUDIO,
 444         [0x65] = KEY_ANGLE,
 445         [0x70] = KEY_INFO,              /* display */
 446         [0x80] = KEY_BLUE,
 447         [0x81] = KEY_RED,
 448         [0x82] = KEY_GREEN,
 449         [0x83] = KEY_YELLOW,
 450 };
 451
 452 static const unsigned int buzz_keymap[] = {
 453         /* The controller has 4 remote buzzers, each with one LED and 5
 454          * buttons.
 455          *
 456          * We use the mapping chosen by the controller, which is:
 457          *
 458          * Key          Offset
 459          * -------------------
 460          * Buzz              1
 461          * Blue              5
 462          * Orange            4
 463          * Green             3
 464          * Yellow            2
 465          *
 466          * So, for example, the orange button on the third buzzer is mapped to
 467          * BTN_TRIGGER_HAPPY14
 468          */
 469         [ 1] = BTN_TRIGGER_HAPPY1,
 470         [ 2] = BTN_TRIGGER_HAPPY2,
 471         [ 3] = BTN_TRIGGER_HAPPY3,
 472         [ 4] = BTN_TRIGGER_HAPPY4,
 473         [ 5] = BTN_TRIGGER_HAPPY5,
 474         [ 6] = BTN_TRIGGER_HAPPY6,
 475         [ 7] = BTN_TRIGGER_HAPPY7,
 476         [ 8] = BTN_TRIGGER_HAPPY8,
 477         [ 9] = BTN_TRIGGER_HAPPY9,
 478         [10] = BTN_TRIGGER_HAPPY10,
 479         [11] = BTN_TRIGGER_HAPPY11,
 480         [12] = BTN_TRIGGER_HAPPY12,
 481         [13] = BTN_TRIGGER_HAPPY13,
 482         [14] = BTN_TRIGGER_HAPPY14,
 483         [15] = BTN_TRIGGER_HAPPY15,
 484         [16] = BTN_TRIGGER_HAPPY16,
 485         [17] = BTN_TRIGGER_HAPPY17,
 486         [18] = BTN_TRIGGER_HAPPY18,
 487         [19] = BTN_TRIGGER_HAPPY19,
 488         [20] = BTN_TRIGGER_HAPPY20,
 489 };
 490
 491 struct sony_sc {
 492         struct hid_device *hdev;
 493         struct led_classdev *leds[MAX_LEDS];
 494         struct hid_report *output_report;
 495         unsigned long quirks;
 496         struct work_struct state_worker;
 497
 498 #ifdef CONFIG_SONY_FF
 499         __u8 left;
 500         __u8 right;
 501 #endif
 502
 503         __u8 worker_initialized;
 504         __u8 led_state[MAX_LEDS];
 505         __u8 led_count;
 506 };
 507
 508 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
 509                              unsigned int *rsize)
 510 {
 511         *rsize = sizeof(ps3remote_rdesc);
 512         return ps3remote_rdesc;
 513 }
 514
 515 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
 516                              struct hid_field *field, struct hid_usage *usage,
 517                              unsigned long **bit, int *max)
 518 {
 519         unsigned int key = usage->hid & HID_USAGE;
 520
 521         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 522                 return -1;
 523
 524         switch (usage->collection_index) {
 525         case 1:
 526                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
 527                         return -1;
 528
 529                 key = ps3remote_keymap_joypad_buttons[key];
 530                 if (!key)
 531                         return -1;
 532                 break;
 533         case 2:
 534                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
 535                         return -1;
 536
 537                 key = ps3remote_keymap_remote_buttons[key];
 538                 if (!key)
 539                         return -1;
 540                 break;
 541         default:
 542                 return -1;
 543         }
 544
 545         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 546         return 1;
 547 }
 548
 549
 550 /* Sony Vaio VGX has wrongly mouse pointer declared as constant */
 551 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 552                 unsigned int *rsize)
 553 {
 554         struct sony_sc *sc = hid_get_drvdata(hdev);
 555
 556         /*
 557          * Some Sony RF receivers wrongly declare the mouse pointer as a
 558          * a constant non-data variable.
 559          */
 560         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
 561             /* usage page: generic desktop controls */
 562             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
 563             /* usage: mouse */
 564             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
 565             /* input (usage page for x,y axes): constant, variable, relative */
 566             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
 567                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
 568                 /* input: data, variable, relative */
 569                 rdesc[55] = 0x06;
 570         }
 571
 572         /*
 573          * The default Dualshock 4 USB descriptor doesn't assign
 574          * the gyroscope values to corresponding axes so we need a
 575          * modified one.
 576          */
 577         if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
 578                 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
 579                 rdesc = dualshock4_usb_rdesc;
 580                 *rsize = sizeof(dualshock4_usb_rdesc);
 581         }
 582
 583         /* The HID descriptor exposed over BT has a trailing zero byte */
 584         if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
 585                         ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
 586                         rdesc[83] == 0x75) {
 587                 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
 588                 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
 589                         sizeof(sixaxis_rdesc_fixup));
 590         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
 591                    *rsize > sizeof(sixaxis_rdesc_fixup2)) {
 592                 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
 593                          *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
 594                 *rsize = sizeof(sixaxis_rdesc_fixup2);
 595                 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
 596         }
 597
 598         if (sc->quirks & PS3REMOTE)
 599                 return ps3remote_fixup(hdev, rdesc, rsize);
 600
 601         return rdesc;
 602 }
 603
 604 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
 605                 __u8 *rd, int size)
 606 {
 607         struct sony_sc *sc = hid_get_drvdata(hdev);
 608
 609         /* Sixaxis HID report has acclerometers/gyro with MSByte first, this
 610          * has to be BYTE_SWAPPED before passing up to joystick interface
 611          */
 612         if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) &&
 613                         rd[0] == 0x01 && size == 49) {
 614                 swap(rd[41], rd[42]);
 615                 swap(rd[43], rd[44]);
 616                 swap(rd[45], rd[46]);
 617                 swap(rd[47], rd[48]);
 618         }
 619
 620         return 0;
 621 }
 622
 623 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
 624                         struct hid_field *field, struct hid_usage *usage,
 625                         unsigned long **bit, int *max)
 626 {
 627         struct sony_sc *sc = hid_get_drvdata(hdev);
 628
 629         if (sc->quirks & BUZZ_CONTROLLER) {
 630                 unsigned int key = usage->hid & HID_USAGE;
 631
 632                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
 633                         return -1;
 634
 635                 switch (usage->collection_index) {
 636                 case 1:
 637                         if (key >= ARRAY_SIZE(buzz_keymap))
 638                                 return -1;
 639
 640                         key = buzz_keymap[key];
 641                         if (!key)
 642                                 return -1;
 643                         break;
 644                 default:
 645                         return -1;
 646                 }
 647
 648                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
 649                 return 1;
 650         }
 651
 652         if (sc->quirks & PS3REMOTE)
 653                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
 654
 655         /* Let hid-core decide for the others */
 656         return 0;
 657 }
 658
 659 /*
 660  * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
 661  * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
 662  * so we need to override that forcing HID Output Reports on the Control EP.
 663  *
 664  * There is also another issue about HID Output Reports via USB, the Sixaxis
 665  * does not want the report_id as part of the data packet, so we have to
 666  * discard buf[0] when sending the actual control message, even for numbered
 667  * reports, humpf!
 668  */
 669 static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
 670                 size_t count, unsigned char report_type)
 671 {
 672         struct usb_interface *intf = to_usb_interface(hid->dev.parent);
 673         struct usb_device *dev = interface_to_usbdev(intf);
 674         struct usb_host_interface *interface = intf->cur_altsetting;
 675         int report_id = buf[0];
 676         int ret;
 677
 678         if (report_type == HID_OUTPUT_REPORT) {
 679                 /* Don't send the Report ID */
 680                 buf++;
 681                 count--;
 682         }
 683
 684         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 685                 HID_REQ_SET_REPORT,
 686                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 687                 ((report_type + 1) << 8) | report_id,
 688                 interface->desc.bInterfaceNumber, buf, count,
 689                 USB_CTRL_SET_TIMEOUT);
 690
 691         /* Count also the Report ID, in case of an Output report. */
 692         if (ret > 0 && report_type == HID_OUTPUT_REPORT)
 693                 ret++;
 694
 695         return ret;
 696 }
 697
 698 /*
 699  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
 700  * to "operational".  Without this, the ps3 controller will not report any
 701  * events.
 702  */
 703 static int sixaxis_set_operational_usb(struct hid_device *hdev)
 704 {
 705         int ret;
 706         char *buf = kmalloc(18, GFP_KERNEL);
 707
 708         if (!buf)
 709                 return -ENOMEM;
 710
 711         ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT);
 712
 713         if (ret < 0)
 714                 hid_err(hdev, "can't set operational mode\n");
 715
 716         kfree(buf);
 717
 718         return ret;
 719 }
 720
 721 static int sixaxis_set_operational_bt(struct hid_device *hdev)
 722 {
 723         unsigned char buf[] = { 0xf4,  0x42, 0x03, 0x00, 0x00 };
 724         return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
 725 }
 726
 727 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
 728 {
 729         struct list_head *report_list =
 730                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
 731         struct hid_report *report = list_entry(report_list->next,
 732                 struct hid_report, list);
 733         __s32 *value = report->field[0]->value;
 734
 735         value[0] = 0x00;
 736         value[1] = leds[0] ? 0xff : 0x00;
 737         value[2] = leds[1] ? 0xff : 0x00;
 738         value[3] = leds[2] ? 0xff : 0x00;
 739         value[4] = leds[3] ? 0xff : 0x00;
 740         value[5] = 0x00;
 741         value[6] = 0x00;
 742         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 743 }
 744
 745 static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
 746 {
 747         struct sony_sc *drv_data = hid_get_drvdata(hdev);
 748         int n;
 749
 750         BUG_ON(count > MAX_LEDS);
 751
 752         if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
 753                 buzz_set_leds(hdev, leds);
 754         } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) ||
 755                    (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
 756                 for (n = 0; n < count; n++)
 757                         drv_data->led_state[n] = leds[n];
 758                 schedule_work(&drv_data->state_worker);
 759         }
 760 }
 761
 762 static void sony_led_set_brightness(struct led_classdev *led,
 763                                     enum led_brightness value)
 764 {
 765         struct device *dev = led->dev->parent;
 766         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 767         struct sony_sc *drv_data;
 768
 769         int n;
 770
 771         drv_data = hid_get_drvdata(hdev);
 772         if (!drv_data) {
 773                 hid_err(hdev, "No device data\n");
 774                 return;
 775         }
 776
 777         for (n = 0; n < drv_data->led_count; n++) {
 778                 if (led == drv_data->leds[n]) {
 779                         if (value != drv_data->led_state[n]) {
 780                                 drv_data->led_state[n] = value;
 781                                 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
 782                         }
 783                         break;
 784                 }
 785         }
 786 }
 787
 788 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
 789 {
 790         struct device *dev = led->dev->parent;
 791         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 792         struct sony_sc *drv_data;
 793
 794         int n;
 795         int on = 0;
 796
 797         drv_data = hid_get_drvdata(hdev);
 798         if (!drv_data) {
 799                 hid_err(hdev, "No device data\n");
 800                 return LED_OFF;
 801         }
 802
 803         for (n = 0; n < drv_data->led_count; n++) {
 804                 if (led == drv_data->leds[n]) {
 805                         on = !!(drv_data->led_state[n]);
 806                         break;
 807                 }
 808         }
 809
 810         return on ? LED_FULL : LED_OFF;
 811 }
 812
 813 static void sony_leds_remove(struct hid_device *hdev)
 814 {
 815         struct sony_sc *drv_data;
 816         struct led_classdev *led;
 817         int n;
 818
 819         drv_data = hid_get_drvdata(hdev);
 820         BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
 821
 822         for (n = 0; n < drv_data->led_count; n++) {
 823                 led = drv_data->leds[n];
 824                 drv_data->leds[n] = NULL;
 825                 if (!led)
 826                         continue;
 827                 led_classdev_unregister(led);
 828                 kfree(led);
 829         }
 830
 831         drv_data->led_count = 0;
 832 }
 833
 834 static int sony_leds_init(struct hid_device *hdev)
 835 {
 836         struct sony_sc *drv_data;
 837         int n, ret = 0;
 838         int max_brightness;
 839         int use_colors;
 840         struct led_classdev *led;
 841         size_t name_sz;
 842         char *name;
 843         size_t name_len;
 844         const char *name_fmt;
 845         static const char * const color_str[] = { "red", "green", "blue" };
 846         static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
 847
 848         drv_data = hid_get_drvdata(hdev);
 849         BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
 850
 851         if (drv_data->quirks & BUZZ_CONTROLLER) {
 852                 drv_data->led_count = 4;
 853                 max_brightness = 1;
 854                 use_colors = 0;
 855                 name_len = strlen("::buzz#");
 856                 name_fmt = "%s::buzz%d";
 857                 /* Validate expected report characteristics. */
 858                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
 859                         return -ENODEV;
 860         } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) {
 861                 drv_data->led_count = 3;
 862                 max_brightness = 255;
 863                 use_colors = 1;
 864                 name_len = 0;
 865                 name_fmt = "%s:%s";
 866         } else {
 867                 drv_data->led_count = 4;
 868                 max_brightness = 1;
 869                 use_colors = 0;
 870                 name_len = strlen("::sony#");
 871                 name_fmt = "%s::sony%d";
 872         }
 873
 874         /* Clear LEDs as we have no way of reading their initial state. This is
 875          * only relevant if the driver is loaded after somebody actively set the
 876          * LEDs to on */
 877         sony_set_leds(hdev, initial_values, drv_data->led_count);
 878
 879         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
 880
 881         for (n = 0; n < drv_data->led_count; n++) {
 882
 883                 if (use_colors)
 884                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
 885
 886                 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
 887                 if (!led) {
 888                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
 889                         ret = -ENOMEM;
 890                         goto error_leds;
 891                 }
 892
 893                 name = (void *)(&led[1]);
 894                 if (use_colors)
 895                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
 896                 else
 897                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
 898                 led->name = name;
 899                 led->brightness = 0;
 900                 led->max_brightness = max_brightness;
 901                 led->brightness_get = sony_led_get_brightness;
 902                 led->brightness_set = sony_led_set_brightness;
 903
 904                 ret = led_classdev_register(&hdev->dev, led);
 905                 if (ret) {
 906                         hid_err(hdev, "Failed to register LED %d\n", n);
 907                         kfree(led);
 908                         goto error_leds;
 909                 }
 910
 911                 drv_data->leds[n] = led;
 912         }
 913
 914         return ret;
 915
 916 error_leds:
 917         sony_leds_remove(hdev);
 918
 919         return ret;
 920 }
 921
 922 static void sixaxis_state_worker(struct work_struct *work)
 923 {
 924         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
 925         unsigned char buf[] = {
 926                 0x01,
 927                 0x00, 0xff, 0x00, 0xff, 0x00,
 928                 0x00, 0x00, 0x00, 0x00, 0x00,
 929                 0xff, 0x27, 0x10, 0x00, 0x32,
 930                 0xff, 0x27, 0x10, 0x00, 0x32,
 931                 0xff, 0x27, 0x10, 0x00, 0x32,
 932                 0xff, 0x27, 0x10, 0x00, 0x32,
 933                 0x00, 0x00, 0x00, 0x00, 0x00
 934         };
 935
 936 #ifdef CONFIG_SONY_FF
 937         buf[3] = sc->right ? 1 : 0;
 938         buf[5] = sc->left;
 939 #endif
 940
 941         buf[10] |= sc->led_state[0] << 1;
 942         buf[10] |= sc->led_state[1] << 2;
 943         buf[10] |= sc->led_state[2] << 3;
 944         buf[10] |= sc->led_state[3] << 4;
 945
 946         sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf),
 947                                         HID_OUTPUT_REPORT);
 948 }
 949
 950 static void dualshock4_state_worker(struct work_struct *work)
 951 {
 952         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
 953         struct hid_device *hdev = sc->hdev;
 954         struct hid_report *report = sc->output_report;
 955         __s32 *value = report->field[0]->value;
 956
 957         value[0] = 0x03;
 958
 959 #ifdef CONFIG_SONY_FF
 960         value[3] = sc->right;
 961         value[4] = sc->left;
 962 #endif
 963
 964         value[5] = sc->led_state[0];
 965         value[6] = sc->led_state[1];
 966         value[7] = sc->led_state[2];
 967
 968         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 969 }
 970
 971 #ifdef CONFIG_SONY_FF
 972 static int sony_play_effect(struct input_dev *dev, void *data,
 973                             struct ff_effect *effect)
 974 {
 975         struct hid_device *hid = input_get_drvdata(dev);
 976         struct sony_sc *sc = hid_get_drvdata(hid);
 977
 978         if (effect->type != FF_RUMBLE)
 979                 return 0;
 980
 981         sc->left = effect->u.rumble.strong_magnitude / 256;
 982         sc->right = effect->u.rumble.weak_magnitude / 256;
 983
 984         schedule_work(&sc->state_worker);
 985         return 0;
 986 }
 987
 988 static int sony_init_ff(struct hid_device *hdev)
 989 {
 990         struct hid_input *hidinput = list_entry(hdev->inputs.next,
 991                                                 struct hid_input, list);
 992         struct input_dev *input_dev = hidinput->input;
 993
 994         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
 995         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
 996 }
 997
 998 #else
 999 static int sony_init_ff(struct hid_device *hdev)
1000 {
1001         return 0;
1002 }
1003 #endif
1004
1005 static int sony_set_output_report(struct sony_sc *sc, int req_id, int req_size)
1006 {
1007         struct list_head *head, *list;
1008         struct hid_report *report;
1009         struct hid_device *hdev = sc->hdev;
1010
1011         list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1012
1013         list_for_each(head, list) {
1014                 report = list_entry(head, struct hid_report, list);
1015
1016                 if (report->id == req_id) {
1017                         if (report->size < req_size) {
1018                                 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n",
1019                                         req_id, report->size, req_size);
1020                                 return -EINVAL;
1021                         }
1022                         sc->output_report = report;
1023                         return 0;
1024                 }
1025         }
1026
1027         hid_err(hdev, "Unable to locate output report 0x%02x\n", req_id);
1028
1029         return -EINVAL;
1030 }
1031
1032 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1033 {
1034         int ret;
1035         unsigned long quirks = id->driver_data;
1036         struct sony_sc *sc;
1037         unsigned int connect_mask = HID_CONNECT_DEFAULT;
1038
1039         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1040         if (sc == NULL) {
1041                 hid_err(hdev, "can't alloc sony descriptor\n");
1042                 return -ENOMEM;
1043         }
1044
1045         sc->quirks = quirks;
1046         hid_set_drvdata(hdev, sc);
1047         sc->hdev = hdev;
1048
1049         ret = hid_parse(hdev);
1050         if (ret) {
1051                 hid_err(hdev, "parse failed\n");
1052                 return ret;
1053         }
1054
1055         if (sc->quirks & VAIO_RDESC_CONSTANT)
1056                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1057         else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1058                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1059         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1060                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1061
1062         ret = hid_hw_start(hdev, connect_mask);
1063         if (ret) {
1064                 hid_err(hdev, "hw start failed\n");
1065                 return ret;
1066         }
1067
1068         if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1069                 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
1070                 ret = sixaxis_set_operational_usb(hdev);
1071
1072                 sc->worker_initialized = 1;
1073                 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1074         }
1075         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1076                 ret = sixaxis_set_operational_bt(hdev);
1077         else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1078                 /* Report 5 (31 bytes) is used to send data to the controller via USB */
1079                 ret = sony_set_output_report(sc, 0x05, 248);
1080                 if (ret < 0)
1081                         goto err_stop;
1082
1083                 sc->worker_initialized = 1;
1084                 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1085         } else {
1086                 ret = 0;
1087         }
1088
1089         if (ret < 0)
1090                 goto err_stop;
1091
1092         if (sc->quirks & SONY_LED_SUPPORT) {
1093                 ret = sony_leds_init(hdev);
1094                 if (ret < 0)
1095                         goto err_stop;
1096         }
1097
1098         if (sc->quirks & SONY_FF_SUPPORT) {
1099                 ret = sony_init_ff(hdev);
1100                 if (ret < 0)
1101                         goto err_stop;
1102         }
1103
1104         return 0;
1105 err_stop:
1106         if (sc->quirks & SONY_LED_SUPPORT)
1107                 sony_leds_remove(hdev);
1108         hid_hw_stop(hdev);
1109         return ret;
1110 }
1111
1112 static void sony_remove(struct hid_device *hdev)
1113 {
1114         struct sony_sc *sc = hid_get_drvdata(hdev);
1115
1116         if (sc->quirks & SONY_LED_SUPPORT)
1117                 sony_leds_remove(hdev);
1118
1119         if (sc->worker_initialized)
1120                 cancel_work_sync(&sc->state_worker);
1121
1122         hid_hw_stop(hdev);
1123 }
1124
1125 static const struct hid_device_id sony_devices[] = {
1126         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1127                 .driver_data = SIXAXIS_CONTROLLER_USB },
1128         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1129                 .driver_data = SIXAXIS_CONTROLLER_USB },
1130         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1131                 .driver_data = SIXAXIS_CONTROLLER_BT },
1132         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1133                 .driver_data = VAIO_RDESC_CONSTANT },
1134         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1135                 .driver_data = VAIO_RDESC_CONSTANT },
1136         /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1137          * Logitech joystick from the device descriptor. */
1138         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1139                 .driver_data = BUZZ_CONTROLLER },
1140         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1141                 .driver_data = BUZZ_CONTROLLER },
1142         /* PS3 BD Remote Control */
1143         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1144                 .driver_data = PS3REMOTE },
1145         /* Logitech Harmony Adapter for PS3 */
1146         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1147                 .driver_data = PS3REMOTE },
1148         /* Sony Dualshock 4 controllers for PS4 */
1149         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1150                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
1151         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1152                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
1153         { }
1154 };
1155 MODULE_DEVICE_TABLE(hid, sony_devices);
1156
1157 static struct hid_driver sony_driver = {
1158         .name          = "sony",
1159         .id_table      = sony_devices,
1160         .input_mapping = sony_mapping,
1161         .probe         = sony_probe,
1162         .remove        = sony_remove,
1163         .report_fixup  = sony_report_fixup,
1164         .raw_event     = sony_raw_event
1165 };
1166 module_hid_driver(sony_driver);
1167
1168 MODULE_LICENSE("GPL");