drivers/hid/hid-sony.c

   1 /*
   2  *  HID driver for some sony "special" 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) 2007 Paul Walmsley
   8  *  Copyright (c) 2008 Jiri Slaby
   9  *  Copyright (c) 2006-2008 Jiri Kosina
  10  */
  11
  12 /*
  13  * This program is free software; you can redistribute it and/or modify it
  14  * under the terms of the GNU General Public License as published by the Free
  15  * Software Foundation; either version 2 of the License, or (at your option)
  16  * any later version.
  17  */
  18
  19 #include <linux/device.h>
  20 #include <linux/hid.h>
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23 #include <linux/usb.h>
  24
  25 #include "hid-ids.h"
  26
  27 #define VAIO_RDESC_CONSTANT     (1 << 0)
  28 #define SIXAXIS_CONTROLLER_USB  (1 << 1)
  29 #define SIXAXIS_CONTROLLER_BT   (1 << 2)
  30
  31 struct sony_sc {
  32         unsigned long quirks;
  33 };
  34
  35 /* Sony Vaio VGX has wrongly mouse pointer declared as constant */
  36 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  37                 unsigned int *rsize)
  38 {
  39         struct sony_sc *sc = hid_get_drvdata(hdev);
  40
  41         if ((sc->quirks & VAIO_RDESC_CONSTANT) &&
  42                         *rsize >= 56 && rdesc[54] == 0x81 && rdesc[55] == 0x07) {
  43                 hid_info(hdev, "Fixing up Sony Vaio VGX report descriptor\n");
  44                 rdesc[55] = 0x06;
  45         }
  46         return rdesc;
  47 }
  48
  49 /*
  50  * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
  51  * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
  52  * so we need to override that forcing HID Output Reports on the Control EP.
  53  *
  54  * There is also another issue about HID Output Reports via USB, the Sixaxis
  55  * does not want the report_id as part of the data packet, so we have to
  56  * discard buf[0] when sending the actual control message, even for numbered
  57  * reports, humpf!
  58  */
  59 static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
  60                 size_t count, unsigned char report_type)
  61 {
  62         struct usb_interface *intf = to_usb_interface(hid->dev.parent);
  63         struct usb_device *dev = interface_to_usbdev(intf);
  64         struct usb_host_interface *interface = intf->cur_altsetting;
  65         int report_id = buf[0];
  66         int ret;
  67
  68         if (report_type == HID_OUTPUT_REPORT) {
  69                 /* Don't send the Report ID */
  70                 buf++;
  71                 count--;
  72         }
  73
  74         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  75                 HID_REQ_SET_REPORT,
  76                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  77                 ((report_type + 1) << 8) | report_id,
  78                 interface->desc.bInterfaceNumber, buf, count,
  79                 USB_CTRL_SET_TIMEOUT);
  80
  81         /* Count also the Report ID, in case of an Output report. */
  82         if (ret > 0 && report_type == HID_OUTPUT_REPORT)
  83                 ret++;
  84
  85         return ret;
  86 }
  87
  88 /*
  89  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
  90  * to "operational".  Without this, the ps3 controller will not report any
  91  * events.
  92  */
  93 static int sixaxis_set_operational_usb(struct hid_device *hdev)
  94 {
  95         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
  96         struct usb_device *dev = interface_to_usbdev(intf);
  97         __u16 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
  98         int ret;
  99         char *buf = kmalloc(18, GFP_KERNEL);
 100
 101         if (!buf)
 102                 return -ENOMEM;
 103
 104         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 105                                  HID_REQ_GET_REPORT,
 106                                  USB_DIR_IN | USB_TYPE_CLASS |
 107                                  USB_RECIP_INTERFACE,
 108                                  (3 << 8) | 0xf2, ifnum, buf, 17,
 109                                  USB_CTRL_GET_TIMEOUT);
 110         if (ret < 0)
 111                 hid_err(hdev, "can't set operational mode\n");
 112
 113         kfree(buf);
 114
 115         return ret;
 116 }
 117
 118 static int sixaxis_set_operational_bt(struct hid_device *hdev)
 119 {
 120         unsigned char buf[] = { 0xf4,  0x42, 0x03, 0x00, 0x00 };
 121         return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
 122 }
 123
 124 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
 125 {
 126         int ret;
 127         unsigned long quirks = id->driver_data;
 128         struct sony_sc *sc;
 129
 130         sc = kzalloc(sizeof(*sc), GFP_KERNEL);
 131         if (sc == NULL) {
 132                 hid_err(hdev, "can't alloc sony descriptor\n");
 133                 return -ENOMEM;
 134         }
 135
 136         sc->quirks = quirks;
 137         hid_set_drvdata(hdev, sc);
 138
 139         ret = hid_parse(hdev);
 140         if (ret) {
 141                 hid_err(hdev, "parse failed\n");
 142                 goto err_free;
 143         }
 144
 145         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
 146                         HID_CONNECT_HIDDEV_FORCE);
 147         if (ret) {
 148                 hid_err(hdev, "hw start failed\n");
 149                 goto err_free;
 150         }
 151
 152         if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
 153                 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
 154                 ret = sixaxis_set_operational_usb(hdev);
 155         }
 156         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
 157                 ret = sixaxis_set_operational_bt(hdev);
 158         else
 159                 ret = 0;
 160
 161         if (ret < 0)
 162                 goto err_stop;
 163
 164         return 0;
 165 err_stop:
 166         hid_hw_stop(hdev);
 167 err_free:
 168         kfree(sc);
 169         return ret;
 170 }
 171
 172 static void sony_remove(struct hid_device *hdev)
 173 {
 174         hid_hw_stop(hdev);
 175         kfree(hid_get_drvdata(hdev));
 176 }
 177
 178 static const struct hid_device_id sony_devices[] = {
 179         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
 180                 .driver_data = SIXAXIS_CONTROLLER_USB },
 181         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
 182                 .driver_data = SIXAXIS_CONTROLLER_BT },
 183         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
 184                 .driver_data = VAIO_RDESC_CONSTANT },
 185         { }
 186 };
 187 MODULE_DEVICE_TABLE(hid, sony_devices);
 188
 189 static struct hid_driver sony_driver = {
 190         .name = "sony",
 191         .id_table = sony_devices,
 192         .probe = sony_probe,
 193         .remove = sony_remove,
 194         .report_fixup = sony_report_fixup,
 195 };
 196
 197 static int __init sony_init(void)
 198 {
 199         return hid_register_driver(&sony_driver);
 200 }
 201
 202 static void __exit sony_exit(void)
 203 {
 204         hid_unregister_driver(&sony_driver);
 205 }
 206
 207 module_init(sony_init);
 208 module_exit(sony_exit);
 209 MODULE_LICENSE("GPL");