1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/device.h>
30#include <linux/hid.h>
31#include <linux/module.h>
32#include <linux/slab.h>
33#include <linux/leds.h>
34#include <linux/power_supply.h>
35#include <linux/spinlock.h>
36#include <linux/list.h>
37#include <linux/idr.h>
38#include <linux/input/mt.h>
39#include <linux/crc32.h>
40#include <linux/usb.h>
41#include <linux/timer.h>
42#include <asm/unaligned.h>
43
44#include "hid-ids.h"
45
46#define VAIO_RDESC_CONSTANT BIT(0)
47#define SIXAXIS_CONTROLLER_USB BIT(1)
48#define SIXAXIS_CONTROLLER_BT BIT(2)
49#define BUZZ_CONTROLLER BIT(3)
50#define PS3REMOTE BIT(4)
51#define DUALSHOCK4_CONTROLLER_USB BIT(5)
52#define DUALSHOCK4_CONTROLLER_BT BIT(6)
53#define DUALSHOCK4_DONGLE BIT(7)
54#define MOTION_CONTROLLER_USB BIT(8)
55#define MOTION_CONTROLLER_BT BIT(9)
56#define NAVIGATION_CONTROLLER_USB BIT(10)
57#define NAVIGATION_CONTROLLER_BT BIT(11)
58#define SINO_LITE_CONTROLLER BIT(12)
59#define FUTUREMAX_DANCE_MAT BIT(13)
60#define NSG_MR5U_REMOTE_BT BIT(14)
61#define NSG_MR7U_REMOTE_BT BIT(15)
62#define SHANWAN_GAMEPAD BIT(16)
63#define GH_GUITAR_CONTROLLER BIT(17)
64#define GHL_GUITAR_PS3WIIU BIT(18)
65
66#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
67#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
68#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
69 NAVIGATION_CONTROLLER_BT)
70#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
71 DUALSHOCK4_CONTROLLER_BT | \
72 DUALSHOCK4_DONGLE)
73#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
74 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
75 NAVIGATION_CONTROLLER)
76#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
77 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
78#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
79 MOTION_CONTROLLER)
80#define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
81 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
82#define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
83
84#define MAX_LEDS 4
85#define NSG_MRXU_MAX_X 1667
86#define NSG_MRXU_MAX_Y 1868
87
88#define GHL_GUITAR_POKE_INTERVAL 10
89#define GUITAR_TILT_USAGE 44
90
91
92
93
94
95static const u16 ghl_ps3wiiu_magic_value = 0x201;
96static const char ghl_ps3wiiu_magic_data[] = {
97 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
98};
99
100
101static u8 motion_rdesc[] = {
102 0x05, 0x01,
103 0x09, 0x04,
104 0xA1, 0x01,
105 0xA1, 0x02,
106 0x85, 0x01,
107 0x75, 0x01,
108 0x95, 0x15,
109 0x15, 0x00,
110 0x25, 0x01,
111 0x35, 0x00,
112 0x45, 0x01,
113 0x05, 0x09,
114 0x19, 0x01,
115 0x29, 0x15,
116 0x81, 0x02,
117 0x95, 0x0B,
118 0x06, 0x00, 0xFF,
119 0x81, 0x03,
120 0x15, 0x00,
121 0x26, 0xFF, 0x00,
122 0x05, 0x01,
123 0xA1, 0x00,
124 0x75, 0x08,
125 0x95, 0x01,
126 0x35, 0x00,
127 0x46, 0xFF, 0x00,
128 0x09, 0x30,
129 0x81, 0x02,
130 0xC0,
131 0x06, 0x00, 0xFF,
132 0x75, 0x08,
133 0x95, 0x07,
134 0x81, 0x02,
135 0x05, 0x01,
136 0x75, 0x10,
137 0x46, 0xFF, 0xFF,
138 0x27, 0xFF, 0xFF, 0x00, 0x00,
139 0x95, 0x03,
140 0x09, 0x33,
141 0x09, 0x34,
142 0x09, 0x35,
143 0x81, 0x02,
144 0x06, 0x00, 0xFF,
145 0x95, 0x03,
146 0x81, 0x02,
147 0x05, 0x01,
148 0x09, 0x01,
149 0x95, 0x03,
150 0x81, 0x02,
151 0x06, 0x00, 0xFF,
152 0x95, 0x03,
153 0x81, 0x02,
154 0x75, 0x0C,
155 0x46, 0xFF, 0x0F,
156 0x26, 0xFF, 0x0F,
157 0x95, 0x04,
158 0x81, 0x02,
159 0x75, 0x08,
160 0x46, 0xFF, 0x00,
161 0x26, 0xFF, 0x00,
162 0x95, 0x06,
163 0x81, 0x02,
164 0x75, 0x08,
165 0x95, 0x30,
166 0x09, 0x01,
167 0x91, 0x02,
168 0x75, 0x08,
169 0x95, 0x30,
170 0x09, 0x01,
171 0xB1, 0x02,
172 0xC0,
173 0xA1, 0x02,
174 0x85, 0x02,
175 0x75, 0x08,
176 0x95, 0x30,
177 0x09, 0x01,
178 0xB1, 0x02,
179 0xC0,
180 0xA1, 0x02,
181 0x85, 0xEE,
182 0x75, 0x08,
183 0x95, 0x30,
184 0x09, 0x01,
185 0xB1, 0x02,
186 0xC0,
187 0xA1, 0x02,
188 0x85, 0xEF,
189 0x75, 0x08,
190 0x95, 0x30,
191 0x09, 0x01,
192 0xB1, 0x02,
193 0xC0,
194 0xC0
195};
196
197static u8 ps3remote_rdesc[] = {
198 0x05, 0x01,
199 0x09, 0x05,
200 0xA1, 0x01,
201
202
203 0xA1, 0x02,
204
205
206
207
208
209 0x75, 0x08,
210 0x95, 0x01,
211 0x81, 0x01,
212
213
214
215
216
217 0x05, 0x09,
218 0x19, 0x01,
219 0x29, 0x18,
220 0x14,
221 0x25, 0x01,
222 0x75, 0x01,
223 0x95, 0x18,
224 0x81, 0x02,
225
226 0xC0,
227
228
229 0xA1, 0x02,
230
231
232 0x05, 0x09,
233 0x18,
234 0x29, 0xFE,
235 0x14,
236 0x26, 0xFE, 0x00,
237 0x75, 0x08,
238 0x95, 0x01,
239 0x80,
240
241
242
243
244
245 0x75, 0x08,
246 0x95, 0x06,
247 0x81, 0x01,
248
249
250 0x05, 0x06,
251 0x09, 0x20,
252 0x14,
253 0x25, 0x05,
254 0x75, 0x08,
255 0x95, 0x01,
256 0x81, 0x02,
257
258 0xC0,
259
260 0xC0
261};
262
263static const unsigned int ps3remote_keymap_joypad_buttons[] = {
264 [0x01] = KEY_SELECT,
265 [0x02] = BTN_THUMBL,
266 [0x03] = BTN_THUMBR,
267 [0x04] = BTN_START,
268 [0x05] = KEY_UP,
269 [0x06] = KEY_RIGHT,
270 [0x07] = KEY_DOWN,
271 [0x08] = KEY_LEFT,
272 [0x09] = BTN_TL2,
273 [0x0a] = BTN_TR2,
274 [0x0b] = BTN_TL,
275 [0x0c] = BTN_TR,
276 [0x0d] = KEY_OPTION,
277 [0x0e] = KEY_BACK,
278 [0x0f] = BTN_0,
279 [0x10] = KEY_SCREEN,
280 [0x11] = KEY_HOMEPAGE,
281 [0x14] = KEY_ENTER,
282};
283static const unsigned int ps3remote_keymap_remote_buttons[] = {
284 [0x00] = KEY_1,
285 [0x01] = KEY_2,
286 [0x02] = KEY_3,
287 [0x03] = KEY_4,
288 [0x04] = KEY_5,
289 [0x05] = KEY_6,
290 [0x06] = KEY_7,
291 [0x07] = KEY_8,
292 [0x08] = KEY_9,
293 [0x09] = KEY_0,
294 [0x0e] = KEY_ESC,
295 [0x0f] = KEY_CLEAR,
296 [0x16] = KEY_EJECTCD,
297 [0x1a] = KEY_MENU,
298 [0x28] = KEY_TIME,
299 [0x30] = KEY_PREVIOUS,
300 [0x31] = KEY_NEXT,
301 [0x32] = KEY_PLAY,
302 [0x33] = KEY_REWIND,
303 [0x34] = KEY_FORWARD,
304 [0x38] = KEY_STOP,
305 [0x39] = KEY_PAUSE,
306 [0x40] = KEY_CONTEXT_MENU,
307 [0x60] = KEY_FRAMEBACK,
308 [0x61] = KEY_FRAMEFORWARD,
309 [0x63] = KEY_SUBTITLE,
310 [0x64] = KEY_AUDIO,
311 [0x65] = KEY_ANGLE,
312 [0x70] = KEY_INFO,
313 [0x80] = KEY_BLUE,
314 [0x81] = KEY_RED,
315 [0x82] = KEY_GREEN,
316 [0x83] = KEY_YELLOW,
317};
318
319static const unsigned int buzz_keymap[] = {
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337 [1] = BTN_TRIGGER_HAPPY1,
338 [2] = BTN_TRIGGER_HAPPY2,
339 [3] = BTN_TRIGGER_HAPPY3,
340 [4] = BTN_TRIGGER_HAPPY4,
341 [5] = BTN_TRIGGER_HAPPY5,
342 [6] = BTN_TRIGGER_HAPPY6,
343 [7] = BTN_TRIGGER_HAPPY7,
344 [8] = BTN_TRIGGER_HAPPY8,
345 [9] = BTN_TRIGGER_HAPPY9,
346 [10] = BTN_TRIGGER_HAPPY10,
347 [11] = BTN_TRIGGER_HAPPY11,
348 [12] = BTN_TRIGGER_HAPPY12,
349 [13] = BTN_TRIGGER_HAPPY13,
350 [14] = BTN_TRIGGER_HAPPY14,
351 [15] = BTN_TRIGGER_HAPPY15,
352 [16] = BTN_TRIGGER_HAPPY16,
353 [17] = BTN_TRIGGER_HAPPY17,
354 [18] = BTN_TRIGGER_HAPPY18,
355 [19] = BTN_TRIGGER_HAPPY19,
356 [20] = BTN_TRIGGER_HAPPY20,
357};
358
359
360
361
362
363
364static const unsigned int navigation_absmap[] = {
365 [0x30] = ABS_X,
366 [0x31] = ABS_Y,
367 [0x33] = ABS_Z,
368};
369
370
371
372
373static const unsigned int navigation_keymap[] = {
374 [0x01] = 0,
375 [0x02] = BTN_THUMBL,
376 [0x03] = 0,
377 [0x04] = 0,
378 [0x05] = BTN_DPAD_UP,
379 [0x06] = BTN_DPAD_RIGHT,
380 [0x07] = BTN_DPAD_DOWN,
381 [0x08] = BTN_DPAD_LEFT,
382 [0x09] = BTN_TL2,
383 [0x0a] = 0,
384 [0x0b] = BTN_TL,
385 [0x0c] = 0,
386 [0x0d] = BTN_NORTH,
387 [0x0e] = BTN_EAST,
388 [0x0f] = BTN_SOUTH,
389 [0x10] = BTN_WEST,
390 [0x11] = BTN_MODE,
391};
392
393static const unsigned int sixaxis_absmap[] = {
394 [0x30] = ABS_X,
395 [0x31] = ABS_Y,
396 [0x32] = ABS_RX,
397 [0x35] = ABS_RY,
398};
399
400static const unsigned int sixaxis_keymap[] = {
401 [0x01] = BTN_SELECT,
402 [0x02] = BTN_THUMBL,
403 [0x03] = BTN_THUMBR,
404 [0x04] = BTN_START,
405 [0x05] = BTN_DPAD_UP,
406 [0x06] = BTN_DPAD_RIGHT,
407 [0x07] = BTN_DPAD_DOWN,
408 [0x08] = BTN_DPAD_LEFT,
409 [0x09] = BTN_TL2,
410 [0x0a] = BTN_TR2,
411 [0x0b] = BTN_TL,
412 [0x0c] = BTN_TR,
413 [0x0d] = BTN_NORTH,
414 [0x0e] = BTN_EAST,
415 [0x0f] = BTN_SOUTH,
416 [0x10] = BTN_WEST,
417 [0x11] = BTN_MODE,
418};
419
420static const unsigned int ds4_absmap[] = {
421 [0x30] = ABS_X,
422 [0x31] = ABS_Y,
423 [0x32] = ABS_RX,
424 [0x33] = ABS_Z,
425 [0x34] = ABS_RZ,
426 [0x35] = ABS_RY,
427};
428
429static const unsigned int ds4_keymap[] = {
430 [0x1] = BTN_WEST,
431 [0x2] = BTN_SOUTH,
432 [0x3] = BTN_EAST,
433 [0x4] = BTN_NORTH,
434 [0x5] = BTN_TL,
435 [0x6] = BTN_TR,
436 [0x7] = BTN_TL2,
437 [0x8] = BTN_TR2,
438 [0x9] = BTN_SELECT,
439 [0xa] = BTN_START,
440 [0xb] = BTN_THUMBL,
441 [0xc] = BTN_THUMBR,
442 [0xd] = BTN_MODE,
443};
444
445static const struct {int x; int y; } ds4_hat_mapping[] = {
446 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
447 {0, 0}
448};
449
450static enum power_supply_property sony_battery_props[] = {
451 POWER_SUPPLY_PROP_PRESENT,
452 POWER_SUPPLY_PROP_CAPACITY,
453 POWER_SUPPLY_PROP_SCOPE,
454 POWER_SUPPLY_PROP_STATUS,
455};
456
457struct sixaxis_led {
458 u8 time_enabled;
459 u8 duty_length;
460 u8 enabled;
461 u8 duty_off;
462 u8 duty_on;
463} __packed;
464
465struct sixaxis_rumble {
466 u8 padding;
467 u8 right_duration;
468 u8 right_motor_on;
469 u8 left_duration;
470 u8 left_motor_force;
471} __packed;
472
473struct sixaxis_output_report {
474 u8 report_id;
475 struct sixaxis_rumble rumble;
476 u8 padding[4];
477 u8 leds_bitmap;
478 struct sixaxis_led led[4];
479 struct sixaxis_led _reserved;
480} __packed;
481
482union sixaxis_output_report_01 {
483 struct sixaxis_output_report data;
484 u8 buf[36];
485};
486
487struct motion_output_report_02 {
488 u8 type, zero;
489 u8 r, g, b;
490 u8 zero2;
491 u8 rumble;
492};
493
494#define DS4_FEATURE_REPORT_0x02_SIZE 37
495#define DS4_FEATURE_REPORT_0x05_SIZE 41
496#define DS4_FEATURE_REPORT_0x81_SIZE 7
497#define DS4_FEATURE_REPORT_0xA3_SIZE 49
498#define DS4_INPUT_REPORT_0x11_SIZE 78
499#define DS4_OUTPUT_REPORT_0x05_SIZE 32
500#define DS4_OUTPUT_REPORT_0x11_SIZE 78
501#define SIXAXIS_REPORT_0xF2_SIZE 17
502#define SIXAXIS_REPORT_0xF5_SIZE 8
503#define MOTION_REPORT_0x02_SIZE 49
504
505
506
507
508#define DS4_INPUT_REPORT_AXIS_OFFSET 1
509#define DS4_INPUT_REPORT_BUTTON_OFFSET 5
510#define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
511#define DS4_INPUT_REPORT_GYRO_X_OFFSET 13
512#define DS4_INPUT_REPORT_BATTERY_OFFSET 30
513#define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
514
515#define SENSOR_SUFFIX " Motion Sensors"
516#define DS4_TOUCHPAD_SUFFIX " Touchpad"
517
518
519#define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
520#define DS4_BT_MAX_POLL_INTERVAL_MS 62
521#define DS4_GYRO_RES_PER_DEG_S 1024
522#define DS4_ACC_RES_PER_G 8192
523
524#define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
525#define SIXAXIS_ACC_RES_PER_G 113
526
527static DEFINE_SPINLOCK(sony_dev_list_lock);
528static LIST_HEAD(sony_device_list);
529static DEFINE_IDA(sony_device_id_allocator);
530
531
532struct ds4_calibration_data {
533 int abs_code;
534 short bias;
535
536
537
538
539 int sens_numer;
540 int sens_denom;
541};
542
543enum ds4_dongle_state {
544 DONGLE_DISCONNECTED,
545 DONGLE_CALIBRATING,
546 DONGLE_CONNECTED,
547 DONGLE_DISABLED
548};
549
550enum sony_worker {
551 SONY_WORKER_STATE,
552 SONY_WORKER_HOTPLUG
553};
554
555struct sony_sc {
556 spinlock_t lock;
557 struct list_head list_node;
558 struct hid_device *hdev;
559 struct input_dev *touchpad;
560 struct input_dev *sensor_dev;
561 struct led_classdev *leds[MAX_LEDS];
562 unsigned long quirks;
563 struct work_struct hotplug_worker;
564 struct work_struct state_worker;
565 void (*send_output_report)(struct sony_sc *);
566 struct power_supply *battery;
567 struct power_supply_desc battery_desc;
568 int device_id;
569 unsigned fw_version;
570 bool fw_version_created;
571 unsigned hw_version;
572 bool hw_version_created;
573 u8 *output_report_dmabuf;
574
575#ifdef CONFIG_SONY_FF
576 u8 left;
577 u8 right;
578#endif
579
580 u8 mac_address[6];
581 u8 hotplug_worker_initialized;
582 u8 state_worker_initialized;
583 u8 defer_initialization;
584 u8 battery_capacity;
585 int battery_status;
586 u8 led_state[MAX_LEDS];
587 u8 led_delay_on[MAX_LEDS];
588 u8 led_delay_off[MAX_LEDS];
589 u8 led_count;
590
591 bool timestamp_initialized;
592 u16 prev_timestamp;
593 unsigned int timestamp_us;
594
595 u8 ds4_bt_poll_interval;
596 enum ds4_dongle_state ds4_dongle_state;
597
598 struct ds4_calibration_data ds4_calib_data[6];
599
600 struct urb *ghl_urb;
601 struct timer_list ghl_poke_timer;
602};
603
604static void sony_set_leds(struct sony_sc *sc);
605
606static inline void sony_schedule_work(struct sony_sc *sc,
607 enum sony_worker which)
608{
609 unsigned long flags;
610
611 switch (which) {
612 case SONY_WORKER_STATE:
613 spin_lock_irqsave(&sc->lock, flags);
614 if (!sc->defer_initialization && sc->state_worker_initialized)
615 schedule_work(&sc->state_worker);
616 spin_unlock_irqrestore(&sc->lock, flags);
617 break;
618 case SONY_WORKER_HOTPLUG:
619 if (sc->hotplug_worker_initialized)
620 schedule_work(&sc->hotplug_worker);
621 break;
622 }
623}
624
625static void ghl_magic_poke_cb(struct urb *urb)
626{
627 struct sony_sc *sc = urb->context;
628
629 if (urb->status < 0)
630 hid_err(sc->hdev, "URB transfer failed : %d", urb->status);
631
632 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
633}
634
635static void ghl_magic_poke(struct timer_list *t)
636{
637 int ret;
638 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
639
640 ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC);
641 if (ret < 0)
642 hid_err(sc->hdev, "usb_submit_urb failed: %d", ret);
643}
644
645static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev)
646{
647 struct usb_ctrlrequest *cr;
648 u16 poke_size;
649 u8 *databuf;
650 unsigned int pipe;
651
652 poke_size = ARRAY_SIZE(ghl_ps3wiiu_magic_data);
653 pipe = usb_sndctrlpipe(usbdev, 0);
654
655 cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
656 if (cr == NULL)
657 return -ENOMEM;
658
659 databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
660 if (databuf == NULL)
661 return -ENOMEM;
662
663 cr->bRequestType =
664 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
665 cr->bRequest = USB_REQ_SET_CONFIGURATION;
666 cr->wValue = cpu_to_le16(ghl_ps3wiiu_magic_value);
667 cr->wIndex = 0;
668 cr->wLength = cpu_to_le16(poke_size);
669 memcpy(databuf, ghl_ps3wiiu_magic_data, poke_size);
670 usb_fill_control_urb(
671 sc->ghl_urb, usbdev, pipe,
672 (unsigned char *) cr, databuf, poke_size,
673 ghl_magic_poke_cb, sc);
674 return 0;
675}
676
677static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
678 struct hid_field *field, struct hid_usage *usage,
679 unsigned long **bit, int *max)
680{
681 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
682 unsigned int abs = usage->hid & HID_USAGE;
683
684 if (abs == GUITAR_TILT_USAGE) {
685 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
686 return 1;
687 }
688 }
689 return 0;
690}
691
692static ssize_t ds4_show_poll_interval(struct device *dev,
693 struct device_attribute
694 *attr, char *buf)
695{
696 struct hid_device *hdev = to_hid_device(dev);
697 struct sony_sc *sc = hid_get_drvdata(hdev);
698
699 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
700}
701
702static ssize_t ds4_store_poll_interval(struct device *dev,
703 struct device_attribute *attr,
704 const char *buf, size_t count)
705{
706 struct hid_device *hdev = to_hid_device(dev);
707 struct sony_sc *sc = hid_get_drvdata(hdev);
708 unsigned long flags;
709 u8 interval;
710
711 if (kstrtou8(buf, 0, &interval))
712 return -EINVAL;
713
714 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
715 return -EINVAL;
716
717 spin_lock_irqsave(&sc->lock, flags);
718 sc->ds4_bt_poll_interval = interval;
719 spin_unlock_irqrestore(&sc->lock, flags);
720
721 sony_schedule_work(sc, SONY_WORKER_STATE);
722
723 return count;
724}
725
726static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
727 ds4_store_poll_interval);
728
729static ssize_t sony_show_firmware_version(struct device *dev,
730 struct device_attribute
731 *attr, char *buf)
732{
733 struct hid_device *hdev = to_hid_device(dev);
734 struct sony_sc *sc = hid_get_drvdata(hdev);
735
736 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
737}
738
739static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
740
741static ssize_t sony_show_hardware_version(struct device *dev,
742 struct device_attribute
743 *attr, char *buf)
744{
745 struct hid_device *hdev = to_hid_device(dev);
746 struct sony_sc *sc = hid_get_drvdata(hdev);
747
748 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
749}
750
751static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
752
753static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
754 unsigned int *rsize)
755{
756 *rsize = sizeof(motion_rdesc);
757 return motion_rdesc;
758}
759
760static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
761 unsigned int *rsize)
762{
763 *rsize = sizeof(ps3remote_rdesc);
764 return ps3remote_rdesc;
765}
766
767static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
768 struct hid_field *field, struct hid_usage *usage,
769 unsigned long **bit, int *max)
770{
771 unsigned int key = usage->hid & HID_USAGE;
772
773 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
774 return -1;
775
776 switch (usage->collection_index) {
777 case 1:
778 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
779 return -1;
780
781 key = ps3remote_keymap_joypad_buttons[key];
782 if (!key)
783 return -1;
784 break;
785 case 2:
786 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
787 return -1;
788
789 key = ps3remote_keymap_remote_buttons[key];
790 if (!key)
791 return -1;
792 break;
793 default:
794 return -1;
795 }
796
797 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
798 return 1;
799}
800
801static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
802 struct hid_field *field, struct hid_usage *usage,
803 unsigned long **bit, int *max)
804{
805 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
806 unsigned int key = usage->hid & HID_USAGE;
807
808 if (key >= ARRAY_SIZE(sixaxis_keymap))
809 return -1;
810
811 key = navigation_keymap[key];
812 if (!key)
813 return -1;
814
815 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
816 return 1;
817 } else if (usage->hid == HID_GD_POINTER) {
818
819
820
821
822
823 switch (usage->usage_index) {
824 case 8:
825 usage->hid = HID_GD_Z;
826 break;
827 default:
828 return -1;
829 }
830
831 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
832 return 1;
833 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
834 unsigned int abs = usage->hid & HID_USAGE;
835
836 if (abs >= ARRAY_SIZE(navigation_absmap))
837 return -1;
838
839 abs = navigation_absmap[abs];
840
841 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
842 return 1;
843 }
844
845 return -1;
846}
847
848
849static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
850 struct hid_field *field, struct hid_usage *usage,
851 unsigned long **bit, int *max)
852{
853 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
854 unsigned int key = usage->hid & HID_USAGE;
855
856 if (key >= ARRAY_SIZE(sixaxis_keymap))
857 return -1;
858
859 key = sixaxis_keymap[key];
860 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
861 return 1;
862 } else if (usage->hid == HID_GD_POINTER) {
863
864
865
866
867
868
869 switch (usage->usage_index) {
870 case 8:
871 usage->hid = HID_GD_Z;
872 break;
873 case 9:
874 usage->hid = HID_GD_RZ;
875 break;
876 default:
877 return -1;
878 }
879
880 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
881 return 1;
882 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
883 unsigned int abs = usage->hid & HID_USAGE;
884
885 if (abs >= ARRAY_SIZE(sixaxis_absmap))
886 return -1;
887
888 abs = sixaxis_absmap[abs];
889
890 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
891 return 1;
892 }
893
894 return -1;
895}
896
897static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
898 struct hid_field *field, struct hid_usage *usage,
899 unsigned long **bit, int *max)
900{
901 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
902 unsigned int key = usage->hid & HID_USAGE;
903
904 if (key >= ARRAY_SIZE(ds4_keymap))
905 return -1;
906
907 key = ds4_keymap[key];
908 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
909 return 1;
910 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
911 unsigned int abs = usage->hid & HID_USAGE;
912
913
914 if (usage->hid == HID_GD_HATSWITCH)
915 return 0;
916
917 if (abs >= ARRAY_SIZE(ds4_absmap))
918 return -1;
919
920 abs = ds4_absmap[abs];
921 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
922 return 1;
923 }
924
925 return 0;
926}
927
928static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
929 unsigned int *rsize)
930{
931 struct sony_sc *sc = hid_get_drvdata(hdev);
932
933 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
934 return rdesc;
935
936
937
938
939
940 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
941
942
943
944 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
945
946 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
947 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
948
949 rdesc[55] = 0x06;
950 }
951
952 if (sc->quirks & MOTION_CONTROLLER)
953 return motion_fixup(hdev, rdesc, rsize);
954
955 if (sc->quirks & PS3REMOTE)
956 return ps3remote_fixup(hdev, rdesc, rsize);
957
958
959
960
961
962 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
963
964 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
965
966 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
967
968 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
969 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
970 rdesc[24] = 0x10;
971 rdesc[38] = 0x10;
972 rdesc[44] = 0x00;
973 }
974
975 return rdesc;
976}
977
978static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
979{
980 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
981 unsigned long flags;
982 int offset;
983 u8 battery_capacity;
984 int battery_status;
985
986
987
988
989
990
991
992 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
993
994 if (rd[offset] >= 0xee) {
995 battery_capacity = 100;
996 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
997 } else {
998 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
999 battery_capacity = sixaxis_battery_capacity[index];
1000 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1001 }
1002
1003 spin_lock_irqsave(&sc->lock, flags);
1004 sc->battery_capacity = battery_capacity;
1005 sc->battery_status = battery_status;
1006 spin_unlock_irqrestore(&sc->lock, flags);
1007
1008 if (sc->quirks & SIXAXIS_CONTROLLER) {
1009 int val;
1010
1011 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
1012 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
1013 input_report_abs(sc->sensor_dev, ABS_X, val);
1014
1015
1016 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
1017 input_report_abs(sc->sensor_dev, ABS_Y, val);
1018
1019 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
1020 input_report_abs(sc->sensor_dev, ABS_Z, val);
1021
1022 input_sync(sc->sensor_dev);
1023 }
1024}
1025
1026static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
1027{
1028 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1029 struct hid_input, list);
1030 struct input_dev *input_dev = hidinput->input;
1031 unsigned long flags;
1032 int n, m, offset, num_touch_data, max_touch_data;
1033 u8 cable_state, battery_capacity;
1034 int battery_status;
1035 u16 timestamp;
1036
1037
1038 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
1039
1040
1041 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
1042 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058 if (rd[0] == 17) {
1059 int value;
1060
1061 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
1062 input_report_abs(input_dev, ABS_X, rd[offset]);
1063 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
1064 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
1065 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
1066
1067 value = rd[offset+4] & 0xf;
1068 if (value > 7)
1069 value = 8;
1070 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
1071 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
1072
1073 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
1074 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
1075 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
1076 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
1077
1078 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
1079 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
1080 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
1081 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
1082 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
1083 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
1084 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
1085 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
1086
1087 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
1088
1089 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
1090 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
1091
1092 input_sync(input_dev);
1093 }
1094
1095
1096 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
1097 timestamp = get_unaligned_le16(&rd[offset]);
1098 if (!sc->timestamp_initialized) {
1099 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1100 sc->timestamp_initialized = true;
1101 } else {
1102 u16 delta;
1103
1104 if (sc->prev_timestamp > timestamp)
1105 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1106 else
1107 delta = timestamp - sc->prev_timestamp;
1108 sc->timestamp_us += (delta * 16) / 3;
1109 }
1110 sc->prev_timestamp = timestamp;
1111 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1112
1113 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
1114 for (n = 0; n < 6; n++) {
1115
1116 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1117 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1118
1119
1120
1121
1122
1123
1124 int calib_data = mult_frac(calib->sens_numer,
1125 raw_data - calib->bias,
1126 calib->sens_denom);
1127
1128 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1129 offset += 2;
1130 }
1131 input_sync(sc->sensor_dev);
1132
1133
1134
1135
1136
1137 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1138 cable_state = (rd[offset] >> 4) & 0x01;
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150 if (cable_state) {
1151 u8 battery_data = rd[offset] & 0xf;
1152
1153 if (battery_data < 10) {
1154
1155
1156
1157
1158
1159 battery_capacity = battery_data * 10 + 5;
1160 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1161 } else if (battery_data == 10) {
1162 battery_capacity = 100;
1163 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1164 } else if (battery_data == 11) {
1165 battery_capacity = 100;
1166 battery_status = POWER_SUPPLY_STATUS_FULL;
1167 } else {
1168 battery_capacity = 0;
1169 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1170 }
1171 } else {
1172 u8 battery_data = rd[offset] & 0xf;
1173
1174 if (battery_data < 10)
1175 battery_capacity = battery_data * 10 + 5;
1176 else
1177 battery_capacity = 100;
1178
1179 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1180 }
1181
1182 spin_lock_irqsave(&sc->lock, flags);
1183 sc->battery_capacity = battery_capacity;
1184 sc->battery_status = battery_status;
1185 spin_unlock_irqrestore(&sc->lock, flags);
1186
1187
1188
1189
1190
1191
1192
1193 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1194 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1195 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1196 num_touch_data = rd[offset];
1197 else
1198 num_touch_data = 1;
1199 offset += 1;
1200
1201 for (m = 0; m < num_touch_data; m++) {
1202
1203 offset += 1;
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213 for (n = 0; n < 2; n++) {
1214 u16 x, y;
1215 bool active;
1216
1217 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1218 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1219
1220 active = !(rd[offset] >> 7);
1221 input_mt_slot(sc->touchpad, n);
1222 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1223
1224 if (active) {
1225 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1226 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1227 }
1228
1229 offset += 4;
1230 }
1231 input_mt_sync_frame(sc->touchpad);
1232 input_sync(sc->touchpad);
1233 }
1234}
1235
1236static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1237{
1238 int n, offset, relx, rely;
1239 u8 active;
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259 offset = 1;
1260
1261 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1262 active = (rd[offset] >> 4);
1263 relx = (s8) rd[offset+5];
1264 rely = ((s8) rd[offset+10]) * -1;
1265
1266 offset++;
1267
1268 for (n = 0; n < 2; n++) {
1269 u16 x, y;
1270 u8 contactx, contacty;
1271
1272 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1273 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1274
1275 input_mt_slot(sc->touchpad, n);
1276 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1277
1278 if (active & 0x03) {
1279 contactx = rd[offset+3] & 0x0F;
1280 contacty = rd[offset+3] >> 4;
1281 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1282 max(contactx, contacty));
1283 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1284 min(contactx, contacty));
1285 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1286 (bool) (contactx > contacty));
1287 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1288 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1289 NSG_MRXU_MAX_Y - y);
1290
1291
1292
1293
1294
1295 if ((n == 0) || ((n == 1) && (active & 0x01))) {
1296 input_report_rel(sc->touchpad, REL_X, relx);
1297 input_report_rel(sc->touchpad, REL_Y, rely);
1298 }
1299 }
1300
1301 offset += 5;
1302 active >>= 2;
1303 }
1304
1305 input_mt_sync_frame(sc->touchpad);
1306
1307 input_sync(sc->touchpad);
1308}
1309
1310static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1311 u8 *rd, int size)
1312{
1313 struct sony_sc *sc = hid_get_drvdata(hdev);
1314
1315
1316
1317
1318
1319 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1320
1321
1322
1323
1324
1325
1326
1327
1328 if (rd[1] == 0xff)
1329 return -EINVAL;
1330
1331 swap(rd[41], rd[42]);
1332 swap(rd[43], rd[44]);
1333 swap(rd[45], rd[46]);
1334 swap(rd[47], rd[48]);
1335
1336 sixaxis_parse_report(sc, rd, size);
1337 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1338 sixaxis_parse_report(sc, rd, size);
1339 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1340 size == 49) {
1341 sixaxis_parse_report(sc, rd, size);
1342 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1343 size == 64) {
1344 dualshock4_parse_report(sc, rd, size);
1345 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1346 size == 78)) {
1347
1348 u8 bthdr = 0xA1;
1349 u32 crc;
1350 u32 report_crc;
1351
1352 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1353 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1354 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1355 if (crc != report_crc) {
1356 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1357 report_crc, crc);
1358 return -EILSEQ;
1359 }
1360
1361 dualshock4_parse_report(sc, rd, size);
1362 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1363 size == 64) {
1364 unsigned long flags;
1365 enum ds4_dongle_state dongle_state;
1366
1367
1368
1369
1370
1371
1372 bool connected = (rd[31] & 0x04) ? false : true;
1373
1374 spin_lock_irqsave(&sc->lock, flags);
1375 dongle_state = sc->ds4_dongle_state;
1376 spin_unlock_irqrestore(&sc->lock, flags);
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1387 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1388 sony_set_leds(sc);
1389
1390 spin_lock_irqsave(&sc->lock, flags);
1391 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1392 spin_unlock_irqrestore(&sc->lock, flags);
1393
1394 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1395
1396
1397
1398
1399 return 0;
1400 } else if ((dongle_state == DONGLE_CONNECTED ||
1401 dongle_state == DONGLE_DISABLED) && !connected) {
1402 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1403
1404 spin_lock_irqsave(&sc->lock, flags);
1405 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1406 spin_unlock_irqrestore(&sc->lock, flags);
1407
1408
1409 return 0;
1410 } else if (dongle_state == DONGLE_CALIBRATING ||
1411 dongle_state == DONGLE_DISABLED ||
1412 dongle_state == DONGLE_DISCONNECTED) {
1413
1414 return 0;
1415 }
1416
1417 dualshock4_parse_report(sc, rd, size);
1418
1419 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1420 nsg_mrxu_parse_report(sc, rd, size);
1421 return 1;
1422 }
1423
1424 if (sc->defer_initialization) {
1425 sc->defer_initialization = 0;
1426 sony_schedule_work(sc, SONY_WORKER_STATE);
1427 }
1428
1429 return 0;
1430}
1431
1432static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1433 struct hid_field *field, struct hid_usage *usage,
1434 unsigned long **bit, int *max)
1435{
1436 struct sony_sc *sc = hid_get_drvdata(hdev);
1437
1438 if (sc->quirks & BUZZ_CONTROLLER) {
1439 unsigned int key = usage->hid & HID_USAGE;
1440
1441 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1442 return -1;
1443
1444 switch (usage->collection_index) {
1445 case 1:
1446 if (key >= ARRAY_SIZE(buzz_keymap))
1447 return -1;
1448
1449 key = buzz_keymap[key];
1450 if (!key)
1451 return -1;
1452 break;
1453 default:
1454 return -1;
1455 }
1456
1457 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1458 return 1;
1459 }
1460
1461 if (sc->quirks & PS3REMOTE)
1462 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1463
1464 if (sc->quirks & NAVIGATION_CONTROLLER)
1465 return navigation_mapping(hdev, hi, field, usage, bit, max);
1466
1467 if (sc->quirks & SIXAXIS_CONTROLLER)
1468 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1469
1470 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1471 return ds4_mapping(hdev, hi, field, usage, bit, max);
1472
1473 if (sc->quirks & GH_GUITAR_CONTROLLER)
1474 return guitar_mapping(hdev, hi, field, usage, bit, max);
1475
1476
1477 return 0;
1478}
1479
1480static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1481 int w, int h, int touch_major, int touch_minor, int orientation)
1482{
1483 size_t name_sz;
1484 char *name;
1485 int ret;
1486
1487 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1488 if (!sc->touchpad)
1489 return -ENOMEM;
1490
1491 input_set_drvdata(sc->touchpad, sc);
1492 sc->touchpad->dev.parent = &sc->hdev->dev;
1493 sc->touchpad->phys = sc->hdev->phys;
1494 sc->touchpad->uniq = sc->hdev->uniq;
1495 sc->touchpad->id.bustype = sc->hdev->bus;
1496 sc->touchpad->id.vendor = sc->hdev->vendor;
1497 sc->touchpad->id.product = sc->hdev->product;
1498 sc->touchpad->id.version = sc->hdev->version;
1499
1500
1501
1502
1503 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1504 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1505 if (!name)
1506 return -ENOMEM;
1507 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1508 sc->touchpad->name = name;
1509
1510
1511 __set_bit(EV_KEY, sc->touchpad->evbit);
1512 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1513 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1514
1515 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1516 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1517
1518 if (touch_major > 0) {
1519 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1520 0, touch_major, 0, 0);
1521 if (touch_minor > 0)
1522 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1523 0, touch_minor, 0, 0);
1524 if (orientation > 0)
1525 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1526 0, orientation, 0, 0);
1527 }
1528
1529 if (sc->quirks & NSG_MRXU_REMOTE) {
1530 __set_bit(EV_REL, sc->touchpad->evbit);
1531 }
1532
1533 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1534 if (ret < 0)
1535 return ret;
1536
1537 ret = input_register_device(sc->touchpad);
1538 if (ret < 0)
1539 return ret;
1540
1541 return 0;
1542}
1543
1544static int sony_register_sensors(struct sony_sc *sc)
1545{
1546 size_t name_sz;
1547 char *name;
1548 int ret;
1549 int range;
1550
1551 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1552 if (!sc->sensor_dev)
1553 return -ENOMEM;
1554
1555 input_set_drvdata(sc->sensor_dev, sc);
1556 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1557 sc->sensor_dev->phys = sc->hdev->phys;
1558 sc->sensor_dev->uniq = sc->hdev->uniq;
1559 sc->sensor_dev->id.bustype = sc->hdev->bus;
1560 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1561 sc->sensor_dev->id.product = sc->hdev->product;
1562 sc->sensor_dev->id.version = sc->hdev->version;
1563
1564
1565
1566
1567 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1568 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1569 if (!name)
1570 return -ENOMEM;
1571 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1572 sc->sensor_dev->name = name;
1573
1574 if (sc->quirks & SIXAXIS_CONTROLLER) {
1575
1576
1577
1578
1579
1580
1581 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1582 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1583 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1584 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1585 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1586 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1587 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1588 range = DS4_ACC_RES_PER_G*4;
1589 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1590 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1591 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1592 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1593 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1594 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1595
1596 range = DS4_GYRO_RES_PER_DEG_S*2048;
1597 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1598 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1599 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1600 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1601 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1602 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1603
1604 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1605 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1606 }
1607
1608 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1609
1610 ret = input_register_device(sc->sensor_dev);
1611 if (ret < 0)
1612 return ret;
1613
1614 return 0;
1615}
1616
1617
1618
1619
1620
1621
1622static int sixaxis_set_operational_usb(struct hid_device *hdev)
1623{
1624 struct sony_sc *sc = hid_get_drvdata(hdev);
1625 const int buf_size =
1626 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1627 u8 *buf;
1628 int ret;
1629
1630 buf = kmalloc(buf_size, GFP_KERNEL);
1631 if (!buf)
1632 return -ENOMEM;
1633
1634 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1635 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1636 if (ret < 0) {
1637 hid_err(hdev, "can't set operational mode: step 1\n");
1638 goto out;
1639 }
1640
1641
1642
1643
1644
1645 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1646 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1647 if (ret < 0) {
1648 hid_err(hdev, "can't set operational mode: step 2\n");
1649 goto out;
1650 }
1651
1652
1653
1654
1655
1656 if (sc->quirks & SHANWAN_GAMEPAD)
1657 goto out;
1658
1659 ret = hid_hw_output_report(hdev, buf, 1);
1660 if (ret < 0) {
1661 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1662 ret = 0;
1663 }
1664
1665out:
1666 kfree(buf);
1667
1668 return ret;
1669}
1670
1671static int sixaxis_set_operational_bt(struct hid_device *hdev)
1672{
1673 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1674 u8 *buf;
1675 int ret;
1676
1677 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1678 if (!buf)
1679 return -ENOMEM;
1680
1681 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1682 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1683
1684 kfree(buf);
1685
1686 return ret;
1687}
1688
1689
1690
1691
1692
1693static int dualshock4_get_calibration_data(struct sony_sc *sc)
1694{
1695 u8 *buf;
1696 int ret;
1697 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1698 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1699 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1700 short gyro_speed_plus, gyro_speed_minus;
1701 short acc_x_plus, acc_x_minus;
1702 short acc_y_plus, acc_y_minus;
1703 short acc_z_plus, acc_z_minus;
1704 int speed_2x;
1705 int range_2g;
1706
1707
1708
1709
1710
1711 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1712 int retries;
1713
1714 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1715 if (!buf)
1716 return -ENOMEM;
1717
1718
1719
1720
1721
1722
1723
1724 for (retries = 0; retries < 3; retries++) {
1725 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1726 DS4_FEATURE_REPORT_0x02_SIZE,
1727 HID_FEATURE_REPORT,
1728 HID_REQ_GET_REPORT);
1729 if (ret < 0)
1730 goto err_stop;
1731
1732 if (buf[0] != 0x02) {
1733 if (retries < 2) {
1734 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1735 continue;
1736 } else {
1737 ret = -EILSEQ;
1738 goto err_stop;
1739 }
1740 } else {
1741 break;
1742 }
1743 }
1744 } else {
1745 u8 bthdr = 0xA3;
1746 u32 crc;
1747 u32 report_crc;
1748 int retries;
1749
1750 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1751 if (!buf)
1752 return -ENOMEM;
1753
1754 for (retries = 0; retries < 3; retries++) {
1755 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1756 DS4_FEATURE_REPORT_0x05_SIZE,
1757 HID_FEATURE_REPORT,
1758 HID_REQ_GET_REPORT);
1759 if (ret < 0)
1760 goto err_stop;
1761
1762
1763 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1764 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1765 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1766 if (crc != report_crc) {
1767 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1768 report_crc, crc);
1769 if (retries < 2) {
1770 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1771 continue;
1772 } else {
1773 ret = -EILSEQ;
1774 goto err_stop;
1775 }
1776 } else {
1777 break;
1778 }
1779 }
1780 }
1781
1782 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1783 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1784 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1785 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1786 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1787 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1788 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1789 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1790 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1791 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1792 } else {
1793
1794 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1795 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1796 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1797 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1798 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1799 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1800 }
1801 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1802 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1803 acc_x_plus = get_unaligned_le16(&buf[23]);
1804 acc_x_minus = get_unaligned_le16(&buf[25]);
1805 acc_y_plus = get_unaligned_le16(&buf[27]);
1806 acc_y_minus = get_unaligned_le16(&buf[29]);
1807 acc_z_plus = get_unaligned_le16(&buf[31]);
1808 acc_z_minus = get_unaligned_le16(&buf[33]);
1809
1810
1811
1812
1813 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1814 sc->ds4_calib_data[0].abs_code = ABS_RX;
1815 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1816 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1817 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1818
1819 sc->ds4_calib_data[1].abs_code = ABS_RY;
1820 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1821 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1822 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1823
1824 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1825 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1826 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1827 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1828
1829
1830
1831
1832 range_2g = acc_x_plus - acc_x_minus;
1833 sc->ds4_calib_data[3].abs_code = ABS_X;
1834 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1835 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1836 sc->ds4_calib_data[3].sens_denom = range_2g;
1837
1838 range_2g = acc_y_plus - acc_y_minus;
1839 sc->ds4_calib_data[4].abs_code = ABS_Y;
1840 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1841 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1842 sc->ds4_calib_data[4].sens_denom = range_2g;
1843
1844 range_2g = acc_z_plus - acc_z_minus;
1845 sc->ds4_calib_data[5].abs_code = ABS_Z;
1846 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1847 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1848 sc->ds4_calib_data[5].sens_denom = range_2g;
1849
1850err_stop:
1851 kfree(buf);
1852 return ret;
1853}
1854
1855static void dualshock4_calibration_work(struct work_struct *work)
1856{
1857 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1858 unsigned long flags;
1859 enum ds4_dongle_state dongle_state;
1860 int ret;
1861
1862 ret = dualshock4_get_calibration_data(sc);
1863 if (ret < 0) {
1864
1865
1866
1867
1868
1869
1870 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1871 dongle_state = DONGLE_DISABLED;
1872 } else {
1873 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1874 dongle_state = DONGLE_CONNECTED;
1875 }
1876
1877 spin_lock_irqsave(&sc->lock, flags);
1878 sc->ds4_dongle_state = dongle_state;
1879 spin_unlock_irqrestore(&sc->lock, flags);
1880}
1881
1882static int dualshock4_get_version_info(struct sony_sc *sc)
1883{
1884 u8 *buf;
1885 int ret;
1886
1887 buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1888 if (!buf)
1889 return -ENOMEM;
1890
1891 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1892 DS4_FEATURE_REPORT_0xA3_SIZE,
1893 HID_FEATURE_REPORT,
1894 HID_REQ_GET_REPORT);
1895 if (ret < 0) {
1896 kfree(buf);
1897 return ret;
1898 }
1899
1900 sc->hw_version = get_unaligned_le16(&buf[35]);
1901 sc->fw_version = get_unaligned_le16(&buf[41]);
1902
1903 kfree(buf);
1904 return 0;
1905}
1906
1907static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1908{
1909 static const u8 sixaxis_leds[10][4] = {
1910 { 0x01, 0x00, 0x00, 0x00 },
1911 { 0x00, 0x01, 0x00, 0x00 },
1912 { 0x00, 0x00, 0x01, 0x00 },
1913 { 0x00, 0x00, 0x00, 0x01 },
1914 { 0x01, 0x00, 0x00, 0x01 },
1915 { 0x00, 0x01, 0x00, 0x01 },
1916 { 0x00, 0x00, 0x01, 0x01 },
1917 { 0x01, 0x00, 0x01, 0x01 },
1918 { 0x00, 0x01, 0x01, 0x01 },
1919 { 0x01, 0x01, 0x01, 0x01 }
1920 };
1921
1922 int id = sc->device_id;
1923
1924 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1925
1926 if (id < 0)
1927 return;
1928
1929 id %= 10;
1930 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1931}
1932
1933static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1934{
1935
1936 static const u8 color_code[7][3] = {
1937 { 0x00, 0x00, 0x40 },
1938 { 0x40, 0x00, 0x00 },
1939 { 0x00, 0x40, 0x00 },
1940 { 0x20, 0x00, 0x20 },
1941 { 0x02, 0x01, 0x00 },
1942 { 0x00, 0x01, 0x01 },
1943 { 0x01, 0x01, 0x01 }
1944 };
1945
1946 int id = sc->device_id;
1947
1948 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1949
1950 if (id < 0)
1951 return;
1952
1953 id %= 7;
1954 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1955}
1956
1957static void buzz_set_leds(struct sony_sc *sc)
1958{
1959 struct hid_device *hdev = sc->hdev;
1960 struct list_head *report_list =
1961 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1962 struct hid_report *report = list_entry(report_list->next,
1963 struct hid_report, list);
1964 s32 *value = report->field[0]->value;
1965
1966 BUILD_BUG_ON(MAX_LEDS < 4);
1967
1968 value[0] = 0x00;
1969 value[1] = sc->led_state[0] ? 0xff : 0x00;
1970 value[2] = sc->led_state[1] ? 0xff : 0x00;
1971 value[3] = sc->led_state[2] ? 0xff : 0x00;
1972 value[4] = sc->led_state[3] ? 0xff : 0x00;
1973 value[5] = 0x00;
1974 value[6] = 0x00;
1975 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1976}
1977
1978static void sony_set_leds(struct sony_sc *sc)
1979{
1980 if (!(sc->quirks & BUZZ_CONTROLLER))
1981 sony_schedule_work(sc, SONY_WORKER_STATE);
1982 else
1983 buzz_set_leds(sc);
1984}
1985
1986static void sony_led_set_brightness(struct led_classdev *led,
1987 enum led_brightness value)
1988{
1989 struct device *dev = led->dev->parent;
1990 struct hid_device *hdev = to_hid_device(dev);
1991 struct sony_sc *drv_data;
1992
1993 int n;
1994 int force_update;
1995
1996 drv_data = hid_get_drvdata(hdev);
1997 if (!drv_data) {
1998 hid_err(hdev, "No device data\n");
1999 return;
2000 }
2001
2002
2003
2004
2005
2006
2007
2008
2009 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
2010
2011 for (n = 0; n < drv_data->led_count; n++) {
2012 if (led == drv_data->leds[n] && (force_update ||
2013 (value != drv_data->led_state[n] ||
2014 drv_data->led_delay_on[n] ||
2015 drv_data->led_delay_off[n]))) {
2016
2017 drv_data->led_state[n] = value;
2018
2019
2020 drv_data->led_delay_on[n] = 0;
2021 drv_data->led_delay_off[n] = 0;
2022
2023 sony_set_leds(drv_data);
2024 break;
2025 }
2026 }
2027}
2028
2029static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
2030{
2031 struct device *dev = led->dev->parent;
2032 struct hid_device *hdev = to_hid_device(dev);
2033 struct sony_sc *drv_data;
2034
2035 int n;
2036
2037 drv_data = hid_get_drvdata(hdev);
2038 if (!drv_data) {
2039 hid_err(hdev, "No device data\n");
2040 return LED_OFF;
2041 }
2042
2043 for (n = 0; n < drv_data->led_count; n++) {
2044 if (led == drv_data->leds[n])
2045 return drv_data->led_state[n];
2046 }
2047
2048 return LED_OFF;
2049}
2050
2051static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
2052 unsigned long *delay_off)
2053{
2054 struct device *dev = led->dev->parent;
2055 struct hid_device *hdev = to_hid_device(dev);
2056 struct sony_sc *drv_data = hid_get_drvdata(hdev);
2057 int n;
2058 u8 new_on, new_off;
2059
2060 if (!drv_data) {
2061 hid_err(hdev, "No device data\n");
2062 return -EINVAL;
2063 }
2064
2065
2066 if (*delay_on > 2550)
2067 *delay_on = 2550;
2068 if (*delay_off > 2550)
2069 *delay_off = 2550;
2070
2071
2072 if (!*delay_on && !*delay_off)
2073 *delay_on = *delay_off = 500;
2074
2075 new_on = *delay_on / 10;
2076 new_off = *delay_off / 10;
2077
2078 for (n = 0; n < drv_data->led_count; n++) {
2079 if (led == drv_data->leds[n])
2080 break;
2081 }
2082
2083
2084 if (n >= drv_data->led_count)
2085 return -EINVAL;
2086
2087
2088 if (new_on != drv_data->led_delay_on[n] ||
2089 new_off != drv_data->led_delay_off[n]) {
2090 drv_data->led_delay_on[n] = new_on;
2091 drv_data->led_delay_off[n] = new_off;
2092 sony_schedule_work(drv_data, SONY_WORKER_STATE);
2093 }
2094
2095 return 0;
2096}
2097
2098static int sony_leds_init(struct sony_sc *sc)
2099{
2100 struct hid_device *hdev = sc->hdev;
2101 int n, ret = 0;
2102 int use_ds4_names;
2103 struct led_classdev *led;
2104 size_t name_sz;
2105 char *name;
2106 size_t name_len;
2107 const char *name_fmt;
2108 static const char * const ds4_name_str[] = { "red", "green", "blue",
2109 "global" };
2110 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
2111 u8 use_hw_blink[MAX_LEDS] = { 0 };
2112
2113 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
2114
2115 if (sc->quirks & BUZZ_CONTROLLER) {
2116 sc->led_count = 4;
2117 use_ds4_names = 0;
2118 name_len = strlen("::buzz#");
2119 name_fmt = "%s::buzz%d";
2120
2121 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
2122 return -ENODEV;
2123 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2124 dualshock4_set_leds_from_id(sc);
2125 sc->led_state[3] = 1;
2126 sc->led_count = 4;
2127 memset(max_brightness, 255, 3);
2128 use_hw_blink[3] = 1;
2129 use_ds4_names = 1;
2130 name_len = 0;
2131 name_fmt = "%s:%s";
2132 } else if (sc->quirks & MOTION_CONTROLLER) {
2133 sc->led_count = 3;
2134 memset(max_brightness, 255, 3);
2135 use_ds4_names = 1;
2136 name_len = 0;
2137 name_fmt = "%s:%s";
2138 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
2139 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
2140
2141 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2142 sc->led_count = 1;
2143 memset(use_hw_blink, 1, 4);
2144 use_ds4_names = 0;
2145 name_len = strlen("::sony#");
2146 name_fmt = "%s::sony%d";
2147 } else {
2148 sixaxis_set_leds_from_id(sc);
2149 sc->led_count = 4;
2150 memset(use_hw_blink, 1, 4);
2151 use_ds4_names = 0;
2152 name_len = strlen("::sony#");
2153 name_fmt = "%s::sony%d";
2154 }
2155
2156
2157
2158
2159
2160
2161 sony_set_leds(sc);
2162
2163 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2164
2165 for (n = 0; n < sc->led_count; n++) {
2166
2167 if (use_ds4_names)
2168 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2169
2170 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2171 if (!led) {
2172 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2173 return -ENOMEM;
2174 }
2175
2176 name = (void *)(&led[1]);
2177 if (use_ds4_names)
2178 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2179 ds4_name_str[n]);
2180 else
2181 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2182 led->name = name;
2183 led->brightness = sc->led_state[n];
2184 led->max_brightness = max_brightness[n];
2185 led->flags = LED_CORE_SUSPENDRESUME;
2186 led->brightness_get = sony_led_get_brightness;
2187 led->brightness_set = sony_led_set_brightness;
2188
2189 if (use_hw_blink[n])
2190 led->blink_set = sony_led_blink_set;
2191
2192 sc->leds[n] = led;
2193
2194 ret = devm_led_classdev_register(&hdev->dev, led);
2195 if (ret) {
2196 hid_err(hdev, "Failed to register LED %d\n", n);
2197 return ret;
2198 }
2199 }
2200
2201 return 0;
2202}
2203
2204static void sixaxis_send_output_report(struct sony_sc *sc)
2205{
2206 static const union sixaxis_output_report_01 default_report = {
2207 .buf = {
2208 0x01,
2209 0x01, 0xff, 0x00, 0xff, 0x00,
2210 0x00, 0x00, 0x00, 0x00, 0x00,
2211 0xff, 0x27, 0x10, 0x00, 0x32,
2212 0xff, 0x27, 0x10, 0x00, 0x32,
2213 0xff, 0x27, 0x10, 0x00, 0x32,
2214 0xff, 0x27, 0x10, 0x00, 0x32,
2215 0x00, 0x00, 0x00, 0x00, 0x00
2216 }
2217 };
2218 struct sixaxis_output_report *report =
2219 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2220 int n;
2221
2222
2223 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2224
2225#ifdef CONFIG_SONY_FF
2226 report->rumble.right_motor_on = sc->right ? 1 : 0;
2227 report->rumble.left_motor_force = sc->left;
2228#endif
2229
2230 report->leds_bitmap |= sc->led_state[0] << 1;
2231 report->leds_bitmap |= sc->led_state[1] << 2;
2232 report->leds_bitmap |= sc->led_state[2] << 3;
2233 report->leds_bitmap |= sc->led_state[3] << 4;
2234
2235
2236 if ((report->leds_bitmap & 0x1E) == 0)
2237 report->leds_bitmap |= 0x20;
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248 for (n = 0; n < 4; n++) {
2249 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2250 report->led[3 - n].duty_off = sc->led_delay_off[n];
2251 report->led[3 - n].duty_on = sc->led_delay_on[n];
2252 }
2253 }
2254
2255
2256 if (sc->quirks & SHANWAN_GAMEPAD)
2257 hid_hw_output_report(sc->hdev, (u8 *)report,
2258 sizeof(struct sixaxis_output_report));
2259 else
2260 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2261 sizeof(struct sixaxis_output_report),
2262 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2263}
2264
2265static void dualshock4_send_output_report(struct sony_sc *sc)
2266{
2267 struct hid_device *hdev = sc->hdev;
2268 u8 *buf = sc->output_report_dmabuf;
2269 int offset;
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2281 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2282 buf[0] = 0x05;
2283 buf[1] = 0x07;
2284 offset = 4;
2285 } else {
2286 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2287 buf[0] = 0x11;
2288 buf[1] = 0xC0 | sc->ds4_bt_poll_interval;
2289 buf[3] = 0x07;
2290 offset = 6;
2291 }
2292
2293#ifdef CONFIG_SONY_FF
2294 buf[offset++] = sc->right;
2295 buf[offset++] = sc->left;
2296#else
2297 offset += 2;
2298#endif
2299
2300
2301 if (sc->led_state[3]) {
2302 buf[offset++] = sc->led_state[0];
2303 buf[offset++] = sc->led_state[1];
2304 buf[offset++] = sc->led_state[2];
2305 } else {
2306 offset += 3;
2307 }
2308
2309
2310 buf[offset++] = sc->led_delay_on[3];
2311 buf[offset++] = sc->led_delay_off[3];
2312
2313 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2314 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2315 else {
2316
2317 u8 bthdr = 0xA2;
2318 u32 crc;
2319
2320 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2321 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2322 put_unaligned_le32(crc, &buf[74]);
2323 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2324 }
2325}
2326
2327static void motion_send_output_report(struct sony_sc *sc)
2328{
2329 struct hid_device *hdev = sc->hdev;
2330 struct motion_output_report_02 *report =
2331 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2332
2333 memset(report, 0, MOTION_REPORT_0x02_SIZE);
2334
2335 report->type = 0x02;
2336 report->r = sc->led_state[0];
2337 report->g = sc->led_state[1];
2338 report->b = sc->led_state[2];
2339
2340#ifdef CONFIG_SONY_FF
2341 report->rumble = max(sc->right, sc->left);
2342#endif
2343
2344 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2345}
2346
2347static inline void sony_send_output_report(struct sony_sc *sc)
2348{
2349 if (sc->send_output_report)
2350 sc->send_output_report(sc);
2351}
2352
2353static void sony_state_worker(struct work_struct *work)
2354{
2355 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2356
2357 sc->send_output_report(sc);
2358}
2359
2360static int sony_allocate_output_report(struct sony_sc *sc)
2361{
2362 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2363 (sc->quirks & NAVIGATION_CONTROLLER))
2364 sc->output_report_dmabuf =
2365 devm_kmalloc(&sc->hdev->dev,
2366 sizeof(union sixaxis_output_report_01),
2367 GFP_KERNEL);
2368 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2369 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2370 DS4_OUTPUT_REPORT_0x11_SIZE,
2371 GFP_KERNEL);
2372 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2373 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2374 DS4_OUTPUT_REPORT_0x05_SIZE,
2375 GFP_KERNEL);
2376 else if (sc->quirks & MOTION_CONTROLLER)
2377 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2378 MOTION_REPORT_0x02_SIZE,
2379 GFP_KERNEL);
2380 else
2381 return 0;
2382
2383 if (!sc->output_report_dmabuf)
2384 return -ENOMEM;
2385
2386 return 0;
2387}
2388
2389#ifdef CONFIG_SONY_FF
2390static int sony_play_effect(struct input_dev *dev, void *data,
2391 struct ff_effect *effect)
2392{
2393 struct hid_device *hid = input_get_drvdata(dev);
2394 struct sony_sc *sc = hid_get_drvdata(hid);
2395
2396 if (effect->type != FF_RUMBLE)
2397 return 0;
2398
2399 sc->left = effect->u.rumble.strong_magnitude / 256;
2400 sc->right = effect->u.rumble.weak_magnitude / 256;
2401
2402 sony_schedule_work(sc, SONY_WORKER_STATE);
2403 return 0;
2404}
2405
2406static int sony_init_ff(struct sony_sc *sc)
2407{
2408 struct hid_input *hidinput;
2409 struct input_dev *input_dev;
2410
2411 if (list_empty(&sc->hdev->inputs)) {
2412 hid_err(sc->hdev, "no inputs found\n");
2413 return -ENODEV;
2414 }
2415 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2416 input_dev = hidinput->input;
2417
2418 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2419 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2420}
2421
2422#else
2423static int sony_init_ff(struct sony_sc *sc)
2424{
2425 return 0;
2426}
2427
2428#endif
2429
2430static int sony_battery_get_property(struct power_supply *psy,
2431 enum power_supply_property psp,
2432 union power_supply_propval *val)
2433{
2434 struct sony_sc *sc = power_supply_get_drvdata(psy);
2435 unsigned long flags;
2436 int ret = 0;
2437 u8 battery_capacity;
2438 int battery_status;
2439
2440 spin_lock_irqsave(&sc->lock, flags);
2441 battery_capacity = sc->battery_capacity;
2442 battery_status = sc->battery_status;
2443 spin_unlock_irqrestore(&sc->lock, flags);
2444
2445 switch (psp) {
2446 case POWER_SUPPLY_PROP_PRESENT:
2447 val->intval = 1;
2448 break;
2449 case POWER_SUPPLY_PROP_SCOPE:
2450 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2451 break;
2452 case POWER_SUPPLY_PROP_CAPACITY:
2453 val->intval = battery_capacity;
2454 break;
2455 case POWER_SUPPLY_PROP_STATUS:
2456 val->intval = battery_status;
2457 break;
2458 default:
2459 ret = -EINVAL;
2460 break;
2461 }
2462 return ret;
2463}
2464
2465static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2466{
2467 const char *battery_str_fmt = append_dev_id ?
2468 "sony_controller_battery_%pMR_%i" :
2469 "sony_controller_battery_%pMR";
2470 struct power_supply_config psy_cfg = { .drv_data = sc, };
2471 struct hid_device *hdev = sc->hdev;
2472 int ret;
2473
2474
2475
2476
2477
2478 sc->battery_capacity = 100;
2479
2480 sc->battery_desc.properties = sony_battery_props;
2481 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2482 sc->battery_desc.get_property = sony_battery_get_property;
2483 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2484 sc->battery_desc.use_for_apm = 0;
2485 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2486 battery_str_fmt, sc->mac_address, sc->device_id);
2487 if (!sc->battery_desc.name)
2488 return -ENOMEM;
2489
2490 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2491 &psy_cfg);
2492 if (IS_ERR(sc->battery)) {
2493 ret = PTR_ERR(sc->battery);
2494 hid_err(hdev, "Unable to register battery device\n");
2495 return ret;
2496 }
2497
2498 power_supply_powers(sc->battery, &hdev->dev);
2499 return 0;
2500}
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513static inline int sony_compare_connection_type(struct sony_sc *sc0,
2514 struct sony_sc *sc1)
2515{
2516 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2517 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2518
2519 return sc0_not_bt == sc1_not_bt;
2520}
2521
2522static int sony_check_add_dev_list(struct sony_sc *sc)
2523{
2524 struct sony_sc *entry;
2525 unsigned long flags;
2526 int ret;
2527
2528 spin_lock_irqsave(&sony_dev_list_lock, flags);
2529
2530 list_for_each_entry(entry, &sony_device_list, list_node) {
2531 ret = memcmp(sc->mac_address, entry->mac_address,
2532 sizeof(sc->mac_address));
2533 if (!ret) {
2534 if (sony_compare_connection_type(sc, entry)) {
2535 ret = 1;
2536 } else {
2537 ret = -EEXIST;
2538 hid_info(sc->hdev,
2539 "controller with MAC address %pMR already connected\n",
2540 sc->mac_address);
2541 }
2542 goto unlock;
2543 }
2544 }
2545
2546 ret = 0;
2547 list_add(&(sc->list_node), &sony_device_list);
2548
2549unlock:
2550 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2551 return ret;
2552}
2553
2554static void sony_remove_dev_list(struct sony_sc *sc)
2555{
2556 unsigned long flags;
2557
2558 if (sc->list_node.next) {
2559 spin_lock_irqsave(&sony_dev_list_lock, flags);
2560 list_del(&(sc->list_node));
2561 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2562 }
2563}
2564
2565static int sony_get_bt_devaddr(struct sony_sc *sc)
2566{
2567 int ret;
2568
2569
2570 ret = strlen(sc->hdev->uniq);
2571 if (ret != 17)
2572 return -EINVAL;
2573
2574 ret = sscanf(sc->hdev->uniq,
2575 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2576 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2577 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2578
2579 if (ret != 6)
2580 return -EINVAL;
2581
2582 return 0;
2583}
2584
2585static int sony_check_add(struct sony_sc *sc)
2586{
2587 u8 *buf = NULL;
2588 int n, ret;
2589
2590 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2591 (sc->quirks & MOTION_CONTROLLER_BT) ||
2592 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2593 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2594
2595
2596
2597
2598
2599
2600 if (sony_get_bt_devaddr(sc) < 0) {
2601 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2602 return 0;
2603 }
2604 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2605 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2606 if (!buf)
2607 return -ENOMEM;
2608
2609
2610
2611
2612
2613
2614 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2615 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2616 HID_REQ_GET_REPORT);
2617
2618 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2619 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2620 ret = ret < 0 ? ret : -EINVAL;
2621 goto out_free;
2622 }
2623
2624 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2625
2626 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2627 "%pMR", sc->mac_address);
2628 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2629 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2630 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2631 if (!buf)
2632 return -ENOMEM;
2633
2634
2635
2636
2637
2638
2639 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2640 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2641 HID_REQ_GET_REPORT);
2642
2643 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2644 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2645 ret = ret < 0 ? ret : -EINVAL;
2646 goto out_free;
2647 }
2648
2649
2650
2651
2652
2653 for (n = 0; n < 6; n++)
2654 sc->mac_address[5-n] = buf[4+n];
2655
2656 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2657 "%pMR", sc->mac_address);
2658 } else {
2659 return 0;
2660 }
2661
2662 ret = sony_check_add_dev_list(sc);
2663
2664out_free:
2665
2666 kfree(buf);
2667
2668 return ret;
2669}
2670
2671static int sony_set_device_id(struct sony_sc *sc)
2672{
2673 int ret;
2674
2675
2676
2677
2678
2679 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2680 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2681 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2682 GFP_KERNEL);
2683 if (ret < 0) {
2684 sc->device_id = -1;
2685 return ret;
2686 }
2687 sc->device_id = ret;
2688 } else {
2689 sc->device_id = -1;
2690 }
2691
2692 return 0;
2693}
2694
2695static void sony_release_device_id(struct sony_sc *sc)
2696{
2697 if (sc->device_id >= 0) {
2698 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2699 sc->device_id = -1;
2700 }
2701}
2702
2703static inline void sony_init_output_report(struct sony_sc *sc,
2704 void (*send_output_report)(struct sony_sc *))
2705{
2706 sc->send_output_report = send_output_report;
2707
2708 if (!sc->state_worker_initialized)
2709 INIT_WORK(&sc->state_worker, sony_state_worker);
2710
2711 sc->state_worker_initialized = 1;
2712}
2713
2714static inline void sony_cancel_work_sync(struct sony_sc *sc)
2715{
2716 unsigned long flags;
2717
2718 if (sc->hotplug_worker_initialized)
2719 cancel_work_sync(&sc->hotplug_worker);
2720 if (sc->state_worker_initialized) {
2721 spin_lock_irqsave(&sc->lock, flags);
2722 sc->state_worker_initialized = 0;
2723 spin_unlock_irqrestore(&sc->lock, flags);
2724 cancel_work_sync(&sc->state_worker);
2725 }
2726}
2727
2728static int sony_input_configured(struct hid_device *hdev,
2729 struct hid_input *hidinput)
2730{
2731 struct sony_sc *sc = hid_get_drvdata(hdev);
2732 int append_dev_id;
2733 int ret;
2734
2735 ret = sony_set_device_id(sc);
2736 if (ret < 0) {
2737 hid_err(hdev, "failed to allocate the device id\n");
2738 goto err_stop;
2739 }
2740
2741 ret = append_dev_id = sony_check_add(sc);
2742 if (ret < 0)
2743 goto err_stop;
2744
2745 ret = sony_allocate_output_report(sc);
2746 if (ret < 0) {
2747 hid_err(hdev, "failed to allocate the output report buffer\n");
2748 goto err_stop;
2749 }
2750
2751 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2769 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2770 sc->defer_initialization = 1;
2771
2772 ret = sixaxis_set_operational_usb(hdev);
2773 if (ret < 0) {
2774 hid_err(hdev, "Failed to set controller into operational mode\n");
2775 goto err_stop;
2776 }
2777
2778 sony_init_output_report(sc, sixaxis_send_output_report);
2779 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2780
2781
2782
2783
2784 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2785
2786 ret = sixaxis_set_operational_bt(hdev);
2787 if (ret < 0) {
2788 hid_err(hdev, "Failed to set controller into operational mode\n");
2789 goto err_stop;
2790 }
2791
2792 sony_init_output_report(sc, sixaxis_send_output_report);
2793 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2794
2795
2796
2797
2798
2799
2800 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2801 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2802 sc->defer_initialization = 1;
2803
2804 ret = sixaxis_set_operational_usb(hdev);
2805 if (ret < 0) {
2806 hid_err(hdev, "Failed to set controller into operational mode\n");
2807 goto err_stop;
2808 }
2809
2810 ret = sony_register_sensors(sc);
2811 if (ret) {
2812 hid_err(sc->hdev,
2813 "Unable to initialize motion sensors: %d\n", ret);
2814 goto err_stop;
2815 }
2816
2817 sony_init_output_report(sc, sixaxis_send_output_report);
2818 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2819
2820
2821
2822
2823 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2824
2825 ret = sixaxis_set_operational_bt(hdev);
2826 if (ret < 0) {
2827 hid_err(hdev, "Failed to set controller into operational mode\n");
2828 goto err_stop;
2829 }
2830
2831 ret = sony_register_sensors(sc);
2832 if (ret) {
2833 hid_err(sc->hdev,
2834 "Unable to initialize motion sensors: %d\n", ret);
2835 goto err_stop;
2836 }
2837
2838 sony_init_output_report(sc, sixaxis_send_output_report);
2839 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2840 ret = dualshock4_get_calibration_data(sc);
2841 if (ret < 0) {
2842 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2843 goto err_stop;
2844 }
2845
2846 ret = dualshock4_get_version_info(sc);
2847 if (ret < 0) {
2848 hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2849 goto err_stop;
2850 }
2851
2852 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2853 if (ret) {
2854 hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2855 goto err_stop;
2856 }
2857 sc->fw_version_created = true;
2858
2859 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2860 if (ret) {
2861 hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2862 goto err_stop;
2863 }
2864 sc->hw_version_created = true;
2865
2866
2867
2868
2869
2870 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2871 if (ret) {
2872 hid_err(sc->hdev,
2873 "Unable to initialize multi-touch slots: %d\n",
2874 ret);
2875 goto err_stop;
2876 }
2877
2878 ret = sony_register_sensors(sc);
2879 if (ret) {
2880 hid_err(sc->hdev,
2881 "Unable to initialize motion sensors: %d\n", ret);
2882 goto err_stop;
2883 }
2884
2885 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2886 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2887 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2888 if (ret)
2889 hid_warn(sc->hdev,
2890 "can't create sysfs bt_poll_interval attribute err: %d\n",
2891 ret);
2892 }
2893
2894 if (sc->quirks & DUALSHOCK4_DONGLE) {
2895 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2896 sc->hotplug_worker_initialized = 1;
2897 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2898 }
2899
2900 sony_init_output_report(sc, dualshock4_send_output_report);
2901 } else if (sc->quirks & NSG_MRXU_REMOTE) {
2902
2903
2904
2905
2906 ret = sony_register_touchpad(sc, 2,
2907 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2908 if (ret) {
2909 hid_err(sc->hdev,
2910 "Unable to initialize multi-touch slots: %d\n",
2911 ret);
2912 goto err_stop;
2913 }
2914
2915 } else if (sc->quirks & MOTION_CONTROLLER) {
2916 sony_init_output_report(sc, motion_send_output_report);
2917 } else {
2918 ret = 0;
2919 }
2920
2921 if (sc->quirks & SONY_LED_SUPPORT) {
2922 ret = sony_leds_init(sc);
2923 if (ret < 0)
2924 goto err_stop;
2925 }
2926
2927 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2928 ret = sony_battery_probe(sc, append_dev_id);
2929 if (ret < 0)
2930 goto err_stop;
2931
2932
2933 ret = hid_hw_open(hdev);
2934 if (ret < 0) {
2935 hid_err(hdev, "hw open failed\n");
2936 goto err_stop;
2937 }
2938 }
2939
2940 if (sc->quirks & SONY_FF_SUPPORT) {
2941 ret = sony_init_ff(sc);
2942 if (ret < 0)
2943 goto err_close;
2944 }
2945
2946 return 0;
2947err_close:
2948 hid_hw_close(hdev);
2949err_stop:
2950
2951
2952
2953
2954 if (sc->ds4_bt_poll_interval)
2955 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2956 if (sc->fw_version_created)
2957 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2958 if (sc->hw_version_created)
2959 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2960 sony_cancel_work_sync(sc);
2961 sony_remove_dev_list(sc);
2962 sony_release_device_id(sc);
2963 return ret;
2964}
2965
2966static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2967{
2968 int ret;
2969 unsigned long quirks = id->driver_data;
2970 struct sony_sc *sc;
2971 struct usb_device *usbdev;
2972 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2973
2974 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2975 quirks |= FUTUREMAX_DANCE_MAT;
2976
2977 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad"))
2978 quirks |= SHANWAN_GAMEPAD;
2979
2980 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2981 if (sc == NULL) {
2982 hid_err(hdev, "can't alloc sony descriptor\n");
2983 return -ENOMEM;
2984 }
2985
2986 spin_lock_init(&sc->lock);
2987
2988 sc->quirks = quirks;
2989 hid_set_drvdata(hdev, sc);
2990 sc->hdev = hdev;
2991 usbdev = to_usb_device(sc->hdev->dev.parent->parent);
2992
2993 ret = hid_parse(hdev);
2994 if (ret) {
2995 hid_err(hdev, "parse failed\n");
2996 return ret;
2997 }
2998
2999 if (sc->quirks & VAIO_RDESC_CONSTANT)
3000 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3001 else if (sc->quirks & SIXAXIS_CONTROLLER)
3002 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3003
3004
3005
3006
3007
3008
3009
3010 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
3011 hdev->version |= 0x8000;
3012
3013 ret = hid_hw_start(hdev, connect_mask);
3014 if (ret) {
3015 hid_err(hdev, "hw start failed\n");
3016 return ret;
3017 }
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
3028 hid_err(hdev, "failed to claim input\n");
3029 hid_hw_stop(hdev);
3030 return -ENODEV;
3031 }
3032
3033 if (sc->quirks & GHL_GUITAR_PS3WIIU) {
3034 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
3035 if (!sc->ghl_urb)
3036 return -ENOMEM;
3037 ret = ghl_init_urb(sc, usbdev);
3038 if (ret) {
3039 hid_err(hdev, "error preparing URB\n");
3040 return ret;
3041 }
3042
3043 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
3044 mod_timer(&sc->ghl_poke_timer,
3045 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
3046 }
3047
3048 return ret;
3049}
3050
3051static void sony_remove(struct hid_device *hdev)
3052{
3053 struct sony_sc *sc = hid_get_drvdata(hdev);
3054
3055 if (sc->quirks & GHL_GUITAR_PS3WIIU) {
3056 del_timer_sync(&sc->ghl_poke_timer);
3057 usb_free_urb(sc->ghl_urb);
3058 }
3059
3060 hid_hw_close(hdev);
3061
3062 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
3063 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
3064
3065 if (sc->fw_version_created)
3066 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
3067
3068 if (sc->hw_version_created)
3069 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
3070
3071 sony_cancel_work_sync(sc);
3072
3073 sony_remove_dev_list(sc);
3074
3075 sony_release_device_id(sc);
3076
3077 hid_hw_stop(hdev);
3078}
3079
3080#ifdef CONFIG_PM
3081
3082static int sony_suspend(struct hid_device *hdev, pm_message_t message)
3083{
3084#ifdef CONFIG_SONY_FF
3085
3086
3087 if (SONY_FF_SUPPORT) {
3088 struct sony_sc *sc = hid_get_drvdata(hdev);
3089
3090 sc->left = sc->right = 0;
3091 sony_send_output_report(sc);
3092 }
3093
3094#endif
3095 return 0;
3096}
3097
3098static int sony_resume(struct hid_device *hdev)
3099{
3100 struct sony_sc *sc = hid_get_drvdata(hdev);
3101
3102
3103
3104
3105
3106 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
3107 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
3108 sixaxis_set_operational_usb(sc->hdev);
3109 sc->defer_initialization = 1;
3110 }
3111
3112 return 0;
3113}
3114
3115#endif
3116
3117static const struct hid_device_id sony_devices[] = {
3118 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3119 .driver_data = SIXAXIS_CONTROLLER_USB },
3120 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
3121 .driver_data = NAVIGATION_CONTROLLER_USB },
3122 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
3123 .driver_data = NAVIGATION_CONTROLLER_BT },
3124 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
3125 .driver_data = MOTION_CONTROLLER_USB },
3126 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
3127 .driver_data = MOTION_CONTROLLER_BT },
3128 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3129 .driver_data = SIXAXIS_CONTROLLER_BT },
3130 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
3131 .driver_data = VAIO_RDESC_CONSTANT },
3132 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
3133 .driver_data = VAIO_RDESC_CONSTANT },
3134
3135
3136
3137
3138 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
3139 .driver_data = BUZZ_CONTROLLER },
3140 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
3141 .driver_data = BUZZ_CONTROLLER },
3142
3143 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
3144 .driver_data = PS3REMOTE },
3145
3146 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
3147 .driver_data = PS3REMOTE },
3148
3149 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
3150 .driver_data = PS3REMOTE },
3151
3152 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3153 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3154 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3155 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3156 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3157 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3158 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3159 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3160 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
3161 .driver_data = DUALSHOCK4_DONGLE },
3162
3163 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
3164 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
3165
3166 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3167 .driver_data = NSG_MR5U_REMOTE_BT },
3168
3169 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3170 .driver_data = NSG_MR7U_REMOTE_BT },
3171
3172 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
3173 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
3174
3175 { HID_USB_DEVICE(USB_VENDOR_ID_ACTIVISION, USB_DEVICE_ID_ACTIVISION_GUITAR_DONGLE),
3176 .driver_data = GH_GUITAR_CONTROLLER },
3177
3178 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
3179 .driver_data = GH_GUITAR_CONTROLLER },
3180 { }
3181};
3182MODULE_DEVICE_TABLE(hid, sony_devices);
3183
3184static struct hid_driver sony_driver = {
3185 .name = "sony",
3186 .id_table = sony_devices,
3187 .input_mapping = sony_mapping,
3188 .input_configured = sony_input_configured,
3189 .probe = sony_probe,
3190 .remove = sony_remove,
3191 .report_fixup = sony_report_fixup,
3192 .raw_event = sony_raw_event,
3193
3194#ifdef CONFIG_PM
3195 .suspend = sony_suspend,
3196 .resume = sony_resume,
3197 .reset_resume = sony_resume,
3198#endif
3199};
3200
3201static int __init sony_init(void)
3202{
3203 dbg_hid("Sony:%s\n", __func__);
3204
3205 return hid_register_driver(&sony_driver);
3206}
3207
3208static void __exit sony_exit(void)
3209{
3210 dbg_hid("Sony:%s\n", __func__);
3211
3212 hid_unregister_driver(&sony_driver);
3213 ida_destroy(&sony_device_id_allocator);
3214}
3215module_init(sony_init);
3216module_exit(sony_exit);
3217
3218MODULE_LICENSE("GPL");
3219