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