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
40#include "hid-ids.h"
41
42#define VAIO_RDESC_CONSTANT BIT(0)
43#define SIXAXIS_CONTROLLER_USB BIT(1)
44#define SIXAXIS_CONTROLLER_BT BIT(2)
45#define BUZZ_CONTROLLER BIT(3)
46#define PS3REMOTE BIT(4)
47#define DUALSHOCK4_CONTROLLER_USB BIT(5)
48#define DUALSHOCK4_CONTROLLER_BT BIT(6)
49#define MOTION_CONTROLLER_USB BIT(7)
50#define MOTION_CONTROLLER_BT BIT(8)
51#define NAVIGATION_CONTROLLER_USB BIT(9)
52#define NAVIGATION_CONTROLLER_BT BIT(10)
53#define SINO_LITE_CONTROLLER BIT(11)
54
55#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
56#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
57#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
58 NAVIGATION_CONTROLLER_BT)
59#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
60 DUALSHOCK4_CONTROLLER_BT)
61#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
62 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
63 NAVIGATION_CONTROLLER)
64#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
65 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
66#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
67 MOTION_CONTROLLER)
68
69#define MAX_LEDS 4
70
71
72
73
74
75
76
77
78static u8 sixaxis_rdesc[] = {
79 0x05, 0x01,
80 0x09, 0x04,
81 0xA1, 0x01,
82 0xA1, 0x02,
83 0x85, 0x01,
84 0x75, 0x08,
85 0x95, 0x01,
86 0x15, 0x00,
87 0x26, 0xFF, 0x00,
88 0x81, 0x03,
89 0x75, 0x01,
90 0x95, 0x13,
91 0x15, 0x00,
92 0x25, 0x01,
93 0x35, 0x00,
94 0x45, 0x01,
95 0x05, 0x09,
96 0x19, 0x01,
97 0x29, 0x13,
98 0x81, 0x02,
99 0x75, 0x01,
100 0x95, 0x0D,
101 0x06, 0x00, 0xFF,
102 0x81, 0x03,
103 0x15, 0x00,
104 0x26, 0xFF, 0x00,
105 0x05, 0x01,
106 0x09, 0x01,
107 0xA1, 0x00,
108 0x75, 0x08,
109 0x95, 0x04,
110 0x35, 0x00,
111 0x46, 0xFF, 0x00,
112 0x09, 0x30,
113 0x09, 0x31,
114 0x09, 0x32,
115 0x09, 0x35,
116 0x81, 0x02,
117 0xC0,
118 0x05, 0x01,
119 0x95, 0x13,
120 0x09, 0x01,
121 0x81, 0x02,
122 0x95, 0x0C,
123 0x81, 0x01,
124 0x75, 0x10,
125 0x95, 0x04,
126 0x26, 0xFF, 0x03,
127 0x46, 0xFF, 0x03,
128 0x09, 0x01,
129 0x81, 0x02,
130 0xC0,
131 0xA1, 0x02,
132 0x85, 0x02,
133 0x75, 0x08,
134 0x95, 0x30,
135 0x09, 0x01,
136 0xB1, 0x02,
137 0xC0,
138 0xA1, 0x02,
139 0x85, 0xEE,
140 0x75, 0x08,
141 0x95, 0x30,
142 0x09, 0x01,
143 0xB1, 0x02,
144 0xC0,
145 0xA1, 0x02,
146 0x85, 0xEF,
147 0x75, 0x08,
148 0x95, 0x30,
149 0x09, 0x01,
150 0xB1, 0x02,
151 0xC0,
152 0xC0
153};
154
155
156static u8 motion_rdesc[] = {
157 0x05, 0x01,
158 0x09, 0x04,
159 0xA1, 0x01,
160 0xA1, 0x02,
161 0x85, 0x01,
162 0x75, 0x01,
163 0x95, 0x15,
164 0x15, 0x00,
165 0x25, 0x01,
166 0x35, 0x00,
167 0x45, 0x01,
168 0x05, 0x09,
169 0x19, 0x01,
170 0x29, 0x15,
171 0x81, 0x02,
172 0x95, 0x0B,
173 0x06, 0x00, 0xFF,
174 0x81, 0x03,
175 0x15, 0x00,
176 0x26, 0xFF, 0x00,
177 0x05, 0x01,
178 0xA1, 0x00,
179 0x75, 0x08,
180 0x95, 0x01,
181 0x35, 0x00,
182 0x46, 0xFF, 0x00,
183 0x09, 0x30,
184 0x81, 0x02,
185 0xC0,
186 0x06, 0x00, 0xFF,
187 0x75, 0x08,
188 0x95, 0x07,
189 0x81, 0x02,
190 0x05, 0x01,
191 0x75, 0x10,
192 0x46, 0xFF, 0xFF,
193 0x27, 0xFF, 0xFF, 0x00, 0x00,
194 0x95, 0x03,
195 0x09, 0x33,
196 0x09, 0x34,
197 0x09, 0x35,
198 0x81, 0x02,
199 0x06, 0x00, 0xFF,
200 0x95, 0x03,
201 0x81, 0x02,
202 0x05, 0x01,
203 0x09, 0x01,
204 0x95, 0x03,
205 0x81, 0x02,
206 0x06, 0x00, 0xFF,
207 0x95, 0x03,
208 0x81, 0x02,
209 0x75, 0x0C,
210 0x46, 0xFF, 0x0F,
211 0x26, 0xFF, 0x0F,
212 0x95, 0x04,
213 0x81, 0x02,
214 0x75, 0x08,
215 0x46, 0xFF, 0x00,
216 0x26, 0xFF, 0x00,
217 0x95, 0x06,
218 0x81, 0x02,
219 0x75, 0x08,
220 0x95, 0x30,
221 0x09, 0x01,
222 0x91, 0x02,
223 0x75, 0x08,
224 0x95, 0x30,
225 0x09, 0x01,
226 0xB1, 0x02,
227 0xC0,
228 0xA1, 0x02,
229 0x85, 0x02,
230 0x75, 0x08,
231 0x95, 0x30,
232 0x09, 0x01,
233 0xB1, 0x02,
234 0xC0,
235 0xA1, 0x02,
236 0x85, 0xEE,
237 0x75, 0x08,
238 0x95, 0x30,
239 0x09, 0x01,
240 0xB1, 0x02,
241 0xC0,
242 0xA1, 0x02,
243 0x85, 0xEF,
244 0x75, 0x08,
245 0x95, 0x30,
246 0x09, 0x01,
247 0xB1, 0x02,
248 0xC0,
249 0xC0
250};
251
252
253static u8 navigation_rdesc[] = {
254 0x05, 0x01,
255 0x09, 0x04,
256 0xA1, 0x01,
257 0xA1, 0x02,
258 0x85, 0x01,
259 0x75, 0x08,
260 0x95, 0x01,
261 0x15, 0x00,
262 0x26, 0xFF, 0x00,
263 0x81, 0x03,
264 0x75, 0x01,
265 0x95, 0x13,
266 0x15, 0x00,
267 0x25, 0x01,
268 0x35, 0x00,
269 0x45, 0x01,
270 0x05, 0x09,
271 0x19, 0x01,
272 0x29, 0x13,
273 0x81, 0x02,
274 0x75, 0x01,
275 0x95, 0x0D,
276 0x06, 0x00, 0xFF,
277 0x81, 0x03,
278 0x15, 0x00,
279 0x26, 0xFF, 0x00,
280 0x05, 0x01,
281 0x09, 0x01,
282 0xA1, 0x00,
283 0x75, 0x08,
284 0x95, 0x02,
285 0x35, 0x00,
286 0x46, 0xFF, 0x00,
287 0x09, 0x30,
288 0x09, 0x31,
289 0x81, 0x02,
290 0xC0,
291 0x06, 0x00, 0xFF,
292 0x95, 0x06,
293 0x81, 0x03,
294 0x05, 0x01,
295 0x75, 0x08,
296 0x95, 0x05,
297 0x09, 0x01,
298 0x81, 0x02,
299 0x06, 0x00, 0xFF,
300 0x95, 0x01,
301 0x81, 0x02,
302 0x05, 0x01,
303 0x95, 0x01,
304 0x09, 0x01,
305 0x81, 0x02,
306 0x06, 0x00, 0xFF,
307 0x95, 0x1E,
308 0x81, 0x02,
309 0x75, 0x08,
310 0x95, 0x30,
311 0x09, 0x01,
312 0x91, 0x02,
313 0x75, 0x08,
314 0x95, 0x30,
315 0x09, 0x01,
316 0xB1, 0x02,
317 0xC0,
318 0xA1, 0x02,
319 0x85, 0x02,
320 0x75, 0x08,
321 0x95, 0x30,
322 0x09, 0x01,
323 0xB1, 0x02,
324 0xC0,
325 0xA1, 0x02,
326 0x85, 0xEE,
327 0x75, 0x08,
328 0x95, 0x30,
329 0x09, 0x01,
330 0xB1, 0x02,
331 0xC0,
332 0xA1, 0x02,
333 0x85, 0xEF,
334 0x75, 0x08,
335 0x95, 0x30,
336 0x09, 0x01,
337 0xB1, 0x02,
338 0xC0,
339 0xC0
340};
341
342
343
344
345
346
347
348static u8 dualshock4_usb_rdesc[] = {
349 0x05, 0x01,
350 0x09, 0x05,
351 0xA1, 0x01,
352 0x85, 0x01,
353 0x09, 0x30,
354 0x09, 0x31,
355 0x09, 0x32,
356 0x09, 0x35,
357 0x15, 0x00,
358 0x26, 0xFF, 0x00,
359 0x75, 0x08,
360 0x95, 0x04,
361 0x81, 0x02,
362 0x09, 0x39,
363 0x15, 0x00,
364 0x25, 0x07,
365 0x35, 0x00,
366 0x46, 0x3B, 0x01,
367 0x65, 0x14,
368 0x75, 0x04,
369 0x95, 0x01,
370 0x81, 0x42,
371 0x65, 0x00,
372 0x05, 0x09,
373 0x19, 0x01,
374 0x29, 0x0E,
375 0x15, 0x00,
376 0x25, 0x01,
377 0x75, 0x01,
378 0x95, 0x0E,
379 0x81, 0x02,
380 0x06, 0x00, 0xFF,
381 0x09, 0x20,
382 0x75, 0x06,
383 0x95, 0x01,
384 0x15, 0x00,
385 0x25, 0x3F,
386 0x81, 0x02,
387 0x05, 0x01,
388 0x09, 0x33,
389 0x09, 0x34,
390 0x15, 0x00,
391 0x26, 0xFF, 0x00,
392 0x75, 0x08,
393 0x95, 0x02,
394 0x81, 0x02,
395 0x06, 0x00, 0xFF,
396 0x09, 0x21,
397 0x95, 0x03,
398 0x81, 0x02,
399 0x05, 0x01,
400 0x19, 0x40,
401 0x29, 0x42,
402 0x16, 0x00, 0x80,
403 0x26, 0x00, 0x7F,
404 0x75, 0x10,
405 0x95, 0x03,
406 0x81, 0x02,
407 0x19, 0x43,
408 0x29, 0x45,
409 0x16, 0x00, 0xE0,
410 0x26, 0xFF, 0x1F,
411 0x95, 0x03,
412 0x81, 0x02,
413 0x06, 0x00, 0xFF,
414 0x09, 0x21,
415 0x15, 0x00,
416 0x26, 0xFF, 0x00,
417 0x75, 0x08,
418 0x95, 0x27,
419 0x81, 0x02,
420 0x85, 0x05,
421 0x09, 0x22,
422 0x95, 0x1F,
423 0x91, 0x02,
424 0x85, 0x04,
425 0x09, 0x23,
426 0x95, 0x24,
427 0xB1, 0x02,
428 0x85, 0x02,
429 0x09, 0x24,
430 0x95, 0x24,
431 0xB1, 0x02,
432 0x85, 0x08,
433 0x09, 0x25,
434 0x95, 0x03,
435 0xB1, 0x02,
436 0x85, 0x10,
437 0x09, 0x26,
438 0x95, 0x04,
439 0xB1, 0x02,
440 0x85, 0x11,
441 0x09, 0x27,
442 0x95, 0x02,
443 0xB1, 0x02,
444 0x85, 0x12,
445 0x06, 0x02, 0xFF,
446 0x09, 0x21,
447 0x95, 0x0F,
448 0xB1, 0x02,
449 0x85, 0x13,
450 0x09, 0x22,
451 0x95, 0x16,
452 0xB1, 0x02,
453 0x85, 0x14,
454 0x06, 0x05, 0xFF,
455 0x09, 0x20,
456 0x95, 0x10,
457 0xB1, 0x02,
458 0x85, 0x15,
459 0x09, 0x21,
460 0x95, 0x2C,
461 0xB1, 0x02,
462 0x06, 0x80, 0xFF,
463 0x85, 0x80,
464 0x09, 0x20,
465 0x95, 0x06,
466 0xB1, 0x02,
467 0x85, 0x81,
468 0x09, 0x21,
469 0x95, 0x06,
470 0xB1, 0x02,
471 0x85, 0x82,
472 0x09, 0x22,
473 0x95, 0x05,
474 0xB1, 0x02,
475 0x85, 0x83,
476 0x09, 0x23,
477 0x95, 0x01,
478 0xB1, 0x02,
479 0x85, 0x84,
480 0x09, 0x24,
481 0x95, 0x04,
482 0xB1, 0x02,
483 0x85, 0x85,
484 0x09, 0x25,
485 0x95, 0x06,
486 0xB1, 0x02,
487 0x85, 0x86,
488 0x09, 0x26,
489 0x95, 0x06,
490 0xB1, 0x02,
491 0x85, 0x87,
492 0x09, 0x27,
493 0x95, 0x23,
494 0xB1, 0x02,
495 0x85, 0x88,
496 0x09, 0x28,
497 0x95, 0x22,
498 0xB1, 0x02,
499 0x85, 0x89,
500 0x09, 0x29,
501 0x95, 0x02,
502 0xB1, 0x02,
503 0x85, 0x90,
504 0x09, 0x30,
505 0x95, 0x05,
506 0xB1, 0x02,
507 0x85, 0x91,
508 0x09, 0x31,
509 0x95, 0x03,
510 0xB1, 0x02,
511 0x85, 0x92,
512 0x09, 0x32,
513 0x95, 0x03,
514 0xB1, 0x02,
515 0x85, 0x93,
516 0x09, 0x33,
517 0x95, 0x0C,
518 0xB1, 0x02,
519 0x85, 0xA0,
520 0x09, 0x40,
521 0x95, 0x06,
522 0xB1, 0x02,
523 0x85, 0xA1,
524 0x09, 0x41,
525 0x95, 0x01,
526 0xB1, 0x02,
527 0x85, 0xA2,
528 0x09, 0x42,
529 0x95, 0x01,
530 0xB1, 0x02,
531 0x85, 0xA3,
532 0x09, 0x43,
533 0x95, 0x30,
534 0xB1, 0x02,
535 0x85, 0xA4,
536 0x09, 0x44,
537 0x95, 0x0D,
538 0xB1, 0x02,
539 0x85, 0xA5,
540 0x09, 0x45,
541 0x95, 0x15,
542 0xB1, 0x02,
543 0x85, 0xA6,
544 0x09, 0x46,
545 0x95, 0x15,
546 0xB1, 0x02,
547 0x85, 0xF0,
548 0x09, 0x47,
549 0x95, 0x3F,
550 0xB1, 0x02,
551 0x85, 0xF1,
552 0x09, 0x48,
553 0x95, 0x3F,
554 0xB1, 0x02,
555 0x85, 0xF2,
556 0x09, 0x49,
557 0x95, 0x0F,
558 0xB1, 0x02,
559 0x85, 0xA7,
560 0x09, 0x4A,
561 0x95, 0x01,
562 0xB1, 0x02,
563 0x85, 0xA8,
564 0x09, 0x4B,
565 0x95, 0x01,
566 0xB1, 0x02,
567 0x85, 0xA9,
568 0x09, 0x4C,
569 0x95, 0x08,
570 0xB1, 0x02,
571 0x85, 0xAA,
572 0x09, 0x4E,
573 0x95, 0x01,
574 0xB1, 0x02,
575 0x85, 0xAB,
576 0x09, 0x4F,
577 0x95, 0x39,
578 0xB1, 0x02,
579 0x85, 0xAC,
580 0x09, 0x50,
581 0x95, 0x39,
582 0xB1, 0x02,
583 0x85, 0xAD,
584 0x09, 0x51,
585 0x95, 0x0B,
586 0xB1, 0x02,
587 0x85, 0xAE,
588 0x09, 0x52,
589 0x95, 0x01,
590 0xB1, 0x02,
591 0x85, 0xAF,
592 0x09, 0x53,
593 0x95, 0x02,
594 0xB1, 0x02,
595 0x85, 0xB0,
596 0x09, 0x54,
597 0x95, 0x3F,
598 0xB1, 0x02,
599 0xC0
600};
601
602
603
604
605
606
607
608
609
610static u8 dualshock4_bt_rdesc[] = {
611 0x05, 0x01,
612 0x09, 0x05,
613 0xA1, 0x01,
614 0x85, 0x01,
615 0x75, 0x08,
616 0x95, 0x0A,
617 0x81, 0x02,
618 0x06, 0x04, 0xFF,
619 0x85, 0x02,
620 0x09, 0x24,
621 0x95, 0x24,
622 0xB1, 0x02,
623 0x85, 0xA3,
624 0x09, 0x25,
625 0x95, 0x30,
626 0xB1, 0x02,
627 0x85, 0x05,
628 0x09, 0x26,
629 0x95, 0x28,
630 0xB1, 0x02,
631 0x85, 0x06,
632 0x09, 0x27,
633 0x95, 0x34,
634 0xB1, 0x02,
635 0x85, 0x07,
636 0x09, 0x28,
637 0x95, 0x30,
638 0xB1, 0x02,
639 0x85, 0x08,
640 0x09, 0x29,
641 0x95, 0x2F,
642 0xB1, 0x02,
643 0x06, 0x03, 0xFF,
644 0x85, 0x03,
645 0x09, 0x21,
646 0x95, 0x26,
647 0xB1, 0x02,
648 0x85, 0x04,
649 0x09, 0x22,
650 0x95, 0x2E,
651 0xB1, 0x02,
652 0x85, 0xF0,
653 0x09, 0x47,
654 0x95, 0x3F,
655 0xB1, 0x02,
656 0x85, 0xF1,
657 0x09, 0x48,
658 0x95, 0x3F,
659 0xB1, 0x02,
660 0x85, 0xF2,
661 0x09, 0x49,
662 0x95, 0x0F,
663 0xB1, 0x02,
664 0x85, 0x11,
665 0x06, 0x00, 0xFF,
666 0x09, 0x20,
667 0x95, 0x02,
668 0x81, 0x02,
669 0x05, 0x01,
670 0x09, 0x30,
671 0x09, 0x31,
672 0x09, 0x32,
673 0x09, 0x35,
674 0x15, 0x00,
675 0x26, 0xFF, 0x00,
676 0x75, 0x08,
677 0x95, 0x04,
678 0x81, 0x02,
679 0x09, 0x39,
680 0x15, 0x00,
681 0x25, 0x07,
682 0x75, 0x04,
683 0x95, 0x01,
684 0x81, 0x42,
685 0x05, 0x09,
686 0x19, 0x01,
687 0x29, 0x0E,
688 0x15, 0x00,
689 0x25, 0x01,
690 0x75, 0x01,
691 0x95, 0x0E,
692 0x81, 0x02,
693 0x75, 0x06,
694 0x95, 0x01,
695 0x81, 0x01,
696 0x05, 0x01,
697 0x09, 0x33,
698 0x09, 0x34,
699 0x15, 0x00,
700 0x26, 0xFF, 0x00,
701 0x75, 0x08,
702 0x95, 0x02,
703 0x81, 0x02,
704 0x06, 0x00, 0xFF,
705 0x09, 0x20,
706 0x95, 0x03,
707 0x81, 0x02,
708 0x05, 0x01,
709 0x19, 0x40,
710 0x29, 0x42,
711 0x16, 0x00, 0x80,
712 0x26, 0x00, 0x7F,
713 0x75, 0x10,
714 0x95, 0x03,
715 0x81, 0x02,
716 0x19, 0x43,
717 0x29, 0x45,
718 0x16, 0x00, 0xE0,
719 0x26, 0xFF, 0x1F,
720 0x95, 0x03,
721 0x81, 0x02,
722 0x06, 0x00, 0xFF,
723 0x09, 0x20,
724 0x15, 0x00,
725 0x26, 0xFF, 0x00,
726 0x75, 0x08,
727 0x95, 0x31,
728 0x81, 0x02,
729 0x09, 0x21,
730 0x75, 0x08,
731 0x95, 0x4D,
732 0x91, 0x02,
733 0x85, 0x12,
734 0x09, 0x22,
735 0x95, 0x8D,
736 0x81, 0x02,
737 0x09, 0x23,
738 0x91, 0x02,
739 0x85, 0x13,
740 0x09, 0x24,
741 0x95, 0xCD,
742 0x81, 0x02,
743 0x09, 0x25,
744 0x91, 0x02,
745 0x85, 0x14,
746 0x09, 0x26,
747 0x96, 0x0D, 0x01,
748 0x81, 0x02,
749 0x09, 0x27,
750 0x91, 0x02,
751 0x85, 0x15,
752 0x09, 0x28,
753 0x96, 0x4D, 0x01,
754 0x81, 0x02,
755 0x09, 0x29,
756 0x91, 0x02,
757 0x85, 0x16,
758 0x09, 0x2A,
759 0x96, 0x8D, 0x01,
760 0x81, 0x02,
761 0x09, 0x2B,
762 0x91, 0x02,
763 0x85, 0x17,
764 0x09, 0x2C,
765 0x96, 0xCD, 0x01,
766 0x81, 0x02,
767 0x09, 0x2D,
768 0x91, 0x02,
769 0x85, 0x18,
770 0x09, 0x2E,
771 0x96, 0x0D, 0x02,
772 0x81, 0x02,
773 0x09, 0x2F,
774 0x91, 0x02,
775 0x85, 0x19,
776 0x09, 0x30,
777 0x96, 0x22, 0x02,
778 0x81, 0x02,
779 0x09, 0x31,
780 0x91, 0x02,
781 0x06, 0x80, 0xFF,
782 0x85, 0x82,
783 0x09, 0x22,
784 0x95, 0x3F,
785 0xB1, 0x02,
786 0x85, 0x83,
787 0x09, 0x23,
788 0xB1, 0x02,
789 0x85, 0x84,
790 0x09, 0x24,
791 0xB1, 0x02,
792 0x85, 0x90,
793 0x09, 0x30,
794 0xB1, 0x02,
795 0x85, 0x91,
796 0x09, 0x31,
797 0xB1, 0x02,
798 0x85, 0x92,
799 0x09, 0x32,
800 0xB1, 0x02,
801 0x85, 0x93,
802 0x09, 0x33,
803 0xB1, 0x02,
804 0x85, 0xA0,
805 0x09, 0x40,
806 0xB1, 0x02,
807 0x85, 0xA4,
808 0x09, 0x44,
809 0xB1, 0x02,
810 0xC0
811};
812
813static u8 ps3remote_rdesc[] = {
814 0x05, 0x01,
815 0x09, 0x05,
816 0xA1, 0x01,
817
818
819 0xA1, 0x02,
820
821
822
823
824
825 0x75, 0x08,
826 0x95, 0x01,
827 0x81, 0x01,
828
829
830
831
832
833 0x05, 0x09,
834 0x19, 0x01,
835 0x29, 0x18,
836 0x14,
837 0x25, 0x01,
838 0x75, 0x01,
839 0x95, 0x18,
840 0x81, 0x02,
841
842 0xC0,
843
844
845 0xA1, 0x02,
846
847
848 0x05, 0x09,
849 0x18,
850 0x29, 0xFE,
851 0x14,
852 0x26, 0xFE, 0x00,
853 0x75, 0x08,
854 0x95, 0x01,
855 0x80,
856
857
858
859
860
861 0x75, 0x08,
862 0x95, 0x06,
863 0x81, 0x01,
864
865
866 0x05, 0x06,
867 0x09, 0x20,
868 0x14,
869 0x25, 0x05,
870 0x75, 0x08,
871 0x95, 0x01,
872 0x81, 0x02,
873
874 0xC0,
875
876 0xC0
877};
878
879static const unsigned int ps3remote_keymap_joypad_buttons[] = {
880 [0x01] = KEY_SELECT,
881 [0x02] = BTN_THUMBL,
882 [0x03] = BTN_THUMBR,
883 [0x04] = BTN_START,
884 [0x05] = KEY_UP,
885 [0x06] = KEY_RIGHT,
886 [0x07] = KEY_DOWN,
887 [0x08] = KEY_LEFT,
888 [0x09] = BTN_TL2,
889 [0x0a] = BTN_TR2,
890 [0x0b] = BTN_TL,
891 [0x0c] = BTN_TR,
892 [0x0d] = KEY_OPTION,
893 [0x0e] = KEY_BACK,
894 [0x0f] = BTN_0,
895 [0x10] = KEY_SCREEN,
896 [0x11] = KEY_HOMEPAGE,
897 [0x14] = KEY_ENTER,
898};
899static const unsigned int ps3remote_keymap_remote_buttons[] = {
900 [0x00] = KEY_1,
901 [0x01] = KEY_2,
902 [0x02] = KEY_3,
903 [0x03] = KEY_4,
904 [0x04] = KEY_5,
905 [0x05] = KEY_6,
906 [0x06] = KEY_7,
907 [0x07] = KEY_8,
908 [0x08] = KEY_9,
909 [0x09] = KEY_0,
910 [0x0e] = KEY_ESC,
911 [0x0f] = KEY_CLEAR,
912 [0x16] = KEY_EJECTCD,
913 [0x1a] = KEY_MENU,
914 [0x28] = KEY_TIME,
915 [0x30] = KEY_PREVIOUS,
916 [0x31] = KEY_NEXT,
917 [0x32] = KEY_PLAY,
918 [0x33] = KEY_REWIND,
919 [0x34] = KEY_FORWARD,
920 [0x38] = KEY_STOP,
921 [0x39] = KEY_PAUSE,
922 [0x40] = KEY_CONTEXT_MENU,
923 [0x60] = KEY_FRAMEBACK,
924 [0x61] = KEY_FRAMEFORWARD,
925 [0x63] = KEY_SUBTITLE,
926 [0x64] = KEY_AUDIO,
927 [0x65] = KEY_ANGLE,
928 [0x70] = KEY_INFO,
929 [0x80] = KEY_BLUE,
930 [0x81] = KEY_RED,
931 [0x82] = KEY_GREEN,
932 [0x83] = KEY_YELLOW,
933};
934
935static const unsigned int buzz_keymap[] = {
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953 [1] = BTN_TRIGGER_HAPPY1,
954 [2] = BTN_TRIGGER_HAPPY2,
955 [3] = BTN_TRIGGER_HAPPY3,
956 [4] = BTN_TRIGGER_HAPPY4,
957 [5] = BTN_TRIGGER_HAPPY5,
958 [6] = BTN_TRIGGER_HAPPY6,
959 [7] = BTN_TRIGGER_HAPPY7,
960 [8] = BTN_TRIGGER_HAPPY8,
961 [9] = BTN_TRIGGER_HAPPY9,
962 [10] = BTN_TRIGGER_HAPPY10,
963 [11] = BTN_TRIGGER_HAPPY11,
964 [12] = BTN_TRIGGER_HAPPY12,
965 [13] = BTN_TRIGGER_HAPPY13,
966 [14] = BTN_TRIGGER_HAPPY14,
967 [15] = BTN_TRIGGER_HAPPY15,
968 [16] = BTN_TRIGGER_HAPPY16,
969 [17] = BTN_TRIGGER_HAPPY17,
970 [18] = BTN_TRIGGER_HAPPY18,
971 [19] = BTN_TRIGGER_HAPPY19,
972 [20] = BTN_TRIGGER_HAPPY20,
973};
974
975static enum power_supply_property sony_battery_props[] = {
976 POWER_SUPPLY_PROP_PRESENT,
977 POWER_SUPPLY_PROP_CAPACITY,
978 POWER_SUPPLY_PROP_SCOPE,
979 POWER_SUPPLY_PROP_STATUS,
980};
981
982struct sixaxis_led {
983 u8 time_enabled;
984 u8 duty_length;
985 u8 enabled;
986 u8 duty_off;
987 u8 duty_on;
988} __packed;
989
990struct sixaxis_rumble {
991 u8 padding;
992 u8 right_duration;
993 u8 right_motor_on;
994 u8 left_duration;
995 u8 left_motor_force;
996} __packed;
997
998struct sixaxis_output_report {
999 u8 report_id;
1000 struct sixaxis_rumble rumble;
1001 u8 padding[4];
1002 u8 leds_bitmap;
1003 struct sixaxis_led led[4];
1004 struct sixaxis_led _reserved;
1005} __packed;
1006
1007union sixaxis_output_report_01 {
1008 struct sixaxis_output_report data;
1009 u8 buf[36];
1010};
1011
1012struct motion_output_report_02 {
1013 u8 type, zero;
1014 u8 r, g, b;
1015 u8 zero2;
1016 u8 rumble;
1017};
1018
1019#define DS4_REPORT_0x02_SIZE 37
1020#define DS4_REPORT_0x05_SIZE 32
1021#define DS4_REPORT_0x11_SIZE 78
1022#define DS4_REPORT_0x81_SIZE 7
1023#define SIXAXIS_REPORT_0xF2_SIZE 17
1024#define SIXAXIS_REPORT_0xF5_SIZE 8
1025#define MOTION_REPORT_0x02_SIZE 49
1026
1027static DEFINE_SPINLOCK(sony_dev_list_lock);
1028static LIST_HEAD(sony_device_list);
1029static DEFINE_IDA(sony_device_id_allocator);
1030
1031struct sony_sc {
1032 spinlock_t lock;
1033 struct list_head list_node;
1034 struct hid_device *hdev;
1035 struct led_classdev *leds[MAX_LEDS];
1036 unsigned long quirks;
1037 struct work_struct state_worker;
1038 void (*send_output_report)(struct sony_sc *);
1039 struct power_supply *battery;
1040 struct power_supply_desc battery_desc;
1041 int device_id;
1042 u8 *output_report_dmabuf;
1043
1044#ifdef CONFIG_SONY_FF
1045 u8 left;
1046 u8 right;
1047#endif
1048
1049 u8 mac_address[6];
1050 u8 worker_initialized;
1051 u8 cable_state;
1052 u8 battery_charging;
1053 u8 battery_capacity;
1054 u8 led_state[MAX_LEDS];
1055 u8 resume_led_state[MAX_LEDS];
1056 u8 led_delay_on[MAX_LEDS];
1057 u8 led_delay_off[MAX_LEDS];
1058 u8 led_count;
1059};
1060
1061static u8 *sixaxis_fixup(struct hid_device *hdev, u8 *rdesc,
1062 unsigned int *rsize)
1063{
1064 *rsize = sizeof(sixaxis_rdesc);
1065 return sixaxis_rdesc;
1066}
1067
1068static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
1069 unsigned int *rsize)
1070{
1071 *rsize = sizeof(motion_rdesc);
1072 return motion_rdesc;
1073}
1074
1075static u8 *navigation_fixup(struct hid_device *hdev, u8 *rdesc,
1076 unsigned int *rsize)
1077{
1078 *rsize = sizeof(navigation_rdesc);
1079 return navigation_rdesc;
1080}
1081
1082static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
1083 unsigned int *rsize)
1084{
1085 *rsize = sizeof(ps3remote_rdesc);
1086 return ps3remote_rdesc;
1087}
1088
1089static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
1090 struct hid_field *field, struct hid_usage *usage,
1091 unsigned long **bit, int *max)
1092{
1093 unsigned int key = usage->hid & HID_USAGE;
1094
1095 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1096 return -1;
1097
1098 switch (usage->collection_index) {
1099 case 1:
1100 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
1101 return -1;
1102
1103 key = ps3remote_keymap_joypad_buttons[key];
1104 if (!key)
1105 return -1;
1106 break;
1107 case 2:
1108 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
1109 return -1;
1110
1111 key = ps3remote_keymap_remote_buttons[key];
1112 if (!key)
1113 return -1;
1114 break;
1115 default:
1116 return -1;
1117 }
1118
1119 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1120 return 1;
1121}
1122
1123static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
1124 unsigned int *rsize)
1125{
1126 struct sony_sc *sc = hid_get_drvdata(hdev);
1127
1128 if (sc->quirks & SINO_LITE_CONTROLLER)
1129 return rdesc;
1130
1131
1132
1133
1134
1135 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
1136
1137
1138
1139 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
1140
1141 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
1142 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
1143
1144 rdesc[55] = 0x06;
1145 }
1146
1147
1148
1149
1150
1151
1152 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1153 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
1154 rdesc = dualshock4_usb_rdesc;
1155 *rsize = sizeof(dualshock4_usb_rdesc);
1156 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1157 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
1158 rdesc = dualshock4_bt_rdesc;
1159 *rsize = sizeof(dualshock4_bt_rdesc);
1160 }
1161
1162 if (sc->quirks & SIXAXIS_CONTROLLER)
1163 return sixaxis_fixup(hdev, rdesc, rsize);
1164
1165 if (sc->quirks & MOTION_CONTROLLER)
1166 return motion_fixup(hdev, rdesc, rsize);
1167
1168 if (sc->quirks & NAVIGATION_CONTROLLER)
1169 return navigation_fixup(hdev, rdesc, rsize);
1170
1171 if (sc->quirks & PS3REMOTE)
1172 return ps3remote_fixup(hdev, rdesc, rsize);
1173
1174 return rdesc;
1175}
1176
1177static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
1178{
1179 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
1180 unsigned long flags;
1181 int offset;
1182 u8 cable_state, battery_capacity, battery_charging;
1183
1184
1185
1186
1187
1188
1189
1190 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1191
1192 if (rd[offset] >= 0xee) {
1193 battery_capacity = 100;
1194 battery_charging = !(rd[offset] & 0x01);
1195 cable_state = 1;
1196 } else {
1197 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
1198 battery_capacity = sixaxis_battery_capacity[index];
1199 battery_charging = 0;
1200 cable_state = 0;
1201 }
1202
1203 spin_lock_irqsave(&sc->lock, flags);
1204 sc->cable_state = cable_state;
1205 sc->battery_capacity = battery_capacity;
1206 sc->battery_charging = battery_charging;
1207 spin_unlock_irqrestore(&sc->lock, flags);
1208}
1209
1210static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
1211{
1212 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1213 struct hid_input, list);
1214 struct input_dev *input_dev = hidinput->input;
1215 unsigned long flags;
1216 int n, offset;
1217 u8 cable_state, battery_capacity, battery_charging;
1218
1219
1220
1221
1222
1223 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
1224
1225
1226
1227
1228
1229 cable_state = (rd[offset] >> 4) & 0x01;
1230 battery_capacity = rd[offset] & 0x0F;
1231
1232
1233
1234
1235
1236
1237 if (!cable_state || battery_capacity > 10)
1238 battery_charging = 0;
1239 else
1240 battery_charging = 1;
1241
1242 if (!cable_state)
1243 battery_capacity++;
1244 if (battery_capacity > 10)
1245 battery_capacity = 10;
1246
1247 battery_capacity *= 10;
1248
1249 spin_lock_irqsave(&sc->lock, flags);
1250 sc->cable_state = cable_state;
1251 sc->battery_capacity = battery_capacity;
1252 sc->battery_charging = battery_charging;
1253 spin_unlock_irqrestore(&sc->lock, flags);
1254
1255 offset += 5;
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266 for (n = 0; n < 2; n++) {
1267 u16 x, y;
1268
1269 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1270 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1271
1272 input_mt_slot(input_dev, n);
1273 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
1274 !(rd[offset] >> 7));
1275 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1276 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1277
1278 offset += 4;
1279 }
1280}
1281
1282static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1283 u8 *rd, int size)
1284{
1285 struct sony_sc *sc = hid_get_drvdata(hdev);
1286
1287
1288
1289
1290
1291 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1292
1293
1294
1295
1296
1297
1298
1299
1300 if (rd[1] == 0xff)
1301 return -EINVAL;
1302
1303 swap(rd[41], rd[42]);
1304 swap(rd[43], rd[44]);
1305 swap(rd[45], rd[46]);
1306 swap(rd[47], rd[48]);
1307
1308 sixaxis_parse_report(sc, rd, size);
1309 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1310 sixaxis_parse_report(sc, rd, size);
1311 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1312 size == 49) {
1313 sixaxis_parse_report(sc, rd, size);
1314 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1315 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1316 && rd[0] == 0x11 && size == 78)) {
1317 dualshock4_parse_report(sc, rd, size);
1318 }
1319
1320 return 0;
1321}
1322
1323static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1324 struct hid_field *field, struct hid_usage *usage,
1325 unsigned long **bit, int *max)
1326{
1327 struct sony_sc *sc = hid_get_drvdata(hdev);
1328
1329 if (sc->quirks & BUZZ_CONTROLLER) {
1330 unsigned int key = usage->hid & HID_USAGE;
1331
1332 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1333 return -1;
1334
1335 switch (usage->collection_index) {
1336 case 1:
1337 if (key >= ARRAY_SIZE(buzz_keymap))
1338 return -1;
1339
1340 key = buzz_keymap[key];
1341 if (!key)
1342 return -1;
1343 break;
1344 default:
1345 return -1;
1346 }
1347
1348 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1349 return 1;
1350 }
1351
1352 if (sc->quirks & PS3REMOTE)
1353 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1354
1355
1356 return 0;
1357}
1358
1359static int sony_register_touchpad(struct hid_input *hi, int touch_count,
1360 int w, int h)
1361{
1362 struct input_dev *input_dev = hi->input;
1363 int ret;
1364
1365 ret = input_mt_init_slots(input_dev, touch_count, 0);
1366 if (ret < 0)
1367 return ret;
1368
1369 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1370 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1371
1372 return 0;
1373}
1374
1375static int sony_input_configured(struct hid_device *hdev,
1376 struct hid_input *hidinput)
1377{
1378 struct sony_sc *sc = hid_get_drvdata(hdev);
1379 int ret;
1380
1381
1382
1383
1384
1385 if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1386 ret = sony_register_touchpad(hidinput, 2, 1920, 942);
1387 if (ret) {
1388 hid_err(sc->hdev,
1389 "Unable to initialize multi-touch slots: %d\n",
1390 ret);
1391 return ret;
1392 }
1393 }
1394
1395 return 0;
1396}
1397
1398
1399
1400
1401
1402
1403static int sixaxis_set_operational_usb(struct hid_device *hdev)
1404{
1405 const int buf_size =
1406 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1407 u8 *buf;
1408 int ret;
1409
1410 buf = kmalloc(buf_size, GFP_KERNEL);
1411 if (!buf)
1412 return -ENOMEM;
1413
1414 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1415 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1416 if (ret < 0) {
1417 hid_err(hdev, "can't set operational mode: step 1\n");
1418 goto out;
1419 }
1420
1421
1422
1423
1424
1425 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1426 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1427 if (ret < 0) {
1428 hid_err(hdev, "can't set operational mode: step 2\n");
1429 goto out;
1430 }
1431
1432 ret = hid_hw_output_report(hdev, buf, 1);
1433 if (ret < 0) {
1434 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1435 ret = 0;
1436 }
1437
1438out:
1439 kfree(buf);
1440
1441 return ret;
1442}
1443
1444static int sixaxis_set_operational_bt(struct hid_device *hdev)
1445{
1446 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1447 u8 *buf;
1448 int ret;
1449
1450 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1451 if (!buf)
1452 return -ENOMEM;
1453
1454 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1455 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1456
1457 kfree(buf);
1458
1459 return ret;
1460}
1461
1462
1463
1464
1465
1466static int dualshock4_set_operational_bt(struct hid_device *hdev)
1467{
1468 u8 *buf;
1469 int ret;
1470
1471 buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1472 if (!buf)
1473 return -ENOMEM;
1474
1475 ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
1476 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1477
1478 kfree(buf);
1479
1480 return ret;
1481}
1482
1483static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1484{
1485 static const u8 sixaxis_leds[10][4] = {
1486 { 0x01, 0x00, 0x00, 0x00 },
1487 { 0x00, 0x01, 0x00, 0x00 },
1488 { 0x00, 0x00, 0x01, 0x00 },
1489 { 0x00, 0x00, 0x00, 0x01 },
1490 { 0x01, 0x00, 0x00, 0x01 },
1491 { 0x00, 0x01, 0x00, 0x01 },
1492 { 0x00, 0x00, 0x01, 0x01 },
1493 { 0x01, 0x00, 0x01, 0x01 },
1494 { 0x00, 0x01, 0x01, 0x01 },
1495 { 0x01, 0x01, 0x01, 0x01 }
1496 };
1497
1498 int id = sc->device_id;
1499
1500 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1501
1502 if (id < 0)
1503 return;
1504
1505 id %= 10;
1506 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1507}
1508
1509static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1510{
1511
1512 static const u8 color_code[7][3] = {
1513 { 0x00, 0x00, 0x01 },
1514 { 0x01, 0x00, 0x00 },
1515 { 0x00, 0x01, 0x00 },
1516 { 0x02, 0x00, 0x01 },
1517 { 0x02, 0x01, 0x00 },
1518 { 0x00, 0x01, 0x01 },
1519 { 0x01, 0x01, 0x01 }
1520 };
1521
1522 int id = sc->device_id;
1523
1524 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1525
1526 if (id < 0)
1527 return;
1528
1529 id %= 7;
1530 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1531}
1532
1533static void buzz_set_leds(struct sony_sc *sc)
1534{
1535 struct hid_device *hdev = sc->hdev;
1536 struct list_head *report_list =
1537 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1538 struct hid_report *report = list_entry(report_list->next,
1539 struct hid_report, list);
1540 s32 *value = report->field[0]->value;
1541
1542 BUILD_BUG_ON(MAX_LEDS < 4);
1543
1544 value[0] = 0x00;
1545 value[1] = sc->led_state[0] ? 0xff : 0x00;
1546 value[2] = sc->led_state[1] ? 0xff : 0x00;
1547 value[3] = sc->led_state[2] ? 0xff : 0x00;
1548 value[4] = sc->led_state[3] ? 0xff : 0x00;
1549 value[5] = 0x00;
1550 value[6] = 0x00;
1551 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1552}
1553
1554static void sony_set_leds(struct sony_sc *sc)
1555{
1556 if (!(sc->quirks & BUZZ_CONTROLLER))
1557 schedule_work(&sc->state_worker);
1558 else
1559 buzz_set_leds(sc);
1560}
1561
1562static void sony_led_set_brightness(struct led_classdev *led,
1563 enum led_brightness value)
1564{
1565 struct device *dev = led->dev->parent;
1566 struct hid_device *hdev = to_hid_device(dev);
1567 struct sony_sc *drv_data;
1568
1569 int n;
1570 int force_update;
1571
1572 drv_data = hid_get_drvdata(hdev);
1573 if (!drv_data) {
1574 hid_err(hdev, "No device data\n");
1575 return;
1576 }
1577
1578
1579
1580
1581
1582
1583
1584
1585 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1586
1587 for (n = 0; n < drv_data->led_count; n++) {
1588 if (led == drv_data->leds[n] && (force_update ||
1589 (value != drv_data->led_state[n] ||
1590 drv_data->led_delay_on[n] ||
1591 drv_data->led_delay_off[n]))) {
1592
1593 drv_data->led_state[n] = value;
1594
1595
1596 drv_data->led_delay_on[n] = 0;
1597 drv_data->led_delay_off[n] = 0;
1598
1599 sony_set_leds(drv_data);
1600 break;
1601 }
1602 }
1603}
1604
1605static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1606{
1607 struct device *dev = led->dev->parent;
1608 struct hid_device *hdev = to_hid_device(dev);
1609 struct sony_sc *drv_data;
1610
1611 int n;
1612
1613 drv_data = hid_get_drvdata(hdev);
1614 if (!drv_data) {
1615 hid_err(hdev, "No device data\n");
1616 return LED_OFF;
1617 }
1618
1619 for (n = 0; n < drv_data->led_count; n++) {
1620 if (led == drv_data->leds[n])
1621 return drv_data->led_state[n];
1622 }
1623
1624 return LED_OFF;
1625}
1626
1627static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1628 unsigned long *delay_off)
1629{
1630 struct device *dev = led->dev->parent;
1631 struct hid_device *hdev = to_hid_device(dev);
1632 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1633 int n;
1634 u8 new_on, new_off;
1635
1636 if (!drv_data) {
1637 hid_err(hdev, "No device data\n");
1638 return -EINVAL;
1639 }
1640
1641
1642 if (*delay_on > 2550)
1643 *delay_on = 2550;
1644 if (*delay_off > 2550)
1645 *delay_off = 2550;
1646
1647
1648 if (!*delay_on && !*delay_off)
1649 *delay_on = *delay_off = 500;
1650
1651 new_on = *delay_on / 10;
1652 new_off = *delay_off / 10;
1653
1654 for (n = 0; n < drv_data->led_count; n++) {
1655 if (led == drv_data->leds[n])
1656 break;
1657 }
1658
1659
1660 if (n >= drv_data->led_count)
1661 return -EINVAL;
1662
1663
1664 if (new_on != drv_data->led_delay_on[n] ||
1665 new_off != drv_data->led_delay_off[n]) {
1666 drv_data->led_delay_on[n] = new_on;
1667 drv_data->led_delay_off[n] = new_off;
1668 schedule_work(&drv_data->state_worker);
1669 }
1670
1671 return 0;
1672}
1673
1674static void sony_leds_remove(struct sony_sc *sc)
1675{
1676 struct led_classdev *led;
1677 int n;
1678
1679 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1680
1681 for (n = 0; n < sc->led_count; n++) {
1682 led = sc->leds[n];
1683 sc->leds[n] = NULL;
1684 if (!led)
1685 continue;
1686 led_classdev_unregister(led);
1687 kfree(led);
1688 }
1689
1690 sc->led_count = 0;
1691}
1692
1693static int sony_leds_init(struct sony_sc *sc)
1694{
1695 struct hid_device *hdev = sc->hdev;
1696 int n, ret = 0;
1697 int use_ds4_names;
1698 struct led_classdev *led;
1699 size_t name_sz;
1700 char *name;
1701 size_t name_len;
1702 const char *name_fmt;
1703 static const char * const ds4_name_str[] = { "red", "green", "blue",
1704 "global" };
1705 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1706 u8 use_hw_blink[MAX_LEDS] = { 0 };
1707
1708 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1709
1710 if (sc->quirks & BUZZ_CONTROLLER) {
1711 sc->led_count = 4;
1712 use_ds4_names = 0;
1713 name_len = strlen("::buzz#");
1714 name_fmt = "%s::buzz%d";
1715
1716 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1717 return -ENODEV;
1718 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1719 dualshock4_set_leds_from_id(sc);
1720 sc->led_state[3] = 1;
1721 sc->led_count = 4;
1722 memset(max_brightness, 255, 3);
1723 use_hw_blink[3] = 1;
1724 use_ds4_names = 1;
1725 name_len = 0;
1726 name_fmt = "%s:%s";
1727 } else if (sc->quirks & MOTION_CONTROLLER) {
1728 sc->led_count = 3;
1729 memset(max_brightness, 255, 3);
1730 use_ds4_names = 1;
1731 name_len = 0;
1732 name_fmt = "%s:%s";
1733 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1734 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1735
1736 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1737 sc->led_count = 1;
1738 memset(use_hw_blink, 1, 4);
1739 use_ds4_names = 0;
1740 name_len = strlen("::sony#");
1741 name_fmt = "%s::sony%d";
1742 } else {
1743 sixaxis_set_leds_from_id(sc);
1744 sc->led_count = 4;
1745 memset(use_hw_blink, 1, 4);
1746 use_ds4_names = 0;
1747 name_len = strlen("::sony#");
1748 name_fmt = "%s::sony%d";
1749 }
1750
1751
1752
1753
1754
1755
1756 sony_set_leds(sc);
1757
1758 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1759
1760 for (n = 0; n < sc->led_count; n++) {
1761
1762 if (use_ds4_names)
1763 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1764
1765 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1766 if (!led) {
1767 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1768 ret = -ENOMEM;
1769 goto error_leds;
1770 }
1771
1772 name = (void *)(&led[1]);
1773 if (use_ds4_names)
1774 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1775 ds4_name_str[n]);
1776 else
1777 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1778 led->name = name;
1779 led->brightness = sc->led_state[n];
1780 led->max_brightness = max_brightness[n];
1781 led->brightness_get = sony_led_get_brightness;
1782 led->brightness_set = sony_led_set_brightness;
1783
1784 if (use_hw_blink[n])
1785 led->blink_set = sony_led_blink_set;
1786
1787 sc->leds[n] = led;
1788
1789 ret = led_classdev_register(&hdev->dev, led);
1790 if (ret) {
1791 hid_err(hdev, "Failed to register LED %d\n", n);
1792 sc->leds[n] = NULL;
1793 kfree(led);
1794 goto error_leds;
1795 }
1796 }
1797
1798 return ret;
1799
1800error_leds:
1801 sony_leds_remove(sc);
1802
1803 return ret;
1804}
1805
1806static void sixaxis_send_output_report(struct sony_sc *sc)
1807{
1808 static const union sixaxis_output_report_01 default_report = {
1809 .buf = {
1810 0x01,
1811 0x01, 0xff, 0x00, 0xff, 0x00,
1812 0x00, 0x00, 0x00, 0x00, 0x00,
1813 0xff, 0x27, 0x10, 0x00, 0x32,
1814 0xff, 0x27, 0x10, 0x00, 0x32,
1815 0xff, 0x27, 0x10, 0x00, 0x32,
1816 0xff, 0x27, 0x10, 0x00, 0x32,
1817 0x00, 0x00, 0x00, 0x00, 0x00
1818 }
1819 };
1820 struct sixaxis_output_report *report =
1821 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1822 int n;
1823
1824
1825 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1826
1827#ifdef CONFIG_SONY_FF
1828 report->rumble.right_motor_on = sc->right ? 1 : 0;
1829 report->rumble.left_motor_force = sc->left;
1830#endif
1831
1832 report->leds_bitmap |= sc->led_state[0] << 1;
1833 report->leds_bitmap |= sc->led_state[1] << 2;
1834 report->leds_bitmap |= sc->led_state[2] << 3;
1835 report->leds_bitmap |= sc->led_state[3] << 4;
1836
1837
1838 if ((report->leds_bitmap & 0x1E) == 0)
1839 report->leds_bitmap |= 0x20;
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850 for (n = 0; n < 4; n++) {
1851 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1852 report->led[3 - n].duty_off = sc->led_delay_off[n];
1853 report->led[3 - n].duty_on = sc->led_delay_on[n];
1854 }
1855 }
1856
1857 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
1858 sizeof(struct sixaxis_output_report),
1859 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1860}
1861
1862static void dualshock4_send_output_report(struct sony_sc *sc)
1863{
1864 struct hid_device *hdev = sc->hdev;
1865 u8 *buf = sc->output_report_dmabuf;
1866 int offset;
1867
1868 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1869 memset(buf, 0, DS4_REPORT_0x05_SIZE);
1870 buf[0] = 0x05;
1871 buf[1] = 0xFF;
1872 offset = 4;
1873 } else {
1874 memset(buf, 0, DS4_REPORT_0x11_SIZE);
1875 buf[0] = 0x11;
1876 buf[1] = 0x80;
1877 buf[3] = 0x0F;
1878 offset = 6;
1879 }
1880
1881#ifdef CONFIG_SONY_FF
1882 buf[offset++] = sc->right;
1883 buf[offset++] = sc->left;
1884#else
1885 offset += 2;
1886#endif
1887
1888
1889 if (sc->led_state[3]) {
1890 buf[offset++] = sc->led_state[0];
1891 buf[offset++] = sc->led_state[1];
1892 buf[offset++] = sc->led_state[2];
1893 } else {
1894 offset += 3;
1895 }
1896
1897
1898 buf[offset++] = sc->led_delay_on[3];
1899 buf[offset++] = sc->led_delay_off[3];
1900
1901 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1902 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
1903 else
1904 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
1905 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1906}
1907
1908static void motion_send_output_report(struct sony_sc *sc)
1909{
1910 struct hid_device *hdev = sc->hdev;
1911 struct motion_output_report_02 *report =
1912 (struct motion_output_report_02 *)sc->output_report_dmabuf;
1913
1914 memset(report, 0, MOTION_REPORT_0x02_SIZE);
1915
1916 report->type = 0x02;
1917 report->r = sc->led_state[0];
1918 report->g = sc->led_state[1];
1919 report->b = sc->led_state[2];
1920
1921#ifdef CONFIG_SONY_FF
1922 report->rumble = max(sc->right, sc->left);
1923#endif
1924
1925 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
1926}
1927
1928static inline void sony_send_output_report(struct sony_sc *sc)
1929{
1930 if (sc->send_output_report)
1931 sc->send_output_report(sc);
1932}
1933
1934static void sony_state_worker(struct work_struct *work)
1935{
1936 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1937
1938 sc->send_output_report(sc);
1939}
1940
1941static int sony_allocate_output_report(struct sony_sc *sc)
1942{
1943 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1944 (sc->quirks & NAVIGATION_CONTROLLER))
1945 sc->output_report_dmabuf =
1946 kmalloc(sizeof(union sixaxis_output_report_01),
1947 GFP_KERNEL);
1948 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1949 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1950 GFP_KERNEL);
1951 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1952 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1953 GFP_KERNEL);
1954 else if (sc->quirks & MOTION_CONTROLLER)
1955 sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
1956 GFP_KERNEL);
1957 else
1958 return 0;
1959
1960 if (!sc->output_report_dmabuf)
1961 return -ENOMEM;
1962
1963 return 0;
1964}
1965
1966#ifdef CONFIG_SONY_FF
1967static int sony_play_effect(struct input_dev *dev, void *data,
1968 struct ff_effect *effect)
1969{
1970 struct hid_device *hid = input_get_drvdata(dev);
1971 struct sony_sc *sc = hid_get_drvdata(hid);
1972
1973 if (effect->type != FF_RUMBLE)
1974 return 0;
1975
1976 sc->left = effect->u.rumble.strong_magnitude / 256;
1977 sc->right = effect->u.rumble.weak_magnitude / 256;
1978
1979 schedule_work(&sc->state_worker);
1980 return 0;
1981}
1982
1983static int sony_init_ff(struct sony_sc *sc)
1984{
1985 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1986 struct hid_input, list);
1987 struct input_dev *input_dev = hidinput->input;
1988
1989 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1990 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1991}
1992
1993#else
1994static int sony_init_ff(struct sony_sc *sc)
1995{
1996 return 0;
1997}
1998
1999#endif
2000
2001static int sony_battery_get_property(struct power_supply *psy,
2002 enum power_supply_property psp,
2003 union power_supply_propval *val)
2004{
2005 struct sony_sc *sc = power_supply_get_drvdata(psy);
2006 unsigned long flags;
2007 int ret = 0;
2008 u8 battery_charging, battery_capacity, cable_state;
2009
2010 spin_lock_irqsave(&sc->lock, flags);
2011 battery_charging = sc->battery_charging;
2012 battery_capacity = sc->battery_capacity;
2013 cable_state = sc->cable_state;
2014 spin_unlock_irqrestore(&sc->lock, flags);
2015
2016 switch (psp) {
2017 case POWER_SUPPLY_PROP_PRESENT:
2018 val->intval = 1;
2019 break;
2020 case POWER_SUPPLY_PROP_SCOPE:
2021 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2022 break;
2023 case POWER_SUPPLY_PROP_CAPACITY:
2024 val->intval = battery_capacity;
2025 break;
2026 case POWER_SUPPLY_PROP_STATUS:
2027 if (battery_charging)
2028 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2029 else
2030 if (battery_capacity == 100 && cable_state)
2031 val->intval = POWER_SUPPLY_STATUS_FULL;
2032 else
2033 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2034 break;
2035 default:
2036 ret = -EINVAL;
2037 break;
2038 }
2039 return ret;
2040}
2041
2042static int sony_battery_probe(struct sony_sc *sc)
2043{
2044 struct power_supply_config psy_cfg = { .drv_data = sc, };
2045 struct hid_device *hdev = sc->hdev;
2046 int ret;
2047
2048
2049
2050
2051
2052 sc->battery_capacity = 100;
2053
2054 sc->battery_desc.properties = sony_battery_props;
2055 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2056 sc->battery_desc.get_property = sony_battery_get_property;
2057 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2058 sc->battery_desc.use_for_apm = 0;
2059 sc->battery_desc.name = kasprintf(GFP_KERNEL,
2060 "sony_controller_battery_%pMR",
2061 sc->mac_address);
2062 if (!sc->battery_desc.name)
2063 return -ENOMEM;
2064
2065 sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
2066 &psy_cfg);
2067 if (IS_ERR(sc->battery)) {
2068 ret = PTR_ERR(sc->battery);
2069 hid_err(hdev, "Unable to register battery device\n");
2070 goto err_free;
2071 }
2072
2073 power_supply_powers(sc->battery, &hdev->dev);
2074 return 0;
2075
2076err_free:
2077 kfree(sc->battery_desc.name);
2078 sc->battery_desc.name = NULL;
2079 return ret;
2080}
2081
2082static void sony_battery_remove(struct sony_sc *sc)
2083{
2084 if (!sc->battery_desc.name)
2085 return;
2086
2087 power_supply_unregister(sc->battery);
2088 kfree(sc->battery_desc.name);
2089 sc->battery_desc.name = NULL;
2090}
2091
2092
2093
2094
2095
2096
2097
2098static int sony_check_add_dev_list(struct sony_sc *sc)
2099{
2100 struct sony_sc *entry;
2101 unsigned long flags;
2102 int ret;
2103
2104 spin_lock_irqsave(&sony_dev_list_lock, flags);
2105
2106 list_for_each_entry(entry, &sony_device_list, list_node) {
2107 ret = memcmp(sc->mac_address, entry->mac_address,
2108 sizeof(sc->mac_address));
2109 if (!ret) {
2110 ret = -EEXIST;
2111 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
2112 sc->mac_address);
2113 goto unlock;
2114 }
2115 }
2116
2117 ret = 0;
2118 list_add(&(sc->list_node), &sony_device_list);
2119
2120unlock:
2121 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2122 return ret;
2123}
2124
2125static void sony_remove_dev_list(struct sony_sc *sc)
2126{
2127 unsigned long flags;
2128
2129 if (sc->list_node.next) {
2130 spin_lock_irqsave(&sony_dev_list_lock, flags);
2131 list_del(&(sc->list_node));
2132 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2133 }
2134}
2135
2136static int sony_get_bt_devaddr(struct sony_sc *sc)
2137{
2138 int ret;
2139
2140
2141 ret = strlen(sc->hdev->uniq);
2142 if (ret != 17)
2143 return -EINVAL;
2144
2145 ret = sscanf(sc->hdev->uniq,
2146 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2147 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2148 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2149
2150 if (ret != 6)
2151 return -EINVAL;
2152
2153 return 0;
2154}
2155
2156static int sony_check_add(struct sony_sc *sc)
2157{
2158 u8 *buf = NULL;
2159 int n, ret;
2160
2161 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2162 (sc->quirks & MOTION_CONTROLLER_BT) ||
2163 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2164 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2165
2166
2167
2168
2169
2170
2171 if (sony_get_bt_devaddr(sc) < 0) {
2172 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2173 return 0;
2174 }
2175 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
2176 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
2177 if (!buf)
2178 return -ENOMEM;
2179
2180
2181
2182
2183
2184
2185 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2186 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2187 HID_REQ_GET_REPORT);
2188
2189 if (ret != DS4_REPORT_0x81_SIZE) {
2190 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2191 ret = ret < 0 ? ret : -EINVAL;
2192 goto out_free;
2193 }
2194
2195 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2196 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2197 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2198 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2199 if (!buf)
2200 return -ENOMEM;
2201
2202
2203
2204
2205
2206
2207 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2208 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2209 HID_REQ_GET_REPORT);
2210
2211 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2212 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2213 ret = ret < 0 ? ret : -EINVAL;
2214 goto out_free;
2215 }
2216
2217
2218
2219
2220
2221 for (n = 0; n < 6; n++)
2222 sc->mac_address[5-n] = buf[4+n];
2223 } else {
2224 return 0;
2225 }
2226
2227 ret = sony_check_add_dev_list(sc);
2228
2229out_free:
2230
2231 kfree(buf);
2232
2233 return ret;
2234}
2235
2236static int sony_set_device_id(struct sony_sc *sc)
2237{
2238 int ret;
2239
2240
2241
2242
2243
2244 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2245 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2246 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2247 GFP_KERNEL);
2248 if (ret < 0) {
2249 sc->device_id = -1;
2250 return ret;
2251 }
2252 sc->device_id = ret;
2253 } else {
2254 sc->device_id = -1;
2255 }
2256
2257 return 0;
2258}
2259
2260static void sony_release_device_id(struct sony_sc *sc)
2261{
2262 if (sc->device_id >= 0) {
2263 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2264 sc->device_id = -1;
2265 }
2266}
2267
2268static inline void sony_init_output_report(struct sony_sc *sc,
2269 void (*send_output_report)(struct sony_sc *))
2270{
2271 sc->send_output_report = send_output_report;
2272
2273 if (!sc->worker_initialized)
2274 INIT_WORK(&sc->state_worker, sony_state_worker);
2275
2276 sc->worker_initialized = 1;
2277}
2278
2279static inline void sony_cancel_work_sync(struct sony_sc *sc)
2280{
2281 if (sc->worker_initialized)
2282 cancel_work_sync(&sc->state_worker);
2283}
2284
2285static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2286{
2287 int ret;
2288 unsigned long quirks = id->driver_data;
2289 struct sony_sc *sc;
2290 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2291
2292 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2293 if (sc == NULL) {
2294 hid_err(hdev, "can't alloc sony descriptor\n");
2295 return -ENOMEM;
2296 }
2297
2298 spin_lock_init(&sc->lock);
2299
2300 sc->quirks = quirks;
2301 hid_set_drvdata(hdev, sc);
2302 sc->hdev = hdev;
2303
2304 ret = hid_parse(hdev);
2305 if (ret) {
2306 hid_err(hdev, "parse failed\n");
2307 return ret;
2308 }
2309
2310 if (sc->quirks & VAIO_RDESC_CONSTANT)
2311 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2312 else if (sc->quirks & SIXAXIS_CONTROLLER)
2313 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2314
2315 ret = hid_hw_start(hdev, connect_mask);
2316 if (ret) {
2317 hid_err(hdev, "hw start failed\n");
2318 return ret;
2319 }
2320
2321 ret = sony_set_device_id(sc);
2322 if (ret < 0) {
2323 hid_err(hdev, "failed to allocate the device id\n");
2324 goto err_stop;
2325 }
2326
2327 ret = sony_allocate_output_report(sc);
2328 if (ret < 0) {
2329 hid_err(hdev, "failed to allocate the output report buffer\n");
2330 goto err_stop;
2331 }
2332
2333 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2334 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2346 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2347 ret = sixaxis_set_operational_usb(hdev);
2348 sony_init_output_report(sc, sixaxis_send_output_report);
2349 } else if ((sc->quirks & SIXAXIS_CONTROLLER_BT) ||
2350 (sc->quirks & NAVIGATION_CONTROLLER_BT)) {
2351
2352
2353
2354
2355 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2356 ret = sixaxis_set_operational_bt(hdev);
2357 sony_init_output_report(sc, sixaxis_send_output_report);
2358 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2359 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2360
2361
2362
2363
2364 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2365 ret = dualshock4_set_operational_bt(hdev);
2366 if (ret < 0) {
2367 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2368 goto err_stop;
2369 }
2370 }
2371
2372 sony_init_output_report(sc, dualshock4_send_output_report);
2373 } else if (sc->quirks & MOTION_CONTROLLER) {
2374 sony_init_output_report(sc, motion_send_output_report);
2375 } else {
2376 ret = 0;
2377 }
2378
2379 if (ret < 0)
2380 goto err_stop;
2381
2382 ret = sony_check_add(sc);
2383 if (ret < 0)
2384 goto err_stop;
2385
2386 if (sc->quirks & SONY_LED_SUPPORT) {
2387 ret = sony_leds_init(sc);
2388 if (ret < 0)
2389 goto err_stop;
2390 }
2391
2392 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2393 ret = sony_battery_probe(sc);
2394 if (ret < 0)
2395 goto err_stop;
2396
2397
2398 ret = hid_hw_open(hdev);
2399 if (ret < 0) {
2400 hid_err(hdev, "hw open failed\n");
2401 goto err_stop;
2402 }
2403 }
2404
2405 if (sc->quirks & SONY_FF_SUPPORT) {
2406 ret = sony_init_ff(sc);
2407 if (ret < 0)
2408 goto err_close;
2409 }
2410
2411 return 0;
2412err_close:
2413 hid_hw_close(hdev);
2414err_stop:
2415 if (sc->quirks & SONY_LED_SUPPORT)
2416 sony_leds_remove(sc);
2417 if (sc->quirks & SONY_BATTERY_SUPPORT)
2418 sony_battery_remove(sc);
2419 sony_cancel_work_sync(sc);
2420 kfree(sc->output_report_dmabuf);
2421 sony_remove_dev_list(sc);
2422 sony_release_device_id(sc);
2423 hid_hw_stop(hdev);
2424 return ret;
2425}
2426
2427static void sony_remove(struct hid_device *hdev)
2428{
2429 struct sony_sc *sc = hid_get_drvdata(hdev);
2430
2431 if (sc->quirks & SONY_LED_SUPPORT)
2432 sony_leds_remove(sc);
2433
2434 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2435 hid_hw_close(hdev);
2436 sony_battery_remove(sc);
2437 }
2438
2439 sony_cancel_work_sync(sc);
2440
2441 kfree(sc->output_report_dmabuf);
2442
2443 sony_remove_dev_list(sc);
2444
2445 sony_release_device_id(sc);
2446
2447 hid_hw_stop(hdev);
2448}
2449
2450#ifdef CONFIG_PM
2451
2452static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2453{
2454
2455
2456
2457
2458 if (SONY_LED_SUPPORT || SONY_FF_SUPPORT) {
2459 struct sony_sc *sc = hid_get_drvdata(hdev);
2460
2461#ifdef CONFIG_SONY_FF
2462 sc->left = sc->right = 0;
2463#endif
2464
2465 memcpy(sc->resume_led_state, sc->led_state,
2466 sizeof(sc->resume_led_state));
2467 memset(sc->led_state, 0, sizeof(sc->led_state));
2468
2469 sony_send_output_report(sc);
2470 }
2471
2472 return 0;
2473}
2474
2475static int sony_resume(struct hid_device *hdev)
2476{
2477
2478 if (SONY_LED_SUPPORT) {
2479 struct sony_sc *sc = hid_get_drvdata(hdev);
2480
2481 memcpy(sc->led_state, sc->resume_led_state,
2482 sizeof(sc->led_state));
2483
2484
2485
2486
2487
2488 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2489 (sc->quirks & NAVIGATION_CONTROLLER_USB))
2490 sixaxis_set_operational_usb(sc->hdev);
2491
2492 sony_set_leds(sc);
2493 }
2494
2495 return 0;
2496}
2497
2498#endif
2499
2500static const struct hid_device_id sony_devices[] = {
2501 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2502 .driver_data = SIXAXIS_CONTROLLER_USB },
2503 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2504 .driver_data = NAVIGATION_CONTROLLER_USB },
2505 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2506 .driver_data = NAVIGATION_CONTROLLER_BT },
2507 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2508 .driver_data = MOTION_CONTROLLER_USB },
2509 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2510 .driver_data = MOTION_CONTROLLER_BT },
2511 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2512 .driver_data = SIXAXIS_CONTROLLER_BT },
2513 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2514 .driver_data = VAIO_RDESC_CONSTANT },
2515 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2516 .driver_data = VAIO_RDESC_CONSTANT },
2517
2518
2519
2520
2521 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2522 .driver_data = BUZZ_CONTROLLER },
2523 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2524 .driver_data = BUZZ_CONTROLLER },
2525
2526 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2527 .driver_data = PS3REMOTE },
2528
2529 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2530 .driver_data = PS3REMOTE },
2531
2532 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2533 .driver_data = PS3REMOTE },
2534
2535 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2536 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2537 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2538 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2539
2540 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2541 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2542 { }
2543};
2544MODULE_DEVICE_TABLE(hid, sony_devices);
2545
2546static struct hid_driver sony_driver = {
2547 .name = "sony",
2548 .id_table = sony_devices,
2549 .input_mapping = sony_mapping,
2550 .input_configured = sony_input_configured,
2551 .probe = sony_probe,
2552 .remove = sony_remove,
2553 .report_fixup = sony_report_fixup,
2554 .raw_event = sony_raw_event,
2555
2556#ifdef CONFIG_PM
2557 .suspend = sony_suspend,
2558 .resume = sony_resume,
2559 .reset_resume = sony_resume,
2560#endif
2561};
2562
2563static int __init sony_init(void)
2564{
2565 dbg_hid("Sony:%s\n", __func__);
2566
2567 return hid_register_driver(&sony_driver);
2568}
2569
2570static void __exit sony_exit(void)
2571{
2572 dbg_hid("Sony:%s\n", __func__);
2573
2574 hid_unregister_driver(&sony_driver);
2575 ida_destroy(&sony_device_id_allocator);
2576}
2577module_init(sony_init);
2578module_exit(sony_exit);
2579
2580MODULE_LICENSE("GPL");
2581
