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
20#define WAC_CMD_WL_LED_CONTROL 0x03
21#define WAC_CMD_LED_CONTROL 0x20
22#define WAC_CMD_ICON_START 0x21
23#define WAC_CMD_ICON_XFER 0x23
24#define WAC_CMD_ICON_BT_XFER 0x26
25#define WAC_CMD_RETRIES 10
26#define WAC_CMD_DELETE_PAIRING 0x20
27#define WAC_CMD_UNPAIR_ALL 0xFF
28#define WAC_REMOTE_SERIAL_MAX_STRLEN 9
29
30#define DEV_ATTR_RW_PERM (S_IRUGO | S_IWUSR | S_IWGRP)
31#define DEV_ATTR_WO_PERM (S_IWUSR | S_IWGRP)
32#define DEV_ATTR_RO_PERM (S_IRUSR | S_IRGRP)
33
34static int wacom_get_report(struct hid_device *hdev, u8 type, u8 *buf,
35 size_t size, unsigned int retries)
36{
37 int retval;
38
39 do {
40 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
41 HID_REQ_GET_REPORT);
42 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries);
43
44 if (retval < 0)
45 hid_err(hdev, "wacom_get_report: ran out of retries "
46 "(last error = %d)\n", retval);
47
48 return retval;
49}
50
51static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf,
52 size_t size, unsigned int retries)
53{
54 int retval;
55
56 do {
57 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
58 HID_REQ_SET_REPORT);
59 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries);
60
61 if (retval < 0)
62 hid_err(hdev, "wacom_set_report: ran out of retries "
63 "(last error = %d)\n", retval);
64
65 return retval;
66}
67
68static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
69 u8 *raw_data, int size)
70{
71 struct wacom *wacom = hid_get_drvdata(hdev);
72
73 if (size > WACOM_PKGLEN_MAX)
74 return 1;
75
76 memcpy(wacom->wacom_wac.data, raw_data, size);
77
78 wacom_wac_irq(&wacom->wacom_wac, size);
79
80 return 0;
81}
82
83static int wacom_open(struct input_dev *dev)
84{
85 struct wacom *wacom = input_get_drvdata(dev);
86
87 return hid_hw_open(wacom->hdev);
88}
89
90static void wacom_close(struct input_dev *dev)
91{
92 struct wacom *wacom = input_get_drvdata(dev);
93
94 hid_hw_close(wacom->hdev);
95}
96
97
98
99
100static int wacom_calc_hid_res(int logical_extents, int physical_extents,
101 unsigned unit, int exponent)
102{
103 struct hid_field field = {
104 .logical_maximum = logical_extents,
105 .physical_maximum = physical_extents,
106 .unit = unit,
107 .unit_exponent = exponent,
108 };
109
110 return hidinput_calc_abs_res(&field, ABS_X);
111}
112
113static void wacom_feature_mapping(struct hid_device *hdev,
114 struct hid_field *field, struct hid_usage *usage)
115{
116 struct wacom *wacom = hid_get_drvdata(hdev);
117 struct wacom_features *features = &wacom->wacom_wac.features;
118 struct hid_data *hid_data = &wacom->wacom_wac.hid_data;
119 u8 *data;
120 int ret;
121
122 switch (usage->hid) {
123 case HID_DG_CONTACTMAX:
124
125 if (!features->touch_max) {
126
127 data = kzalloc(2, GFP_KERNEL);
128 if (!data)
129 break;
130 data[0] = field->report->id;
131 ret = wacom_get_report(hdev, HID_FEATURE_REPORT,
132 data, 2, WAC_CMD_RETRIES);
133 if (ret == 2) {
134 features->touch_max = data[1];
135 } else {
136 features->touch_max = 16;
137 hid_warn(hdev, "wacom_feature_mapping: "
138 "could not get HID_DG_CONTACTMAX, "
139 "defaulting to %d\n",
140 features->touch_max);
141 }
142 kfree(data);
143 }
144 break;
145 case HID_DG_INPUTMODE:
146
147 if (usage->usage_index >= field->report_count) {
148 dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n");
149 break;
150 }
151
152 hid_data->inputmode = field->report->id;
153 hid_data->inputmode_index = usage->usage_index;
154 break;
155
156 case HID_UP_DIGITIZER:
157 if (field->report->id == 0x0B &&
158 (field->application == WACOM_G9_DIGITIZER ||
159 field->application == WACOM_G11_DIGITIZER)) {
160 wacom->wacom_wac.mode_report = field->report->id;
161 wacom->wacom_wac.mode_value = 0;
162 }
163 break;
164
165 case WACOM_G9_PAGE:
166 case WACOM_G11_PAGE:
167 if (field->report->id == 0x03 &&
168 (field->application == WACOM_G9_TOUCHSCREEN ||
169 field->application == WACOM_G11_TOUCHSCREEN)) {
170 wacom->wacom_wac.mode_report = field->report->id;
171 wacom->wacom_wac.mode_value = 0;
172 }
173 break;
174 }
175}
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209static void wacom_usage_mapping(struct hid_device *hdev,
210 struct hid_field *field, struct hid_usage *usage)
211{
212 struct wacom *wacom = hid_get_drvdata(hdev);
213 struct wacom_features *features = &wacom->wacom_wac.features;
214 bool finger = WACOM_FINGER_FIELD(field);
215 bool pen = WACOM_PEN_FIELD(field);
216
217
218
219
220
221
222 if (pen)
223 features->device_type |= WACOM_DEVICETYPE_PEN;
224 else if (finger)
225 features->device_type |= WACOM_DEVICETYPE_TOUCH;
226 else
227 return;
228
229
230
231
232
233 if (features->type > BAMBOO_PT) {
234
235 if (finger && !features->touch_max)
236 features->touch_max = 1;
237 }
238
239 switch (usage->hid) {
240 case HID_GD_X:
241 features->x_max = field->logical_maximum;
242 if (finger) {
243 features->x_phy = field->physical_maximum;
244 if ((features->type != BAMBOO_PT) &&
245 (features->type != BAMBOO_TOUCH)) {
246 features->unit = field->unit;
247 features->unitExpo = field->unit_exponent;
248 }
249 }
250 break;
251 case HID_GD_Y:
252 features->y_max = field->logical_maximum;
253 if (finger) {
254 features->y_phy = field->physical_maximum;
255 if ((features->type != BAMBOO_PT) &&
256 (features->type != BAMBOO_TOUCH)) {
257 features->unit = field->unit;
258 features->unitExpo = field->unit_exponent;
259 }
260 }
261 break;
262 case HID_DG_TIPPRESSURE:
263 if (pen)
264 features->pressure_max = field->logical_maximum;
265 break;
266 }
267
268 if (features->type == HID_GENERIC)
269 wacom_wac_usage_mapping(hdev, field, usage);
270}
271
272static void wacom_post_parse_hid(struct hid_device *hdev,
273 struct wacom_features *features)
274{
275 struct wacom *wacom = hid_get_drvdata(hdev);
276 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
277
278 if (features->type == HID_GENERIC) {
279
280 if (features->touch_max > 1) {
281 input_mt_init_slots(wacom_wac->touch_input, wacom_wac->features.touch_max,
282 INPUT_MT_DIRECT);
283 }
284 }
285}
286
287static void wacom_parse_hid(struct hid_device *hdev,
288 struct wacom_features *features)
289{
290 struct hid_report_enum *rep_enum;
291 struct hid_report *hreport;
292 int i, j;
293
294
295 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
296 list_for_each_entry(hreport, &rep_enum->report_list, list) {
297 for (i = 0; i < hreport->maxfield; i++) {
298
299 if (hreport->field[i]->report_count < 1)
300 continue;
301
302 for (j = 0; j < hreport->field[i]->maxusage; j++) {
303 wacom_feature_mapping(hdev, hreport->field[i],
304 hreport->field[i]->usage + j);
305 }
306 }
307 }
308
309
310 rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
311 list_for_each_entry(hreport, &rep_enum->report_list, list) {
312
313 if (!hreport->maxfield)
314 continue;
315
316 for (i = 0; i < hreport->maxfield; i++)
317 for (j = 0; j < hreport->field[i]->maxusage; j++)
318 wacom_usage_mapping(hdev, hreport->field[i],
319 hreport->field[i]->usage + j);
320 }
321
322 wacom_post_parse_hid(hdev, features);
323}
324
325static int wacom_hid_set_device_mode(struct hid_device *hdev)
326{
327 struct wacom *wacom = hid_get_drvdata(hdev);
328 struct hid_data *hid_data = &wacom->wacom_wac.hid_data;
329 struct hid_report *r;
330 struct hid_report_enum *re;
331
332 if (hid_data->inputmode < 0)
333 return 0;
334
335 re = &(hdev->report_enum[HID_FEATURE_REPORT]);
336 r = re->report_id_hash[hid_data->inputmode];
337 if (r) {
338 r->field[0]->value[hid_data->inputmode_index] = 2;
339 hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
340 }
341 return 0;
342}
343
344static int wacom_set_device_mode(struct hid_device *hdev,
345 struct wacom_wac *wacom_wac)
346{
347 u8 *rep_data;
348 struct hid_report *r;
349 struct hid_report_enum *re;
350 int length;
351 int error = -ENOMEM, limit = 0;
352
353 if (wacom_wac->mode_report < 0)
354 return 0;
355
356 re = &(hdev->report_enum[HID_FEATURE_REPORT]);
357 r = re->report_id_hash[wacom_wac->mode_report];
358 if (!r)
359 return -EINVAL;
360
361 rep_data = hid_alloc_report_buf(r, GFP_KERNEL);
362 if (!rep_data)
363 return -ENOMEM;
364
365 length = hid_report_len(r);
366
367 do {
368 rep_data[0] = wacom_wac->mode_report;
369 rep_data[1] = wacom_wac->mode_value;
370
371 error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
372 length, 1);
373 if (error >= 0)
374 error = wacom_get_report(hdev, HID_FEATURE_REPORT,
375 rep_data, length, 1);
376 } while (error >= 0 &&
377 rep_data[1] != wacom_wac->mode_report &&
378 limit++ < WAC_MSG_RETRIES);
379
380 kfree(rep_data);
381
382 return error < 0 ? error : 0;
383}
384
385static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
386 struct wacom_features *features)
387{
388 struct wacom *wacom = hid_get_drvdata(hdev);
389 int ret;
390 u8 rep_data[2];
391
392 switch (features->type) {
393 case GRAPHIRE_BT:
394 rep_data[0] = 0x03;
395 rep_data[1] = 0x00;
396 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
397 3);
398
399 if (ret >= 0) {
400 rep_data[0] = speed == 0 ? 0x05 : 0x06;
401 rep_data[1] = 0x00;
402
403 ret = wacom_set_report(hdev, HID_FEATURE_REPORT,
404 rep_data, 2, 3);
405
406 if (ret >= 0) {
407 wacom->wacom_wac.bt_high_speed = speed;
408 return 0;
409 }
410 }
411
412
413
414
415
416 hid_warn(hdev, "failed to poke device, command %d, err %d\n",
417 rep_data[0], ret);
418 break;
419 case INTUOS4WL:
420 if (speed == 1)
421 wacom->wacom_wac.bt_features &= ~0x20;
422 else
423 wacom->wacom_wac.bt_features |= 0x20;
424
425 rep_data[0] = 0x03;
426 rep_data[1] = wacom->wacom_wac.bt_features;
427
428 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
429 1);
430 if (ret >= 0)
431 wacom->wacom_wac.bt_high_speed = speed;
432 break;
433 }
434
435 return 0;
436}
437
438
439
440
441
442
443
444
445static int wacom_query_tablet_data(struct hid_device *hdev,
446 struct wacom_features *features)
447{
448 struct wacom *wacom = hid_get_drvdata(hdev);
449 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
450
451 if (hdev->bus == BUS_BLUETOOTH)
452 return wacom_bt_query_tablet_data(hdev, 1, features);
453
454 if (features->type != HID_GENERIC) {
455 if (features->device_type & WACOM_DEVICETYPE_TOUCH) {
456 if (features->type > TABLETPC) {
457
458 wacom_wac->mode_report = 3;
459 wacom_wac->mode_value = 4;
460 } else if (features->type == WACOM_24HDT) {
461 wacom_wac->mode_report = 18;
462 wacom_wac->mode_value = 2;
463 } else if (features->type == WACOM_27QHDT) {
464 wacom_wac->mode_report = 131;
465 wacom_wac->mode_value = 2;
466 } else if (features->type == BAMBOO_PAD) {
467 wacom_wac->mode_report = 2;
468 wacom_wac->mode_value = 2;
469 }
470 } else if (features->device_type & WACOM_DEVICETYPE_PEN) {
471 if (features->type <= BAMBOO_PT) {
472 wacom_wac->mode_report = 2;
473 wacom_wac->mode_value = 2;
474 }
475 }
476 }
477
478 wacom_set_device_mode(hdev, wacom_wac);
479
480 if (features->type == HID_GENERIC)
481 return wacom_hid_set_device_mode(hdev);
482
483 return 0;
484}
485
486static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
487 struct wacom_features *features)
488{
489 struct wacom *wacom = hid_get_drvdata(hdev);
490 struct usb_interface *intf = wacom->intf;
491
492
493 features->x_fuzz = 4;
494 features->y_fuzz = 4;
495 features->pressure_fuzz = 0;
496 features->distance_fuzz = 0;
497
498
499
500
501
502
503
504 if (features->type == WIRELESS) {
505 if (intf->cur_altsetting->desc.bInterfaceNumber == 0)
506 features->device_type = WACOM_DEVICETYPE_WL_MONITOR;
507 else
508 features->device_type = WACOM_DEVICETYPE_NONE;
509 return;
510 }
511
512 wacom_parse_hid(hdev, features);
513}
514
515struct wacom_hdev_data {
516 struct list_head list;
517 struct kref kref;
518 struct hid_device *dev;
519 struct wacom_shared shared;
520};
521
522static LIST_HEAD(wacom_udev_list);
523static DEFINE_MUTEX(wacom_udev_list_lock);
524
525static bool wacom_are_sibling(struct hid_device *hdev,
526 struct hid_device *sibling)
527{
528 struct wacom *wacom = hid_get_drvdata(hdev);
529 struct wacom_features *features = &wacom->wacom_wac.features;
530 int vid = features->oVid;
531 int pid = features->oPid;
532 int n1,n2;
533
534 if (vid == 0 && pid == 0) {
535 vid = hdev->vendor;
536 pid = hdev->product;
537 }
538
539 if (vid != sibling->vendor || pid != sibling->product)
540 return false;
541
542
543 n1 = strrchr(hdev->phys, '.') - hdev->phys;
544 n2 = strrchr(sibling->phys, '.') - sibling->phys;
545 if (n1 != n2 || n1 <= 0 || n2 <= 0)
546 return false;
547
548 return !strncmp(hdev->phys, sibling->phys, n1);
549}
550
551static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
552{
553 struct wacom_hdev_data *data;
554
555 list_for_each_entry(data, &wacom_udev_list, list) {
556 if (wacom_are_sibling(hdev, data->dev)) {
557 kref_get(&data->kref);
558 return data;
559 }
560 }
561
562 return NULL;
563}
564
565static int wacom_add_shared_data(struct hid_device *hdev)
566{
567 struct wacom *wacom = hid_get_drvdata(hdev);
568 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
569 struct wacom_hdev_data *data;
570 int retval = 0;
571
572 mutex_lock(&wacom_udev_list_lock);
573
574 data = wacom_get_hdev_data(hdev);
575 if (!data) {
576 data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
577 if (!data) {
578 retval = -ENOMEM;
579 goto out;
580 }
581
582 kref_init(&data->kref);
583 data->dev = hdev;
584 list_add_tail(&data->list, &wacom_udev_list);
585 }
586
587 wacom_wac->shared = &data->shared;
588
589 if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)
590 wacom_wac->shared->touch = hdev;
591 else if (wacom_wac->features.device_type & WACOM_DEVICETYPE_PEN)
592 wacom_wac->shared->pen = hdev;
593
594out:
595 mutex_unlock(&wacom_udev_list_lock);
596 return retval;
597}
598
599static void wacom_release_shared_data(struct kref *kref)
600{
601 struct wacom_hdev_data *data =
602 container_of(kref, struct wacom_hdev_data, kref);
603
604 mutex_lock(&wacom_udev_list_lock);
605 list_del(&data->list);
606 mutex_unlock(&wacom_udev_list_lock);
607
608 kfree(data);
609}
610
611static void wacom_remove_shared_data(struct wacom *wacom)
612{
613 struct wacom_hdev_data *data;
614 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
615
616 if (wacom_wac->shared) {
617 data = container_of(wacom_wac->shared, struct wacom_hdev_data,
618 shared);
619
620 if (wacom_wac->shared->touch == wacom->hdev)
621 wacom_wac->shared->touch = NULL;
622 else if (wacom_wac->shared->pen == wacom->hdev)
623 wacom_wac->shared->pen = NULL;
624
625 kref_put(&data->kref, wacom_release_shared_data);
626 wacom_wac->shared = NULL;
627 }
628}
629
630static int wacom_led_control(struct wacom *wacom)
631{
632 unsigned char *buf;
633 int retval;
634 unsigned char report_id = WAC_CMD_LED_CONTROL;
635 int buf_size = 9;
636
637 if (wacom->wacom_wac.pid) {
638 report_id = WAC_CMD_WL_LED_CONTROL;
639 buf_size = 13;
640 }
641 buf = kzalloc(buf_size, GFP_KERNEL);
642 if (!buf)
643 return -ENOMEM;
644
645 if (wacom->wacom_wac.features.type >= INTUOS5S &&
646 wacom->wacom_wac.features.type <= INTUOSPL) {
647
648
649
650
651
652 int ring_led = wacom->led.select[0] & 0x03;
653 int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03;
654 int crop_lum = 0;
655 unsigned char led_bits = (crop_lum << 4) | (ring_lum << 2) | (ring_led);
656
657 buf[0] = report_id;
658 if (wacom->wacom_wac.pid) {
659 wacom_get_report(wacom->hdev, HID_FEATURE_REPORT,
660 buf, buf_size, WAC_CMD_RETRIES);
661 buf[0] = report_id;
662 buf[4] = led_bits;
663 } else
664 buf[1] = led_bits;
665 }
666 else {
667 int led = wacom->led.select[0] | 0x4;
668
669 if (wacom->wacom_wac.features.type == WACOM_21UX2 ||
670 wacom->wacom_wac.features.type == WACOM_24HD)
671 led |= (wacom->led.select[1] << 4) | 0x40;
672
673 buf[0] = report_id;
674 buf[1] = led;
675 buf[2] = wacom->led.llv;
676 buf[3] = wacom->led.hlv;
677 buf[4] = wacom->led.img_lum;
678 }
679
680 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, buf_size,
681 WAC_CMD_RETRIES);
682 kfree(buf);
683
684 return retval;
685}
686
687static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id,
688 const unsigned len, const void *img)
689{
690 unsigned char *buf;
691 int i, retval;
692 const unsigned chunk_len = len / 4;
693
694 buf = kzalloc(chunk_len + 3 , GFP_KERNEL);
695 if (!buf)
696 return -ENOMEM;
697
698
699 buf[0] = WAC_CMD_ICON_START;
700 buf[1] = 1;
701 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
702 WAC_CMD_RETRIES);
703 if (retval < 0)
704 goto out;
705
706 buf[0] = xfer_id;
707 buf[1] = button_id & 0x07;
708 for (i = 0; i < 4; i++) {
709 buf[2] = i;
710 memcpy(buf + 3, img + i * chunk_len, chunk_len);
711
712 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
713 buf, chunk_len + 3, WAC_CMD_RETRIES);
714 if (retval < 0)
715 break;
716 }
717
718
719 buf[0] = WAC_CMD_ICON_START;
720 buf[1] = 0;
721 wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
722 WAC_CMD_RETRIES);
723
724out:
725 kfree(buf);
726 return retval;
727}
728
729static ssize_t wacom_led_select_store(struct device *dev, int set_id,
730 const char *buf, size_t count)
731{
732 struct hid_device *hdev = to_hid_device(dev);
733 struct wacom *wacom = hid_get_drvdata(hdev);
734 unsigned int id;
735 int err;
736
737 err = kstrtouint(buf, 10, &id);
738 if (err)
739 return err;
740
741 mutex_lock(&wacom->lock);
742
743 wacom->led.select[set_id] = id & 0x3;
744 err = wacom_led_control(wacom);
745
746 mutex_unlock(&wacom->lock);
747
748 return err < 0 ? err : count;
749}
750
751#define DEVICE_LED_SELECT_ATTR(SET_ID) \
752static ssize_t wacom_led##SET_ID##_select_store(struct device *dev, \
753 struct device_attribute *attr, const char *buf, size_t count) \
754{ \
755 return wacom_led_select_store(dev, SET_ID, buf, count); \
756} \
757static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \
758 struct device_attribute *attr, char *buf) \
759{ \
760 struct hid_device *hdev = to_hid_device(dev);\
761 struct wacom *wacom = hid_get_drvdata(hdev); \
762 return scnprintf(buf, PAGE_SIZE, "%d\n", \
763 wacom->led.select[SET_ID]); \
764} \
765static DEVICE_ATTR(status_led##SET_ID##_select, DEV_ATTR_RW_PERM, \
766 wacom_led##SET_ID##_select_show, \
767 wacom_led##SET_ID##_select_store)
768
769DEVICE_LED_SELECT_ATTR(0);
770DEVICE_LED_SELECT_ATTR(1);
771
772static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest,
773 const char *buf, size_t count)
774{
775 unsigned int value;
776 int err;
777
778 err = kstrtouint(buf, 10, &value);
779 if (err)
780 return err;
781
782 mutex_lock(&wacom->lock);
783
784 *dest = value & 0x7f;
785 err = wacom_led_control(wacom);
786
787 mutex_unlock(&wacom->lock);
788
789 return err < 0 ? err : count;
790}
791
792#define DEVICE_LUMINANCE_ATTR(name, field) \
793static ssize_t wacom_##name##_luminance_store(struct device *dev, \
794 struct device_attribute *attr, const char *buf, size_t count) \
795{ \
796 struct hid_device *hdev = to_hid_device(dev);\
797 struct wacom *wacom = hid_get_drvdata(hdev); \
798 \
799 return wacom_luminance_store(wacom, &wacom->led.field, \
800 buf, count); \
801} \
802static ssize_t wacom_##name##_luminance_show(struct device *dev, \
803 struct device_attribute *attr, char *buf) \
804{ \
805 struct wacom *wacom = dev_get_drvdata(dev); \
806 return scnprintf(buf, PAGE_SIZE, "%d\n", wacom->led.field); \
807} \
808static DEVICE_ATTR(name##_luminance, DEV_ATTR_RW_PERM, \
809 wacom_##name##_luminance_show, \
810 wacom_##name##_luminance_store)
811
812DEVICE_LUMINANCE_ATTR(status0, llv);
813DEVICE_LUMINANCE_ATTR(status1, hlv);
814DEVICE_LUMINANCE_ATTR(buttons, img_lum);
815
816static ssize_t wacom_button_image_store(struct device *dev, int button_id,
817 const char *buf, size_t count)
818{
819 struct hid_device *hdev = to_hid_device(dev);
820 struct wacom *wacom = hid_get_drvdata(hdev);
821 int err;
822 unsigned len;
823 u8 xfer_id;
824
825 if (hdev->bus == BUS_BLUETOOTH) {
826 len = 256;
827 xfer_id = WAC_CMD_ICON_BT_XFER;
828 } else {
829 len = 1024;
830 xfer_id = WAC_CMD_ICON_XFER;
831 }
832
833 if (count != len)
834 return -EINVAL;
835
836 mutex_lock(&wacom->lock);
837
838 err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf);
839
840 mutex_unlock(&wacom->lock);
841
842 return err < 0 ? err : count;
843}
844
845#define DEVICE_BTNIMG_ATTR(BUTTON_ID) \
846static ssize_t wacom_btnimg##BUTTON_ID##_store(struct device *dev, \
847 struct device_attribute *attr, const char *buf, size_t count) \
848{ \
849 return wacom_button_image_store(dev, BUTTON_ID, buf, count); \
850} \
851static DEVICE_ATTR(button##BUTTON_ID##_rawimg, DEV_ATTR_WO_PERM, \
852 NULL, wacom_btnimg##BUTTON_ID##_store)
853
854DEVICE_BTNIMG_ATTR(0);
855DEVICE_BTNIMG_ATTR(1);
856DEVICE_BTNIMG_ATTR(2);
857DEVICE_BTNIMG_ATTR(3);
858DEVICE_BTNIMG_ATTR(4);
859DEVICE_BTNIMG_ATTR(5);
860DEVICE_BTNIMG_ATTR(6);
861DEVICE_BTNIMG_ATTR(7);
862
863static struct attribute *cintiq_led_attrs[] = {
864 &dev_attr_status_led0_select.attr,
865 &dev_attr_status_led1_select.attr,
866 NULL
867};
868
869static struct attribute_group cintiq_led_attr_group = {
870 .name = "wacom_led",
871 .attrs = cintiq_led_attrs,
872};
873
874static struct attribute *intuos4_led_attrs[] = {
875 &dev_attr_status0_luminance.attr,
876 &dev_attr_status1_luminance.attr,
877 &dev_attr_status_led0_select.attr,
878 &dev_attr_buttons_luminance.attr,
879 &dev_attr_button0_rawimg.attr,
880 &dev_attr_button1_rawimg.attr,
881 &dev_attr_button2_rawimg.attr,
882 &dev_attr_button3_rawimg.attr,
883 &dev_attr_button4_rawimg.attr,
884 &dev_attr_button5_rawimg.attr,
885 &dev_attr_button6_rawimg.attr,
886 &dev_attr_button7_rawimg.attr,
887 NULL
888};
889
890static struct attribute_group intuos4_led_attr_group = {
891 .name = "wacom_led",
892 .attrs = intuos4_led_attrs,
893};
894
895static struct attribute *intuos5_led_attrs[] = {
896 &dev_attr_status0_luminance.attr,
897 &dev_attr_status_led0_select.attr,
898 NULL
899};
900
901static struct attribute_group intuos5_led_attr_group = {
902 .name = "wacom_led",
903 .attrs = intuos5_led_attrs,
904};
905
906static int wacom_initialize_leds(struct wacom *wacom)
907{
908 int error;
909
910 if (!(wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD))
911 return 0;
912
913
914 switch (wacom->wacom_wac.features.type) {
915 case INTUOS4S:
916 case INTUOS4:
917 case INTUOS4WL:
918 case INTUOS4L:
919 wacom->led.select[0] = 0;
920 wacom->led.select[1] = 0;
921 wacom->led.llv = 10;
922 wacom->led.hlv = 20;
923 wacom->led.img_lum = 10;
924 error = sysfs_create_group(&wacom->hdev->dev.kobj,
925 &intuos4_led_attr_group);
926 break;
927
928 case WACOM_24HD:
929 case WACOM_21UX2:
930 wacom->led.select[0] = 0;
931 wacom->led.select[1] = 0;
932 wacom->led.llv = 0;
933 wacom->led.hlv = 0;
934 wacom->led.img_lum = 0;
935
936 error = sysfs_create_group(&wacom->hdev->dev.kobj,
937 &cintiq_led_attr_group);
938 break;
939
940 case INTUOS5S:
941 case INTUOS5:
942 case INTUOS5L:
943 case INTUOSPS:
944 case INTUOSPM:
945 case INTUOSPL:
946 wacom->led.select[0] = 0;
947 wacom->led.select[1] = 0;
948 wacom->led.llv = 32;
949 wacom->led.hlv = 0;
950 wacom->led.img_lum = 0;
951
952 error = sysfs_create_group(&wacom->hdev->dev.kobj,
953 &intuos5_led_attr_group);
954 break;
955
956 default:
957 return 0;
958 }
959
960 if (error) {
961 hid_err(wacom->hdev,
962 "cannot create sysfs group err: %d\n", error);
963 return error;
964 }
965 wacom_led_control(wacom);
966 wacom->led_initialized = true;
967
968 return 0;
969}
970
971static void wacom_destroy_leds(struct wacom *wacom)
972{
973 if (!wacom->led_initialized)
974 return;
975
976 if (!(wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD))
977 return;
978
979 wacom->led_initialized = false;
980
981 switch (wacom->wacom_wac.features.type) {
982 case INTUOS4S:
983 case INTUOS4:
984 case INTUOS4WL:
985 case INTUOS4L:
986 sysfs_remove_group(&wacom->hdev->dev.kobj,
987 &intuos4_led_attr_group);
988 break;
989
990 case WACOM_24HD:
991 case WACOM_21UX2:
992 sysfs_remove_group(&wacom->hdev->dev.kobj,
993 &cintiq_led_attr_group);
994 break;
995
996 case INTUOS5S:
997 case INTUOS5:
998 case INTUOS5L:
999 case INTUOSPS:
1000 case INTUOSPM:
1001 case INTUOSPL:
1002 sysfs_remove_group(&wacom->hdev->dev.kobj,
1003 &intuos5_led_attr_group);
1004 break;
1005 }
1006}
1007
1008static enum power_supply_property wacom_battery_props[] = {
1009 POWER_SUPPLY_PROP_PRESENT,
1010 POWER_SUPPLY_PROP_STATUS,
1011 POWER_SUPPLY_PROP_SCOPE,
1012 POWER_SUPPLY_PROP_CAPACITY
1013};
1014
1015static enum power_supply_property wacom_ac_props[] = {
1016 POWER_SUPPLY_PROP_PRESENT,
1017 POWER_SUPPLY_PROP_ONLINE,
1018 POWER_SUPPLY_PROP_SCOPE,
1019};
1020
1021static int wacom_battery_get_property(struct power_supply *psy,
1022 enum power_supply_property psp,
1023 union power_supply_propval *val)
1024{
1025 struct wacom *wacom = power_supply_get_drvdata(psy);
1026 int ret = 0;
1027
1028 switch (psp) {
1029 case POWER_SUPPLY_PROP_PRESENT:
1030 val->intval = wacom->wacom_wac.bat_connected;
1031 break;
1032 case POWER_SUPPLY_PROP_SCOPE:
1033 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1034 break;
1035 case POWER_SUPPLY_PROP_CAPACITY:
1036 val->intval =
1037 wacom->wacom_wac.battery_capacity;
1038 break;
1039 case POWER_SUPPLY_PROP_STATUS:
1040 if (wacom->wacom_wac.bat_charging)
1041 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1042 else if (wacom->wacom_wac.battery_capacity == 100 &&
1043 wacom->wacom_wac.ps_connected)
1044 val->intval = POWER_SUPPLY_STATUS_FULL;
1045 else if (wacom->wacom_wac.ps_connected)
1046 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
1047 else
1048 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1049 break;
1050 default:
1051 ret = -EINVAL;
1052 break;
1053 }
1054
1055 return ret;
1056}
1057
1058static int wacom_ac_get_property(struct power_supply *psy,
1059 enum power_supply_property psp,
1060 union power_supply_propval *val)
1061{
1062 struct wacom *wacom = power_supply_get_drvdata(psy);
1063 int ret = 0;
1064
1065 switch (psp) {
1066 case POWER_SUPPLY_PROP_PRESENT:
1067
1068 case POWER_SUPPLY_PROP_ONLINE:
1069 val->intval = wacom->wacom_wac.ps_connected;
1070 break;
1071 case POWER_SUPPLY_PROP_SCOPE:
1072 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1073 break;
1074 default:
1075 ret = -EINVAL;
1076 break;
1077 }
1078 return ret;
1079}
1080
1081static int wacom_initialize_battery(struct wacom *wacom)
1082{
1083 static atomic_t battery_no = ATOMIC_INIT(0);
1084 struct power_supply_config psy_cfg = { .drv_data = wacom, };
1085 unsigned long n;
1086
1087 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) {
1088 struct power_supply_desc *bat_desc = &wacom->battery_desc;
1089 struct power_supply_desc *ac_desc = &wacom->ac_desc;
1090 n = atomic_inc_return(&battery_no) - 1;
1091
1092 bat_desc->properties = wacom_battery_props;
1093 bat_desc->num_properties = ARRAY_SIZE(wacom_battery_props);
1094 bat_desc->get_property = wacom_battery_get_property;
1095 sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
1096 bat_desc->name = wacom->wacom_wac.bat_name;
1097 bat_desc->type = POWER_SUPPLY_TYPE_BATTERY;
1098 bat_desc->use_for_apm = 0;
1099
1100 ac_desc->properties = wacom_ac_props;
1101 ac_desc->num_properties = ARRAY_SIZE(wacom_ac_props);
1102 ac_desc->get_property = wacom_ac_get_property;
1103 sprintf(wacom->wacom_wac.ac_name, "wacom_ac_%ld", n);
1104 ac_desc->name = wacom->wacom_wac.ac_name;
1105 ac_desc->type = POWER_SUPPLY_TYPE_MAINS;
1106 ac_desc->use_for_apm = 0;
1107
1108 wacom->battery = power_supply_register(&wacom->hdev->dev,
1109 &wacom->battery_desc, &psy_cfg);
1110 if (IS_ERR(wacom->battery))
1111 return PTR_ERR(wacom->battery);
1112
1113 power_supply_powers(wacom->battery, &wacom->hdev->dev);
1114
1115 wacom->ac = power_supply_register(&wacom->hdev->dev,
1116 &wacom->ac_desc,
1117 &psy_cfg);
1118 if (IS_ERR(wacom->ac)) {
1119 power_supply_unregister(wacom->battery);
1120 return PTR_ERR(wacom->ac);
1121 }
1122
1123 power_supply_powers(wacom->ac, &wacom->hdev->dev);
1124 }
1125
1126 return 0;
1127}
1128
1129static void wacom_destroy_battery(struct wacom *wacom)
1130{
1131 if (wacom->battery) {
1132 power_supply_unregister(wacom->battery);
1133 wacom->battery = NULL;
1134 power_supply_unregister(wacom->ac);
1135 wacom->ac = NULL;
1136 }
1137}
1138
1139static ssize_t wacom_show_speed(struct device *dev,
1140 struct device_attribute
1141 *attr, char *buf)
1142{
1143 struct hid_device *hdev = to_hid_device(dev);
1144 struct wacom *wacom = hid_get_drvdata(hdev);
1145
1146 return snprintf(buf, PAGE_SIZE, "%i\n", wacom->wacom_wac.bt_high_speed);
1147}
1148
1149static ssize_t wacom_store_speed(struct device *dev,
1150 struct device_attribute *attr,
1151 const char *buf, size_t count)
1152{
1153 struct hid_device *hdev = to_hid_device(dev);
1154 struct wacom *wacom = hid_get_drvdata(hdev);
1155 u8 new_speed;
1156
1157 if (kstrtou8(buf, 0, &new_speed))
1158 return -EINVAL;
1159
1160 if (new_speed != 0 && new_speed != 1)
1161 return -EINVAL;
1162
1163 wacom_bt_query_tablet_data(hdev, new_speed, &wacom->wacom_wac.features);
1164
1165 return count;
1166}
1167
1168static DEVICE_ATTR(speed, DEV_ATTR_RW_PERM,
1169 wacom_show_speed, wacom_store_speed);
1170
1171
1172static ssize_t wacom_show_remote_mode(struct kobject *kobj,
1173 struct kobj_attribute *kattr,
1174 char *buf, int index)
1175{
1176 struct device *dev = kobj_to_dev(kobj->parent);
1177 struct hid_device *hdev = to_hid_device(dev);
1178 struct wacom *wacom = hid_get_drvdata(hdev);
1179 u8 mode;
1180
1181 mode = wacom->led.select[index];
1182 if (mode >= 0 && mode < 3)
1183 return snprintf(buf, PAGE_SIZE, "%d\n", mode);
1184 else
1185 return snprintf(buf, PAGE_SIZE, "%d\n", -1);
1186}
1187
1188#define DEVICE_EKR_ATTR_GROUP(SET_ID) \
1189static ssize_t wacom_show_remote##SET_ID##_mode(struct kobject *kobj, \
1190 struct kobj_attribute *kattr, char *buf) \
1191{ \
1192 return wacom_show_remote_mode(kobj, kattr, buf, SET_ID); \
1193} \
1194static struct kobj_attribute remote##SET_ID##_mode_attr = { \
1195 .attr = {.name = "remote_mode", \
1196 .mode = DEV_ATTR_RO_PERM}, \
1197 .show = wacom_show_remote##SET_ID##_mode, \
1198}; \
1199static struct attribute *remote##SET_ID##_serial_attrs[] = { \
1200 &remote##SET_ID##_mode_attr.attr, \
1201 NULL \
1202}; \
1203static struct attribute_group remote##SET_ID##_serial_group = { \
1204 .name = NULL, \
1205 .attrs = remote##SET_ID##_serial_attrs, \
1206}
1207
1208DEVICE_EKR_ATTR_GROUP(0);
1209DEVICE_EKR_ATTR_GROUP(1);
1210DEVICE_EKR_ATTR_GROUP(2);
1211DEVICE_EKR_ATTR_GROUP(3);
1212DEVICE_EKR_ATTR_GROUP(4);
1213
1214int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial, int index)
1215{
1216 int error = 0;
1217 char *buf;
1218 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1219
1220 wacom_wac->serial[index] = serial;
1221
1222 buf = kzalloc(WAC_REMOTE_SERIAL_MAX_STRLEN, GFP_KERNEL);
1223 if (!buf)
1224 return -ENOMEM;
1225 snprintf(buf, WAC_REMOTE_SERIAL_MAX_STRLEN, "%d", serial);
1226 wacom->remote_group[index].name = buf;
1227
1228 error = sysfs_create_group(wacom->remote_dir,
1229 &wacom->remote_group[index]);
1230 if (error) {
1231 hid_err(wacom->hdev,
1232 "cannot create sysfs group err: %d\n", error);
1233 kobject_put(wacom->remote_dir);
1234 return error;
1235 }
1236
1237 return 0;
1238}
1239
1240void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial)
1241{
1242 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1243 int i;
1244
1245 if (!serial)
1246 return;
1247
1248 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
1249 if (wacom_wac->serial[i] == serial) {
1250 wacom_wac->serial[i] = 0;
1251 wacom->led.select[i] = WACOM_STATUS_UNKNOWN;
1252 if (wacom->remote_group[i].name) {
1253 sysfs_remove_group(wacom->remote_dir,
1254 &wacom->remote_group[i]);
1255 kfree(wacom->remote_group[i].name);
1256 wacom->remote_group[i].name = NULL;
1257 }
1258 }
1259 }
1260}
1261
1262static int wacom_cmd_unpair_remote(struct wacom *wacom, unsigned char selector)
1263{
1264 const size_t buf_size = 2;
1265 unsigned char *buf;
1266 int retval;
1267
1268 buf = kzalloc(buf_size, GFP_KERNEL);
1269 if (!buf)
1270 return -ENOMEM;
1271
1272 buf[0] = WAC_CMD_DELETE_PAIRING;
1273 buf[1] = selector;
1274
1275 retval = wacom_set_report(wacom->hdev, HID_OUTPUT_REPORT, buf,
1276 buf_size, WAC_CMD_RETRIES);
1277 kfree(buf);
1278
1279 return retval;
1280}
1281
1282static ssize_t wacom_store_unpair_remote(struct kobject *kobj,
1283 struct kobj_attribute *attr,
1284 const char *buf, size_t count)
1285{
1286 unsigned char selector = 0;
1287 struct device *dev = kobj_to_dev(kobj->parent);
1288 struct hid_device *hdev = to_hid_device(dev);
1289 struct wacom *wacom = hid_get_drvdata(hdev);
1290 int err;
1291
1292 if (!strncmp(buf, "*\n", 2)) {
1293 selector = WAC_CMD_UNPAIR_ALL;
1294 } else {
1295 hid_info(wacom->hdev, "remote: unrecognized unpair code: %s\n",
1296 buf);
1297 return -1;
1298 }
1299
1300 mutex_lock(&wacom->lock);
1301
1302 err = wacom_cmd_unpair_remote(wacom, selector);
1303 mutex_unlock(&wacom->lock);
1304
1305 return err < 0 ? err : count;
1306}
1307
1308static struct kobj_attribute unpair_remote_attr = {
1309 .attr = {.name = "unpair_remote", .mode = 0200},
1310 .store = wacom_store_unpair_remote,
1311};
1312
1313static const struct attribute *remote_unpair_attrs[] = {
1314 &unpair_remote_attr.attr,
1315 NULL
1316};
1317
1318static int wacom_initialize_remote(struct wacom *wacom)
1319{
1320 int error = 0;
1321 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1322 int i;
1323
1324 if (wacom->wacom_wac.features.type != REMOTE)
1325 return 0;
1326
1327 wacom->remote_group[0] = remote0_serial_group;
1328 wacom->remote_group[1] = remote1_serial_group;
1329 wacom->remote_group[2] = remote2_serial_group;
1330 wacom->remote_group[3] = remote3_serial_group;
1331 wacom->remote_group[4] = remote4_serial_group;
1332
1333 wacom->remote_dir = kobject_create_and_add("wacom_remote",
1334 &wacom->hdev->dev.kobj);
1335 if (!wacom->remote_dir)
1336 return -ENOMEM;
1337
1338 error = sysfs_create_files(wacom->remote_dir, remote_unpair_attrs);
1339
1340 if (error) {
1341 hid_err(wacom->hdev,
1342 "cannot create sysfs group err: %d\n", error);
1343 return error;
1344 }
1345
1346 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
1347 wacom->led.select[i] = WACOM_STATUS_UNKNOWN;
1348 wacom_wac->serial[i] = 0;
1349 }
1350
1351 return 0;
1352}
1353
1354static struct input_dev *wacom_allocate_input(struct wacom *wacom)
1355{
1356 struct input_dev *input_dev;
1357 struct hid_device *hdev = wacom->hdev;
1358 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1359
1360 input_dev = input_allocate_device();
1361 if (!input_dev)
1362 return NULL;
1363
1364 input_dev->name = wacom_wac->features.name;
1365 input_dev->phys = hdev->phys;
1366 input_dev->dev.parent = &hdev->dev;
1367 input_dev->open = wacom_open;
1368 input_dev->close = wacom_close;
1369 input_dev->uniq = hdev->uniq;
1370 input_dev->id.bustype = hdev->bus;
1371 input_dev->id.vendor = hdev->vendor;
1372 input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product;
1373 input_dev->id.version = hdev->version;
1374 input_set_drvdata(input_dev, wacom);
1375
1376 return input_dev;
1377}
1378
1379static void wacom_clean_inputs(struct wacom *wacom)
1380{
1381 if (wacom->wacom_wac.pen_input) {
1382 if (wacom->wacom_wac.pen_registered)
1383 input_unregister_device(wacom->wacom_wac.pen_input);
1384 else
1385 input_free_device(wacom->wacom_wac.pen_input);
1386 }
1387 if (wacom->wacom_wac.touch_input) {
1388 if (wacom->wacom_wac.touch_registered)
1389 input_unregister_device(wacom->wacom_wac.touch_input);
1390 else
1391 input_free_device(wacom->wacom_wac.touch_input);
1392 }
1393 if (wacom->wacom_wac.pad_input) {
1394 if (wacom->wacom_wac.pad_registered)
1395 input_unregister_device(wacom->wacom_wac.pad_input);
1396 else
1397 input_free_device(wacom->wacom_wac.pad_input);
1398 }
1399 kobject_put(wacom->remote_dir);
1400 wacom->wacom_wac.pen_input = NULL;
1401 wacom->wacom_wac.touch_input = NULL;
1402 wacom->wacom_wac.pad_input = NULL;
1403 wacom->wacom_wac.pen_registered = false;
1404 wacom->wacom_wac.touch_registered = false;
1405 wacom->wacom_wac.pad_registered = false;
1406 wacom_destroy_leds(wacom);
1407}
1408
1409static int wacom_allocate_inputs(struct wacom *wacom)
1410{
1411 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1412
1413 wacom_wac->pen_input = wacom_allocate_input(wacom);
1414 wacom_wac->touch_input = wacom_allocate_input(wacom);
1415 wacom_wac->pad_input = wacom_allocate_input(wacom);
1416 if (!wacom_wac->pen_input || !wacom_wac->touch_input || !wacom_wac->pad_input) {
1417 wacom_clean_inputs(wacom);
1418 return -ENOMEM;
1419 }
1420
1421 wacom_wac->pen_input->name = wacom_wac->pen_name;
1422 wacom_wac->touch_input->name = wacom_wac->touch_name;
1423 wacom_wac->pad_input->name = wacom_wac->pad_name;
1424
1425 return 0;
1426}
1427
1428static int wacom_register_inputs(struct wacom *wacom)
1429{
1430 struct input_dev *pen_input_dev, *touch_input_dev, *pad_input_dev;
1431 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1432 int error = 0;
1433
1434 pen_input_dev = wacom_wac->pen_input;
1435 touch_input_dev = wacom_wac->touch_input;
1436 pad_input_dev = wacom_wac->pad_input;
1437
1438 if (!pen_input_dev || !touch_input_dev || !pad_input_dev)
1439 return -EINVAL;
1440
1441 error = wacom_setup_pen_input_capabilities(pen_input_dev, wacom_wac);
1442 if (error) {
1443
1444 input_free_device(pen_input_dev);
1445 wacom_wac->pen_input = NULL;
1446 pen_input_dev = NULL;
1447 } else {
1448 error = input_register_device(pen_input_dev);
1449 if (error)
1450 goto fail_register_pen_input;
1451 wacom_wac->pen_registered = true;
1452 }
1453
1454 error = wacom_setup_touch_input_capabilities(touch_input_dev, wacom_wac);
1455 if (error) {
1456
1457 input_free_device(touch_input_dev);
1458 wacom_wac->touch_input = NULL;
1459 touch_input_dev = NULL;
1460 } else {
1461 error = input_register_device(touch_input_dev);
1462 if (error)
1463 goto fail_register_touch_input;
1464 wacom_wac->touch_registered = true;
1465 }
1466
1467 error = wacom_setup_pad_input_capabilities(pad_input_dev, wacom_wac);
1468 if (error) {
1469
1470 input_free_device(pad_input_dev);
1471 wacom_wac->pad_input = NULL;
1472 pad_input_dev = NULL;
1473 } else {
1474 error = input_register_device(pad_input_dev);
1475 if (error)
1476 goto fail_register_pad_input;
1477 wacom_wac->pad_registered = true;
1478
1479 error = wacom_initialize_leds(wacom);
1480 if (error)
1481 goto fail_leds;
1482
1483 error = wacom_initialize_remote(wacom);
1484 if (error)
1485 goto fail_remote;
1486 }
1487
1488 return 0;
1489
1490fail_remote:
1491 wacom_destroy_leds(wacom);
1492fail_leds:
1493 input_unregister_device(pad_input_dev);
1494 pad_input_dev = NULL;
1495 wacom_wac->pad_registered = false;
1496fail_register_pad_input:
1497 if (touch_input_dev)
1498 input_unregister_device(touch_input_dev);
1499 wacom_wac->touch_input = NULL;
1500 wacom_wac->touch_registered = false;
1501fail_register_touch_input:
1502 if (pen_input_dev)
1503 input_unregister_device(pen_input_dev);
1504 wacom_wac->pen_input = NULL;
1505 wacom_wac->pen_registered = false;
1506fail_register_pen_input:
1507 return error;
1508}
1509
1510
1511
1512
1513
1514
1515static void wacom_set_default_phy(struct wacom_features *features)
1516{
1517 if (features->x_resolution) {
1518 features->x_phy = (features->x_max * 100) /
1519 features->x_resolution;
1520 features->y_phy = (features->y_max * 100) /
1521 features->y_resolution;
1522 }
1523}
1524
1525static void wacom_calculate_res(struct wacom_features *features)
1526{
1527
1528 if (!features->unit) {
1529 features->unit = 0x11;
1530 features->unitExpo = -3;
1531 }
1532
1533 features->x_resolution = wacom_calc_hid_res(features->x_max,
1534 features->x_phy,
1535 features->unit,
1536 features->unitExpo);
1537 features->y_resolution = wacom_calc_hid_res(features->y_max,
1538 features->y_phy,
1539 features->unit,
1540 features->unitExpo);
1541}
1542
1543void wacom_battery_work(struct work_struct *work)
1544{
1545 struct wacom *wacom = container_of(work, struct wacom, work);
1546
1547 if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
1548 !wacom->battery) {
1549 wacom_initialize_battery(wacom);
1550 }
1551 else if (!(wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
1552 wacom->battery) {
1553 wacom_destroy_battery(wacom);
1554 }
1555}
1556
1557static size_t wacom_compute_pktlen(struct hid_device *hdev)
1558{
1559 struct hid_report_enum *report_enum;
1560 struct hid_report *report;
1561 size_t size = 0;
1562
1563 report_enum = hdev->report_enum + HID_INPUT_REPORT;
1564
1565 list_for_each_entry(report, &report_enum->report_list, list) {
1566 size_t report_size = hid_report_len(report);
1567 if (report_size > size)
1568 size = report_size;
1569 }
1570
1571 return size;
1572}
1573
1574static void wacom_update_name(struct wacom *wacom, const char *suffix)
1575{
1576 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1577 struct wacom_features *features = &wacom_wac->features;
1578 char name[WACOM_NAME_MAX];
1579
1580
1581 if ((features->type == HID_GENERIC) && !strcmp("Wacom HID", features->name)) {
1582 if (strstr(wacom->hdev->name, "Wacom") ||
1583 strstr(wacom->hdev->name, "wacom") ||
1584 strstr(wacom->hdev->name, "WACOM")) {
1585
1586 strlcpy(name, wacom->hdev->name, sizeof(name));
1587
1588
1589 while (1) {
1590 char *gap = strstr(name, " ");
1591 if (gap == NULL)
1592 break;
1593
1594 memmove(gap, gap+1, strlen(gap));
1595 }
1596
1597 if (name[strlen(name)-1] == ' ')
1598 name[strlen(name)-1] = '\0';
1599 } else {
1600
1601 snprintf(name, sizeof(name),
1602 "%s %X", features->name, wacom->hdev->product);
1603 }
1604 } else {
1605 strlcpy(name, features->name, sizeof(name));
1606 }
1607
1608
1609 snprintf(wacom_wac->pen_name, sizeof(wacom_wac->pen_name),
1610 "%s%s Pen", name, suffix);
1611 snprintf(wacom_wac->touch_name, sizeof(wacom_wac->touch_name),
1612 "%s%s Finger", name, suffix);
1613 snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name),
1614 "%s%s Pad", name, suffix);
1615}
1616
1617static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
1618{
1619 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1620 struct wacom_features *features = &wacom_wac->features;
1621 struct hid_device *hdev = wacom->hdev;
1622 int error;
1623 unsigned int connect_mask = HID_CONNECT_HIDRAW;
1624
1625 features->pktlen = wacom_compute_pktlen(hdev);
1626 if (features->pktlen > WACOM_PKGLEN_MAX)
1627 return -EINVAL;
1628
1629 error = wacom_allocate_inputs(wacom);
1630 if (error)
1631 return error;
1632
1633
1634
1635
1636
1637
1638 if (features->type == BAMBOO_PAD) {
1639 if (features->pktlen == WACOM_PKGLEN_PENABLED) {
1640 features->type = HID_GENERIC;
1641 } else if ((features->pktlen != WACOM_PKGLEN_BPAD_TOUCH) &&
1642 (features->pktlen != WACOM_PKGLEN_BPAD_TOUCH_USB)) {
1643 error = -ENODEV;
1644 goto fail_allocate_inputs;
1645 }
1646 }
1647
1648
1649 wacom_set_default_phy(features);
1650
1651
1652 wacom_retrieve_hid_descriptor(hdev, features);
1653 wacom_setup_device_quirks(wacom);
1654
1655 if (features->device_type == WACOM_DEVICETYPE_NONE &&
1656 features->type != WIRELESS) {
1657 error = features->type == HID_GENERIC ? -ENODEV : 0;
1658
1659 dev_warn(&hdev->dev, "Unknown device_type for '%s'. %s.",
1660 hdev->name,
1661 error ? "Ignoring" : "Assuming pen");
1662
1663 if (error)
1664 goto fail_parsed;
1665
1666 features->device_type |= WACOM_DEVICETYPE_PEN;
1667 }
1668
1669 wacom_calculate_res(features);
1670
1671 wacom_update_name(wacom, wireless ? " (WL)" : "");
1672
1673 error = wacom_add_shared_data(hdev);
1674 if (error)
1675 goto fail_shared_data;
1676
1677 if (!(features->device_type & WACOM_DEVICETYPE_WL_MONITOR) &&
1678 (features->quirks & WACOM_QUIRK_BATTERY)) {
1679 error = wacom_initialize_battery(wacom);
1680 if (error)
1681 goto fail_battery;
1682 }
1683
1684 error = wacom_register_inputs(wacom);
1685 if (error)
1686 goto fail_register_inputs;
1687
1688 if (features->type == HID_GENERIC)
1689 connect_mask |= HID_CONNECT_DRIVER;
1690
1691
1692 error = hid_hw_start(hdev, connect_mask);
1693 if (error) {
1694 hid_err(hdev, "hw start failed\n");
1695 goto fail_hw_start;
1696 }
1697
1698 if (!wireless) {
1699
1700 wacom_query_tablet_data(hdev, features);
1701 }
1702
1703
1704 if ((features->type == BAMBOO_TOUCH) &&
1705 (features->device_type & WACOM_DEVICETYPE_PEN)) {
1706 error = -ENODEV;
1707 goto fail_hw_start;
1708 }
1709
1710
1711 if ((features->type == BAMBOO_PEN) &&
1712 ((features->device_type & WACOM_DEVICETYPE_TOUCH) ||
1713 (features->device_type & WACOM_DEVICETYPE_PAD))) {
1714 error = -ENODEV;
1715 goto fail_hw_start;
1716 }
1717
1718 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR)
1719 error = hid_hw_open(hdev);
1720
1721 if ((wacom_wac->features.type == INTUOSHT ||
1722 wacom_wac->features.type == INTUOSHT2) &&
1723 (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)) {
1724 wacom_wac->shared->touch_input = wacom_wac->touch_input;
1725 }
1726
1727 return 0;
1728
1729fail_hw_start:
1730 hid_hw_stop(hdev);
1731fail_register_inputs:
1732 wacom_clean_inputs(wacom);
1733 wacom_destroy_battery(wacom);
1734fail_battery:
1735 wacom_remove_shared_data(wacom);
1736fail_shared_data:
1737fail_parsed:
1738fail_allocate_inputs:
1739 wacom_clean_inputs(wacom);
1740 return error;
1741}
1742
1743static void wacom_wireless_work(struct work_struct *work)
1744{
1745 struct wacom *wacom = container_of(work, struct wacom, work);
1746 struct usb_device *usbdev = wacom->usbdev;
1747 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1748 struct hid_device *hdev1, *hdev2;
1749 struct wacom *wacom1, *wacom2;
1750 struct wacom_wac *wacom_wac1, *wacom_wac2;
1751 int error;
1752
1753
1754
1755
1756
1757
1758 wacom_destroy_battery(wacom);
1759
1760
1761 hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
1762 wacom1 = hid_get_drvdata(hdev1);
1763 wacom_wac1 = &(wacom1->wacom_wac);
1764 wacom_clean_inputs(wacom1);
1765
1766
1767 hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
1768 wacom2 = hid_get_drvdata(hdev2);
1769 wacom_wac2 = &(wacom2->wacom_wac);
1770 wacom_clean_inputs(wacom2);
1771
1772 if (wacom_wac->pid == 0) {
1773 hid_info(wacom->hdev, "wireless tablet disconnected\n");
1774 wacom_wac1->shared->type = 0;
1775 } else {
1776 const struct hid_device_id *id = wacom_ids;
1777
1778 hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
1779 wacom_wac->pid);
1780
1781 while (id->bus) {
1782 if (id->vendor == USB_VENDOR_ID_WACOM &&
1783 id->product == wacom_wac->pid)
1784 break;
1785 id++;
1786 }
1787
1788 if (!id->bus) {
1789 hid_info(wacom->hdev, "ignoring unknown PID.\n");
1790 return;
1791 }
1792
1793
1794 wacom_wac1->features =
1795 *((struct wacom_features *)id->driver_data);
1796
1797 wacom_wac1->pid = wacom_wac->pid;
1798 hid_hw_stop(hdev1);
1799 error = wacom_parse_and_register(wacom1, true);
1800 if (error)
1801 goto fail;
1802
1803
1804 if (wacom_wac1->features.touch_max ||
1805 (wacom_wac1->features.type >= INTUOSHT &&
1806 wacom_wac1->features.type <= BAMBOO_PT)) {
1807 wacom_wac2->features =
1808 *((struct wacom_features *)id->driver_data);
1809 wacom_wac2->pid = wacom_wac->pid;
1810 hid_hw_stop(hdev2);
1811 error = wacom_parse_and_register(wacom2, true);
1812 if (error)
1813 goto fail;
1814 }
1815
1816 error = wacom_initialize_battery(wacom);
1817 if (error)
1818 goto fail;
1819 }
1820
1821 return;
1822
1823fail:
1824 wacom_clean_inputs(wacom1);
1825 wacom_clean_inputs(wacom2);
1826 return;
1827}
1828
1829static int wacom_probe(struct hid_device *hdev,
1830 const struct hid_device_id *id)
1831{
1832 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
1833 struct usb_device *dev = interface_to_usbdev(intf);
1834 struct wacom *wacom;
1835 struct wacom_wac *wacom_wac;
1836 struct wacom_features *features;
1837 int error;
1838
1839 if (!id->driver_data)
1840 return -EINVAL;
1841
1842 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
1843
1844
1845 hdev->quirks &= ~HID_QUIRK_NOGET;
1846
1847 wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
1848 if (!wacom)
1849 return -ENOMEM;
1850
1851 hid_set_drvdata(hdev, wacom);
1852 wacom->hdev = hdev;
1853
1854 wacom_wac = &wacom->wacom_wac;
1855 wacom_wac->features = *((struct wacom_features *)id->driver_data);
1856 features = &wacom_wac->features;
1857
1858 if (features->check_for_hid_type && features->hid_type != hdev->type) {
1859 error = -ENODEV;
1860 goto fail_type;
1861 }
1862
1863 wacom_wac->hid_data.inputmode = -1;
1864 wacom_wac->mode_report = -1;
1865
1866 wacom->usbdev = dev;
1867 wacom->intf = intf;
1868 mutex_init(&wacom->lock);
1869 INIT_WORK(&wacom->work, wacom_wireless_work);
1870
1871
1872 error = hid_parse(hdev);
1873 if (error) {
1874 hid_err(hdev, "parse failed\n");
1875 goto fail_parse;
1876 }
1877
1878 error = wacom_parse_and_register(wacom, false);
1879 if (error)
1880 goto fail_parse;
1881
1882 if (hdev->bus == BUS_BLUETOOTH) {
1883 error = device_create_file(&hdev->dev, &dev_attr_speed);
1884 if (error)
1885 hid_warn(hdev,
1886 "can't create sysfs speed attribute err: %d\n",
1887 error);
1888 }
1889
1890 return 0;
1891
1892fail_type:
1893fail_parse:
1894 kfree(wacom);
1895 hid_set_drvdata(hdev, NULL);
1896 return error;
1897}
1898
1899static void wacom_remove(struct hid_device *hdev)
1900{
1901 struct wacom *wacom = hid_get_drvdata(hdev);
1902 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1903 struct wacom_features *features = &wacom_wac->features;
1904
1905 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR)
1906 hid_hw_close(hdev);
1907
1908 hid_hw_stop(hdev);
1909
1910 cancel_work_sync(&wacom->work);
1911 wacom_clean_inputs(wacom);
1912 if (hdev->bus == BUS_BLUETOOTH)
1913 device_remove_file(&hdev->dev, &dev_attr_speed);
1914 wacom_destroy_battery(wacom);
1915 wacom_remove_shared_data(wacom);
1916
1917 hid_set_drvdata(hdev, NULL);
1918 kfree(wacom);
1919}
1920
1921#ifdef CONFIG_PM
1922static int wacom_resume(struct hid_device *hdev)
1923{
1924 struct wacom *wacom = hid_get_drvdata(hdev);
1925 struct wacom_features *features = &wacom->wacom_wac.features;
1926
1927 mutex_lock(&wacom->lock);
1928
1929
1930 wacom_query_tablet_data(hdev, features);
1931 wacom_led_control(wacom);
1932
1933 mutex_unlock(&wacom->lock);
1934
1935 return 0;
1936}
1937
1938static int wacom_reset_resume(struct hid_device *hdev)
1939{
1940 return wacom_resume(hdev);
1941}
1942#endif
1943
1944static struct hid_driver wacom_driver = {
1945 .name = "wacom",
1946 .id_table = wacom_ids,
1947 .probe = wacom_probe,
1948 .remove = wacom_remove,
1949 .report = wacom_wac_report,
1950#ifdef CONFIG_PM
1951 .resume = wacom_resume,
1952 .reset_resume = wacom_reset_resume,
1953#endif
1954 .raw_event = wacom_raw_event,
1955};
1956module_hid_driver(wacom_driver);
1957
1958MODULE_VERSION(DRIVER_VERSION);
1959MODULE_AUTHOR(DRIVER_AUTHOR);
1960MODULE_DESCRIPTION(DRIVER_DESC);
1961MODULE_LICENSE(DRIVER_LICENSE);
1962