projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branches 'pm-cpuidle' and 'pm-cpufreq'
[deliverable/linux.git] / drivers / hid / hid-sony.c
CommitLineData
bd28ce00 1/*
078328da 2 * HID driver for Sony / PS2 / PS3 BD devices.
bd28ce00
JS		 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
bd28ce00 7 * Copyright (c) 2008 Jiri Slaby
078328da
JK		 8 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
f04d5140 10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
bd28ce00
JS		 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
078328da
JK		 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
bd28ce00
JS		 27#include <linux/device.h>
28#include <linux/hid.h>
29#include <linux/module.h>
5a0e3ad6 30#include <linux/slab.h>
bd28ce00 31#include <linux/usb.h>
40e32ee6 32#include <linux/leds.h>
bd28ce00
JS		 33
34#include "hid-ids.h"
35
816651a7
AO		 36#define VAIO_RDESC_CONSTANT (1 << 0)
37#define SIXAXIS_CONTROLLER_USB (1 << 1)
38#define SIXAXIS_CONTROLLER_BT (1 << 2)
f04d5140 39#define BUZZ_CONTROLLER (1 << 3)
078328da 40#define PS3REMOTE (1 << 4)
cc6e0bbb 41
61ab44be
SW		 42static const u8 sixaxis_rdesc_fixup[] = {
43 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
44 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
45 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
46};
47
e57a67da
MCC		 48static const u8 sixaxis_rdesc_fixup2[] = {
49 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
50 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
51 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
52 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
53 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
54 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
55 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
56 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
57 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
58 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
59 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
60 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
61 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
62 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
63 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
64 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
65 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
66 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
67 0xb1, 0x02, 0xc0, 0xc0,
68};
69
078328da
JK		 70static __u8 ps3remote_rdesc[] = {
71 0x05, 0x01, /* GUsagePage Generic Desktop */
72 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
73 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
74
75 /* Use collection 1 for joypad buttons */
76 0xA1, 0x02, /* MCollection Logical (interrelated data) */
77
78 /* Ignore the 1st byte, maybe it is used for a controller
79 * number but it's not needed for correct operation */
80 0x75, 0x08, /* GReportSize 0x08 [8] */
81 0x95, 0x01, /* GReportCount 0x01 [1] */
82 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
83
84 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
85 * buttons multiple keypresses are allowed */
86 0x05, 0x09, /* GUsagePage Button */
87 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
88 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
89 0x14, /* GLogicalMinimum [0] */
90 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
91 0x75, 0x01, /* GReportSize 0x01 [1] */
92 0x95, 0x18, /* GReportCount 0x18 [24] */
93 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
94
95 0xC0, /* MEndCollection */
96
97 /* Use collection 2 for remote control buttons */
98 0xA1, 0x02, /* MCollection Logical (interrelated data) */
99
100 /* 5th byte is used for remote control buttons */
101 0x05, 0x09, /* GUsagePage Button */
102 0x18, /* LUsageMinimum [No button pressed] */
103 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
104 0x14, /* GLogicalMinimum [0] */
105 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
106 0x75, 0x08, /* GReportSize 0x08 [8] */
107 0x95, 0x01, /* GReportCount 0x01 [1] */
108 0x80, /* MInput */
109
110 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
111 * 0xff and 11th is for press indication */
112 0x75, 0x08, /* GReportSize 0x08 [8] */
113 0x95, 0x06, /* GReportCount 0x06 [6] */
114 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
115
116 /* 12th byte is for battery strength */
117 0x05, 0x06, /* GUsagePage Generic Device Controls */
118 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
119 0x14, /* GLogicalMinimum [0] */
120 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
121 0x75, 0x08, /* GReportSize 0x08 [8] */
122 0x95, 0x01, /* GReportCount 0x01 [1] */
123 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
124
125 0xC0, /* MEndCollection */
126
127 0xC0 /* MEndCollection [Game Pad] */
128};
129
130static const unsigned int ps3remote_keymap_joypad_buttons[] = {
131 [0x01] = KEY_SELECT,
132 [0x02] = BTN_THUMBL, /* L3 */
133 [0x03] = BTN_THUMBR, /* R3 */
134 [0x04] = BTN_START,
135 [0x05] = KEY_UP,
136 [0x06] = KEY_RIGHT,
137 [0x07] = KEY_DOWN,
138 [0x08] = KEY_LEFT,
139 [0x09] = BTN_TL2, /* L2 */
140 [0x0a] = BTN_TR2, /* R2 */
141 [0x0b] = BTN_TL, /* L1 */
142 [0x0c] = BTN_TR, /* R1 */
143 [0x0d] = KEY_OPTION, /* options/triangle */
144 [0x0e] = KEY_BACK, /* back/circle */
145 [0x0f] = BTN_0, /* cross */
146 [0x10] = KEY_SCREEN, /* view/square */
147 [0x11] = KEY_HOMEPAGE, /* PS button */
148 [0x14] = KEY_ENTER,
149};
150static const unsigned int ps3remote_keymap_remote_buttons[] = {
151 [0x00] = KEY_1,
152 [0x01] = KEY_2,
153 [0x02] = KEY_3,
154 [0x03] = KEY_4,
155 [0x04] = KEY_5,
156 [0x05] = KEY_6,
157 [0x06] = KEY_7,
158 [0x07] = KEY_8,
159 [0x08] = KEY_9,
160 [0x09] = KEY_0,
161 [0x0e] = KEY_ESC, /* return */
162 [0x0f] = KEY_CLEAR,
163 [0x16] = KEY_EJECTCD,
164 [0x1a] = KEY_MENU, /* top menu */
165 [0x28] = KEY_TIME,
166 [0x30] = KEY_PREVIOUS,
167 [0x31] = KEY_NEXT,
168 [0x32] = KEY_PLAY,
169 [0x33] = KEY_REWIND, /* scan back */
170 [0x34] = KEY_FORWARD, /* scan forward */
171 [0x38] = KEY_STOP,
172 [0x39] = KEY_PAUSE,
173 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
174 [0x60] = KEY_FRAMEBACK, /* slow/step back */
175 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
176 [0x63] = KEY_SUBTITLE,
177 [0x64] = KEY_AUDIO,
178 [0x65] = KEY_ANGLE,
179 [0x70] = KEY_INFO, /* display */
180 [0x80] = KEY_BLUE,
181 [0x81] = KEY_RED,
182 [0x82] = KEY_GREEN,
183 [0x83] = KEY_YELLOW,
184};
185
f04d5140
CL		 186static const unsigned int buzz_keymap[] = {
187 /* The controller has 4 remote buzzers, each with one LED and 5
188 * buttons.
189 *
190 * We use the mapping chosen by the controller, which is:
191 *
192 * Key Offset
193 * -------------------
194 * Buzz 1
195 * Blue 5
196 * Orange 4
197 * Green 3
198 * Yellow 2
199 *
200 * So, for example, the orange button on the third buzzer is mapped to
201 * BTN_TRIGGER_HAPPY14
202 */
203 [ 1] = BTN_TRIGGER_HAPPY1,
204 [ 2] = BTN_TRIGGER_HAPPY2,
205 [ 3] = BTN_TRIGGER_HAPPY3,
206 [ 4] = BTN_TRIGGER_HAPPY4,
207 [ 5] = BTN_TRIGGER_HAPPY5,
208 [ 6] = BTN_TRIGGER_HAPPY6,
209 [ 7] = BTN_TRIGGER_HAPPY7,
210 [ 8] = BTN_TRIGGER_HAPPY8,
211 [ 9] = BTN_TRIGGER_HAPPY9,
212 [10] = BTN_TRIGGER_HAPPY10,
213 [11] = BTN_TRIGGER_HAPPY11,
214 [12] = BTN_TRIGGER_HAPPY12,
215 [13] = BTN_TRIGGER_HAPPY13,
216 [14] = BTN_TRIGGER_HAPPY14,
217 [15] = BTN_TRIGGER_HAPPY15,
218 [16] = BTN_TRIGGER_HAPPY16,
219 [17] = BTN_TRIGGER_HAPPY17,
220 [18] = BTN_TRIGGER_HAPPY18,
221 [19] = BTN_TRIGGER_HAPPY19,
222 [20] = BTN_TRIGGER_HAPPY20,
223};
224
cc6e0bbb
JK		 225struct sony_sc {
226 unsigned long quirks;
f04d5140 227
9f323b68
SE		 228#ifdef CONFIG_SONY_FF
229 struct work_struct rumble_worker;
230 struct hid_device *hdev;
231 __u8 left;
232 __u8 right;
233#endif
234
f04d5140
CL		 235 void *extra;
236};
237
238struct buzz_extra {
f04d5140
CL		 239 int led_state;
240 struct led_classdev *leds[4];
cc6e0bbb
JK		 241};
242
078328da
JK		 243static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
244 unsigned int *rsize)
245{
246 *rsize = sizeof(ps3remote_rdesc);
247 return ps3remote_rdesc;
248}
249
250static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
251 struct hid_field *field, struct hid_usage *usage,
252 unsigned long **bit, int *max)
253{
254 unsigned int key = usage->hid & HID_USAGE;
255
256 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
257 return -1;
258
259 switch (usage->collection_index) {
260 case 1:
261 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
262 return -1;
263
264 key = ps3remote_keymap_joypad_buttons[key];
265 if (!key)
266 return -1;
267 break;
268 case 2:
269 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
270 return -1;
271
272 key = ps3remote_keymap_remote_buttons[key];
273 if (!key)
274 return -1;
275 break;
276 default:
277 return -1;
278 }
279
280 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
281 return 1;
282}
283
284
cc6e0bbb 285/* Sony Vaio VGX has wrongly mouse pointer declared as constant */
73e4008d
NK		 286static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
287 unsigned int *rsize)
cc6e0bbb
JK		 288{
289 struct sony_sc *sc = hid_get_drvdata(hdev);
290
99d24902
FLVC		 291 /*
292 * Some Sony RF receivers wrongly declare the mouse pointer as a
293 * a constant non-data variable.
294 */
295 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
296 /* usage page: generic desktop controls */
297 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
298 /* usage: mouse */
299 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
300 /* input (usage page for x,y axes): constant, variable, relative */
301 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
a4649184 302 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 303 /* input: data, variable, relative */
cc6e0bbb
JK		 304 rdesc[55] = 0x06;
305 }
61ab44be
SW		 306
307 /* The HID descriptor exposed over BT has a trailing zero byte */
308 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
309 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
310 rdesc[83] == 0x75) {
311 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
312 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
313 sizeof(sixaxis_rdesc_fixup));
e57a67da
MCC		 314 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
315 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
316 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
317 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
318 *rsize = sizeof(sixaxis_rdesc_fixup2);
319 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
61ab44be 320 }
078328da
JK		 321
322 if (sc->quirks & PS3REMOTE)
323 return ps3remote_fixup(hdev, rdesc, rsize);
324
73e4008d 325 return rdesc;
cc6e0bbb
JK		 326}
327
c9e4d877
SW		 328static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
329 __u8 *rd, int size)
330{
331 struct sony_sc *sc = hid_get_drvdata(hdev);
332
333 /* Sixaxis HID report has acclerometers/gyro with MSByte first, this
334 * has to be BYTE_SWAPPED before passing up to joystick interface
335 */
336 if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) &&
337 rd[0] == 0x01 && size == 49) {
338 swap(rd[41], rd[42]);
339 swap(rd[43], rd[44]);
340 swap(rd[45], rd[46]);
341 swap(rd[47], rd[48]);
342 }
343
344 return 0;
345}
346
f04d5140
CL		 347static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
348 struct hid_field *field, struct hid_usage *usage,
349 unsigned long **bit, int *max)
350{
351 struct sony_sc *sc = hid_get_drvdata(hdev);
352
353 if (sc->quirks & BUZZ_CONTROLLER) {
354 unsigned int key = usage->hid & HID_USAGE;
355
356 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
357 return -1;
358
359 switch (usage->collection_index) {
360 case 1:
361 if (key >= ARRAY_SIZE(buzz_keymap))
362 return -1;
363
364 key = buzz_keymap[key];
365 if (!key)
366 return -1;
367 break;
368 default:
369 return -1;
370 }
371
372 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
373 return 1;
374 }
375
078328da
JK		 376 if (sc->quirks & PS3REMOTE)
377 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
378
6f498018
BT		 379 /* Let hid-core decide for the others */
380 return 0;
f04d5140
CL		 381}
382
5710fabf
AO		 383/*
384 * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
385 * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
386 * so we need to override that forcing HID Output Reports on the Control EP.
387 *
388 * There is also another issue about HID Output Reports via USB, the Sixaxis
389 * does not want the report_id as part of the data packet, so we have to
390 * discard buf[0] when sending the actual control message, even for numbered
391 * reports, humpf!
392 */
569b10a5
AO		 393static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
394 size_t count, unsigned char report_type)
395{
396 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
397 struct usb_device *dev = interface_to_usbdev(intf);
398 struct usb_host_interface *interface = intf->cur_altsetting;
399 int report_id = buf[0];
400 int ret;
401
5710fabf
AO		 402 if (report_type == HID_OUTPUT_REPORT) {
403 /* Don't send the Report ID */
404 buf++;
405 count--;
406 }
407
569b10a5
AO		 408 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
409 HID_REQ_SET_REPORT,
410 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
411 ((report_type + 1) << 8) | report_id,
412 interface->desc.bInterfaceNumber, buf, count,
413 USB_CTRL_SET_TIMEOUT);
414
5710fabf
AO		 415 /* Count also the Report ID, in case of an Output report. */
416 if (ret > 0 && report_type == HID_OUTPUT_REPORT)
417 ret++;
418
569b10a5
AO		 419 return ret;
420}
421
bd28ce00
JS		 422/*
423 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
424 * to "operational". Without this, the ps3 controller will not report any
425 * events.
426 */
816651a7 427static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 428{
bd28ce00
JS		 429 int ret;
430 char *buf = kmalloc(18, GFP_KERNEL);
431
432 if (!buf)
433 return -ENOMEM;
434
f204828a
BT		 435 ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT);
436
bd28ce00 437 if (ret < 0)
4291ee30 438 hid_err(hdev, "can't set operational mode\n");
bd28ce00
JS		 439
440 kfree(buf);
441
442 return ret;
443}
444
816651a7 445static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 446{
fddb33f2 447 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
f9ce7c28
BN		 448 return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
449}
450
f04d5140
CL		 451static void buzz_set_leds(struct hid_device *hdev, int leds)
452{
453 struct list_head *report_list =
454 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
455 struct hid_report *report = list_entry(report_list->next,
456 struct hid_report, list);
457 __s32 *value = report->field[0]->value;
458
459 value[0] = 0x00;
460 value[1] = (leds & 1) ? 0xff : 0x00;
461 value[2] = (leds & 2) ? 0xff : 0x00;
462 value[3] = (leds & 4) ? 0xff : 0x00;
463 value[4] = (leds & 8) ? 0xff : 0x00;
464 value[5] = 0x00;
465 value[6] = 0x00;
466 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
467}
468
469static void buzz_led_set_brightness(struct led_classdev *led,
470 enum led_brightness value)
471{
472 struct device *dev = led->dev->parent;
473 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
474 struct sony_sc *drv_data;
475 struct buzz_extra *buzz;
476
477 int n;
478
479 drv_data = hid_get_drvdata(hdev);
480 if (!drv_data || !drv_data->extra) {
481 hid_err(hdev, "No device data\n");
482 return;
483 }
484 buzz = drv_data->extra;
485
486 for (n = 0; n < 4; n++) {
487 if (led == buzz->leds[n]) {
488 int on = !! (buzz->led_state & (1 << n));
489 if (value == LED_OFF && on) {
490 buzz->led_state &= ~(1 << n);
491 buzz_set_leds(hdev, buzz->led_state);
492 } else if (value != LED_OFF && !on) {
493 buzz->led_state |= (1 << n);
494 buzz_set_leds(hdev, buzz->led_state);
495 }
496 break;
497 }
498 }
499}
500
501static enum led_brightness buzz_led_get_brightness(struct led_classdev *led)
502{
503 struct device *dev = led->dev->parent;
504 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
505 struct sony_sc *drv_data;
506 struct buzz_extra *buzz;
507
508 int n;
509 int on = 0;
510
511 drv_data = hid_get_drvdata(hdev);
512 if (!drv_data || !drv_data->extra) {
513 hid_err(hdev, "No device data\n");
514 return LED_OFF;
515 }
516 buzz = drv_data->extra;
517
518 for (n = 0; n < 4; n++) {
519 if (led == buzz->leds[n]) {
520 on = !! (buzz->led_state & (1 << n));
521 break;
522 }
523 }
524
525 return on ? LED_FULL : LED_OFF;
526}
f04d5140
CL		 527
528static int buzz_init(struct hid_device *hdev)
529{
530 struct sony_sc *drv_data;
531 struct buzz_extra *buzz;
40e32ee6
JK		 532 int n, ret = 0;
533 struct led_classdev *led;
534 size_t name_sz;
535 char *name;
f04d5140
CL		 536
537 drv_data = hid_get_drvdata(hdev);
538 BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));
539
9446edb9
KC		 540 /* Validate expected report characteristics. */
541 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
542 return -ENODEV;
543
f04d5140
CL		 544 buzz = kzalloc(sizeof(*buzz), GFP_KERNEL);
545 if (!buzz) {
546 hid_err(hdev, "Insufficient memory, cannot allocate driver data\n");
547 return -ENOMEM;
548 }
549 drv_data->extra = buzz;
550
551 /* Clear LEDs as we have no way of reading their initial state. This is
552 * only relevant if the driver is loaded after somebody actively set the
553 * LEDs to on */
554 buzz_set_leds(hdev, 0x00);
555
40e32ee6 556 name_sz = strlen(dev_name(&hdev->dev)) + strlen("::buzz#") + 1;
f04d5140 557
40e32ee6
JK		 558 for (n = 0; n < 4; n++) {
559 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
560 if (!led) {
561 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
562 goto error_leds;
563 }
f04d5140 564
40e32ee6
JK		 565 name = (void *)(&led[1]);
566 snprintf(name, name_sz, "%s::buzz%d", dev_name(&hdev->dev), n + 1);
567 led->name = name;
568 led->brightness = 0;
569 led->max_brightness = 1;
570 led->brightness_get = buzz_led_get_brightness;
571 led->brightness_set = buzz_led_set_brightness;
f04d5140 572
40e32ee6
JK		 573 if (led_classdev_register(&hdev->dev, led)) {
574 hid_err(hdev, "Failed to register LED %d\n", n);
575 kfree(led);
576 goto error_leds;
f04d5140 577 }
40e32ee6
JK		 578
579 buzz->leds[n] = led;
f04d5140 580 }
f04d5140
CL		 581
582 return ret;
583
f04d5140 584error_leds:
40e32ee6
JK		 585 for (n = 0; n < 4; n++) {
586 led = buzz->leds[n];
587 buzz->leds[n] = NULL;
588 if (!led)
589 continue;
590 led_classdev_unregister(led);
591 kfree(led);
f04d5140
CL		 592 }
593
594 kfree(drv_data->extra);
595 drv_data->extra = NULL;
596 return ret;
f04d5140
CL		 597}
598
599static void buzz_remove(struct hid_device *hdev)
600{
601 struct sony_sc *drv_data;
602 struct buzz_extra *buzz;
40e32ee6
JK		 603 struct led_classdev *led;
604 int n;
f04d5140
CL		 605
606 drv_data = hid_get_drvdata(hdev);
607 BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));
608
609 buzz = drv_data->extra;
40e32ee6
JK		 610
611 for (n = 0; n < 4; n++) {
612 led = buzz->leds[n];
613 buzz->leds[n] = NULL;
614 if (!led)
615 continue;
616 led_classdev_unregister(led);
617 kfree(led);
f04d5140 618 }
f04d5140
CL		 619
620 kfree(drv_data->extra);
621 drv_data->extra = NULL;
622}
623
a08c22c0 624#ifdef CONFIG_SONY_FF
9f323b68 625static void sony_rumble_worker(struct work_struct *work)
a08c22c0 626{
9f323b68 627 struct sony_sc *sc = container_of(work, struct sony_sc, rumble_worker);
a08c22c0
SE		 628 unsigned char buf[] = {
629 0x01,
630 0x00, 0xff, 0x00, 0xff, 0x00,
631 0x00, 0x00, 0x00, 0x00, 0x03,
632 0xff, 0x27, 0x10, 0x00, 0x32,
633 0xff, 0x27, 0x10, 0x00, 0x32,
634 0xff, 0x27, 0x10, 0x00, 0x32,
635 0xff, 0x27, 0x10, 0x00, 0x32,
636 0x00, 0x00, 0x00, 0x00, 0x00
637 };
9f323b68
SE		 638
639 buf[3] = sc->right;
640 buf[5] = sc->left;
641
642 sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf),
643 HID_OUTPUT_REPORT);
644}
645
646static int sony_play_effect(struct input_dev *dev, void *data,
647 struct ff_effect *effect)
648{
a08c22c0 649 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 650 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 651
652 if (effect->type != FF_RUMBLE)
653 return 0;
654
9f323b68
SE		 655 sc->left = effect->u.rumble.strong_magnitude / 256;
656 sc->right = effect->u.rumble.weak_magnitude ? 1 : 0;
a08c22c0 657
9f323b68
SE		 658 schedule_work(&sc->rumble_worker);
659 return 0;
a08c22c0
SE		 660}
661
662static int sony_init_ff(struct hid_device *hdev)
663{
664 struct hid_input *hidinput = list_entry(hdev->inputs.next,
665 struct hid_input, list);
666 struct input_dev *input_dev = hidinput->input;
9f323b68
SE		 667 struct sony_sc *sc = hid_get_drvdata(hdev);
668
669 sc->hdev = hdev;
670 INIT_WORK(&sc->rumble_worker, sony_rumble_worker);
a08c22c0
SE		 671
672 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
673 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
674}
675
9f323b68
SE		 676static void sony_destroy_ff(struct hid_device *hdev)
677{
678 struct sony_sc *sc = hid_get_drvdata(hdev);
679
680 cancel_work_sync(&sc->rumble_worker);
681}
682
a08c22c0
SE		 683#else
684static int sony_init_ff(struct hid_device *hdev)
685{
686 return 0;
687}
9f323b68
SE		 688
689static void sony_destroy_ff(struct hid_device *hdev)
690{
691}
a08c22c0
SE		 692#endif
693
bd28ce00
JS		 694static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
695{
696 int ret;
cc6e0bbb
JK		 697 unsigned long quirks = id->driver_data;
698 struct sony_sc *sc;
f04d5140 699 unsigned int connect_mask = HID_CONNECT_DEFAULT;
cc6e0bbb 700
abf832bf 701 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
cc6e0bbb 702 if (sc == NULL) {
4291ee30 703 hid_err(hdev, "can't alloc sony descriptor\n");
cc6e0bbb
JK		 704 return -ENOMEM;
705 }
706
707 sc->quirks = quirks;
708 hid_set_drvdata(hdev, sc);
bd28ce00 709
bd28ce00
JS		 710 ret = hid_parse(hdev);
711 if (ret) {
4291ee30 712 hid_err(hdev, "parse failed\n");
abf832bf 713 return ret;
bd28ce00
JS		 714 }
715
f04d5140
CL		 716 if (sc->quirks & VAIO_RDESC_CONSTANT)
717 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
718 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
719 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
720 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
721 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
722
723 ret = hid_hw_start(hdev, connect_mask);
bd28ce00 724 if (ret) {
4291ee30 725 hid_err(hdev, "hw start failed\n");
abf832bf 726 return ret;
bd28ce00
JS		 727 }
728
569b10a5
AO		 729 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
730 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
816651a7 731 ret = sixaxis_set_operational_usb(hdev);
569b10a5 732 }
816651a7
AO		 733 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
734 ret = sixaxis_set_operational_bt(hdev);
f04d5140
CL		 735 else if (sc->quirks & BUZZ_CONTROLLER)
736 ret = buzz_init(hdev);
816651a7 737 else
f9ce7c28 738 ret = 0;
f9ce7c28 739
4dfdc464 740 if (ret < 0)
bd28ce00
JS		 741 goto err_stop;
742
a08c22c0
SE		 743 ret = sony_init_ff(hdev);
744 if (ret < 0)
745 goto err_stop;
746
bd28ce00
JS		 747 return 0;
748err_stop:
749 hid_hw_stop(hdev);
bd28ce00
JS		 750 return ret;
751}
752
cc6e0bbb
JK		 753static void sony_remove(struct hid_device *hdev)
754{
f04d5140
CL		 755 struct sony_sc *sc = hid_get_drvdata(hdev);
756
757 if (sc->quirks & BUZZ_CONTROLLER)
758 buzz_remove(hdev);
759
9f323b68
SE		 760 sony_destroy_ff(hdev);
761
cc6e0bbb 762 hid_hw_stop(hdev);
cc6e0bbb
JK		 763}
764
bd28ce00 765static const struct hid_device_id sony_devices[] = {
816651a7
AO		 766 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
767 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4
JK		 768 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
769 .driver_data = SIXAXIS_CONTROLLER_USB },
816651a7
AO		 770 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
771 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 772 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
773 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 774 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
775 .driver_data = VAIO_RDESC_CONSTANT },
f04d5140
CL		 776 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
777 * Logitech joystick from the device descriptor. */
778 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
779 .driver_data = BUZZ_CONTROLLER },
780 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
781 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 782 /* PS3 BD Remote Control */
783 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
784 .driver_data = PS3REMOTE },
785 /* Logitech Harmony Adapter for PS3 */
786 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
787 .driver_data = PS3REMOTE },
bd28ce00
JS		 788 { }
789};
790MODULE_DEVICE_TABLE(hid, sony_devices);
791
792static struct hid_driver sony_driver = {
f04d5140
CL		 793 .name = "sony",
794 .id_table = sony_devices,
795 .input_mapping = sony_mapping,
796 .probe = sony_probe,
797 .remove = sony_remove,
798 .report_fixup = sony_report_fixup,
799 .raw_event = sony_raw_event
bd28ce00 800};
f425458e 801module_hid_driver(sony_driver);
bd28ce00 802
bd28ce00 803MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.381722 seconds and 5 git commands to generate.