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