1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
31struct sony_sc {
32 unsigned long quirks;
33};
34
35
36static __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
49static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
50 size_t count, unsigned char report_type)
51{
52 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
53 struct usb_device *dev = interface_to_usbdev(intf);
54 struct usb_host_interface *interface = intf->cur_altsetting;
55 int report_id = buf[0];
56 int ret;
57
58 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
59 HID_REQ_SET_REPORT,
60 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
61 ((report_type + 1) << 8) | report_id,
62 interface->desc.bInterfaceNumber, buf, count,
63 USB_CTRL_SET_TIMEOUT);
64
65 return ret;
66}
67
68
69
70
71
72
73static int sixaxis_set_operational_usb(struct hid_device *hdev)
74{
75 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
76 struct usb_device *dev = interface_to_usbdev(intf);
77 __u16 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
78 int ret;
79 char *buf = kmalloc(18, GFP_KERNEL);
80
81 if (!buf)
82 return -ENOMEM;
83
84 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
85 HID_REQ_GET_REPORT,
86 USB_DIR_IN | USB_TYPE_CLASS |
87 USB_RECIP_INTERFACE,
88 (3 << 8) | 0xf2, ifnum, buf, 17,
89 USB_CTRL_GET_TIMEOUT);
90 if (ret < 0)
91 hid_err(hdev, "can't set operational mode\n");
92
93 kfree(buf);
94
95 return ret;
96}
97
98static int sixaxis_set_operational_bt(struct hid_device *hdev)
99{
100 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
101 return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
102}
103
104static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
105{
106 int ret;
107 unsigned long quirks = id->driver_data;
108 struct sony_sc *sc;
109
110 sc = kzalloc(sizeof(*sc), GFP_KERNEL);
111 if (sc == NULL) {
112 hid_err(hdev, "can't alloc sony descriptor\n");
113 return -ENOMEM;
114 }
115
116 sc->quirks = quirks;
117 hid_set_drvdata(hdev, sc);
118
119 ret = hid_parse(hdev);
120 if (ret) {
121 hid_err(hdev, "parse failed\n");
122 goto err_free;
123 }
124
125 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
126 HID_CONNECT_HIDDEV_FORCE);
127 if (ret) {
128 hid_err(hdev, "hw start failed\n");
129 goto err_free;
130 }
131
132 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
133 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
134 ret = sixaxis_set_operational_usb(hdev);
135 }
136 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
137 ret = sixaxis_set_operational_bt(hdev);
138 else
139 ret = 0;
140
141 if (ret < 0)
142 goto err_stop;
143
144 return 0;
145err_stop:
146 hid_hw_stop(hdev);
147err_free:
148 kfree(sc);
149 return ret;
150}
151
152static void sony_remove(struct hid_device *hdev)
153{
154 hid_hw_stop(hdev);
155 kfree(hid_get_drvdata(hdev));
156}
157
158static const struct hid_device_id sony_devices[] = {
159 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
160 .driver_data = SIXAXIS_CONTROLLER_USB },
161 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
162 .driver_data = SIXAXIS_CONTROLLER_BT },
163 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
164 .driver_data = VAIO_RDESC_CONSTANT },
165 { }
166};
167MODULE_DEVICE_TABLE(hid, sony_devices);
168
169static struct hid_driver sony_driver = {
170 .name = "sony",
171 .id_table = sony_devices,
172 .probe = sony_probe,
173 .remove = sony_remove,
174 .report_fixup = sony_report_fixup,
175};
176
177static int __init sony_init(void)
178{
179 return hid_register_driver(&sony_driver);
180}
181
182static void __exit sony_exit(void)
183{
184 hid_unregister_driver(&sony_driver);
185}
186
187module_init(sony_init);
188module_exit(sony_exit);
189MODULE_LICENSE("GPL");
190
