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#include <linux/device.h>
29#include <linux/hid.h>
30#include <linux/module.h>
31#include <linux/slab.h>
32#include <linux/leds.h>
33#include <linux/power_supply.h>
34#include <linux/spinlock.h>
35#include <linux/list.h>
36#include <linux/input/mt.h>
37
38#include "hid-ids.h"
39
40#define VAIO_RDESC_CONSTANT BIT(0)
41#define SIXAXIS_CONTROLLER_USB BIT(1)
42#define SIXAXIS_CONTROLLER_BT BIT(2)
43#define BUZZ_CONTROLLER BIT(3)
44#define PS3REMOTE BIT(4)
45#define DUALSHOCK4_CONTROLLER_USB BIT(5)
46#define DUALSHOCK4_CONTROLLER_BT BIT(6)
47
48#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
49#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
50 DUALSHOCK4_CONTROLLER_BT)
51#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
52 DUALSHOCK4_CONTROLLER)
53#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
54#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
55
56#define MAX_LEDS 4
57
58static const u8 sixaxis_rdesc_fixup[] = {
59 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
60 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
61 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
62};
63
64static const u8 sixaxis_rdesc_fixup2[] = {
65 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
66 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
67 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
68 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
69 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
70 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
71 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
72 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
73 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
74 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
75 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
76 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
77 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
78 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
79 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
80 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
81 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
82 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
83 0xb1, 0x02, 0xc0, 0xc0,
84};
85
86
87
88
89
90
91
92static u8 dualshock4_usb_rdesc[] = {
93 0x05, 0x01,
94 0x09, 0x05,
95 0xA1, 0x01,
96 0x85, 0x01,
97 0x09, 0x30,
98 0x09, 0x31,
99 0x09, 0x32,
100 0x09, 0x35,
101 0x15, 0x00,
102 0x26, 0xFF, 0x00,
103 0x75, 0x08,
104 0x95, 0x04,
105 0x81, 0x02,
106 0x09, 0x39,
107 0x15, 0x00,
108 0x25, 0x07,
109 0x35, 0x00,
110 0x46, 0x3B, 0x01,
111 0x65, 0x14,
112 0x75, 0x04,
113 0x95, 0x01,
114 0x81, 0x42,
115 0x65, 0x00,
116 0x05, 0x09,
117 0x19, 0x01,
118 0x29, 0x0E,
119 0x15, 0x00,
120 0x25, 0x01,
121 0x75, 0x01,
122 0x95, 0x0E,
123 0x81, 0x02,
124 0x06, 0x00, 0xFF,
125 0x09, 0x20,
126 0x75, 0x06,
127 0x95, 0x01,
128 0x15, 0x00,
129 0x25, 0x7F,
130 0x81, 0x02,
131 0x05, 0x01,
132 0x09, 0x33,
133 0x09, 0x34,
134 0x15, 0x00,
135 0x26, 0xFF, 0x00,
136 0x75, 0x08,
137 0x95, 0x02,
138 0x81, 0x02,
139 0x06, 0x00, 0xFF,
140 0x09, 0x21,
141 0x95, 0x03,
142 0x81, 0x02,
143 0x05, 0x01,
144 0x19, 0x40,
145 0x29, 0x42,
146 0x16, 0x00, 0x80,
147 0x26, 0x00, 0x7F,
148 0x75, 0x10,
149 0x95, 0x03,
150 0x81, 0x02,
151 0x19, 0x43,
152 0x29, 0x45,
153 0x16, 0xFF, 0xBF,
154 0x26, 0x00, 0x40,
155 0x95, 0x03,
156 0x81, 0x02,
157 0x06, 0x00, 0xFF,
158 0x09, 0x21,
159 0x15, 0x00,
160 0x25, 0xFF,
161 0x75, 0x08,
162 0x95, 0x27,
163 0x81, 0x02,
164 0x85, 0x05,
165 0x09, 0x22,
166 0x95, 0x1F,
167 0x91, 0x02,
168 0x85, 0x04,
169 0x09, 0x23,
170 0x95, 0x24,
171 0xB1, 0x02,
172 0x85, 0x02,
173 0x09, 0x24,
174 0x95, 0x24,
175 0xB1, 0x02,
176 0x85, 0x08,
177 0x09, 0x25,
178 0x95, 0x03,
179 0xB1, 0x02,
180 0x85, 0x10,
181 0x09, 0x26,
182 0x95, 0x04,
183 0xB1, 0x02,
184 0x85, 0x11,
185 0x09, 0x27,
186 0x95, 0x02,
187 0xB1, 0x02,
188 0x85, 0x12,
189 0x06, 0x02, 0xFF,
190 0x09, 0x21,
191 0x95, 0x0F,
192 0xB1, 0x02,
193 0x85, 0x13,
194 0x09, 0x22,
195 0x95, 0x16,
196 0xB1, 0x02,
197 0x85, 0x14,
198 0x06, 0x05, 0xFF,
199 0x09, 0x20,
200 0x95, 0x10,
201 0xB1, 0x02,
202 0x85, 0x15,
203 0x09, 0x21,
204 0x95, 0x2C,
205 0xB1, 0x02,
206 0x06, 0x80, 0xFF,
207 0x85, 0x80,
208 0x09, 0x20,
209 0x95, 0x06,
210 0xB1, 0x02,
211 0x85, 0x81,
212 0x09, 0x21,
213 0x95, 0x06,
214 0xB1, 0x02,
215 0x85, 0x82,
216 0x09, 0x22,
217 0x95, 0x05,
218 0xB1, 0x02,
219 0x85, 0x83,
220 0x09, 0x23,
221 0x95, 0x01,
222 0xB1, 0x02,
223 0x85, 0x84,
224 0x09, 0x24,
225 0x95, 0x04,
226 0xB1, 0x02,
227 0x85, 0x85,
228 0x09, 0x25,
229 0x95, 0x06,
230 0xB1, 0x02,
231 0x85, 0x86,
232 0x09, 0x26,
233 0x95, 0x06,
234 0xB1, 0x02,
235 0x85, 0x87,
236 0x09, 0x27,
237 0x95, 0x23,
238 0xB1, 0x02,
239 0x85, 0x88,
240 0x09, 0x28,
241 0x95, 0x22,
242 0xB1, 0x02,
243 0x85, 0x89,
244 0x09, 0x29,
245 0x95, 0x02,
246 0xB1, 0x02,
247 0x85, 0x90,
248 0x09, 0x30,
249 0x95, 0x05,
250 0xB1, 0x02,
251 0x85, 0x91,
252 0x09, 0x31,
253 0x95, 0x03,
254 0xB1, 0x02,
255 0x85, 0x92,
256 0x09, 0x32,
257 0x95, 0x03,
258 0xB1, 0x02,
259 0x85, 0x93,
260 0x09, 0x33,
261 0x95, 0x0C,
262 0xB1, 0x02,
263 0x85, 0xA0,
264 0x09, 0x40,
265 0x95, 0x06,
266 0xB1, 0x02,
267 0x85, 0xA1,
268 0x09, 0x41,
269 0x95, 0x01,
270 0xB1, 0x02,
271 0x85, 0xA2,
272 0x09, 0x42,
273 0x95, 0x01,
274 0xB1, 0x02,
275 0x85, 0xA3,
276 0x09, 0x43,
277 0x95, 0x30,
278 0xB1, 0x02,
279 0x85, 0xA4,
280 0x09, 0x44,
281 0x95, 0x0D,
282 0xB1, 0x02,
283 0x85, 0xA5,
284 0x09, 0x45,
285 0x95, 0x15,
286 0xB1, 0x02,
287 0x85, 0xA6,
288 0x09, 0x46,
289 0x95, 0x15,
290 0xB1, 0x02,
291 0x85, 0xF0,
292 0x09, 0x47,
293 0x95, 0x3F,
294 0xB1, 0x02,
295 0x85, 0xF1,
296 0x09, 0x48,
297 0x95, 0x3F,
298 0xB1, 0x02,
299 0x85, 0xF2,
300 0x09, 0x49,
301 0x95, 0x0F,
302 0xB1, 0x02,
303 0x85, 0xA7,
304 0x09, 0x4A,
305 0x95, 0x01,
306 0xB1, 0x02,
307 0x85, 0xA8,
308 0x09, 0x4B,
309 0x95, 0x01,
310 0xB1, 0x02,
311 0x85, 0xA9,
312 0x09, 0x4C,
313 0x95, 0x08,
314 0xB1, 0x02,
315 0x85, 0xAA,
316 0x09, 0x4E,
317 0x95, 0x01,
318 0xB1, 0x02,
319 0x85, 0xAB,
320 0x09, 0x4F,
321 0x95, 0x39,
322 0xB1, 0x02,
323 0x85, 0xAC,
324 0x09, 0x50,
325 0x95, 0x39,
326 0xB1, 0x02,
327 0x85, 0xAD,
328 0x09, 0x51,
329 0x95, 0x0B,
330 0xB1, 0x02,
331 0x85, 0xAE,
332 0x09, 0x52,
333 0x95, 0x01,
334 0xB1, 0x02,
335 0x85, 0xAF,
336 0x09, 0x53,
337 0x95, 0x02,
338 0xB1, 0x02,
339 0x85, 0xB0,
340 0x09, 0x54,
341 0x95, 0x3F,
342 0xB1, 0x02,
343 0xC0
344};
345
346
347
348
349
350
351
352
353
354static u8 dualshock4_bt_rdesc[] = {
355 0x05, 0x01,
356 0x09, 0x05,
357 0xA1, 0x01,
358 0x85, 0x01,
359 0x75, 0x08,
360 0x95, 0x0A,
361 0x81, 0x02,
362 0x06, 0x04, 0xFF,
363 0x85, 0x02,
364 0x09, 0x24,
365 0x95, 0x24,
366 0xB1, 0x02,
367 0x85, 0xA3,
368 0x09, 0x25,
369 0x95, 0x30,
370 0xB1, 0x02,
371 0x85, 0x05,
372 0x09, 0x26,
373 0x95, 0x28,
374 0xB1, 0x02,
375 0x85, 0x06,
376 0x09, 0x27,
377 0x95, 0x34,
378 0xB1, 0x02,
379 0x85, 0x07,
380 0x09, 0x28,
381 0x95, 0x30,
382 0xB1, 0x02,
383 0x85, 0x08,
384 0x09, 0x29,
385 0x95, 0x2F,
386 0xB1, 0x02,
387 0x06, 0x03, 0xFF,
388 0x85, 0x03,
389 0x09, 0x21,
390 0x95, 0x26,
391 0xB1, 0x02,
392 0x85, 0x04,
393 0x09, 0x22,
394 0x95, 0x2E,
395 0xB1, 0x02,
396 0x85, 0xF0,
397 0x09, 0x47,
398 0x95, 0x3F,
399 0xB1, 0x02,
400 0x85, 0xF1,
401 0x09, 0x48,
402 0x95, 0x3F,
403 0xB1, 0x02,
404 0x85, 0xF2,
405 0x09, 0x49,
406 0x95, 0x0F,
407 0xB1, 0x02,
408 0x85, 0x11,
409 0x06, 0x00, 0xFF,
410 0x09, 0x20,
411 0x95, 0x02,
412 0x81, 0x02,
413 0x05, 0x01,
414 0x09, 0x30,
415 0x09, 0x31,
416 0x09, 0x32,
417 0x09, 0x35,
418 0x15, 0x00,
419 0x26, 0xFF, 0x00,
420 0x75, 0x08,
421 0x95, 0x04,
422 0x81, 0x02,
423 0x09, 0x39,
424 0x15, 0x00,
425 0x25, 0x07,
426 0x75, 0x04,
427 0x95, 0x01,
428 0x81, 0x42,
429 0x05, 0x09,
430 0x19, 0x01,
431 0x29, 0x0E,
432 0x15, 0x00,
433 0x25, 0x01,
434 0x75, 0x01,
435 0x95, 0x0E,
436 0x81, 0x02,
437 0x75, 0x06,
438 0x95, 0x01,
439 0x81, 0x01,
440 0x05, 0x01,
441 0x09, 0x33,
442 0x09, 0x34,
443 0x15, 0x00,
444 0x26, 0xFF, 0x00,
445 0x75, 0x08,
446 0x95, 0x02,
447 0x81, 0x02,
448 0x06, 0x00, 0xFF,
449 0x09, 0x20,
450 0x95, 0x03,
451 0x81, 0x02,
452 0x05, 0x01,
453 0x19, 0x40,
454 0x29, 0x42,
455 0x16, 0x00, 0x80,
456 0x26, 0x00, 0x7F,
457 0x75, 0x10,
458 0x95, 0x03,
459 0x81, 0x02,
460 0x19, 0x43,
461 0x29, 0x45,
462 0x16, 0xFF, 0xBF,
463 0x26, 0x00, 0x40,
464 0x95, 0x03,
465 0x81, 0x02,
466 0x06, 0x00, 0xFF,
467 0x09, 0x20,
468 0x15, 0x00,
469 0x26, 0xFF, 0x00,
470 0x75, 0x08,
471 0x95, 0x31,
472 0x81, 0x02,
473 0x09, 0x21,
474 0x75, 0x08,
475 0x95, 0x4D,
476 0x91, 0x02,
477 0x85, 0x12,
478 0x09, 0x22,
479 0x95, 0x8D,
480 0x81, 0x02,
481 0x09, 0x23,
482 0x91, 0x02,
483 0x85, 0x13,
484 0x09, 0x24,
485 0x95, 0xCD,
486 0x81, 0x02,
487 0x09, 0x25,
488 0x91, 0x02,
489 0x85, 0x14,
490 0x09, 0x26,
491 0x96, 0x0D, 0x01,
492 0x81, 0x02,
493 0x09, 0x27,
494 0x91, 0x02,
495 0x85, 0x15,
496 0x09, 0x28,
497 0x96, 0x4D, 0x01,
498 0x81, 0x02,
499 0x09, 0x29,
500 0x91, 0x02,
501 0x85, 0x16,
502 0x09, 0x2A,
503 0x96, 0x8D, 0x01,
504 0x81, 0x02,
505 0x09, 0x2B,
506 0x91, 0x02,
507 0x85, 0x17,
508 0x09, 0x2C,
509 0x96, 0xCD, 0x01,
510 0x81, 0x02,
511 0x09, 0x2D,
512 0x91, 0x02,
513 0x85, 0x18,
514 0x09, 0x2E,
515 0x96, 0x0D, 0x02,
516 0x81, 0x02,
517 0x09, 0x2F,
518 0x91, 0x02,
519 0x85, 0x19,
520 0x09, 0x30,
521 0x96, 0x22, 0x02,
522 0x81, 0x02,
523 0x09, 0x31,
524 0x91, 0x02,
525 0x06, 0x80, 0xFF,
526 0x85, 0x82,
527 0x09, 0x22,
528 0x95, 0x3F,
529 0xB1, 0x02,
530 0x85, 0x83,
531 0x09, 0x23,
532 0xB1, 0x02,
533 0x85, 0x84,
534 0x09, 0x24,
535 0xB1, 0x02,
536 0x85, 0x90,
537 0x09, 0x30,
538 0xB1, 0x02,
539 0x85, 0x91,
540 0x09, 0x31,
541 0xB1, 0x02,
542 0x85, 0x92,
543 0x09, 0x32,
544 0xB1, 0x02,
545 0x85, 0x93,
546 0x09, 0x33,
547 0xB1, 0x02,
548 0x85, 0xA0,
549 0x09, 0x40,
550 0xB1, 0x02,
551 0x85, 0xA4,
552 0x09, 0x44,
553 0xB1, 0x02,
554 0xC0
555};
556
557static __u8 ps3remote_rdesc[] = {
558 0x05, 0x01,
559 0x09, 0x05,
560 0xA1, 0x01,
561
562
563 0xA1, 0x02,
564
565
566
567 0x75, 0x08,
568 0x95, 0x01,
569 0x81, 0x01,
570
571
572
573 0x05, 0x09,
574 0x19, 0x01,
575 0x29, 0x18,
576 0x14,
577 0x25, 0x01,
578 0x75, 0x01,
579 0x95, 0x18,
580 0x81, 0x02,
581
582 0xC0,
583
584
585 0xA1, 0x02,
586
587
588 0x05, 0x09,
589 0x18,
590 0x29, 0xFE,
591 0x14,
592 0x26, 0xFE, 0x00,
593 0x75, 0x08,
594 0x95, 0x01,
595 0x80,
596
597
598
599 0x75, 0x08,
600 0x95, 0x06,
601 0x81, 0x01,
602
603
604 0x05, 0x06,
605 0x09, 0x20,
606 0x14,
607 0x25, 0x05,
608 0x75, 0x08,
609 0x95, 0x01,
610 0x81, 0x02,
611
612 0xC0,
613
614 0xC0
615};
616
617static const unsigned int ps3remote_keymap_joypad_buttons[] = {
618 [0x01] = KEY_SELECT,
619 [0x02] = BTN_THUMBL,
620 [0x03] = BTN_THUMBR,
621 [0x04] = BTN_START,
622 [0x05] = KEY_UP,
623 [0x06] = KEY_RIGHT,
624 [0x07] = KEY_DOWN,
625 [0x08] = KEY_LEFT,
626 [0x09] = BTN_TL2,
627 [0x0a] = BTN_TR2,
628 [0x0b] = BTN_TL,
629 [0x0c] = BTN_TR,
630 [0x0d] = KEY_OPTION,
631 [0x0e] = KEY_BACK,
632 [0x0f] = BTN_0,
633 [0x10] = KEY_SCREEN,
634 [0x11] = KEY_HOMEPAGE,
635 [0x14] = KEY_ENTER,
636};
637static const unsigned int ps3remote_keymap_remote_buttons[] = {
638 [0x00] = KEY_1,
639 [0x01] = KEY_2,
640 [0x02] = KEY_3,
641 [0x03] = KEY_4,
642 [0x04] = KEY_5,
643 [0x05] = KEY_6,
644 [0x06] = KEY_7,
645 [0x07] = KEY_8,
646 [0x08] = KEY_9,
647 [0x09] = KEY_0,
648 [0x0e] = KEY_ESC,
649 [0x0f] = KEY_CLEAR,
650 [0x16] = KEY_EJECTCD,
651 [0x1a] = KEY_MENU,
652 [0x28] = KEY_TIME,
653 [0x30] = KEY_PREVIOUS,
654 [0x31] = KEY_NEXT,
655 [0x32] = KEY_PLAY,
656 [0x33] = KEY_REWIND,
657 [0x34] = KEY_FORWARD,
658 [0x38] = KEY_STOP,
659 [0x39] = KEY_PAUSE,
660 [0x40] = KEY_CONTEXT_MENU,
661 [0x60] = KEY_FRAMEBACK,
662 [0x61] = KEY_FRAMEFORWARD,
663 [0x63] = KEY_SUBTITLE,
664 [0x64] = KEY_AUDIO,
665 [0x65] = KEY_ANGLE,
666 [0x70] = KEY_INFO,
667 [0x80] = KEY_BLUE,
668 [0x81] = KEY_RED,
669 [0x82] = KEY_GREEN,
670 [0x83] = KEY_YELLOW,
671};
672
673static const unsigned int buzz_keymap[] = {
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691 [ 1] = BTN_TRIGGER_HAPPY1,
692 [ 2] = BTN_TRIGGER_HAPPY2,
693 [ 3] = BTN_TRIGGER_HAPPY3,
694 [ 4] = BTN_TRIGGER_HAPPY4,
695 [ 5] = BTN_TRIGGER_HAPPY5,
696 [ 6] = BTN_TRIGGER_HAPPY6,
697 [ 7] = BTN_TRIGGER_HAPPY7,
698 [ 8] = BTN_TRIGGER_HAPPY8,
699 [ 9] = BTN_TRIGGER_HAPPY9,
700 [10] = BTN_TRIGGER_HAPPY10,
701 [11] = BTN_TRIGGER_HAPPY11,
702 [12] = BTN_TRIGGER_HAPPY12,
703 [13] = BTN_TRIGGER_HAPPY13,
704 [14] = BTN_TRIGGER_HAPPY14,
705 [15] = BTN_TRIGGER_HAPPY15,
706 [16] = BTN_TRIGGER_HAPPY16,
707 [17] = BTN_TRIGGER_HAPPY17,
708 [18] = BTN_TRIGGER_HAPPY18,
709 [19] = BTN_TRIGGER_HAPPY19,
710 [20] = BTN_TRIGGER_HAPPY20,
711};
712
713static enum power_supply_property sony_battery_props[] = {
714 POWER_SUPPLY_PROP_PRESENT,
715 POWER_SUPPLY_PROP_CAPACITY,
716 POWER_SUPPLY_PROP_SCOPE,
717 POWER_SUPPLY_PROP_STATUS,
718};
719
720static spinlock_t sony_dev_list_lock;
721static LIST_HEAD(sony_device_list);
722
723struct sony_sc {
724 spinlock_t lock;
725 struct list_head list_node;
726 struct hid_device *hdev;
727 struct led_classdev *leds[MAX_LEDS];
728 unsigned long quirks;
729 struct work_struct state_worker;
730 struct power_supply battery;
731
732#ifdef CONFIG_SONY_FF
733 __u8 left;
734 __u8 right;
735#endif
736
737 __u8 mac_address[6];
738 __u8 worker_initialized;
739 __u8 cable_state;
740 __u8 battery_charging;
741 __u8 battery_capacity;
742 __u8 led_state[MAX_LEDS];
743 __u8 led_count;
744};
745
746static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
747 unsigned int *rsize)
748{
749 *rsize = sizeof(ps3remote_rdesc);
750 return ps3remote_rdesc;
751}
752
753static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
754 struct hid_field *field, struct hid_usage *usage,
755 unsigned long **bit, int *max)
756{
757 unsigned int key = usage->hid & HID_USAGE;
758
759 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
760 return -1;
761
762 switch (usage->collection_index) {
763 case 1:
764 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
765 return -1;
766
767 key = ps3remote_keymap_joypad_buttons[key];
768 if (!key)
769 return -1;
770 break;
771 case 2:
772 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
773 return -1;
774
775 key = ps3remote_keymap_remote_buttons[key];
776 if (!key)
777 return -1;
778 break;
779 default:
780 return -1;
781 }
782
783 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
784 return 1;
785}
786
787
788
789static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
790 unsigned int *rsize)
791{
792 struct sony_sc *sc = hid_get_drvdata(hdev);
793
794
795
796
797
798 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
799
800
801
802 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
803
804 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
805 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
806
807 rdesc[55] = 0x06;
808 }
809
810
811
812
813
814
815 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
816 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
817 rdesc = dualshock4_usb_rdesc;
818 *rsize = sizeof(dualshock4_usb_rdesc);
819 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
820 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
821 rdesc = dualshock4_bt_rdesc;
822 *rsize = sizeof(dualshock4_bt_rdesc);
823 }
824
825
826 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
827 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
828 rdesc[83] == 0x75) {
829 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
830 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
831 sizeof(sixaxis_rdesc_fixup));
832 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
833 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
834 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
835 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
836 *rsize = sizeof(sixaxis_rdesc_fixup2);
837 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
838 }
839
840 if (sc->quirks & PS3REMOTE)
841 return ps3remote_fixup(hdev, rdesc, rsize);
842
843 return rdesc;
844}
845
846static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
847{
848 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
849 unsigned long flags;
850 __u8 cable_state, battery_capacity, battery_charging;
851
852
853
854
855
856
857
858 if (rd[30] >= 0xee) {
859 battery_capacity = 100;
860 battery_charging = !(rd[30] & 0x01);
861 } else {
862 __u8 index = rd[30] <= 5 ? rd[30] : 5;
863 battery_capacity = sixaxis_battery_capacity[index];
864 battery_charging = 0;
865 }
866 cable_state = !(rd[31] & 0x04);
867
868 spin_lock_irqsave(&sc->lock, flags);
869 sc->cable_state = cable_state;
870 sc->battery_capacity = battery_capacity;
871 sc->battery_charging = battery_charging;
872 spin_unlock_irqrestore(&sc->lock, flags);
873}
874
875static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
876{
877 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
878 struct hid_input, list);
879 struct input_dev *input_dev = hidinput->input;
880 unsigned long flags;
881 int n, offset;
882 __u8 cable_state, battery_capacity, battery_charging;
883
884
885
886
887
888 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
889
890
891
892
893
894 cable_state = (rd[offset] >> 4) & 0x01;
895 battery_capacity = rd[offset] & 0x0F;
896
897
898
899
900
901
902 if (!cable_state || battery_capacity > 10)
903 battery_charging = 0;
904 else
905 battery_charging = 1;
906
907 if (!cable_state)
908 battery_capacity++;
909 if (battery_capacity > 10)
910 battery_capacity = 10;
911
912 battery_capacity *= 10;
913
914 spin_lock_irqsave(&sc->lock, flags);
915 sc->cable_state = cable_state;
916 sc->battery_capacity = battery_capacity;
917 sc->battery_charging = battery_charging;
918 spin_unlock_irqrestore(&sc->lock, flags);
919
920 offset += 5;
921
922
923
924
925
926
927
928
929
930
931 for (n = 0; n < 2; n++) {
932 __u16 x, y;
933
934 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
935 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
936
937 input_mt_slot(input_dev, n);
938 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
939 !(rd[offset] >> 7));
940 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
941 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
942
943 offset += 4;
944 }
945}
946
947static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
948 __u8 *rd, int size)
949{
950 struct sony_sc *sc = hid_get_drvdata(hdev);
951
952
953
954
955
956 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
957 swap(rd[41], rd[42]);
958 swap(rd[43], rd[44]);
959 swap(rd[45], rd[46]);
960 swap(rd[47], rd[48]);
961
962 sixaxis_parse_report(sc, rd, size);
963 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
964 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
965 && rd[0] == 0x11 && size == 78)) {
966 dualshock4_parse_report(sc, rd, size);
967 }
968
969 return 0;
970}
971
972static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
973 struct hid_field *field, struct hid_usage *usage,
974 unsigned long **bit, int *max)
975{
976 struct sony_sc *sc = hid_get_drvdata(hdev);
977
978 if (sc->quirks & BUZZ_CONTROLLER) {
979 unsigned int key = usage->hid & HID_USAGE;
980
981 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
982 return -1;
983
984 switch (usage->collection_index) {
985 case 1:
986 if (key >= ARRAY_SIZE(buzz_keymap))
987 return -1;
988
989 key = buzz_keymap[key];
990 if (!key)
991 return -1;
992 break;
993 default:
994 return -1;
995 }
996
997 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
998 return 1;
999 }
1000
1001 if (sc->quirks & PS3REMOTE)
1002 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1003
1004
1005 return 0;
1006}
1007
1008
1009
1010
1011
1012
1013static int sixaxis_set_operational_usb(struct hid_device *hdev)
1014{
1015 int ret;
1016 char *buf = kmalloc(18, GFP_KERNEL);
1017
1018 if (!buf)
1019 return -ENOMEM;
1020
1021 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1022 HID_REQ_GET_REPORT);
1023
1024 if (ret < 0)
1025 hid_err(hdev, "can't set operational mode\n");
1026
1027 kfree(buf);
1028
1029 return ret;
1030}
1031
1032static int sixaxis_set_operational_bt(struct hid_device *hdev)
1033{
1034 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1035 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
1036 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1037}
1038
1039
1040
1041
1042
1043static int dualshock4_set_operational_bt(struct hid_device *hdev)
1044{
1045 __u8 buf[37] = { 0 };
1046
1047 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf),
1048 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1049}
1050
1051static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1052{
1053 struct list_head *report_list =
1054 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1055 struct hid_report *report = list_entry(report_list->next,
1056 struct hid_report, list);
1057 __s32 *value = report->field[0]->value;
1058
1059 value[0] = 0x00;
1060 value[1] = leds[0] ? 0xff : 0x00;
1061 value[2] = leds[1] ? 0xff : 0x00;
1062 value[3] = leds[2] ? 0xff : 0x00;
1063 value[4] = leds[3] ? 0xff : 0x00;
1064 value[5] = 0x00;
1065 value[6] = 0x00;
1066 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1067}
1068
1069static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
1070{
1071 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1072 int n;
1073
1074 BUG_ON(count > MAX_LEDS);
1075
1076 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
1077 buzz_set_leds(hdev, leds);
1078 } else {
1079 for (n = 0; n < count; n++)
1080 drv_data->led_state[n] = leds[n];
1081 schedule_work(&drv_data->state_worker);
1082 }
1083}
1084
1085static void sony_led_set_brightness(struct led_classdev *led,
1086 enum led_brightness value)
1087{
1088 struct device *dev = led->dev->parent;
1089 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1090 struct sony_sc *drv_data;
1091
1092 int n;
1093
1094 drv_data = hid_get_drvdata(hdev);
1095 if (!drv_data) {
1096 hid_err(hdev, "No device data\n");
1097 return;
1098 }
1099
1100 for (n = 0; n < drv_data->led_count; n++) {
1101 if (led == drv_data->leds[n]) {
1102 if (value != drv_data->led_state[n]) {
1103 drv_data->led_state[n] = value;
1104 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
1105 }
1106 break;
1107 }
1108 }
1109}
1110
1111static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1112{
1113 struct device *dev = led->dev->parent;
1114 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1115 struct sony_sc *drv_data;
1116
1117 int n;
1118
1119 drv_data = hid_get_drvdata(hdev);
1120 if (!drv_data) {
1121 hid_err(hdev, "No device data\n");
1122 return LED_OFF;
1123 }
1124
1125 for (n = 0; n < drv_data->led_count; n++) {
1126 if (led == drv_data->leds[n])
1127 return drv_data->led_state[n];
1128 }
1129
1130 return LED_OFF;
1131}
1132
1133static void sony_leds_remove(struct hid_device *hdev)
1134{
1135 struct sony_sc *drv_data;
1136 struct led_classdev *led;
1137 int n;
1138
1139 drv_data = hid_get_drvdata(hdev);
1140 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
1141
1142 for (n = 0; n < drv_data->led_count; n++) {
1143 led = drv_data->leds[n];
1144 drv_data->leds[n] = NULL;
1145 if (!led)
1146 continue;
1147 led_classdev_unregister(led);
1148 kfree(led);
1149 }
1150
1151 drv_data->led_count = 0;
1152}
1153
1154static int sony_leds_init(struct hid_device *hdev)
1155{
1156 struct sony_sc *drv_data;
1157 int n, ret = 0;
1158 int max_brightness;
1159 int use_colors;
1160 struct led_classdev *led;
1161 size_t name_sz;
1162 char *name;
1163 size_t name_len;
1164 const char *name_fmt;
1165 static const char * const color_str[] = { "red", "green", "blue" };
1166 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
1167
1168 drv_data = hid_get_drvdata(hdev);
1169 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
1170
1171 if (drv_data->quirks & BUZZ_CONTROLLER) {
1172 drv_data->led_count = 4;
1173 max_brightness = 1;
1174 use_colors = 0;
1175 name_len = strlen("::buzz#");
1176 name_fmt = "%s::buzz%d";
1177
1178 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1179 return -ENODEV;
1180 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER) {
1181 drv_data->led_count = 3;
1182 max_brightness = 255;
1183 use_colors = 1;
1184 name_len = 0;
1185 name_fmt = "%s:%s";
1186 } else {
1187 drv_data->led_count = 4;
1188 max_brightness = 1;
1189 use_colors = 0;
1190 name_len = strlen("::sony#");
1191 name_fmt = "%s::sony%d";
1192 }
1193
1194
1195
1196
1197
1198
1199 sony_set_leds(hdev, initial_values, drv_data->led_count);
1200
1201 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1202
1203 for (n = 0; n < drv_data->led_count; n++) {
1204
1205 if (use_colors)
1206 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
1207
1208 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1209 if (!led) {
1210 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1211 ret = -ENOMEM;
1212 goto error_leds;
1213 }
1214
1215 name = (void *)(&led[1]);
1216 if (use_colors)
1217 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
1218 else
1219 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1220 led->name = name;
1221 led->brightness = 0;
1222 led->max_brightness = max_brightness;
1223 led->brightness_get = sony_led_get_brightness;
1224 led->brightness_set = sony_led_set_brightness;
1225
1226 ret = led_classdev_register(&hdev->dev, led);
1227 if (ret) {
1228 hid_err(hdev, "Failed to register LED %d\n", n);
1229 kfree(led);
1230 goto error_leds;
1231 }
1232
1233 drv_data->leds[n] = led;
1234 }
1235
1236 return ret;
1237
1238error_leds:
1239 sony_leds_remove(hdev);
1240
1241 return ret;
1242}
1243
1244static void sixaxis_state_worker(struct work_struct *work)
1245{
1246 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1247 unsigned char buf[] = {
1248 0x01,
1249 0x00, 0xff, 0x00, 0xff, 0x00,
1250 0x00, 0x00, 0x00, 0x00, 0x00,
1251 0xff, 0x27, 0x10, 0x00, 0x32,
1252 0xff, 0x27, 0x10, 0x00, 0x32,
1253 0xff, 0x27, 0x10, 0x00, 0x32,
1254 0xff, 0x27, 0x10, 0x00, 0x32,
1255 0x00, 0x00, 0x00, 0x00, 0x00
1256 };
1257
1258#ifdef CONFIG_SONY_FF
1259 buf[3] = sc->right ? 1 : 0;
1260 buf[5] = sc->left;
1261#endif
1262
1263 buf[10] |= sc->led_state[0] << 1;
1264 buf[10] |= sc->led_state[1] << 2;
1265 buf[10] |= sc->led_state[2] << 3;
1266 buf[10] |= sc->led_state[3] << 4;
1267
1268 hid_hw_raw_request(sc->hdev, 0x01, buf, sizeof(buf), HID_OUTPUT_REPORT,
1269 HID_REQ_SET_REPORT);
1270}
1271
1272static void dualshock4_state_worker(struct work_struct *work)
1273{
1274 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1275 struct hid_device *hdev = sc->hdev;
1276 int offset;
1277
1278 __u8 buf[78] = { 0 };
1279
1280 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1281 buf[0] = 0x05;
1282 buf[1] = 0x03;
1283 offset = 4;
1284 } else {
1285 buf[0] = 0x11;
1286 buf[1] = 0xB0;
1287 buf[3] = 0x0F;
1288 offset = 6;
1289 }
1290
1291#ifdef CONFIG_SONY_FF
1292 buf[offset++] = sc->right;
1293 buf[offset++] = sc->left;
1294#else
1295 offset += 2;
1296#endif
1297
1298 buf[offset++] = sc->led_state[0];
1299 buf[offset++] = sc->led_state[1];
1300 buf[offset++] = sc->led_state[2];
1301
1302 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1303 hid_hw_output_report(hdev, buf, 32);
1304 else
1305 hid_hw_raw_request(hdev, 0x11, buf, 78,
1306 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1307}
1308
1309#ifdef CONFIG_SONY_FF
1310static int sony_play_effect(struct input_dev *dev, void *data,
1311 struct ff_effect *effect)
1312{
1313 struct hid_device *hid = input_get_drvdata(dev);
1314 struct sony_sc *sc = hid_get_drvdata(hid);
1315
1316 if (effect->type != FF_RUMBLE)
1317 return 0;
1318
1319 sc->left = effect->u.rumble.strong_magnitude / 256;
1320 sc->right = effect->u.rumble.weak_magnitude / 256;
1321
1322 schedule_work(&sc->state_worker);
1323 return 0;
1324}
1325
1326static int sony_init_ff(struct hid_device *hdev)
1327{
1328 struct hid_input *hidinput = list_entry(hdev->inputs.next,
1329 struct hid_input, list);
1330 struct input_dev *input_dev = hidinput->input;
1331
1332 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1333 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1334}
1335
1336#else
1337static int sony_init_ff(struct hid_device *hdev)
1338{
1339 return 0;
1340}
1341
1342#endif
1343
1344static int sony_battery_get_property(struct power_supply *psy,
1345 enum power_supply_property psp,
1346 union power_supply_propval *val)
1347{
1348 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1349 unsigned long flags;
1350 int ret = 0;
1351 u8 battery_charging, battery_capacity, cable_state;
1352
1353 spin_lock_irqsave(&sc->lock, flags);
1354 battery_charging = sc->battery_charging;
1355 battery_capacity = sc->battery_capacity;
1356 cable_state = sc->cable_state;
1357 spin_unlock_irqrestore(&sc->lock, flags);
1358
1359 switch (psp) {
1360 case POWER_SUPPLY_PROP_PRESENT:
1361 val->intval = 1;
1362 break;
1363 case POWER_SUPPLY_PROP_SCOPE:
1364 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1365 break;
1366 case POWER_SUPPLY_PROP_CAPACITY:
1367 val->intval = battery_capacity;
1368 break;
1369 case POWER_SUPPLY_PROP_STATUS:
1370 if (battery_charging)
1371 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1372 else
1373 if (battery_capacity == 100 && cable_state)
1374 val->intval = POWER_SUPPLY_STATUS_FULL;
1375 else
1376 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1377 break;
1378 default:
1379 ret = -EINVAL;
1380 break;
1381 }
1382 return ret;
1383}
1384
1385static int sony_battery_probe(struct sony_sc *sc)
1386{
1387 static atomic_t power_id_seq = ATOMIC_INIT(0);
1388 unsigned long power_id;
1389 struct hid_device *hdev = sc->hdev;
1390 int ret;
1391
1392
1393
1394
1395
1396 sc->battery_capacity = 100;
1397
1398 power_id = (unsigned long)atomic_inc_return(&power_id_seq);
1399
1400 sc->battery.properties = sony_battery_props;
1401 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1402 sc->battery.get_property = sony_battery_get_property;
1403 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1404 sc->battery.use_for_apm = 0;
1405 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%lu",
1406 power_id);
1407 if (!sc->battery.name)
1408 return -ENOMEM;
1409
1410 ret = power_supply_register(&hdev->dev, &sc->battery);
1411 if (ret) {
1412 hid_err(hdev, "Unable to register battery device\n");
1413 goto err_free;
1414 }
1415
1416 power_supply_powers(&sc->battery, &hdev->dev);
1417 return 0;
1418
1419err_free:
1420 kfree(sc->battery.name);
1421 sc->battery.name = NULL;
1422 return ret;
1423}
1424
1425static void sony_battery_remove(struct sony_sc *sc)
1426{
1427 if (!sc->battery.name)
1428 return;
1429
1430 power_supply_unregister(&sc->battery);
1431 kfree(sc->battery.name);
1432 sc->battery.name = NULL;
1433}
1434
1435static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1436 int w, int h)
1437{
1438 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1439 struct hid_input, list);
1440 struct input_dev *input_dev = hidinput->input;
1441 int ret;
1442
1443 ret = input_mt_init_slots(input_dev, touch_count, 0);
1444 if (ret < 0) {
1445 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1446 return ret;
1447 }
1448
1449 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1450 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1451
1452 return 0;
1453}
1454
1455
1456
1457
1458
1459
1460
1461static int sony_check_add_dev_list(struct sony_sc *sc)
1462{
1463 struct sony_sc *entry;
1464 unsigned long flags;
1465 int ret;
1466
1467 spin_lock_irqsave(&sony_dev_list_lock, flags);
1468
1469 list_for_each_entry(entry, &sony_device_list, list_node) {
1470 ret = memcmp(sc->mac_address, entry->mac_address,
1471 sizeof(sc->mac_address));
1472 if (!ret) {
1473 ret = -EEXIST;
1474 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1475 sc->mac_address);
1476 goto unlock;
1477 }
1478 }
1479
1480 ret = 0;
1481 list_add(&(sc->list_node), &sony_device_list);
1482
1483unlock:
1484 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1485 return ret;
1486}
1487
1488static void sony_remove_dev_list(struct sony_sc *sc)
1489{
1490 unsigned long flags;
1491
1492 if (sc->list_node.next) {
1493 spin_lock_irqsave(&sony_dev_list_lock, flags);
1494 list_del(&(sc->list_node));
1495 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1496 }
1497}
1498
1499static int sony_get_bt_devaddr(struct sony_sc *sc)
1500{
1501 int ret;
1502
1503
1504 ret = strlen(sc->hdev->uniq);
1505 if (ret != 17)
1506 return -EINVAL;
1507
1508 ret = sscanf(sc->hdev->uniq,
1509 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1510 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1511 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1512
1513 if (ret != 6)
1514 return -EINVAL;
1515
1516 return 0;
1517}
1518
1519static int sony_check_add(struct sony_sc *sc)
1520{
1521 int n, ret;
1522
1523 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1524 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1525
1526
1527
1528
1529
1530
1531 if (sony_get_bt_devaddr(sc) < 0) {
1532 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1533 return 0;
1534 }
1535 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1536 __u8 buf[7];
1537
1538
1539
1540
1541
1542
1543 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1544 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1545
1546 if (ret != 7) {
1547 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1548 return ret < 0 ? ret : -EINVAL;
1549 }
1550
1551 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1552 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1553 __u8 buf[18];
1554
1555
1556
1557
1558
1559
1560 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1561 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1562
1563 if (ret != 18) {
1564 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1565 return ret < 0 ? ret : -EINVAL;
1566 }
1567
1568
1569
1570
1571
1572 for (n = 0; n < 6; n++)
1573 sc->mac_address[5-n] = buf[4+n];
1574 } else {
1575 return 0;
1576 }
1577
1578 return sony_check_add_dev_list(sc);
1579}
1580
1581
1582static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1583{
1584 int ret;
1585 unsigned long quirks = id->driver_data;
1586 struct sony_sc *sc;
1587 unsigned int connect_mask = HID_CONNECT_DEFAULT;
1588
1589 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1590 if (sc == NULL) {
1591 hid_err(hdev, "can't alloc sony descriptor\n");
1592 return -ENOMEM;
1593 }
1594
1595 sc->quirks = quirks;
1596 hid_set_drvdata(hdev, sc);
1597 sc->hdev = hdev;
1598
1599 ret = hid_parse(hdev);
1600 if (ret) {
1601 hid_err(hdev, "parse failed\n");
1602 return ret;
1603 }
1604
1605 if (sc->quirks & VAIO_RDESC_CONSTANT)
1606 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1607 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1608 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1609 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1610 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1611
1612 ret = hid_hw_start(hdev, connect_mask);
1613 if (ret) {
1614 hid_err(hdev, "hw start failed\n");
1615 return ret;
1616 }
1617
1618 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1630 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1631 ret = sixaxis_set_operational_usb(hdev);
1632 sc->worker_initialized = 1;
1633 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1634 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1635
1636
1637
1638
1639 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1640 ret = sixaxis_set_operational_bt(hdev);
1641 sc->worker_initialized = 1;
1642 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1643 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1644 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1645
1646
1647
1648
1649 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1650 ret = dualshock4_set_operational_bt(hdev);
1651 if (ret < 0) {
1652 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1653 goto err_stop;
1654 }
1655 }
1656
1657
1658
1659
1660 ret = sony_register_touchpad(sc, 2, 1920, 940);
1661 if (ret < 0)
1662 goto err_stop;
1663
1664 sc->worker_initialized = 1;
1665 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1666 } else {
1667 ret = 0;
1668 }
1669
1670 if (ret < 0)
1671 goto err_stop;
1672
1673 ret = sony_check_add(sc);
1674 if (ret < 0)
1675 goto err_stop;
1676
1677 if (sc->quirks & SONY_LED_SUPPORT) {
1678 ret = sony_leds_init(hdev);
1679 if (ret < 0)
1680 goto err_stop;
1681 }
1682
1683 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1684 ret = sony_battery_probe(sc);
1685 if (ret < 0)
1686 goto err_stop;
1687
1688
1689 ret = hid_hw_open(hdev);
1690 if (ret < 0) {
1691 hid_err(hdev, "hw open failed\n");
1692 goto err_stop;
1693 }
1694 }
1695
1696 if (sc->quirks & SONY_FF_SUPPORT) {
1697 ret = sony_init_ff(hdev);
1698 if (ret < 0)
1699 goto err_close;
1700 }
1701
1702 return 0;
1703err_close:
1704 hid_hw_close(hdev);
1705err_stop:
1706 if (sc->quirks & SONY_LED_SUPPORT)
1707 sony_leds_remove(hdev);
1708 if (sc->quirks & SONY_BATTERY_SUPPORT)
1709 sony_battery_remove(sc);
1710 if (sc->worker_initialized)
1711 cancel_work_sync(&sc->state_worker);
1712 sony_remove_dev_list(sc);
1713 hid_hw_stop(hdev);
1714 return ret;
1715}
1716
1717static void sony_remove(struct hid_device *hdev)
1718{
1719 struct sony_sc *sc = hid_get_drvdata(hdev);
1720
1721 if (sc->quirks & SONY_LED_SUPPORT)
1722 sony_leds_remove(hdev);
1723
1724 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1725 hid_hw_close(hdev);
1726 sony_battery_remove(sc);
1727 }
1728
1729 if (sc->worker_initialized)
1730 cancel_work_sync(&sc->state_worker);
1731
1732 sony_remove_dev_list(sc);
1733
1734 hid_hw_stop(hdev);
1735}
1736
1737static const struct hid_device_id sony_devices[] = {
1738 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1739 .driver_data = SIXAXIS_CONTROLLER_USB },
1740 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1741 .driver_data = SIXAXIS_CONTROLLER_USB },
1742 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1743 .driver_data = SIXAXIS_CONTROLLER_BT },
1744 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1745 .driver_data = VAIO_RDESC_CONSTANT },
1746 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1747 .driver_data = VAIO_RDESC_CONSTANT },
1748
1749
1750 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1751 .driver_data = BUZZ_CONTROLLER },
1752 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1753 .driver_data = BUZZ_CONTROLLER },
1754
1755 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1756 .driver_data = PS3REMOTE },
1757
1758 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1759 .driver_data = PS3REMOTE },
1760
1761 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1762 .driver_data = DUALSHOCK4_CONTROLLER_USB },
1763 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1764 .driver_data = DUALSHOCK4_CONTROLLER_BT },
1765 { }
1766};
1767MODULE_DEVICE_TABLE(hid, sony_devices);
1768
1769static struct hid_driver sony_driver = {
1770 .name = "sony",
1771 .id_table = sony_devices,
1772 .input_mapping = sony_mapping,
1773 .probe = sony_probe,
1774 .remove = sony_remove,
1775 .report_fixup = sony_report_fixup,
1776 .raw_event = sony_raw_event
1777};
1778module_hid_driver(sony_driver);
1779
1780MODULE_LICENSE("GPL");
1781