1
2
3
4
5
6
7
8
9
10
11#include "wacom_wac.h"
12#include "wacom.h"
13#include <linux/input/mt.h>
14
15#define WAC_MSG_RETRIES 5
16#define WAC_CMD_RETRIES 10
17
18#define DEV_ATTR_RW_PERM (S_IRUGO | S_IWUSR | S_IWGRP)
19#define DEV_ATTR_WO_PERM (S_IWUSR | S_IWGRP)
20#define DEV_ATTR_RO_PERM (S_IRUSR | S_IRGRP)
21
22static int wacom_get_report(struct hid_device *hdev, u8 type, u8 *buf,
23 size_t size, unsigned int retries)
24{
25 int retval;
26
27 do {
28 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
29 HID_REQ_GET_REPORT);
30 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries);
31
32 if (retval < 0)
33 hid_err(hdev, "wacom_get_report: ran out of retries "
34 "(last error = %d)\n", retval);
35
36 return retval;
37}
38
39static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf,
40 size_t size, unsigned int retries)
41{
42 int retval;
43
44 do {
45 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
46 HID_REQ_SET_REPORT);
47 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries);
48
49 if (retval < 0)
50 hid_err(hdev, "wacom_set_report: ran out of retries "
51 "(last error = %d)\n", retval);
52
53 return retval;
54}
55
56static void wacom_wac_queue_insert(struct hid_device *hdev,
57 struct kfifo_rec_ptr_2 *fifo,
58 u8 *raw_data, int size)
59{
60 bool warned = false;
61
62 while (kfifo_avail(fifo) < size) {
63 if (!warned)
64 hid_warn(hdev, "%s: kfifo has filled, starting to drop events\n", __func__);
65 warned = true;
66
67 kfifo_skip(fifo);
68 }
69
70 kfifo_in(fifo, raw_data, size);
71}
72
73static void wacom_wac_queue_flush(struct hid_device *hdev,
74 struct kfifo_rec_ptr_2 *fifo)
75{
76 while (!kfifo_is_empty(fifo)) {
77 u8 buf[WACOM_PKGLEN_MAX];
78 int size;
79 int err;
80
81 size = kfifo_out(fifo, buf, sizeof(buf));
82 err = hid_report_raw_event(hdev, HID_INPUT_REPORT, buf, size, false);
83 if (err) {
84 hid_warn(hdev, "%s: unable to flush event due to error %d\n",
85 __func__, err);
86 }
87 }
88}
89
90static int wacom_wac_pen_serial_enforce(struct hid_device *hdev,
91 struct hid_report *report, u8 *raw_data, int size)
92{
93 struct wacom *wacom = hid_get_drvdata(hdev);
94 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
95 struct wacom_features *features = &wacom_wac->features;
96 bool flush = false;
97 bool insert = false;
98 int i, j;
99
100 if (wacom_wac->serial[0] || !(features->quirks & WACOM_QUIRK_TOOLSERIAL))
101 return 0;
102
103
104 for (i = 0; i < report->maxfield; i++) {
105 for (j = 0; j < report->field[i]->maxusage; j++) {
106 struct hid_field *field = report->field[i];
107 struct hid_usage *usage = &field->usage[j];
108 unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
109 unsigned int offset;
110 unsigned int size;
111 unsigned int value;
112
113 if (equivalent_usage != HID_DG_INRANGE &&
114 equivalent_usage != HID_DG_TOOLSERIALNUMBER &&
115 equivalent_usage != WACOM_HID_WD_SERIALHI &&
116 equivalent_usage != WACOM_HID_WD_TOOLTYPE)
117 continue;
118
119 offset = field->report_offset;
120 size = field->report_size;
121 value = hid_field_extract(hdev, raw_data+1, offset + j * size, size);
122
123
124 if (equivalent_usage == HID_DG_INRANGE)
125 value = !value;
126
127 if (value) {
128 flush = true;
129 switch (equivalent_usage) {
130 case HID_DG_TOOLSERIALNUMBER:
131 wacom_wac->serial[0] = value;
132 break;
133
134 case WACOM_HID_WD_SERIALHI:
135 wacom_wac->serial[0] |= ((__u64)value) << 32;
136 break;
137
138 case WACOM_HID_WD_TOOLTYPE:
139 wacom_wac->id[0] = value;
140 break;
141 }
142 }
143 else {
144 insert = true;
145 }
146 }
147 }
148
149 if (flush)
150 wacom_wac_queue_flush(hdev, &wacom_wac->pen_fifo);
151 else if (insert)
152 wacom_wac_queue_insert(hdev, &wacom_wac->pen_fifo, raw_data, size);
153
154 return insert && !flush;
155}
156
157static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
158 u8 *raw_data, int size)
159{
160 struct wacom *wacom = hid_get_drvdata(hdev);
161
162 if (size > WACOM_PKGLEN_MAX)
163 return 1;
164
165 if (wacom_wac_pen_serial_enforce(hdev, report, raw_data, size))
166 return -1;
167
168 memcpy(wacom->wacom_wac.data, raw_data, size);
169
170 wacom_wac_irq(&wacom->wacom_wac, size);
171
172 return 0;
173}
174
175static int wacom_open(struct input_dev *dev)
176{
177 struct wacom *wacom = input_get_drvdata(dev);
178
179 return hid_hw_open(wacom->hdev);
180}
181
182static void wacom_close(struct input_dev *dev)
183{
184 struct wacom *wacom = input_get_drvdata(dev);
185
186
187
188
189
190 if (wacom->hdev)
191 hid_hw_close(wacom->hdev);
192}
193
194
195
196
197static int wacom_calc_hid_res(int logical_extents, int physical_extents,
198 unsigned unit, int exponent)
199{
200 struct hid_field field = {
201 .logical_maximum = logical_extents,
202 .physical_maximum = physical_extents,
203 .unit = unit,
204 .unit_exponent = exponent,
205 };
206
207 return hidinput_calc_abs_res(&field, ABS_X);
208}
209
210static void wacom_hid_usage_quirk(struct hid_device *hdev,
211 struct hid_field *field, struct hid_usage *usage)
212{
213 struct wacom *wacom = hid_get_drvdata(hdev);
214 struct wacom_features *features = &wacom->wacom_wac.features;
215 unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
216
217
218
219
220
221 if (hdev->vendor == USB_VENDOR_ID_WACOM &&
222 hdev->product == 0x4200 &&
223 field->application == HID_UP_MSVENDOR) {
224 wacom->wacom_wac.mode_report = field->report->id;
225 wacom->wacom_wac.mode_value = 2;
226 }
227
228
229
230
231
232
233
234
235
236 if (features->type == HID_GENERIC &&
237 usage->hid == 0x000D0000 &&
238 field->application == HID_DG_PEN &&
239 field->physical == HID_DG_STYLUS) {
240 int i = usage->usage_index;
241
242 if (i-4 >= 0 && i+1 < field->maxusage &&
243 field->usage[i-4].hid == HID_DG_TIPSWITCH &&
244 field->usage[i-3].hid == HID_DG_BARRELSWITCH &&
245 field->usage[i-2].hid == HID_DG_ERASER &&
246 field->usage[i-1].hid == HID_DG_INVERT &&
247 field->usage[i+1].hid == HID_DG_INRANGE) {
248 usage->hid = HID_DG_BARRELSWITCH2;
249 }
250 }
251
252
253
254
255
256
257
258
259
260 if (usage->hid == WACOM_HID_WT_SERIALNUMBER &&
261 field->report_size == 16 &&
262 field->index + 2 < field->report->maxfield) {
263 struct hid_field *a = field->report->field[field->index + 1];
264 struct hid_field *b = field->report->field[field->index + 2];
265
266 if (a->maxusage > 0 &&
267 a->usage[0].hid == HID_DG_TOOLSERIALNUMBER &&
268 a->report_size == 32 &&
269 b->maxusage > 0 &&
270 b->usage[0].hid == 0xFF000000 &&
271 b->report_size == 8) {
272 features->quirks |= WACOM_QUIRK_AESPEN;
273 usage->hid = WACOM_HID_WD_TOOLTYPE;
274 field->logical_minimum = S16_MIN;
275 field->logical_maximum = S16_MAX;
276 a->logical_minimum = S32_MIN;
277 a->logical_maximum = S32_MAX;
278 b->usage[0].hid = WACOM_HID_WD_SERIALHI;
279 b->logical_minimum = 0;
280 b->logical_maximum = U8_MAX;
281 }
282 }
283
284
285 if (hdev->vendor == USB_VENDOR_ID_WACOM &&
286 hdev->product == 0x0358 &&
287 WACOM_PEN_FIELD(field) &&
288 equivalent_usage == HID_GD_Y) {
289 field->logical_maximum = 43200;
290 }
291}
292
293static void wacom_feature_mapping(struct hid_device *hdev,
294 struct hid_field *field, struct hid_usage *usage)
295{
296 struct wacom *wacom = hid_get_drvdata(hdev);
297 struct wacom_features *features = &wacom->wacom_wac.features;
298 struct hid_data *hid_data = &wacom->wacom_wac.hid_data;
299 unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
300 u8 *data;
301 int ret;
302 u32 n;
303
304 wacom_hid_usage_quirk(hdev, field, usage);
305
306 switch (equivalent_usage) {
307 case WACOM_HID_WD_TOUCH_RING_SETTING:
308 wacom->generic_has_leds = true;
309 break;
310 case HID_DG_CONTACTMAX:
311
312 if (!features->touch_max) {
313
314 n = hid_report_len(field->report);
315 data = hid_alloc_report_buf(field->report, GFP_KERNEL);
316 if (!data)
317 break;
318 data[0] = field->report->id;
319 ret = wacom_get_report(hdev, HID_FEATURE_REPORT,
320 data, n, WAC_CMD_RETRIES);
321 if (ret == n) {
322 ret = hid_report_raw_event(hdev,
323 HID_FEATURE_REPORT, data, n, 0);
324 } else {
325 features->touch_max = 16;
326 hid_warn(hdev, "wacom_feature_mapping: "
327 "could not get HID_DG_CONTACTMAX, "
328 "defaulting to %d\n",
329 features->touch_max);
330 }
331 kfree(data);
332 }
333 break;
334 case HID_DG_INPUTMODE:
335
336 if (usage->usage_index >= field->report_count) {
337 dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n");
338 break;
339 }
340
341 hid_data->inputmode = field->report->id;
342 hid_data->inputmode_index = usage->usage_index;
343 break;
344
345 case HID_UP_DIGITIZER:
346 if (field->report->id == 0x0B &&
347 (field->application == WACOM_HID_G9_PEN ||
348 field->application == WACOM_HID_G11_PEN)) {
349 wacom->wacom_wac.mode_report = field->report->id;
350 wacom->wacom_wac.mode_value = 0;
351 }
352 break;
353
354 case WACOM_HID_WD_DATAMODE:
355 wacom->wacom_wac.mode_report = field->report->id;
356 wacom->wacom_wac.mode_value = 2;
357 break;
358
359 case WACOM_HID_UP_G9:
360 case WACOM_HID_UP_G11:
361 if (field->report->id == 0x03 &&
362 (field->application == WACOM_HID_G9_TOUCHSCREEN ||
363 field->application == WACOM_HID_G11_TOUCHSCREEN)) {
364 wacom->wacom_wac.mode_report = field->report->id;
365 wacom->wacom_wac.mode_value = 0;
366 }
367 break;
368 case WACOM_HID_WD_OFFSETLEFT:
369 case WACOM_HID_WD_OFFSETTOP:
370 case WACOM_HID_WD_OFFSETRIGHT:
371 case WACOM_HID_WD_OFFSETBOTTOM:
372
373 n = hid_report_len(field->report);
374 data = hid_alloc_report_buf(field->report, GFP_KERNEL);
375 if (!data)
376 break;
377 data[0] = field->report->id;
378 ret = wacom_get_report(hdev, HID_FEATURE_REPORT,
379 data, n, WAC_CMD_RETRIES);
380 if (ret == n) {
381 ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT,
382 data, n, 0);
383 } else {
384 hid_warn(hdev, "%s: could not retrieve sensor offsets\n",
385 __func__);
386 }
387 kfree(data);
388 break;
389 }
390}
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424static void wacom_usage_mapping(struct hid_device *hdev,
425 struct hid_field *field, struct hid_usage *usage)
426{
427 struct wacom *wacom = hid_get_drvdata(hdev);
428 struct wacom_features *features = &wacom->wacom_wac.features;
429 bool finger = WACOM_FINGER_FIELD(field);
430 bool pen = WACOM_PEN_FIELD(field);
431 unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
432
433
434
435
436
437
438 if (pen)
439 features->device_type |= WACOM_DEVICETYPE_PEN;
440 else if (finger)
441 features->device_type |= WACOM_DEVICETYPE_TOUCH;
442 else
443 return;
444
445 wacom_hid_usage_quirk(hdev, field, usage);
446
447 switch (equivalent_usage) {
448 case HID_GD_X:
449 features->x_max = field->logical_maximum;
450 if (finger) {
451 features->x_phy = field->physical_maximum;
452 if ((features->type != BAMBOO_PT) &&
453 (features->type != BAMBOO_TOUCH)) {
454 features->unit = field->unit;
455 features->unitExpo = field->unit_exponent;
456 }
457 }
458 break;
459 case HID_GD_Y:
460 features->y_max = field->logical_maximum;
461 if (finger) {
462 features->y_phy = field->physical_maximum;
463 if ((features->type != BAMBOO_PT) &&
464 (features->type != BAMBOO_TOUCH)) {
465 features->unit = field->unit;
466 features->unitExpo = field->unit_exponent;
467 }
468 }
469 break;
470 case HID_DG_TIPPRESSURE:
471 if (pen)
472 features->pressure_max = field->logical_maximum;
473 break;
474 }
475
476 if (features->type == HID_GENERIC)
477 wacom_wac_usage_mapping(hdev, field, usage);
478}
479
480static void wacom_post_parse_hid(struct hid_device *hdev,
481 struct wacom_features *features)
482{
483 struct wacom *wacom = hid_get_drvdata(hdev);
484 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
485
486 if (features->type == HID_GENERIC) {
487
488 if (wacom_wac->has_mode_change) {
489 if (wacom_wac->is_direct_mode)
490 features->device_type |= WACOM_DEVICETYPE_DIRECT;
491 else
492 features->device_type &= ~WACOM_DEVICETYPE_DIRECT;
493 }
494
495 if (features->touch_max > 1) {
496 if (features->device_type & WACOM_DEVICETYPE_DIRECT)
497 input_mt_init_slots(wacom_wac->touch_input,
498 wacom_wac->features.touch_max,
499 INPUT_MT_DIRECT);
500 else
501 input_mt_init_slots(wacom_wac->touch_input,
502 wacom_wac->features.touch_max,
503 INPUT_MT_POINTER);
504 }
505 }
506}
507
508static void wacom_parse_hid(struct hid_device *hdev,
509 struct wacom_features *features)
510{
511 struct hid_report_enum *rep_enum;
512 struct hid_report *hreport;
513 int i, j;
514
515
516 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
517 list_for_each_entry(hreport, &rep_enum->report_list, list) {
518 for (i = 0; i < hreport->maxfield; i++) {
519
520 if (hreport->field[i]->report_count < 1)
521 continue;
522
523 for (j = 0; j < hreport->field[i]->maxusage; j++) {
524 wacom_feature_mapping(hdev, hreport->field[i],
525 hreport->field[i]->usage + j);
526 }
527 }
528 }
529
530
531 rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
532 list_for_each_entry(hreport, &rep_enum->report_list, list) {
533
534 if (!hreport->maxfield)
535 continue;
536
537 for (i = 0; i < hreport->maxfield; i++)
538 for (j = 0; j < hreport->field[i]->maxusage; j++)
539 wacom_usage_mapping(hdev, hreport->field[i],
540 hreport->field[i]->usage + j);
541 }
542
543 wacom_post_parse_hid(hdev, features);
544}
545
546static int wacom_hid_set_device_mode(struct hid_device *hdev)
547{
548 struct wacom *wacom = hid_get_drvdata(hdev);
549 struct hid_data *hid_data = &wacom->wacom_wac.hid_data;
550 struct hid_report *r;
551 struct hid_report_enum *re;
552
553 if (hid_data->inputmode < 0)
554 return 0;
555
556 re = &(hdev->report_enum[HID_FEATURE_REPORT]);
557 r = re->report_id_hash[hid_data->inputmode];
558 if (r) {
559 r->field[0]->value[hid_data->inputmode_index] = 2;
560 hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
561 }
562 return 0;
563}
564
565static int wacom_set_device_mode(struct hid_device *hdev,
566 struct wacom_wac *wacom_wac)
567{
568 u8 *rep_data;
569 struct hid_report *r;
570 struct hid_report_enum *re;
571 u32 length;
572 int error = -ENOMEM, limit = 0;
573
574 if (wacom_wac->mode_report < 0)
575 return 0;
576
577 re = &(hdev->report_enum[HID_FEATURE_REPORT]);
578 r = re->report_id_hash[wacom_wac->mode_report];
579 if (!r)
580 return -EINVAL;
581
582 rep_data = hid_alloc_report_buf(r, GFP_KERNEL);
583 if (!rep_data)
584 return -ENOMEM;
585
586 length = hid_report_len(r);
587
588 do {
589 rep_data[0] = wacom_wac->mode_report;
590 rep_data[1] = wacom_wac->mode_value;
591
592 error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
593 length, 1);
594 if (error >= 0)
595 error = wacom_get_report(hdev, HID_FEATURE_REPORT,
596 rep_data, length, 1);
597 } while (error >= 0 &&
598 rep_data[1] != wacom_wac->mode_report &&
599 limit++ < WAC_MSG_RETRIES);
600
601 kfree(rep_data);
602
603 return error < 0 ? error : 0;
604}
605
606static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
607 struct wacom_features *features)
608{
609 struct wacom *wacom = hid_get_drvdata(hdev);
610 int ret;
611 u8 rep_data[2];
612
613 switch (features->type) {
614 case GRAPHIRE_BT:
615 rep_data[0] = 0x03;
616 rep_data[1] = 0x00;
617 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
618 3);
619
620 if (ret >= 0) {
621 rep_data[0] = speed == 0 ? 0x05 : 0x06;
622 rep_data[1] = 0x00;
623
624 ret = wacom_set_report(hdev, HID_FEATURE_REPORT,
625 rep_data, 2, 3);
626
627 if (ret >= 0) {
628 wacom->wacom_wac.bt_high_speed = speed;
629 return 0;
630 }
631 }
632
633
634
635
636
637 hid_warn(hdev, "failed to poke device, command %d, err %d\n",
638 rep_data[0], ret);
639 break;
640 case INTUOS4WL:
641 if (speed == 1)
642 wacom->wacom_wac.bt_features &= ~0x20;
643 else
644 wacom->wacom_wac.bt_features |= 0x20;
645
646 rep_data[0] = 0x03;
647 rep_data[1] = wacom->wacom_wac.bt_features;
648
649 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
650 1);
651 if (ret >= 0)
652 wacom->wacom_wac.bt_high_speed = speed;
653 break;
654 }
655
656 return 0;
657}
658
659
660
661
662
663
664
665
666static int _wacom_query_tablet_data(struct wacom *wacom)
667{
668 struct hid_device *hdev = wacom->hdev;
669 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
670 struct wacom_features *features = &wacom_wac->features;
671
672 if (hdev->bus == BUS_BLUETOOTH)
673 return wacom_bt_query_tablet_data(hdev, 1, features);
674
675 if (features->type != HID_GENERIC) {
676 if (features->device_type & WACOM_DEVICETYPE_TOUCH) {
677 if (features->type > TABLETPC) {
678
679 wacom_wac->mode_report = 3;
680 wacom_wac->mode_value = 4;
681 } else if (features->type == WACOM_24HDT) {
682 wacom_wac->mode_report = 18;
683 wacom_wac->mode_value = 2;
684 } else if (features->type == WACOM_27QHDT) {
685 wacom_wac->mode_report = 131;
686 wacom_wac->mode_value = 2;
687 } else if (features->type == BAMBOO_PAD) {
688 wacom_wac->mode_report = 2;
689 wacom_wac->mode_value = 2;
690 }
691 } else if (features->device_type & WACOM_DEVICETYPE_PEN) {
692 if (features->type <= BAMBOO_PT) {
693 wacom_wac->mode_report = 2;
694 wacom_wac->mode_value = 2;
695 }
696 }
697 }
698
699 wacom_set_device_mode(hdev, wacom_wac);
700
701 if (features->type == HID_GENERIC)
702 return wacom_hid_set_device_mode(hdev);
703
704 return 0;
705}
706
707static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
708 struct wacom_features *features)
709{
710 struct wacom *wacom = hid_get_drvdata(hdev);
711 struct usb_interface *intf = wacom->intf;
712
713
714 features->x_fuzz = 4;
715 features->y_fuzz = 4;
716 features->pressure_fuzz = 0;
717 features->distance_fuzz = 1;
718 features->tilt_fuzz = 1;
719
720
721
722
723
724
725
726 if (features->type == WIRELESS) {
727 if (intf->cur_altsetting->desc.bInterfaceNumber == 0)
728 features->device_type = WACOM_DEVICETYPE_WL_MONITOR;
729 else
730 features->device_type = WACOM_DEVICETYPE_NONE;
731 return;
732 }
733
734 wacom_parse_hid(hdev, features);
735}
736
737struct wacom_hdev_data {
738 struct list_head list;
739 struct kref kref;
740 struct hid_device *dev;
741 struct wacom_shared shared;
742};
743
744static LIST_HEAD(wacom_udev_list);
745static DEFINE_MUTEX(wacom_udev_list_lock);
746
747static bool wacom_are_sibling(struct hid_device *hdev,
748 struct hid_device *sibling)
749{
750 struct wacom *wacom = hid_get_drvdata(hdev);
751 struct wacom_features *features = &wacom->wacom_wac.features;
752 struct wacom *sibling_wacom = hid_get_drvdata(sibling);
753 struct wacom_features *sibling_features = &sibling_wacom->wacom_wac.features;
754 __u32 oVid = features->oVid ? features->oVid : hdev->vendor;
755 __u32 oPid = features->oPid ? features->oPid : hdev->product;
756
757
758 if (features->oVid != HID_ANY_ID && sibling->vendor != oVid)
759 return false;
760 if (features->oPid != HID_ANY_ID && sibling->product != oPid)
761 return false;
762
763
764
765
766
767
768 if (hdev->vendor == sibling->vendor && hdev->product == sibling->product) {
769 if (!hid_compare_device_paths(hdev, sibling, '/'))
770 return false;
771 } else {
772 if (!hid_compare_device_paths(hdev, sibling, '.'))
773 return false;
774 }
775
776
777 if (features->type != HID_GENERIC)
778 return true;
779
780
781
782
783
784 if ((features->device_type & WACOM_DEVICETYPE_DIRECT) &&
785 !(sibling_features->device_type & WACOM_DEVICETYPE_DIRECT))
786 return false;
787
788
789
790
791
792 if (!(features->device_type & WACOM_DEVICETYPE_DIRECT) &&
793 (sibling_features->device_type & WACOM_DEVICETYPE_DIRECT))
794 return false;
795
796
797 if ((features->device_type & WACOM_DEVICETYPE_PEN) &&
798 !(sibling_features->device_type & WACOM_DEVICETYPE_TOUCH))
799 return false;
800
801
802 if ((features->device_type & WACOM_DEVICETYPE_TOUCH) &&
803 !(sibling_features->device_type & WACOM_DEVICETYPE_PEN))
804 return false;
805
806
807
808
809
810 return true;
811}
812
813static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
814{
815 struct wacom_hdev_data *data;
816
817
818 list_for_each_entry(data, &wacom_udev_list, list) {
819 if (hid_compare_device_paths(hdev, data->dev, '/')) {
820 kref_get(&data->kref);
821 return data;
822 }
823 }
824
825
826 list_for_each_entry(data, &wacom_udev_list, list) {
827 if (wacom_are_sibling(hdev, data->dev)) {
828 kref_get(&data->kref);
829 return data;
830 }
831 }
832
833 return NULL;
834}
835
836static void wacom_release_shared_data(struct kref *kref)
837{
838 struct wacom_hdev_data *data =
839 container_of(kref, struct wacom_hdev_data, kref);
840
841 mutex_lock(&wacom_udev_list_lock);
842 list_del(&data->list);
843 mutex_unlock(&wacom_udev_list_lock);
844
845 kfree(data);
846}
847
848static void wacom_remove_shared_data(void *res)
849{
850 struct wacom *wacom = res;
851 struct wacom_hdev_data *data;
852 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
853
854 if (wacom_wac->shared) {
855 data = container_of(wacom_wac->shared, struct wacom_hdev_data,
856 shared);
857
858 if (wacom_wac->shared->touch == wacom->hdev)
859 wacom_wac->shared->touch = NULL;
860 else if (wacom_wac->shared->pen == wacom->hdev)
861 wacom_wac->shared->pen = NULL;
862
863 kref_put(&data->kref, wacom_release_shared_data);
864 wacom_wac->shared = NULL;
865 }
866}
867
868static int wacom_add_shared_data(struct hid_device *hdev)
869{
870 struct wacom *wacom = hid_get_drvdata(hdev);
871 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
872 struct wacom_hdev_data *data;
873 int retval = 0;
874
875 mutex_lock(&wacom_udev_list_lock);
876
877 data = wacom_get_hdev_data(hdev);
878 if (!data) {
879 data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
880 if (!data) {
881 retval = -ENOMEM;
882 goto out;
883 }
884
885 kref_init(&data->kref);
886 data->dev = hdev;
887 list_add_tail(&data->list, &wacom_udev_list);
888 }
889
890 wacom_wac->shared = &data->shared;
891
892 retval = devm_add_action(&hdev->dev, wacom_remove_shared_data, wacom);
893 if (retval) {
894 mutex_unlock(&wacom_udev_list_lock);
895 wacom_remove_shared_data(wacom);
896 return retval;
897 }
898
899 if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)
900 wacom_wac->shared->touch = hdev;
901 else if (wacom_wac->features.device_type & WACOM_DEVICETYPE_PEN)
902 wacom_wac->shared->pen = hdev;
903
904out:
905 mutex_unlock(&wacom_udev_list_lock);
906 return retval;
907}
908
909static int wacom_led_control(struct wacom *wacom)
910{
911 unsigned char *buf;
912 int retval;
913 unsigned char report_id = WAC_CMD_LED_CONTROL;
914 int buf_size = 9;
915
916 if (!wacom->led.groups)
917 return -ENOTSUPP;
918
919 if (wacom->wacom_wac.features.type == REMOTE)
920 return -ENOTSUPP;
921
922 if (wacom->wacom_wac.pid) {
923 report_id = WAC_CMD_WL_LED_CONTROL;
924 buf_size = 13;
925 }
926 else if (wacom->wacom_wac.features.type == INTUOSP2_BT) {
927 report_id = WAC_CMD_WL_INTUOSP2;
928 buf_size = 51;
929 }
930 buf = kzalloc(buf_size, GFP_KERNEL);
931 if (!buf)
932 return -ENOMEM;
933
934 if (wacom->wacom_wac.features.type == HID_GENERIC) {
935 buf[0] = WAC_CMD_LED_CONTROL_GENERIC;
936 buf[1] = wacom->led.llv;
937 buf[2] = wacom->led.groups[0].select & 0x03;
938
939 } else if ((wacom->wacom_wac.features.type >= INTUOS5S &&
940 wacom->wacom_wac.features.type <= INTUOSPL)) {
941
942
943
944
945
946 int ring_led = wacom->led.groups[0].select & 0x03;
947 int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03;
948 int crop_lum = 0;
949 unsigned char led_bits = (crop_lum << 4) | (ring_lum << 2) | (ring_led);
950
951 buf[0] = report_id;
952 if (wacom->wacom_wac.pid) {
953 wacom_get_report(wacom->hdev, HID_FEATURE_REPORT,
954 buf, buf_size, WAC_CMD_RETRIES);
955 buf[0] = report_id;
956 buf[4] = led_bits;
957 } else
958 buf[1] = led_bits;
959 }
960 else if (wacom->wacom_wac.features.type == INTUOSP2_BT) {
961 buf[0] = report_id;
962 buf[4] = 100;
963 buf[5] = 100;
964 buf[6] = 100;
965 buf[7] = 100;
966 buf[8] = 100;
967 buf[9] = wacom->led.llv;
968 buf[10] = wacom->led.groups[0].select & 0x03;
969 }
970 else {
971 int led = wacom->led.groups[0].select | 0x4;
972
973 if (wacom->wacom_wac.features.type == WACOM_21UX2 ||
974 wacom->wacom_wac.features.type == WACOM_24HD)
975 led |= (wacom->led.groups[1].select << 4) | 0x40;
976
977 buf[0] = report_id;
978 buf[1] = led;
979 buf[2] = wacom->led.llv;
980 buf[3] = wacom->led.hlv;
981 buf[4] = wacom->led.img_lum;
982 }
983
984 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, buf_size,
985 WAC_CMD_RETRIES);
986 kfree(buf);
987
988 return retval;
989}
990
991static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id,
992 const unsigned len, const void *img)
993{
994 unsigned char *buf;
995 int i, retval;
996 const unsigned chunk_len = len / 4;
997
998 buf = kzalloc(chunk_len + 3 , GFP_KERNEL);
999 if (!buf)
1000 return -ENOMEM;
1001
1002
1003 buf[0] = WAC_CMD_ICON_START;
1004 buf[1] = 1;
1005 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
1006 WAC_CMD_RETRIES);
1007 if (retval < 0)
1008 goto out;
1009
1010 buf[0] = xfer_id;
1011 buf[1] = button_id & 0x07;
1012 for (i = 0; i < 4; i++) {
1013 buf[2] = i;
1014 memcpy(buf + 3, img + i * chunk_len, chunk_len);
1015
1016 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
1017 buf, chunk_len + 3, WAC_CMD_RETRIES);
1018 if (retval < 0)
1019 break;
1020 }
1021
1022
1023 buf[0] = WAC_CMD_ICON_START;
1024 buf[1] = 0;
1025 wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
1026 WAC_CMD_RETRIES);
1027
1028out:
1029 kfree(buf);
1030 return retval;
1031}
1032
1033static ssize_t wacom_led_select_store(struct device *dev, int set_id,
1034 const char *buf, size_t count)
1035{
1036 struct hid_device *hdev = to_hid_device(dev);
1037 struct wacom *wacom = hid_get_drvdata(hdev);
1038 unsigned int id;
1039 int err;
1040
1041 err = kstrtouint(buf, 10, &id);
1042 if (err)
1043 return err;
1044
1045 mutex_lock(&wacom->lock);
1046
1047 wacom->led.groups[set_id].select = id & 0x3;
1048 err = wacom_led_control(wacom);
1049
1050 mutex_unlock(&wacom->lock);
1051
1052 return err < 0 ? err : count;
1053}
1054
1055#define DEVICE_LED_SELECT_ATTR(SET_ID) \
1056static ssize_t wacom_led##SET_ID##_select_store(struct device *dev, \
1057 struct device_attribute *attr, const char *buf, size_t count) \
1058{ \
1059 return wacom_led_select_store(dev, SET_ID, buf, count); \
1060} \
1061static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \
1062 struct device_attribute *attr, char *buf) \
1063{ \
1064 struct hid_device *hdev = to_hid_device(dev);\
1065 struct wacom *wacom = hid_get_drvdata(hdev); \
1066 return scnprintf(buf, PAGE_SIZE, "%d\n", \
1067 wacom->led.groups[SET_ID].select); \
1068} \
1069static DEVICE_ATTR(status_led##SET_ID##_select, DEV_ATTR_RW_PERM, \
1070 wacom_led##SET_ID##_select_show, \
1071 wacom_led##SET_ID##_select_store)
1072
1073DEVICE_LED_SELECT_ATTR(0);
1074DEVICE_LED_SELECT_ATTR(1);
1075
1076static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest,
1077 const char *buf, size_t count)
1078{
1079 unsigned int value;
1080 int err;
1081
1082 err = kstrtouint(buf, 10, &value);
1083 if (err)
1084 return err;
1085
1086 mutex_lock(&wacom->lock);
1087
1088 *dest = value & 0x7f;
1089 err = wacom_led_control(wacom);
1090
1091 mutex_unlock(&wacom->lock);
1092
1093 return err < 0 ? err : count;
1094}
1095
1096#define DEVICE_LUMINANCE_ATTR(name, field) \
1097static ssize_t wacom_##name##_luminance_store(struct device *dev, \
1098 struct device_attribute *attr, const char *buf, size_t count) \
1099{ \
1100 struct hid_device *hdev = to_hid_device(dev);\
1101 struct wacom *wacom = hid_get_drvdata(hdev); \
1102 \
1103 return wacom_luminance_store(wacom, &wacom->led.field, \
1104 buf, count); \
1105} \
1106static ssize_t wacom_##name##_luminance_show(struct device *dev, \
1107 struct device_attribute *attr, char *buf) \
1108{ \
1109 struct wacom *wacom = dev_get_drvdata(dev); \
1110 return scnprintf(buf, PAGE_SIZE, "%d\n", wacom->led.field); \
1111} \
1112static DEVICE_ATTR(name##_luminance, DEV_ATTR_RW_PERM, \
1113 wacom_##name##_luminance_show, \
1114 wacom_##name##_luminance_store)
1115
1116DEVICE_LUMINANCE_ATTR(status0, llv);
1117DEVICE_LUMINANCE_ATTR(status1, hlv);
1118DEVICE_LUMINANCE_ATTR(buttons, img_lum);
1119
1120static ssize_t wacom_button_image_store(struct device *dev, int button_id,
1121 const char *buf, size_t count)
1122{
1123 struct hid_device *hdev = to_hid_device(dev);
1124 struct wacom *wacom = hid_get_drvdata(hdev);
1125 int err;
1126 unsigned len;
1127 u8 xfer_id;
1128
1129 if (hdev->bus == BUS_BLUETOOTH) {
1130 len = 256;
1131 xfer_id = WAC_CMD_ICON_BT_XFER;
1132 } else {
1133 len = 1024;
1134 xfer_id = WAC_CMD_ICON_XFER;
1135 }
1136
1137 if (count != len)
1138 return -EINVAL;
1139
1140 mutex_lock(&wacom->lock);
1141
1142 err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf);
1143
1144 mutex_unlock(&wacom->lock);
1145
1146 return err < 0 ? err : count;
1147}
1148
1149#define DEVICE_BTNIMG_ATTR(BUTTON_ID) \
1150static ssize_t wacom_btnimg##BUTTON_ID##_store(struct device *dev, \
1151 struct device_attribute *attr, const char *buf, size_t count) \
1152{ \
1153 return wacom_button_image_store(dev, BUTTON_ID, buf, count); \
1154} \
1155static DEVICE_ATTR(button##BUTTON_ID##_rawimg, DEV_ATTR_WO_PERM, \
1156 NULL, wacom_btnimg##BUTTON_ID##_store)
1157
1158DEVICE_BTNIMG_ATTR(0);
1159DEVICE_BTNIMG_ATTR(1);
1160DEVICE_BTNIMG_ATTR(2);
1161DEVICE_BTNIMG_ATTR(3);
1162DEVICE_BTNIMG_ATTR(4);
1163DEVICE_BTNIMG_ATTR(5);
1164DEVICE_BTNIMG_ATTR(6);
1165DEVICE_BTNIMG_ATTR(7);
1166
1167static struct attribute *cintiq_led_attrs[] = {
1168 &dev_attr_status_led0_select.attr,
1169 &dev_attr_status_led1_select.attr,
1170 NULL
1171};
1172
1173static struct attribute_group cintiq_led_attr_group = {
1174 .name = "wacom_led",
1175 .attrs = cintiq_led_attrs,
1176};
1177
1178static struct attribute *intuos4_led_attrs[] = {
1179 &dev_attr_status0_luminance.attr,
1180 &dev_attr_status1_luminance.attr,
1181 &dev_attr_status_led0_select.attr,
1182 &dev_attr_buttons_luminance.attr,
1183 &dev_attr_button0_rawimg.attr,
1184 &dev_attr_button1_rawimg.attr,
1185 &dev_attr_button2_rawimg.attr,
1186 &dev_attr_button3_rawimg.attr,
1187 &dev_attr_button4_rawimg.attr,
1188 &dev_attr_button5_rawimg.attr,
1189 &dev_attr_button6_rawimg.attr,
1190 &dev_attr_button7_rawimg.attr,
1191 NULL
1192};
1193
1194static struct attribute_group intuos4_led_attr_group = {
1195 .name = "wacom_led",
1196 .attrs = intuos4_led_attrs,
1197};
1198
1199static struct attribute *intuos5_led_attrs[] = {
1200 &dev_attr_status0_luminance.attr,
1201 &dev_attr_status_led0_select.attr,
1202 NULL
1203};
1204
1205static struct attribute_group intuos5_led_attr_group = {
1206 .name = "wacom_led",
1207 .attrs = intuos5_led_attrs,
1208};
1209
1210static struct attribute *generic_led_attrs[] = {
1211 &dev_attr_status0_luminance.attr,
1212 &dev_attr_status_led0_select.attr,
1213 NULL
1214};
1215
1216static struct attribute_group generic_led_attr_group = {
1217 .name = "wacom_led",
1218 .attrs = generic_led_attrs,
1219};
1220
1221struct wacom_sysfs_group_devres {
1222 struct attribute_group *group;
1223 struct kobject *root;
1224};
1225
1226static void wacom_devm_sysfs_group_release(struct device *dev, void *res)
1227{
1228 struct wacom_sysfs_group_devres *devres = res;
1229 struct kobject *kobj = devres->root;
1230
1231 dev_dbg(dev, "%s: dropping reference to %s\n",
1232 __func__, devres->group->name);
1233 sysfs_remove_group(kobj, devres->group);
1234}
1235
1236static int __wacom_devm_sysfs_create_group(struct wacom *wacom,
1237 struct kobject *root,
1238 struct attribute_group *group)
1239{
1240 struct wacom_sysfs_group_devres *devres;
1241 int error;
1242
1243 devres = devres_alloc(wacom_devm_sysfs_group_release,
1244 sizeof(struct wacom_sysfs_group_devres),
1245 GFP_KERNEL);
1246 if (!devres)
1247 return -ENOMEM;
1248
1249 devres->group = group;
1250 devres->root = root;
1251
1252 error = sysfs_create_group(devres->root, group);
1253 if (error) {
1254 devres_free(devres);
1255 return error;
1256 }
1257
1258 devres_add(&wacom->hdev->dev, devres);
1259
1260 return 0;
1261}
1262
1263static int wacom_devm_sysfs_create_group(struct wacom *wacom,
1264 struct attribute_group *group)
1265{
1266 return __wacom_devm_sysfs_create_group(wacom, &wacom->hdev->dev.kobj,
1267 group);
1268}
1269
1270enum led_brightness wacom_leds_brightness_get(struct wacom_led *led)
1271{
1272 struct wacom *wacom = led->wacom;
1273
1274 if (wacom->led.max_hlv)
1275 return led->hlv * LED_FULL / wacom->led.max_hlv;
1276
1277 if (wacom->led.max_llv)
1278 return led->llv * LED_FULL / wacom->led.max_llv;
1279
1280
1281 return LED_FULL;
1282}
1283
1284static enum led_brightness __wacom_led_brightness_get(struct led_classdev *cdev)
1285{
1286 struct wacom_led *led = container_of(cdev, struct wacom_led, cdev);
1287 struct wacom *wacom = led->wacom;
1288
1289 if (wacom->led.groups[led->group].select != led->id)
1290 return LED_OFF;
1291
1292 return wacom_leds_brightness_get(led);
1293}
1294
1295static int wacom_led_brightness_set(struct led_classdev *cdev,
1296 enum led_brightness brightness)
1297{
1298 struct wacom_led *led = container_of(cdev, struct wacom_led, cdev);
1299 struct wacom *wacom = led->wacom;
1300 int error;
1301
1302 mutex_lock(&wacom->lock);
1303
1304 if (!wacom->led.groups || (brightness == LED_OFF &&
1305 wacom->led.groups[led->group].select != led->id)) {
1306 error = 0;
1307 goto out;
1308 }
1309
1310 led->llv = wacom->led.llv = wacom->led.max_llv * brightness / LED_FULL;
1311 led->hlv = wacom->led.hlv = wacom->led.max_hlv * brightness / LED_FULL;
1312
1313 wacom->led.groups[led->group].select = led->id;
1314
1315 error = wacom_led_control(wacom);
1316
1317out:
1318 mutex_unlock(&wacom->lock);
1319
1320 return error;
1321}
1322
1323static void wacom_led_readonly_brightness_set(struct led_classdev *cdev,
1324 enum led_brightness brightness)
1325{
1326}
1327
1328static int wacom_led_register_one(struct device *dev, struct wacom *wacom,
1329 struct wacom_led *led, unsigned int group,
1330 unsigned int id, bool read_only)
1331{
1332 int error;
1333 char *name;
1334
1335 name = devm_kasprintf(dev, GFP_KERNEL,
1336 "%s::wacom-%d.%d",
1337 dev_name(dev),
1338 group,
1339 id);
1340 if (!name)
1341 return -ENOMEM;
1342
1343 if (!read_only) {
1344 led->trigger.name = name;
1345 error = devm_led_trigger_register(dev, &led->trigger);
1346 if (error) {
1347 hid_err(wacom->hdev,
1348 "failed to register LED trigger %s: %d\n",
1349 led->cdev.name, error);
1350 return error;
1351 }
1352 }
1353
1354 led->group = group;
1355 led->id = id;
1356 led->wacom = wacom;
1357 led->llv = wacom->led.llv;
1358 led->hlv = wacom->led.hlv;
1359 led->cdev.name = name;
1360 led->cdev.max_brightness = LED_FULL;
1361 led->cdev.flags = LED_HW_PLUGGABLE;
1362 led->cdev.brightness_get = __wacom_led_brightness_get;
1363 if (!read_only) {
1364 led->cdev.brightness_set_blocking = wacom_led_brightness_set;
1365 led->cdev.default_trigger = led->cdev.name;
1366 } else {
1367 led->cdev.brightness_set = wacom_led_readonly_brightness_set;
1368 }
1369
1370 error = devm_led_classdev_register(dev, &led->cdev);
1371 if (error) {
1372 hid_err(wacom->hdev,
1373 "failed to register LED %s: %d\n",
1374 led->cdev.name, error);
1375 led->cdev.name = NULL;
1376 return error;
1377 }
1378
1379 return 0;
1380}
1381
1382static void wacom_led_groups_release_one(void *data)
1383{
1384 struct wacom_group_leds *group = data;
1385
1386 devres_release_group(group->dev, group);
1387}
1388
1389static int wacom_led_groups_alloc_and_register_one(struct device *dev,
1390 struct wacom *wacom,
1391 int group_id, int count,
1392 bool read_only)
1393{
1394 struct wacom_led *leds;
1395 int i, error;
1396
1397 if (group_id >= wacom->led.count || count <= 0)
1398 return -EINVAL;
1399
1400 if (!devres_open_group(dev, &wacom->led.groups[group_id], GFP_KERNEL))
1401 return -ENOMEM;
1402
1403 leds = devm_kcalloc(dev, count, sizeof(struct wacom_led), GFP_KERNEL);
1404 if (!leds) {
1405 error = -ENOMEM;
1406 goto err;
1407 }
1408
1409 wacom->led.groups[group_id].leds = leds;
1410 wacom->led.groups[group_id].count = count;
1411
1412 for (i = 0; i < count; i++) {
1413 error = wacom_led_register_one(dev, wacom, &leds[i],
1414 group_id, i, read_only);
1415 if (error)
1416 goto err;
1417 }
1418
1419 wacom->led.groups[group_id].dev = dev;
1420
1421 devres_close_group(dev, &wacom->led.groups[group_id]);
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432 error = devm_add_action_or_reset(&wacom->hdev->dev,
1433 wacom_led_groups_release_one,
1434 &wacom->led.groups[group_id]);
1435 if (error)
1436 return error;
1437
1438 return 0;
1439
1440err:
1441 devres_release_group(dev, &wacom->led.groups[group_id]);
1442 return error;
1443}
1444
1445struct wacom_led *wacom_led_find(struct wacom *wacom, unsigned int group_id,
1446 unsigned int id)
1447{
1448 struct wacom_group_leds *group;
1449
1450 if (group_id >= wacom->led.count)
1451 return NULL;
1452
1453 group = &wacom->led.groups[group_id];
1454
1455 if (!group->leds)
1456 return NULL;
1457
1458 id %= group->count;
1459
1460 return &group->leds[id];
1461}
1462
1463
1464
1465
1466
1467
1468
1469struct wacom_led *wacom_led_next(struct wacom *wacom, struct wacom_led *cur)
1470{
1471 struct wacom_led *next_led;
1472 int group, next;
1473
1474 if (!wacom || !cur)
1475 return NULL;
1476
1477 group = cur->group;
1478 next = cur->id;
1479
1480 do {
1481 next_led = wacom_led_find(wacom, group, ++next);
1482 if (!next_led || next_led == cur)
1483 return next_led;
1484 } while (next_led->cdev.trigger != &next_led->trigger);
1485
1486 return next_led;
1487}
1488
1489static void wacom_led_groups_release(void *data)
1490{
1491 struct wacom *wacom = data;
1492
1493 wacom->led.groups = NULL;
1494 wacom->led.count = 0;
1495}
1496
1497static int wacom_led_groups_allocate(struct wacom *wacom, int count)
1498{
1499 struct device *dev = &wacom->hdev->dev;
1500 struct wacom_group_leds *groups;
1501 int error;
1502
1503 groups = devm_kcalloc(dev, count, sizeof(struct wacom_group_leds),
1504 GFP_KERNEL);
1505 if (!groups)
1506 return -ENOMEM;
1507
1508 error = devm_add_action_or_reset(dev, wacom_led_groups_release, wacom);
1509 if (error)
1510 return error;
1511
1512 wacom->led.groups = groups;
1513 wacom->led.count = count;
1514
1515 return 0;
1516}
1517
1518static int wacom_leds_alloc_and_register(struct wacom *wacom, int group_count,
1519 int led_per_group, bool read_only)
1520{
1521 struct device *dev;
1522 int i, error;
1523
1524 if (!wacom->wacom_wac.pad_input)
1525 return -EINVAL;
1526
1527 dev = &wacom->wacom_wac.pad_input->dev;
1528
1529 error = wacom_led_groups_allocate(wacom, group_count);
1530 if (error)
1531 return error;
1532
1533 for (i = 0; i < group_count; i++) {
1534 error = wacom_led_groups_alloc_and_register_one(dev, wacom, i,
1535 led_per_group,
1536 read_only);
1537 if (error)
1538 return error;
1539 }
1540
1541 return 0;
1542}
1543
1544int wacom_initialize_leds(struct wacom *wacom)
1545{
1546 int error;
1547
1548 if (!(wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD))
1549 return 0;
1550
1551
1552 switch (wacom->wacom_wac.features.type) {
1553 case HID_GENERIC:
1554 if (!wacom->generic_has_leds)
1555 return 0;
1556 wacom->led.llv = 100;
1557 wacom->led.max_llv = 100;
1558
1559 error = wacom_leds_alloc_and_register(wacom, 1, 4, false);
1560 if (error) {
1561 hid_err(wacom->hdev,
1562 "cannot create leds err: %d\n", error);
1563 return error;
1564 }
1565
1566 error = wacom_devm_sysfs_create_group(wacom,
1567 &generic_led_attr_group);
1568 break;
1569
1570 case INTUOS4S:
1571 case INTUOS4:
1572 case INTUOS4WL:
1573 case INTUOS4L:
1574 wacom->led.llv = 10;
1575 wacom->led.hlv = 20;
1576 wacom->led.max_llv = 127;
1577 wacom->led.max_hlv = 127;
1578 wacom->led.img_lum = 10;
1579
1580 error = wacom_leds_alloc_and_register(wacom, 1, 4, false);
1581 if (error) {
1582 hid_err(wacom->hdev,
1583 "cannot create leds err: %d\n", error);
1584 return error;
1585 }
1586
1587 error = wacom_devm_sysfs_create_group(wacom,
1588 &intuos4_led_attr_group);
1589 break;
1590
1591 case WACOM_24HD:
1592 case WACOM_21UX2:
1593 wacom->led.llv = 0;
1594 wacom->led.hlv = 0;
1595 wacom->led.img_lum = 0;
1596
1597 error = wacom_leds_alloc_and_register(wacom, 2, 4, false);
1598 if (error) {
1599 hid_err(wacom->hdev,
1600 "cannot create leds err: %d\n", error);
1601 return error;
1602 }
1603
1604 error = wacom_devm_sysfs_create_group(wacom,
1605 &cintiq_led_attr_group);
1606 break;
1607
1608 case INTUOS5S:
1609 case INTUOS5:
1610 case INTUOS5L:
1611 case INTUOSPS:
1612 case INTUOSPM:
1613 case INTUOSPL:
1614 wacom->led.llv = 32;
1615 wacom->led.max_llv = 96;
1616
1617 error = wacom_leds_alloc_and_register(wacom, 1, 4, false);
1618 if (error) {
1619 hid_err(wacom->hdev,
1620 "cannot create leds err: %d\n", error);
1621 return error;
1622 }
1623
1624 error = wacom_devm_sysfs_create_group(wacom,
1625 &intuos5_led_attr_group);
1626 break;
1627
1628 case INTUOSP2_BT:
1629 wacom->led.llv = 50;
1630 wacom->led.max_llv = 100;
1631 error = wacom_leds_alloc_and_register(wacom, 1, 4, false);
1632 if (error) {
1633 hid_err(wacom->hdev,
1634 "cannot create leds err: %d\n", error);
1635 return error;
1636 }
1637 return 0;
1638
1639 case REMOTE:
1640 wacom->led.llv = 255;
1641 wacom->led.max_llv = 255;
1642 error = wacom_led_groups_allocate(wacom, 5);
1643 if (error) {
1644 hid_err(wacom->hdev,
1645 "cannot create leds err: %d\n", error);
1646 return error;
1647 }
1648 return 0;
1649
1650 default:
1651 return 0;
1652 }
1653
1654 if (error) {
1655 hid_err(wacom->hdev,
1656 "cannot create sysfs group err: %d\n", error);
1657 return error;
1658 }
1659
1660 return 0;
1661}
1662
1663static void wacom_init_work(struct work_struct *work)
1664{
1665 struct wacom *wacom = container_of(work, struct wacom, init_work.work);
1666
1667 _wacom_query_tablet_data(wacom);
1668 wacom_led_control(wacom);
1669}
1670
1671static void wacom_query_tablet_data(struct wacom *wacom)
1672{
1673 schedule_delayed_work(&wacom->init_work, msecs_to_jiffies(1000));
1674}
1675
1676static enum power_supply_property wacom_battery_props[] = {
1677 POWER_SUPPLY_PROP_MODEL_NAME,
1678 POWER_SUPPLY_PROP_PRESENT,
1679 POWER_SUPPLY_PROP_STATUS,
1680 POWER_SUPPLY_PROP_SCOPE,
1681 POWER_SUPPLY_PROP_CAPACITY
1682};
1683
1684static int wacom_battery_get_property(struct power_supply *psy,
1685 enum power_supply_property psp,
1686 union power_supply_propval *val)
1687{
1688 struct wacom_battery *battery = power_supply_get_drvdata(psy);
1689 int ret = 0;
1690
1691 switch (psp) {
1692 case POWER_SUPPLY_PROP_MODEL_NAME:
1693 val->strval = battery->wacom->wacom_wac.name;
1694 break;
1695 case POWER_SUPPLY_PROP_PRESENT:
1696 val->intval = battery->bat_connected;
1697 break;
1698 case POWER_SUPPLY_PROP_SCOPE:
1699 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1700 break;
1701 case POWER_SUPPLY_PROP_CAPACITY:
1702 val->intval = battery->battery_capacity;
1703 break;
1704 case POWER_SUPPLY_PROP_STATUS:
1705 if (battery->bat_status != WACOM_POWER_SUPPLY_STATUS_AUTO)
1706 val->intval = battery->bat_status;
1707 else if (battery->bat_charging)
1708 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1709 else if (battery->battery_capacity == 100 &&
1710 battery->ps_connected)
1711 val->intval = POWER_SUPPLY_STATUS_FULL;
1712 else if (battery->ps_connected)
1713 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
1714 else
1715 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1716 break;
1717 default:
1718 ret = -EINVAL;
1719 break;
1720 }
1721
1722 return ret;
1723}
1724
1725static int __wacom_initialize_battery(struct wacom *wacom,
1726 struct wacom_battery *battery)
1727{
1728 static atomic_t battery_no = ATOMIC_INIT(0);
1729 struct device *dev = &wacom->hdev->dev;
1730 struct power_supply_config psy_cfg = { .drv_data = battery, };
1731 struct power_supply *ps_bat;
1732 struct power_supply_desc *bat_desc = &battery->bat_desc;
1733 unsigned long n;
1734 int error;
1735
1736 if (!devres_open_group(dev, bat_desc, GFP_KERNEL))
1737 return -ENOMEM;
1738
1739 battery->wacom = wacom;
1740
1741 n = atomic_inc_return(&battery_no) - 1;
1742
1743 bat_desc->properties = wacom_battery_props;
1744 bat_desc->num_properties = ARRAY_SIZE(wacom_battery_props);
1745 bat_desc->get_property = wacom_battery_get_property;
1746 sprintf(battery->bat_name, "wacom_battery_%ld", n);
1747 bat_desc->name = battery->bat_name;
1748 bat_desc->type = POWER_SUPPLY_TYPE_USB;
1749 bat_desc->use_for_apm = 0;
1750
1751 ps_bat = devm_power_supply_register(dev, bat_desc, &psy_cfg);
1752 if (IS_ERR(ps_bat)) {
1753 error = PTR_ERR(ps_bat);
1754 goto err;
1755 }
1756
1757 power_supply_powers(ps_bat, &wacom->hdev->dev);
1758
1759 battery->battery = ps_bat;
1760
1761 devres_close_group(dev, bat_desc);
1762 return 0;
1763
1764err:
1765 devres_release_group(dev, bat_desc);
1766 return error;
1767}
1768
1769static int wacom_initialize_battery(struct wacom *wacom)
1770{
1771 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY)
1772 return __wacom_initialize_battery(wacom, &wacom->battery);
1773
1774 return 0;
1775}
1776
1777static void wacom_destroy_battery(struct wacom *wacom)
1778{
1779 if (wacom->battery.battery) {
1780 devres_release_group(&wacom->hdev->dev,
1781 &wacom->battery.bat_desc);
1782 wacom->battery.battery = NULL;
1783 }
1784}
1785
1786static ssize_t wacom_show_speed(struct device *dev,
1787 struct device_attribute
1788 *attr, char *buf)
1789{
1790 struct hid_device *hdev = to_hid_device(dev);
1791 struct wacom *wacom = hid_get_drvdata(hdev);
1792
1793 return snprintf(buf, PAGE_SIZE, "%i\n", wacom->wacom_wac.bt_high_speed);
1794}
1795
1796static ssize_t wacom_store_speed(struct device *dev,
1797 struct device_attribute *attr,
1798 const char *buf, size_t count)
1799{
1800 struct hid_device *hdev = to_hid_device(dev);
1801 struct wacom *wacom = hid_get_drvdata(hdev);
1802 u8 new_speed;
1803
1804 if (kstrtou8(buf, 0, &new_speed))
1805 return -EINVAL;
1806
1807 if (new_speed != 0 && new_speed != 1)
1808 return -EINVAL;
1809
1810 wacom_bt_query_tablet_data(hdev, new_speed, &wacom->wacom_wac.features);
1811
1812 return count;
1813}
1814
1815static DEVICE_ATTR(speed, DEV_ATTR_RW_PERM,
1816 wacom_show_speed, wacom_store_speed);
1817
1818
1819static ssize_t wacom_show_remote_mode(struct kobject *kobj,
1820 struct kobj_attribute *kattr,
1821 char *buf, int index)
1822{
1823 struct device *dev = kobj_to_dev(kobj->parent);
1824 struct hid_device *hdev = to_hid_device(dev);
1825 struct wacom *wacom = hid_get_drvdata(hdev);
1826 u8 mode;
1827
1828 mode = wacom->led.groups[index].select;
1829 return sprintf(buf, "%d\n", mode < 3 ? mode : -1);
1830}
1831
1832#define DEVICE_EKR_ATTR_GROUP(SET_ID) \
1833static ssize_t wacom_show_remote##SET_ID##_mode(struct kobject *kobj, \
1834 struct kobj_attribute *kattr, char *buf) \
1835{ \
1836 return wacom_show_remote_mode(kobj, kattr, buf, SET_ID); \
1837} \
1838static struct kobj_attribute remote##SET_ID##_mode_attr = { \
1839 .attr = {.name = "remote_mode", \
1840 .mode = DEV_ATTR_RO_PERM}, \
1841 .show = wacom_show_remote##SET_ID##_mode, \
1842}; \
1843static struct attribute *remote##SET_ID##_serial_attrs[] = { \
1844 &remote##SET_ID##_mode_attr.attr, \
1845 NULL \
1846}; \
1847static struct attribute_group remote##SET_ID##_serial_group = { \
1848 .name = NULL, \
1849 .attrs = remote##SET_ID##_serial_attrs, \
1850}
1851
1852DEVICE_EKR_ATTR_GROUP(0);
1853DEVICE_EKR_ATTR_GROUP(1);
1854DEVICE_EKR_ATTR_GROUP(2);
1855DEVICE_EKR_ATTR_GROUP(3);
1856DEVICE_EKR_ATTR_GROUP(4);
1857
1858static int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
1859 int index)
1860{
1861 int error = 0;
1862 struct wacom_remote *remote = wacom->remote;
1863
1864 remote->remotes[index].group.name = devm_kasprintf(&wacom->hdev->dev,
1865 GFP_KERNEL,
1866 "%d", serial);
1867 if (!remote->remotes[index].group.name)
1868 return -ENOMEM;
1869
1870 error = __wacom_devm_sysfs_create_group(wacom, remote->remote_dir,
1871 &remote->remotes[index].group);
1872 if (error) {
1873 remote->remotes[index].group.name = NULL;
1874 hid_err(wacom->hdev,
1875 "cannot create sysfs group err: %d\n", error);
1876 return error;
1877 }
1878
1879 return 0;
1880}
1881
1882static int wacom_cmd_unpair_remote(struct wacom *wacom, unsigned char selector)
1883{
1884 const size_t buf_size = 2;
1885 unsigned char *buf;
1886 int retval;
1887
1888 buf = kzalloc(buf_size, GFP_KERNEL);
1889 if (!buf)
1890 return -ENOMEM;
1891
1892 buf[0] = WAC_CMD_DELETE_PAIRING;
1893 buf[1] = selector;
1894
1895 retval = wacom_set_report(wacom->hdev, HID_OUTPUT_REPORT, buf,
1896 buf_size, WAC_CMD_RETRIES);
1897 kfree(buf);
1898
1899 return retval;
1900}
1901
1902static ssize_t wacom_store_unpair_remote(struct kobject *kobj,
1903 struct kobj_attribute *attr,
1904 const char *buf, size_t count)
1905{
1906 unsigned char selector = 0;
1907 struct device *dev = kobj_to_dev(kobj->parent);
1908 struct hid_device *hdev = to_hid_device(dev);
1909 struct wacom *wacom = hid_get_drvdata(hdev);
1910 int err;
1911
1912 if (!strncmp(buf, "*\n", 2)) {
1913 selector = WAC_CMD_UNPAIR_ALL;
1914 } else {
1915 hid_info(wacom->hdev, "remote: unrecognized unpair code: %s\n",
1916 buf);
1917 return -1;
1918 }
1919
1920 mutex_lock(&wacom->lock);
1921
1922 err = wacom_cmd_unpair_remote(wacom, selector);
1923 mutex_unlock(&wacom->lock);
1924
1925 return err < 0 ? err : count;
1926}
1927
1928static struct kobj_attribute unpair_remote_attr = {
1929 .attr = {.name = "unpair_remote", .mode = 0200},
1930 .store = wacom_store_unpair_remote,
1931};
1932
1933static const struct attribute *remote_unpair_attrs[] = {
1934 &unpair_remote_attr.attr,
1935 NULL
1936};
1937
1938static void wacom_remotes_destroy(void *data)
1939{
1940 struct wacom *wacom = data;
1941 struct wacom_remote *remote = wacom->remote;
1942
1943 if (!remote)
1944 return;
1945
1946 kobject_put(remote->remote_dir);
1947 kfifo_free(&remote->remote_fifo);
1948 wacom->remote = NULL;
1949}
1950
1951static int wacom_initialize_remotes(struct wacom *wacom)
1952{
1953 int error = 0;
1954 struct wacom_remote *remote;
1955 int i;
1956
1957 if (wacom->wacom_wac.features.type != REMOTE)
1958 return 0;
1959
1960 remote = devm_kzalloc(&wacom->hdev->dev, sizeof(*wacom->remote),
1961 GFP_KERNEL);
1962 if (!remote)
1963 return -ENOMEM;
1964
1965 wacom->remote = remote;
1966
1967 spin_lock_init(&remote->remote_lock);
1968
1969 error = kfifo_alloc(&remote->remote_fifo,
1970 5 * sizeof(struct wacom_remote_data),
1971 GFP_KERNEL);
1972 if (error) {
1973 hid_err(wacom->hdev, "failed allocating remote_fifo\n");
1974 return -ENOMEM;
1975 }
1976
1977 remote->remotes[0].group = remote0_serial_group;
1978 remote->remotes[1].group = remote1_serial_group;
1979 remote->remotes[2].group = remote2_serial_group;
1980 remote->remotes[3].group = remote3_serial_group;
1981 remote->remotes[4].group = remote4_serial_group;
1982
1983 remote->remote_dir = kobject_create_and_add("wacom_remote",
1984 &wacom->hdev->dev.kobj);
1985 if (!remote->remote_dir)
1986 return -ENOMEM;
1987
1988 error = sysfs_create_files(remote->remote_dir, remote_unpair_attrs);
1989
1990 if (error) {
1991 hid_err(wacom->hdev,
1992 "cannot create sysfs group err: %d\n", error);
1993 return error;
1994 }
1995
1996 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
1997 wacom->led.groups[i].select = WACOM_STATUS_UNKNOWN;
1998 remote->remotes[i].serial = 0;
1999 }
2000
2001 error = devm_add_action_or_reset(&wacom->hdev->dev,
2002 wacom_remotes_destroy, wacom);
2003 if (error)
2004 return error;
2005
2006 return 0;
2007}
2008
2009static struct input_dev *wacom_allocate_input(struct wacom *wacom)
2010{
2011 struct input_dev *input_dev;
2012 struct hid_device *hdev = wacom->hdev;
2013 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
2014
2015 input_dev = devm_input_allocate_device(&hdev->dev);
2016 if (!input_dev)
2017 return NULL;
2018
2019 input_dev->name = wacom_wac->features.name;
2020 input_dev->phys = hdev->phys;
2021 input_dev->dev.parent = &hdev->dev;
2022 input_dev->open = wacom_open;
2023 input_dev->close = wacom_close;
2024 input_dev->uniq = hdev->uniq;
2025 input_dev->id.bustype = hdev->bus;
2026 input_dev->id.vendor = hdev->vendor;
2027 input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product;
2028 input_dev->id.version = hdev->version;
2029 input_set_drvdata(input_dev, wacom);
2030
2031 return input_dev;
2032}
2033
2034static int wacom_allocate_inputs(struct wacom *wacom)
2035{
2036 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
2037
2038 wacom_wac->pen_input = wacom_allocate_input(wacom);
2039 wacom_wac->touch_input = wacom_allocate_input(wacom);
2040 wacom_wac->pad_input = wacom_allocate_input(wacom);
2041 if (!wacom_wac->pen_input ||
2042 !wacom_wac->touch_input ||
2043 !wacom_wac->pad_input)
2044 return -ENOMEM;
2045
2046 wacom_wac->pen_input->name = wacom_wac->pen_name;
2047 wacom_wac->touch_input->name = wacom_wac->touch_name;
2048 wacom_wac->pad_input->name = wacom_wac->pad_name;
2049
2050 return 0;
2051}
2052
2053static int wacom_register_inputs(struct wacom *wacom)
2054{
2055 struct input_dev *pen_input_dev, *touch_input_dev, *pad_input_dev;
2056 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
2057 int error = 0;
2058
2059 pen_input_dev = wacom_wac->pen_input;
2060 touch_input_dev = wacom_wac->touch_input;
2061 pad_input_dev = wacom_wac->pad_input;
2062
2063 if (!pen_input_dev || !touch_input_dev || !pad_input_dev)
2064 return -EINVAL;
2065
2066 error = wacom_setup_pen_input_capabilities(pen_input_dev, wacom_wac);
2067 if (error) {
2068
2069 input_free_device(pen_input_dev);
2070 wacom_wac->pen_input = NULL;
2071 pen_input_dev = NULL;
2072 } else {
2073 error = input_register_device(pen_input_dev);
2074 if (error)
2075 goto fail;
2076 }
2077
2078 error = wacom_setup_touch_input_capabilities(touch_input_dev, wacom_wac);
2079 if (error) {
2080
2081 input_free_device(touch_input_dev);
2082 wacom_wac->touch_input = NULL;
2083 touch_input_dev = NULL;
2084 } else {
2085 error = input_register_device(touch_input_dev);
2086 if (error)
2087 goto fail;
2088 }
2089
2090 error = wacom_setup_pad_input_capabilities(pad_input_dev, wacom_wac);
2091 if (error) {
2092
2093 input_free_device(pad_input_dev);
2094 wacom_wac->pad_input = NULL;
2095 pad_input_dev = NULL;
2096 } else {
2097 error = input_register_device(pad_input_dev);
2098 if (error)
2099 goto fail;
2100 }
2101
2102 return 0;
2103
2104fail:
2105 wacom_wac->pad_input = NULL;
2106 wacom_wac->touch_input = NULL;
2107 wacom_wac->pen_input = NULL;
2108 return error;
2109}
2110
2111
2112
2113
2114
2115
2116static void wacom_set_default_phy(struct wacom_features *features)
2117{
2118 if (features->x_resolution) {
2119 features->x_phy = (features->x_max * 100) /
2120 features->x_resolution;
2121 features->y_phy = (features->y_max * 100) /
2122 features->y_resolution;
2123 }
2124}
2125
2126static void wacom_calculate_res(struct wacom_features *features)
2127{
2128
2129 if (!features->unit) {
2130 features->unit = 0x11;
2131 features->unitExpo = -3;
2132 }
2133
2134 features->x_resolution = wacom_calc_hid_res(features->x_max,
2135 features->x_phy,
2136 features->unit,
2137 features->unitExpo);
2138 features->y_resolution = wacom_calc_hid_res(features->y_max,
2139 features->y_phy,
2140 features->unit,
2141 features->unitExpo);
2142}
2143
2144void wacom_battery_work(struct work_struct *work)
2145{
2146 struct wacom *wacom = container_of(work, struct wacom, battery_work);
2147
2148 if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
2149 !wacom->battery.battery) {
2150 wacom_initialize_battery(wacom);
2151 }
2152 else if (!(wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
2153 wacom->battery.battery) {
2154 wacom_destroy_battery(wacom);
2155 }
2156}
2157
2158static size_t wacom_compute_pktlen(struct hid_device *hdev)
2159{
2160 struct hid_report_enum *report_enum;
2161 struct hid_report *report;
2162 size_t size = 0;
2163
2164 report_enum = hdev->report_enum + HID_INPUT_REPORT;
2165
2166 list_for_each_entry(report, &report_enum->report_list, list) {
2167 size_t report_size = hid_report_len(report);
2168 if (report_size > size)
2169 size = report_size;
2170 }
2171
2172 return size;
2173}
2174
2175static void wacom_update_name(struct wacom *wacom, const char *suffix)
2176{
2177 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2178 struct wacom_features *features = &wacom_wac->features;
2179 char name[WACOM_NAME_MAX];
2180
2181
2182 if ((features->type == HID_GENERIC) && !strcmp("Wacom HID", features->name)) {
2183 char *product_name = wacom->hdev->name;
2184
2185 if (hid_is_using_ll_driver(wacom->hdev, &usb_hid_driver)) {
2186 struct usb_interface *intf = to_usb_interface(wacom->hdev->dev.parent);
2187 struct usb_device *dev = interface_to_usbdev(intf);
2188 product_name = dev->product;
2189 }
2190
2191 if (wacom->hdev->bus == BUS_I2C) {
2192 snprintf(name, sizeof(name), "%s %X",
2193 features->name, wacom->hdev->product);
2194 } else if (strstr(product_name, "Wacom") ||
2195 strstr(product_name, "wacom") ||
2196 strstr(product_name, "WACOM")) {
2197 strlcpy(name, product_name, sizeof(name));
2198 } else {
2199 snprintf(name, sizeof(name), "Wacom %s", product_name);
2200 }
2201
2202
2203 while (1) {
2204 char *gap = strstr(name, " ");
2205 if (gap == NULL)
2206 break;
2207
2208 memmove(gap, gap+1, strlen(gap));
2209 }
2210
2211
2212 if (name[strlen(name)-1] == ' ')
2213 name[strlen(name)-1] = '\0';
2214 } else {
2215 strlcpy(name, features->name, sizeof(name));
2216 }
2217
2218 snprintf(wacom_wac->name, sizeof(wacom_wac->name), "%s%s",
2219 name, suffix);
2220
2221
2222 snprintf(wacom_wac->pen_name, sizeof(wacom_wac->pen_name),
2223 "%s%s Pen", name, suffix);
2224 snprintf(wacom_wac->touch_name, sizeof(wacom_wac->touch_name),
2225 "%s%s Finger", name, suffix);
2226 snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name),
2227 "%s%s Pad", name, suffix);
2228}
2229
2230static void wacom_release_resources(struct wacom *wacom)
2231{
2232 struct hid_device *hdev = wacom->hdev;
2233
2234 if (!wacom->resources)
2235 return;
2236
2237 devres_release_group(&hdev->dev, wacom);
2238
2239 wacom->resources = false;
2240
2241 wacom->wacom_wac.pen_input = NULL;
2242 wacom->wacom_wac.touch_input = NULL;
2243 wacom->wacom_wac.pad_input = NULL;
2244}
2245
2246static void wacom_set_shared_values(struct wacom_wac *wacom_wac)
2247{
2248 if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH) {
2249 wacom_wac->shared->type = wacom_wac->features.type;
2250 wacom_wac->shared->touch_input = wacom_wac->touch_input;
2251 }
2252
2253 if (wacom_wac->has_mute_touch_switch) {
2254 wacom_wac->shared->has_mute_touch_switch = true;
2255 wacom_wac->shared->is_touch_on = true;
2256 }
2257
2258 if (wacom_wac->shared->has_mute_touch_switch &&
2259 wacom_wac->shared->touch_input) {
2260 set_bit(EV_SW, wacom_wac->shared->touch_input->evbit);
2261 input_set_capability(wacom_wac->shared->touch_input, EV_SW,
2262 SW_MUTE_DEVICE);
2263 }
2264}
2265
2266static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
2267{
2268 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2269 struct wacom_features *features = &wacom_wac->features;
2270 struct hid_device *hdev = wacom->hdev;
2271 int error;
2272 unsigned int connect_mask = HID_CONNECT_HIDRAW;
2273
2274 features->pktlen = wacom_compute_pktlen(hdev);
2275 if (features->pktlen > WACOM_PKGLEN_MAX)
2276 return -EINVAL;
2277
2278 if (!devres_open_group(&hdev->dev, wacom, GFP_KERNEL))
2279 return -ENOMEM;
2280
2281 wacom->resources = true;
2282
2283 error = wacom_allocate_inputs(wacom);
2284 if (error)
2285 goto fail;
2286
2287
2288
2289
2290
2291
2292 if (features->type == BAMBOO_PAD) {
2293 if (features->pktlen == WACOM_PKGLEN_PENABLED) {
2294 features->type = HID_GENERIC;
2295 } else if ((features->pktlen != WACOM_PKGLEN_BPAD_TOUCH) &&
2296 (features->pktlen != WACOM_PKGLEN_BPAD_TOUCH_USB)) {
2297 error = -ENODEV;
2298 goto fail;
2299 }
2300 }
2301
2302
2303 wacom_set_default_phy(features);
2304
2305
2306 wacom_retrieve_hid_descriptor(hdev, features);
2307 wacom_setup_device_quirks(wacom);
2308
2309 if (features->device_type == WACOM_DEVICETYPE_NONE &&
2310 features->type != WIRELESS) {
2311 error = features->type == HID_GENERIC ? -ENODEV : 0;
2312
2313 dev_warn(&hdev->dev, "Unknown device_type for '%s'. %s.",
2314 hdev->name,
2315 error ? "Ignoring" : "Assuming pen");
2316
2317 if (error)
2318 goto fail;
2319
2320 features->device_type |= WACOM_DEVICETYPE_PEN;
2321 }
2322
2323 wacom_calculate_res(features);
2324
2325 wacom_update_name(wacom, wireless ? " (WL)" : "");
2326
2327
2328 if ((features->type == BAMBOO_PEN) &&
2329 ((features->device_type & WACOM_DEVICETYPE_TOUCH) ||
2330 (features->device_type & WACOM_DEVICETYPE_PAD))) {
2331 error = -ENODEV;
2332 goto fail;
2333 }
2334
2335 error = wacom_add_shared_data(hdev);
2336 if (error)
2337 goto fail;
2338
2339 if (!(features->device_type & WACOM_DEVICETYPE_WL_MONITOR) &&
2340 (features->quirks & WACOM_QUIRK_BATTERY)) {
2341 error = wacom_initialize_battery(wacom);
2342 if (error)
2343 goto fail;
2344 }
2345
2346 error = wacom_register_inputs(wacom);
2347 if (error)
2348 goto fail;
2349
2350 if (wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD) {
2351 error = wacom_initialize_leds(wacom);
2352 if (error)
2353 goto fail;
2354
2355 error = wacom_initialize_remotes(wacom);
2356 if (error)
2357 goto fail;
2358 }
2359
2360 if (features->type == HID_GENERIC)
2361 connect_mask |= HID_CONNECT_DRIVER;
2362
2363
2364 error = hid_hw_start(hdev, connect_mask);
2365 if (error) {
2366 hid_err(hdev, "hw start failed\n");
2367 goto fail;
2368 }
2369
2370 if (!wireless) {
2371
2372 wacom_query_tablet_data(wacom);
2373 }
2374
2375
2376 if ((features->type == BAMBOO_TOUCH) &&
2377 (features->device_type & WACOM_DEVICETYPE_PEN)) {
2378 cancel_delayed_work_sync(&wacom->init_work);
2379 _wacom_query_tablet_data(wacom);
2380 error = -ENODEV;
2381 goto fail_quirks;
2382 }
2383
2384 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR)
2385 error = hid_hw_open(hdev);
2386
2387 wacom_set_shared_values(wacom_wac);
2388 devres_close_group(&hdev->dev, wacom);
2389
2390 return 0;
2391
2392fail_quirks:
2393 hid_hw_stop(hdev);
2394fail:
2395 wacom_release_resources(wacom);
2396 return error;
2397}
2398
2399static void wacom_wireless_work(struct work_struct *work)
2400{
2401 struct wacom *wacom = container_of(work, struct wacom, wireless_work);
2402 struct usb_device *usbdev = wacom->usbdev;
2403 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2404 struct hid_device *hdev1, *hdev2;
2405 struct wacom *wacom1, *wacom2;
2406 struct wacom_wac *wacom_wac1, *wacom_wac2;
2407 int error;
2408
2409
2410
2411
2412
2413
2414 wacom_destroy_battery(wacom);
2415
2416
2417 hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
2418 wacom1 = hid_get_drvdata(hdev1);
2419 wacom_wac1 = &(wacom1->wacom_wac);
2420 wacom_release_resources(wacom1);
2421
2422
2423 hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
2424 wacom2 = hid_get_drvdata(hdev2);
2425 wacom_wac2 = &(wacom2->wacom_wac);
2426 wacom_release_resources(wacom2);
2427
2428 if (wacom_wac->pid == 0) {
2429 hid_info(wacom->hdev, "wireless tablet disconnected\n");
2430 } else {
2431 const struct hid_device_id *id = wacom_ids;
2432
2433 hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
2434 wacom_wac->pid);
2435
2436 while (id->bus) {
2437 if (id->vendor == USB_VENDOR_ID_WACOM &&
2438 id->product == wacom_wac->pid)
2439 break;
2440 id++;
2441 }
2442
2443 if (!id->bus) {
2444 hid_info(wacom->hdev, "ignoring unknown PID.\n");
2445 return;
2446 }
2447
2448
2449 wacom_wac1->features =
2450 *((struct wacom_features *)id->driver_data);
2451
2452 wacom_wac1->pid = wacom_wac->pid;
2453 hid_hw_stop(hdev1);
2454 error = wacom_parse_and_register(wacom1, true);
2455 if (error)
2456 goto fail;
2457
2458
2459 if (wacom_wac1->features.touch_max ||
2460 (wacom_wac1->features.type >= INTUOSHT &&
2461 wacom_wac1->features.type <= BAMBOO_PT)) {
2462 wacom_wac2->features =
2463 *((struct wacom_features *)id->driver_data);
2464 wacom_wac2->pid = wacom_wac->pid;
2465 hid_hw_stop(hdev2);
2466 error = wacom_parse_and_register(wacom2, true);
2467 if (error)
2468 goto fail;
2469 }
2470
2471 strlcpy(wacom_wac->name, wacom_wac1->name,
2472 sizeof(wacom_wac->name));
2473 error = wacom_initialize_battery(wacom);
2474 if (error)
2475 goto fail;
2476 }
2477
2478 return;
2479
2480fail:
2481 wacom_release_resources(wacom1);
2482 wacom_release_resources(wacom2);
2483 return;
2484}
2485
2486static void wacom_remote_destroy_one(struct wacom *wacom, unsigned int index)
2487{
2488 struct wacom_remote *remote = wacom->remote;
2489 u32 serial = remote->remotes[index].serial;
2490 int i;
2491 unsigned long flags;
2492
2493 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
2494 if (remote->remotes[i].serial == serial) {
2495
2496 spin_lock_irqsave(&remote->remote_lock, flags);
2497 remote->remotes[i].registered = false;
2498 spin_unlock_irqrestore(&remote->remote_lock, flags);
2499
2500 if (remote->remotes[i].battery.battery)
2501 devres_release_group(&wacom->hdev->dev,
2502 &remote->remotes[i].battery.bat_desc);
2503
2504 if (remote->remotes[i].group.name)
2505 devres_release_group(&wacom->hdev->dev,
2506 &remote->remotes[i]);
2507
2508 remote->remotes[i].serial = 0;
2509 remote->remotes[i].group.name = NULL;
2510 remote->remotes[i].battery.battery = NULL;
2511 wacom->led.groups[i].select = WACOM_STATUS_UNKNOWN;
2512 }
2513 }
2514}
2515
2516static int wacom_remote_create_one(struct wacom *wacom, u32 serial,
2517 unsigned int index)
2518{
2519 struct wacom_remote *remote = wacom->remote;
2520 struct device *dev = &wacom->hdev->dev;
2521 int error, k;
2522
2523
2524
2525
2526 for (k = 0; k < WACOM_MAX_REMOTES; k++) {
2527 if (remote->remotes[k].serial == serial)
2528 break;
2529 }
2530
2531 if (k < WACOM_MAX_REMOTES) {
2532 remote->remotes[index].serial = serial;
2533 return 0;
2534 }
2535
2536 if (!devres_open_group(dev, &remote->remotes[index], GFP_KERNEL))
2537 return -ENOMEM;
2538
2539 error = wacom_remote_create_attr_group(wacom, serial, index);
2540 if (error)
2541 goto fail;
2542
2543 remote->remotes[index].input = wacom_allocate_input(wacom);
2544 if (!remote->remotes[index].input) {
2545 error = -ENOMEM;
2546 goto fail;
2547 }
2548 remote->remotes[index].input->uniq = remote->remotes[index].group.name;
2549 remote->remotes[index].input->name = wacom->wacom_wac.pad_name;
2550
2551 if (!remote->remotes[index].input->name) {
2552 error = -EINVAL;
2553 goto fail;
2554 }
2555
2556 error = wacom_setup_pad_input_capabilities(remote->remotes[index].input,
2557 &wacom->wacom_wac);
2558 if (error)
2559 goto fail;
2560
2561 remote->remotes[index].serial = serial;
2562
2563 error = input_register_device(remote->remotes[index].input);
2564 if (error)
2565 goto fail;
2566
2567 error = wacom_led_groups_alloc_and_register_one(
2568 &remote->remotes[index].input->dev,
2569 wacom, index, 3, true);
2570 if (error)
2571 goto fail;
2572
2573 remote->remotes[index].registered = true;
2574
2575 devres_close_group(dev, &remote->remotes[index]);
2576 return 0;
2577
2578fail:
2579 devres_release_group(dev, &remote->remotes[index]);
2580 remote->remotes[index].serial = 0;
2581 return error;
2582}
2583
2584static int wacom_remote_attach_battery(struct wacom *wacom, int index)
2585{
2586 struct wacom_remote *remote = wacom->remote;
2587 int error;
2588
2589 if (!remote->remotes[index].registered)
2590 return 0;
2591
2592 if (remote->remotes[index].battery.battery)
2593 return 0;
2594
2595 if (wacom->led.groups[index].select == WACOM_STATUS_UNKNOWN)
2596 return 0;
2597
2598 error = __wacom_initialize_battery(wacom,
2599 &wacom->remote->remotes[index].battery);
2600 if (error)
2601 return error;
2602
2603 return 0;
2604}
2605
2606static void wacom_remote_work(struct work_struct *work)
2607{
2608 struct wacom *wacom = container_of(work, struct wacom, remote_work);
2609 struct wacom_remote *remote = wacom->remote;
2610 struct wacom_remote_data data;
2611 unsigned long flags;
2612 unsigned int count;
2613 u32 serial;
2614 int i;
2615
2616 spin_lock_irqsave(&remote->remote_lock, flags);
2617
2618 count = kfifo_out(&remote->remote_fifo, &data, sizeof(data));
2619
2620 if (count != sizeof(data)) {
2621 hid_err(wacom->hdev,
2622 "workitem triggered without status available\n");
2623 spin_unlock_irqrestore(&remote->remote_lock, flags);
2624 return;
2625 }
2626
2627 if (!kfifo_is_empty(&remote->remote_fifo))
2628 wacom_schedule_work(&wacom->wacom_wac, WACOM_WORKER_REMOTE);
2629
2630 spin_unlock_irqrestore(&remote->remote_lock, flags);
2631
2632 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
2633 serial = data.remote[i].serial;
2634 if (data.remote[i].connected) {
2635
2636 if (remote->remotes[i].serial == serial) {
2637 wacom_remote_attach_battery(wacom, i);
2638 continue;
2639 }
2640
2641 if (remote->remotes[i].serial)
2642 wacom_remote_destroy_one(wacom, i);
2643
2644 wacom_remote_create_one(wacom, serial, i);
2645
2646 } else if (remote->remotes[i].serial) {
2647 wacom_remote_destroy_one(wacom, i);
2648 }
2649 }
2650}
2651
2652static void wacom_mode_change_work(struct work_struct *work)
2653{
2654 struct wacom *wacom = container_of(work, struct wacom, mode_change_work);
2655 struct wacom_shared *shared = wacom->wacom_wac.shared;
2656 struct wacom *wacom1 = NULL;
2657 struct wacom *wacom2 = NULL;
2658 bool is_direct = wacom->wacom_wac.is_direct_mode;
2659 int error = 0;
2660
2661 if (shared->pen) {
2662 wacom1 = hid_get_drvdata(shared->pen);
2663 wacom_release_resources(wacom1);
2664 hid_hw_stop(wacom1->hdev);
2665 wacom1->wacom_wac.has_mode_change = true;
2666 wacom1->wacom_wac.is_direct_mode = is_direct;
2667 }
2668
2669 if (shared->touch) {
2670 wacom2 = hid_get_drvdata(shared->touch);
2671 wacom_release_resources(wacom2);
2672 hid_hw_stop(wacom2->hdev);
2673 wacom2->wacom_wac.has_mode_change = true;
2674 wacom2->wacom_wac.is_direct_mode = is_direct;
2675 }
2676
2677 if (wacom1) {
2678 error = wacom_parse_and_register(wacom1, false);
2679 if (error)
2680 return;
2681 }
2682
2683 if (wacom2) {
2684 error = wacom_parse_and_register(wacom2, false);
2685 if (error)
2686 return;
2687 }
2688
2689 return;
2690}
2691
2692static int wacom_probe(struct hid_device *hdev,
2693 const struct hid_device_id *id)
2694{
2695 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
2696 struct usb_device *dev = interface_to_usbdev(intf);
2697 struct wacom *wacom;
2698 struct wacom_wac *wacom_wac;
2699 struct wacom_features *features;
2700 int error;
2701
2702 if (!id->driver_data)
2703 return -EINVAL;
2704
2705 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
2706
2707
2708 hdev->quirks &= ~HID_QUIRK_NOGET;
2709
2710 wacom = devm_kzalloc(&hdev->dev, sizeof(struct wacom), GFP_KERNEL);
2711 if (!wacom)
2712 return -ENOMEM;
2713
2714 hid_set_drvdata(hdev, wacom);
2715 wacom->hdev = hdev;
2716
2717 wacom_wac = &wacom->wacom_wac;
2718 wacom_wac->features = *((struct wacom_features *)id->driver_data);
2719 features = &wacom_wac->features;
2720
2721 if (features->check_for_hid_type && features->hid_type != hdev->type) {
2722 error = -ENODEV;
2723 goto fail;
2724 }
2725
2726 error = kfifo_alloc(&wacom_wac->pen_fifo, WACOM_PKGLEN_MAX, GFP_KERNEL);
2727 if (error)
2728 goto fail;
2729
2730 wacom_wac->hid_data.inputmode = -1;
2731 wacom_wac->mode_report = -1;
2732
2733 wacom->usbdev = dev;
2734 wacom->intf = intf;
2735 mutex_init(&wacom->lock);
2736 INIT_DELAYED_WORK(&wacom->init_work, wacom_init_work);
2737 INIT_WORK(&wacom->wireless_work, wacom_wireless_work);
2738 INIT_WORK(&wacom->battery_work, wacom_battery_work);
2739 INIT_WORK(&wacom->remote_work, wacom_remote_work);
2740 INIT_WORK(&wacom->mode_change_work, wacom_mode_change_work);
2741
2742
2743 error = hid_parse(hdev);
2744 if (error) {
2745 hid_err(hdev, "parse failed\n");
2746 goto fail;
2747 }
2748
2749 error = wacom_parse_and_register(wacom, false);
2750 if (error)
2751 goto fail;
2752
2753 if (hdev->bus == BUS_BLUETOOTH) {
2754 error = device_create_file(&hdev->dev, &dev_attr_speed);
2755 if (error)
2756 hid_warn(hdev,
2757 "can't create sysfs speed attribute err: %d\n",
2758 error);
2759 }
2760
2761 return 0;
2762
2763fail:
2764 hid_set_drvdata(hdev, NULL);
2765 return error;
2766}
2767
2768static void wacom_remove(struct hid_device *hdev)
2769{
2770 struct wacom *wacom = hid_get_drvdata(hdev);
2771 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2772 struct wacom_features *features = &wacom_wac->features;
2773
2774 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR)
2775 hid_hw_close(hdev);
2776
2777 hid_hw_stop(hdev);
2778
2779 cancel_delayed_work_sync(&wacom->init_work);
2780 cancel_work_sync(&wacom->wireless_work);
2781 cancel_work_sync(&wacom->battery_work);
2782 cancel_work_sync(&wacom->remote_work);
2783 cancel_work_sync(&wacom->mode_change_work);
2784 if (hdev->bus == BUS_BLUETOOTH)
2785 device_remove_file(&hdev->dev, &dev_attr_speed);
2786
2787
2788 wacom_led_groups_release(wacom);
2789
2790 if (wacom->wacom_wac.features.type != REMOTE)
2791 wacom_release_resources(wacom);
2792
2793 kfifo_free(&wacom_wac->pen_fifo);
2794
2795 hid_set_drvdata(hdev, NULL);
2796}
2797
2798#ifdef CONFIG_PM
2799static int wacom_resume(struct hid_device *hdev)
2800{
2801 struct wacom *wacom = hid_get_drvdata(hdev);
2802
2803 mutex_lock(&wacom->lock);
2804
2805
2806 _wacom_query_tablet_data(wacom);
2807 wacom_led_control(wacom);
2808
2809 mutex_unlock(&wacom->lock);
2810
2811 return 0;
2812}
2813
2814static int wacom_reset_resume(struct hid_device *hdev)
2815{
2816 return wacom_resume(hdev);
2817}
2818#endif
2819
2820static struct hid_driver wacom_driver = {
2821 .name = "wacom",
2822 .id_table = wacom_ids,
2823 .probe = wacom_probe,
2824 .remove = wacom_remove,
2825 .report = wacom_wac_report,
2826#ifdef CONFIG_PM
2827 .resume = wacom_resume,
2828 .reset_resume = wacom_reset_resume,
2829#endif
2830 .raw_event = wacom_raw_event,
2831};
2832module_hid_driver(wacom_driver);
2833
2834MODULE_VERSION(DRIVER_VERSION);
2835MODULE_AUTHOR(DRIVER_AUTHOR);
2836MODULE_DESCRIPTION(DRIVER_DESC);
2837MODULE_LICENSE("GPL");
2838