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