1
2
3
4
5
6
7
8
9
10
11
12
13
14#include "wacom_wac.h"
15#include "wacom.h"
16
17
18#define HID_DEVICET_HID (USB_TYPE_CLASS | 0x01)
19#define HID_DEVICET_REPORT (USB_TYPE_CLASS | 0x02)
20#define HID_USAGE_UNDEFINED 0x00
21#define HID_USAGE_PAGE 0x05
22#define HID_USAGE_PAGE_DIGITIZER 0x0d
23#define HID_USAGE_PAGE_DESKTOP 0x01
24#define HID_USAGE 0x09
25#define HID_USAGE_X 0x30
26#define HID_USAGE_Y 0x31
27#define HID_USAGE_X_TILT 0x3d
28#define HID_USAGE_Y_TILT 0x3e
29#define HID_USAGE_FINGER 0x22
30#define HID_USAGE_STYLUS 0x20
31#define HID_USAGE_CONTACTMAX 0x55
32#define HID_COLLECTION 0xa1
33#define HID_COLLECTION_LOGICAL 0x02
34#define HID_COLLECTION_END 0xc0
35
36enum {
37 WCM_UNDEFINED = 0,
38 WCM_DESKTOP,
39 WCM_DIGITIZER,
40};
41
42struct hid_descriptor {
43 struct usb_descriptor_header header;
44 __le16 bcdHID;
45 u8 bCountryCode;
46 u8 bNumDescriptors;
47 u8 bDescriptorType;
48 __le16 wDescriptorLength;
49} __attribute__ ((packed));
50
51
52#define USB_REQ_GET_REPORT 0x01
53#define USB_REQ_SET_REPORT 0x09
54
55#define WAC_HID_FEATURE_REPORT 0x03
56#define WAC_MSG_RETRIES 5
57
58#define WAC_CMD_LED_CONTROL 0x20
59#define WAC_CMD_ICON_START 0x21
60#define WAC_CMD_ICON_XFER 0x23
61#define WAC_CMD_RETRIES 10
62
63static int wacom_get_report(struct usb_interface *intf, u8 type, u8 id,
64 void *buf, size_t size, unsigned int retries)
65{
66 struct usb_device *dev = interface_to_usbdev(intf);
67 int retval;
68
69 do {
70 retval = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
71 USB_REQ_GET_REPORT,
72 USB_DIR_IN | USB_TYPE_CLASS |
73 USB_RECIP_INTERFACE,
74 (type << 8) + id,
75 intf->altsetting[0].desc.bInterfaceNumber,
76 buf, size, 100);
77 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
78
79 return retval;
80}
81
82static int wacom_set_report(struct usb_interface *intf, u8 type, u8 id,
83 void *buf, size_t size, unsigned int retries)
84{
85 struct usb_device *dev = interface_to_usbdev(intf);
86 int retval;
87
88 do {
89 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
90 USB_REQ_SET_REPORT,
91 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
92 (type << 8) + id,
93 intf->altsetting[0].desc.bInterfaceNumber,
94 buf, size, 1000);
95 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
96
97 return retval;
98}
99
100static void wacom_sys_irq(struct urb *urb)
101{
102 struct wacom *wacom = urb->context;
103 struct device *dev = &wacom->intf->dev;
104 int retval;
105
106 switch (urb->status) {
107 case 0:
108
109 break;
110 case -ECONNRESET:
111 case -ENOENT:
112 case -ESHUTDOWN:
113
114 dev_dbg(dev, "%s - urb shutting down with status: %d\n",
115 __func__, urb->status);
116 return;
117 default:
118 dev_dbg(dev, "%s - nonzero urb status received: %d\n",
119 __func__, urb->status);
120 goto exit;
121 }
122
123 wacom_wac_irq(&wacom->wacom_wac, urb->actual_length);
124
125 exit:
126 usb_mark_last_busy(wacom->usbdev);
127 retval = usb_submit_urb(urb, GFP_ATOMIC);
128 if (retval)
129 dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
130 __func__, retval);
131}
132
133static int wacom_open(struct input_dev *dev)
134{
135 struct wacom *wacom = input_get_drvdata(dev);
136 int retval = 0;
137
138 if (usb_autopm_get_interface(wacom->intf) < 0)
139 return -EIO;
140
141 mutex_lock(&wacom->lock);
142
143 if (usb_submit_urb(wacom->irq, GFP_KERNEL)) {
144 retval = -EIO;
145 goto out;
146 }
147
148 wacom->open = true;
149 wacom->intf->needs_remote_wakeup = 1;
150
151out:
152 mutex_unlock(&wacom->lock);
153 usb_autopm_put_interface(wacom->intf);
154 return retval;
155}
156
157static void wacom_close(struct input_dev *dev)
158{
159 struct wacom *wacom = input_get_drvdata(dev);
160 int autopm_error;
161
162 autopm_error = usb_autopm_get_interface(wacom->intf);
163
164 mutex_lock(&wacom->lock);
165 usb_kill_urb(wacom->irq);
166 wacom->open = false;
167 wacom->intf->needs_remote_wakeup = 0;
168 mutex_unlock(&wacom->lock);
169
170 if (!autopm_error)
171 usb_autopm_put_interface(wacom->intf);
172}
173
174
175
176
177
178static int wacom_calc_hid_res(int logical_extents, int physical_extents,
179 unsigned char unit, unsigned char exponent)
180{
181 int prev, unit_exponent;
182
183
184 if (logical_extents <= 0 || physical_extents <= 0)
185 return 0;
186
187
188 unit_exponent = exponent;
189 if (unit_exponent > 7)
190 unit_exponent -= 16;
191
192
193 if (unit == 0x11) {
194 unit_exponent += 1;
195 } else if (unit == 0x13) {
196 prev = physical_extents;
197 physical_extents *= 254;
198 if (physical_extents < prev)
199 return 0;
200 unit_exponent -= 1;
201 } else {
202 return 0;
203 }
204
205
206 for (; unit_exponent < 0; unit_exponent++) {
207 prev = logical_extents;
208 logical_extents *= 10;
209 if (logical_extents < prev)
210 return 0;
211 }
212
213 for (; unit_exponent > 0; unit_exponent--) {
214 prev = physical_extents;
215 physical_extents *= 10;
216 if (physical_extents < prev)
217 return 0;
218 }
219
220
221 return logical_extents / physical_extents;
222}
223
224static int wacom_parse_logical_collection(unsigned char *report,
225 struct wacom_features *features)
226{
227 int length = 0;
228
229 if (features->type == BAMBOO_PT) {
230
231
232 features->pktlen = WACOM_PKGLEN_BBTOUCH3;
233 features->device_type = BTN_TOOL_FINGER;
234
235 features->x_max = features->y_max =
236 get_unaligned_le16(&report[10]);
237
238 length = 11;
239 }
240 return length;
241}
242
243static void wacom_retrieve_report_data(struct usb_interface *intf,
244 struct wacom_features *features)
245{
246 int result = 0;
247 unsigned char *rep_data;
248
249 rep_data = kmalloc(2, GFP_KERNEL);
250 if (rep_data) {
251
252 rep_data[0] = 12;
253 result = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
254 rep_data[0], rep_data, 2,
255 WAC_MSG_RETRIES);
256
257 if (result >= 0 && rep_data[1] > 2)
258 features->touch_max = rep_data[1];
259
260 kfree(rep_data);
261 }
262}
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300static int wacom_parse_hid(struct usb_interface *intf,
301 struct hid_descriptor *hid_desc,
302 struct wacom_features *features)
303{
304 struct usb_device *dev = interface_to_usbdev(intf);
305 char limit = 0;
306
307 int result = 0;
308 int i = 0, usage = WCM_UNDEFINED, finger = 0, pen = 0;
309 unsigned char *report;
310
311 report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
312 if (!report)
313 return -ENOMEM;
314
315
316 do {
317 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
318 USB_REQ_GET_DESCRIPTOR,
319 USB_RECIP_INTERFACE | USB_DIR_IN,
320 HID_DEVICET_REPORT << 8,
321 intf->altsetting[0].desc.bInterfaceNumber,
322 report,
323 hid_desc->wDescriptorLength,
324 5000);
325 } while (result < 0 && limit++ < WAC_MSG_RETRIES);
326
327
328 if (result < 0)
329 goto out;
330
331 for (i = 0; i < hid_desc->wDescriptorLength; i++) {
332
333 switch (report[i]) {
334 case HID_USAGE_PAGE:
335 switch (report[i + 1]) {
336 case HID_USAGE_PAGE_DIGITIZER:
337 usage = WCM_DIGITIZER;
338 i++;
339 break;
340
341 case HID_USAGE_PAGE_DESKTOP:
342 usage = WCM_DESKTOP;
343 i++;
344 break;
345 }
346 break;
347
348 case HID_USAGE:
349 switch (report[i + 1]) {
350 case HID_USAGE_X:
351 if (usage == WCM_DESKTOP) {
352 if (finger) {
353 features->device_type = BTN_TOOL_FINGER;
354
355 switch (features->type) {
356 case TABLETPC2FG:
357 features->pktlen = WACOM_PKGLEN_TPC2FG;
358 break;
359
360 case MTSCREEN:
361 case WACOM_24HDT:
362 features->pktlen = WACOM_PKGLEN_MTOUCH;
363 break;
364
365 case MTTPC:
366 features->pktlen = WACOM_PKGLEN_MTTPC;
367 break;
368
369 case BAMBOO_PT:
370 features->pktlen = WACOM_PKGLEN_BBTOUCH;
371 break;
372
373 default:
374 features->pktlen = WACOM_PKGLEN_GRAPHIRE;
375 break;
376 }
377
378 switch (features->type) {
379 case BAMBOO_PT:
380 features->x_phy =
381 get_unaligned_le16(&report[i + 5]);
382 features->x_max =
383 get_unaligned_le16(&report[i + 8]);
384 i += 15;
385 break;
386
387 case WACOM_24HDT:
388 features->x_max =
389 get_unaligned_le16(&report[i + 3]);
390 features->x_phy =
391 get_unaligned_le16(&report[i + 8]);
392 features->unit = report[i - 1];
393 features->unitExpo = report[i - 3];
394 i += 12;
395 break;
396
397 default:
398 features->x_max =
399 get_unaligned_le16(&report[i + 3]);
400 features->x_phy =
401 get_unaligned_le16(&report[i + 6]);
402 features->unit = report[i + 9];
403 features->unitExpo = report[i + 11];
404 i += 12;
405 break;
406 }
407 } else if (pen) {
408
409 if (features->type >= TABLETPC)
410 features->pktlen = WACOM_PKGLEN_GRAPHIRE;
411 features->device_type = BTN_TOOL_PEN;
412 features->x_max =
413 get_unaligned_le16(&report[i + 3]);
414 i += 4;
415 }
416 }
417 break;
418
419 case HID_USAGE_Y:
420 if (usage == WCM_DESKTOP) {
421 if (finger) {
422 switch (features->type) {
423 case TABLETPC2FG:
424 case MTSCREEN:
425 case MTTPC:
426 features->y_max =
427 get_unaligned_le16(&report[i + 3]);
428 features->y_phy =
429 get_unaligned_le16(&report[i + 6]);
430 i += 7;
431 break;
432
433 case WACOM_24HDT:
434 features->y_max =
435 get_unaligned_le16(&report[i + 3]);
436 features->y_phy =
437 get_unaligned_le16(&report[i - 2]);
438 i += 7;
439 break;
440
441 case BAMBOO_PT:
442 features->y_phy =
443 get_unaligned_le16(&report[i + 3]);
444 features->y_max =
445 get_unaligned_le16(&report[i + 6]);
446 i += 12;
447 break;
448
449 default:
450 features->y_max =
451 features->x_max;
452 features->y_phy =
453 get_unaligned_le16(&report[i + 3]);
454 i += 4;
455 break;
456 }
457 } else if (pen) {
458 features->y_max =
459 get_unaligned_le16(&report[i + 3]);
460 i += 4;
461 }
462 }
463 break;
464
465 case HID_USAGE_FINGER:
466 finger = 1;
467 i++;
468 break;
469
470
471
472
473
474
475 case HID_USAGE_STYLUS:
476 pen = 1;
477 i++;
478 break;
479
480 case HID_USAGE_CONTACTMAX:
481
482 if (!features->touch_max)
483 wacom_retrieve_report_data(intf, features);
484 i++;
485 break;
486 }
487 break;
488
489 case HID_COLLECTION_END:
490
491 finger = usage = 0;
492 break;
493
494 case HID_COLLECTION:
495 i++;
496 switch (report[i]) {
497 case HID_COLLECTION_LOGICAL:
498 i += wacom_parse_logical_collection(&report[i],
499 features);
500 break;
501 }
502 break;
503 }
504 }
505
506 out:
507 result = 0;
508 kfree(report);
509 return result;
510}
511
512static int wacom_set_device_mode(struct usb_interface *intf, int report_id, int length, int mode)
513{
514 unsigned char *rep_data;
515 int error = -ENOMEM, limit = 0;
516
517 rep_data = kzalloc(length, GFP_KERNEL);
518 if (!rep_data)
519 return error;
520
521 do {
522 rep_data[0] = report_id;
523 rep_data[1] = mode;
524
525 error = wacom_set_report(intf, WAC_HID_FEATURE_REPORT,
526 report_id, rep_data, length, 1);
527 if (error >= 0)
528 error = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
529 report_id, rep_data, length, 1);
530 } while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);
531
532 kfree(rep_data);
533
534 return error < 0 ? error : 0;
535}
536
537
538
539
540
541
542
543
544static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_features *features)
545{
546 if (features->device_type == BTN_TOOL_FINGER) {
547 if (features->type > TABLETPC) {
548
549 return wacom_set_device_mode(intf, 3, 4, 4);
550 }
551 else if (features->type == WACOM_24HDT) {
552 return wacom_set_device_mode(intf, 18, 3, 2);
553 }
554 } else if (features->device_type == BTN_TOOL_PEN) {
555 if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
556 return wacom_set_device_mode(intf, 2, 2, 2);
557 }
558 }
559
560 return 0;
561}
562
563static int wacom_retrieve_hid_descriptor(struct usb_interface *intf,
564 struct wacom_features *features)
565{
566 int error = 0;
567 struct usb_host_interface *interface = intf->cur_altsetting;
568 struct hid_descriptor *hid_desc;
569
570
571 features->device_type = BTN_TOOL_PEN;
572 features->x_fuzz = 4;
573 features->y_fuzz = 4;
574 features->pressure_fuzz = 0;
575 features->distance_fuzz = 0;
576
577
578
579
580
581
582
583 if (features->type == WIRELESS) {
584 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
585 features->device_type = 0;
586 } else if (intf->cur_altsetting->desc.bInterfaceNumber == 2) {
587 features->device_type = BTN_TOOL_FINGER;
588 features->pktlen = WACOM_PKGLEN_BBTOUCH3;
589 }
590 }
591
592
593 if (features->type < BAMBOO_PT) {
594 goto out;
595 }
596
597 error = usb_get_extra_descriptor(interface, HID_DEVICET_HID, &hid_desc);
598 if (error) {
599 error = usb_get_extra_descriptor(&interface->endpoint[0],
600 HID_DEVICET_REPORT, &hid_desc);
601 if (error) {
602 dev_err(&intf->dev,
603 "can not retrieve extra class descriptor\n");
604 goto out;
605 }
606 }
607 error = wacom_parse_hid(intf, hid_desc, features);
608
609 out:
610 return error;
611}
612
613struct wacom_usbdev_data {
614 struct list_head list;
615 struct kref kref;
616 struct usb_device *dev;
617 struct wacom_shared shared;
618};
619
620static LIST_HEAD(wacom_udev_list);
621static DEFINE_MUTEX(wacom_udev_list_lock);
622
623static struct usb_device *wacom_get_sibling(struct usb_device *dev, int vendor, int product)
624{
625 int port1;
626 struct usb_device *sibling;
627
628 if (vendor == 0 && product == 0)
629 return dev;
630
631 if (dev->parent == NULL)
632 return NULL;
633
634 usb_hub_for_each_child(dev->parent, port1, sibling) {
635 struct usb_device_descriptor *d;
636 if (sibling == NULL)
637 continue;
638
639 d = &sibling->descriptor;
640 if (d->idVendor == vendor && d->idProduct == product)
641 return sibling;
642 }
643
644 return NULL;
645}
646
647static struct wacom_usbdev_data *wacom_get_usbdev_data(struct usb_device *dev)
648{
649 struct wacom_usbdev_data *data;
650
651 list_for_each_entry(data, &wacom_udev_list, list) {
652 if (data->dev == dev) {
653 kref_get(&data->kref);
654 return data;
655 }
656 }
657
658 return NULL;
659}
660
661static int wacom_add_shared_data(struct wacom_wac *wacom,
662 struct usb_device *dev)
663{
664 struct wacom_usbdev_data *data;
665 int retval = 0;
666
667 mutex_lock(&wacom_udev_list_lock);
668
669 data = wacom_get_usbdev_data(dev);
670 if (!data) {
671 data = kzalloc(sizeof(struct wacom_usbdev_data), GFP_KERNEL);
672 if (!data) {
673 retval = -ENOMEM;
674 goto out;
675 }
676
677 kref_init(&data->kref);
678 data->dev = dev;
679 list_add_tail(&data->list, &wacom_udev_list);
680 }
681
682 wacom->shared = &data->shared;
683
684out:
685 mutex_unlock(&wacom_udev_list_lock);
686 return retval;
687}
688
689static void wacom_release_shared_data(struct kref *kref)
690{
691 struct wacom_usbdev_data *data =
692 container_of(kref, struct wacom_usbdev_data, kref);
693
694 mutex_lock(&wacom_udev_list_lock);
695 list_del(&data->list);
696 mutex_unlock(&wacom_udev_list_lock);
697
698 kfree(data);
699}
700
701static void wacom_remove_shared_data(struct wacom_wac *wacom)
702{
703 struct wacom_usbdev_data *data;
704
705 if (wacom->shared) {
706 data = container_of(wacom->shared, struct wacom_usbdev_data, shared);
707 kref_put(&data->kref, wacom_release_shared_data);
708 wacom->shared = NULL;
709 }
710}
711
712static int wacom_led_control(struct wacom *wacom)
713{
714 unsigned char *buf;
715 int retval;
716
717 buf = kzalloc(9, GFP_KERNEL);
718 if (!buf)
719 return -ENOMEM;
720
721 if (wacom->wacom_wac.features.type >= INTUOS5S &&
722 wacom->wacom_wac.features.type <= INTUOS5L) {
723
724
725
726
727
728 int ring_led = wacom->led.select[0] & 0x03;
729 int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03;
730 int crop_lum = 0;
731
732 buf[0] = WAC_CMD_LED_CONTROL;
733 buf[1] = (crop_lum << 4) | (ring_lum << 2) | (ring_led);
734 }
735 else {
736 int led = wacom->led.select[0] | 0x4;
737
738 if (wacom->wacom_wac.features.type == WACOM_21UX2 ||
739 wacom->wacom_wac.features.type == WACOM_24HD)
740 led |= (wacom->led.select[1] << 4) | 0x40;
741
742 buf[0] = WAC_CMD_LED_CONTROL;
743 buf[1] = led;
744 buf[2] = wacom->led.llv;
745 buf[3] = wacom->led.hlv;
746 buf[4] = wacom->led.img_lum;
747 }
748
749 retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_LED_CONTROL,
750 buf, 9, WAC_CMD_RETRIES);
751 kfree(buf);
752
753 return retval;
754}
755
756static int wacom_led_putimage(struct wacom *wacom, int button_id, const void *img)
757{
758 unsigned char *buf;
759 int i, retval;
760
761 buf = kzalloc(259, GFP_KERNEL);
762 if (!buf)
763 return -ENOMEM;
764
765
766 buf[0] = WAC_CMD_ICON_START;
767 buf[1] = 1;
768 retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_START,
769 buf, 2, WAC_CMD_RETRIES);
770 if (retval < 0)
771 goto out;
772
773 buf[0] = WAC_CMD_ICON_XFER;
774 buf[1] = button_id & 0x07;
775 for (i = 0; i < 4; i++) {
776 buf[2] = i;
777 memcpy(buf + 3, img + i * 256, 256);
778
779 retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_XFER,
780 buf, 259, WAC_CMD_RETRIES);
781 if (retval < 0)
782 break;
783 }
784
785
786 buf[0] = WAC_CMD_ICON_START;
787 buf[1] = 0;
788 wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_START,
789 buf, 2, WAC_CMD_RETRIES);
790
791out:
792 kfree(buf);
793 return retval;
794}
795
796static ssize_t wacom_led_select_store(struct device *dev, int set_id,
797 const char *buf, size_t count)
798{
799 struct wacom *wacom = dev_get_drvdata(dev);
800 unsigned int id;
801 int err;
802
803 err = kstrtouint(buf, 10, &id);
804 if (err)
805 return err;
806
807 mutex_lock(&wacom->lock);
808
809 wacom->led.select[set_id] = id & 0x3;
810 err = wacom_led_control(wacom);
811
812 mutex_unlock(&wacom->lock);
813
814 return err < 0 ? err : count;
815}
816
817#define DEVICE_LED_SELECT_ATTR(SET_ID) \
818static ssize_t wacom_led##SET_ID##_select_store(struct device *dev, \
819 struct device_attribute *attr, const char *buf, size_t count) \
820{ \
821 return wacom_led_select_store(dev, SET_ID, buf, count); \
822} \
823static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \
824 struct device_attribute *attr, char *buf) \
825{ \
826 struct wacom *wacom = dev_get_drvdata(dev); \
827 return snprintf(buf, 2, "%d\n", wacom->led.select[SET_ID]); \
828} \
829static DEVICE_ATTR(status_led##SET_ID##_select, S_IWUSR | S_IRUSR, \
830 wacom_led##SET_ID##_select_show, \
831 wacom_led##SET_ID##_select_store)
832
833DEVICE_LED_SELECT_ATTR(0);
834DEVICE_LED_SELECT_ATTR(1);
835
836static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest,
837 const char *buf, size_t count)
838{
839 unsigned int value;
840 int err;
841
842 err = kstrtouint(buf, 10, &value);
843 if (err)
844 return err;
845
846 mutex_lock(&wacom->lock);
847
848 *dest = value & 0x7f;
849 err = wacom_led_control(wacom);
850
851 mutex_unlock(&wacom->lock);
852
853 return err < 0 ? err : count;
854}
855
856#define DEVICE_LUMINANCE_ATTR(name, field) \
857static ssize_t wacom_##name##_luminance_store(struct device *dev, \
858 struct device_attribute *attr, const char *buf, size_t count) \
859{ \
860 struct wacom *wacom = dev_get_drvdata(dev); \
861 \
862 return wacom_luminance_store(wacom, &wacom->led.field, \
863 buf, count); \
864} \
865static DEVICE_ATTR(name##_luminance, S_IWUSR, \
866 NULL, wacom_##name##_luminance_store)
867
868DEVICE_LUMINANCE_ATTR(status0, llv);
869DEVICE_LUMINANCE_ATTR(status1, hlv);
870DEVICE_LUMINANCE_ATTR(buttons, img_lum);
871
872static ssize_t wacom_button_image_store(struct device *dev, int button_id,
873 const char *buf, size_t count)
874{
875 struct wacom *wacom = dev_get_drvdata(dev);
876 int err;
877
878 if (count != 1024)
879 return -EINVAL;
880
881 mutex_lock(&wacom->lock);
882
883 err = wacom_led_putimage(wacom, button_id, buf);
884
885 mutex_unlock(&wacom->lock);
886
887 return err < 0 ? err : count;
888}
889
890#define DEVICE_BTNIMG_ATTR(BUTTON_ID) \
891static ssize_t wacom_btnimg##BUTTON_ID##_store(struct device *dev, \
892 struct device_attribute *attr, const char *buf, size_t count) \
893{ \
894 return wacom_button_image_store(dev, BUTTON_ID, buf, count); \
895} \
896static DEVICE_ATTR(button##BUTTON_ID##_rawimg, S_IWUSR, \
897 NULL, wacom_btnimg##BUTTON_ID##_store)
898
899DEVICE_BTNIMG_ATTR(0);
900DEVICE_BTNIMG_ATTR(1);
901DEVICE_BTNIMG_ATTR(2);
902DEVICE_BTNIMG_ATTR(3);
903DEVICE_BTNIMG_ATTR(4);
904DEVICE_BTNIMG_ATTR(5);
905DEVICE_BTNIMG_ATTR(6);
906DEVICE_BTNIMG_ATTR(7);
907
908static struct attribute *cintiq_led_attrs[] = {
909 &dev_attr_status_led0_select.attr,
910 &dev_attr_status_led1_select.attr,
911 NULL
912};
913
914static struct attribute_group cintiq_led_attr_group = {
915 .name = "wacom_led",
916 .attrs = cintiq_led_attrs,
917};
918
919static struct attribute *intuos4_led_attrs[] = {
920 &dev_attr_status0_luminance.attr,
921 &dev_attr_status1_luminance.attr,
922 &dev_attr_status_led0_select.attr,
923 &dev_attr_buttons_luminance.attr,
924 &dev_attr_button0_rawimg.attr,
925 &dev_attr_button1_rawimg.attr,
926 &dev_attr_button2_rawimg.attr,
927 &dev_attr_button3_rawimg.attr,
928 &dev_attr_button4_rawimg.attr,
929 &dev_attr_button5_rawimg.attr,
930 &dev_attr_button6_rawimg.attr,
931 &dev_attr_button7_rawimg.attr,
932 NULL
933};
934
935static struct attribute_group intuos4_led_attr_group = {
936 .name = "wacom_led",
937 .attrs = intuos4_led_attrs,
938};
939
940static struct attribute *intuos5_led_attrs[] = {
941 &dev_attr_status0_luminance.attr,
942 &dev_attr_status_led0_select.attr,
943 NULL
944};
945
946static struct attribute_group intuos5_led_attr_group = {
947 .name = "wacom_led",
948 .attrs = intuos5_led_attrs,
949};
950
951static int wacom_initialize_leds(struct wacom *wacom)
952{
953 int error;
954
955
956 switch (wacom->wacom_wac.features.type) {
957 case INTUOS4S:
958 case INTUOS4:
959 case INTUOS4L:
960 wacom->led.select[0] = 0;
961 wacom->led.select[1] = 0;
962 wacom->led.llv = 10;
963 wacom->led.hlv = 20;
964 wacom->led.img_lum = 10;
965 error = sysfs_create_group(&wacom->intf->dev.kobj,
966 &intuos4_led_attr_group);
967 break;
968
969 case WACOM_24HD:
970 case WACOM_21UX2:
971 wacom->led.select[0] = 0;
972 wacom->led.select[1] = 0;
973 wacom->led.llv = 0;
974 wacom->led.hlv = 0;
975 wacom->led.img_lum = 0;
976
977 error = sysfs_create_group(&wacom->intf->dev.kobj,
978 &cintiq_led_attr_group);
979 break;
980
981 case INTUOS5S:
982 case INTUOS5:
983 case INTUOS5L:
984 wacom->led.select[0] = 0;
985 wacom->led.select[1] = 0;
986 wacom->led.llv = 32;
987 wacom->led.hlv = 0;
988 wacom->led.img_lum = 0;
989
990 error = sysfs_create_group(&wacom->intf->dev.kobj,
991 &intuos5_led_attr_group);
992 break;
993
994 default:
995 return 0;
996 }
997
998 if (error) {
999 dev_err(&wacom->intf->dev,
1000 "cannot create sysfs group err: %d\n", error);
1001 return error;
1002 }
1003 wacom_led_control(wacom);
1004
1005 return 0;
1006}
1007
1008static void wacom_destroy_leds(struct wacom *wacom)
1009{
1010 switch (wacom->wacom_wac.features.type) {
1011 case INTUOS4S:
1012 case INTUOS4:
1013 case INTUOS4L:
1014 sysfs_remove_group(&wacom->intf->dev.kobj,
1015 &intuos4_led_attr_group);
1016 break;
1017
1018 case WACOM_24HD:
1019 case WACOM_21UX2:
1020 sysfs_remove_group(&wacom->intf->dev.kobj,
1021 &cintiq_led_attr_group);
1022 break;
1023
1024 case INTUOS5S:
1025 case INTUOS5:
1026 case INTUOS5L:
1027 sysfs_remove_group(&wacom->intf->dev.kobj,
1028 &intuos5_led_attr_group);
1029 break;
1030 }
1031}
1032
1033static enum power_supply_property wacom_battery_props[] = {
1034 POWER_SUPPLY_PROP_SCOPE,
1035 POWER_SUPPLY_PROP_CAPACITY
1036};
1037
1038static int wacom_battery_get_property(struct power_supply *psy,
1039 enum power_supply_property psp,
1040 union power_supply_propval *val)
1041{
1042 struct wacom *wacom = container_of(psy, struct wacom, battery);
1043 int ret = 0;
1044
1045 switch (psp) {
1046 case POWER_SUPPLY_PROP_SCOPE:
1047 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1048 break;
1049 case POWER_SUPPLY_PROP_CAPACITY:
1050 val->intval =
1051 wacom->wacom_wac.battery_capacity * 100 / 31;
1052 break;
1053 default:
1054 ret = -EINVAL;
1055 break;
1056 }
1057
1058 return ret;
1059}
1060
1061static int wacom_initialize_battery(struct wacom *wacom)
1062{
1063 int error = 0;
1064
1065 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_MONITOR) {
1066 wacom->battery.properties = wacom_battery_props;
1067 wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
1068 wacom->battery.get_property = wacom_battery_get_property;
1069 wacom->battery.name = "wacom_battery";
1070 wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1071 wacom->battery.use_for_apm = 0;
1072
1073 error = power_supply_register(&wacom->usbdev->dev,
1074 &wacom->battery);
1075
1076 if (!error)
1077 power_supply_powers(&wacom->battery,
1078 &wacom->usbdev->dev);
1079 }
1080
1081 return error;
1082}
1083
1084static void wacom_destroy_battery(struct wacom *wacom)
1085{
1086 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_MONITOR &&
1087 wacom->battery.dev) {
1088 power_supply_unregister(&wacom->battery);
1089 wacom->battery.dev = NULL;
1090 }
1091}
1092
1093static int wacom_register_input(struct wacom *wacom)
1094{
1095 struct input_dev *input_dev;
1096 struct usb_interface *intf = wacom->intf;
1097 struct usb_device *dev = interface_to_usbdev(intf);
1098 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1099 int error;
1100
1101 input_dev = input_allocate_device();
1102 if (!input_dev) {
1103 error = -ENOMEM;
1104 goto fail1;
1105 }
1106
1107 input_dev->name = wacom_wac->name;
1108 input_dev->dev.parent = &intf->dev;
1109 input_dev->open = wacom_open;
1110 input_dev->close = wacom_close;
1111 usb_to_input_id(dev, &input_dev->id);
1112 input_set_drvdata(input_dev, wacom);
1113
1114 wacom_wac->input = input_dev;
1115 error = wacom_setup_input_capabilities(input_dev, wacom_wac);
1116 if (error)
1117 goto fail1;
1118
1119 error = input_register_device(input_dev);
1120 if (error)
1121 goto fail2;
1122
1123 return 0;
1124
1125fail2:
1126 input_free_device(input_dev);
1127 wacom_wac->input = NULL;
1128fail1:
1129 return error;
1130}
1131
1132static void wacom_wireless_work(struct work_struct *work)
1133{
1134 struct wacom *wacom = container_of(work, struct wacom, work);
1135 struct usb_device *usbdev = wacom->usbdev;
1136 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1137 struct wacom *wacom1, *wacom2;
1138 struct wacom_wac *wacom_wac1, *wacom_wac2;
1139 int error;
1140
1141
1142
1143
1144
1145
1146 wacom_destroy_battery(wacom);
1147
1148
1149 wacom1 = usb_get_intfdata(usbdev->config->interface[1]);
1150 wacom_wac1 = &(wacom1->wacom_wac);
1151 if (wacom_wac1->input)
1152 input_unregister_device(wacom_wac1->input);
1153 wacom_wac1->input = NULL;
1154
1155
1156 wacom2 = usb_get_intfdata(usbdev->config->interface[2]);
1157 wacom_wac2 = &(wacom2->wacom_wac);
1158 if (wacom_wac2->input)
1159 input_unregister_device(wacom_wac2->input);
1160 wacom_wac2->input = NULL;
1161
1162 if (wacom_wac->pid == 0) {
1163 dev_info(&wacom->intf->dev, "wireless tablet disconnected\n");
1164 } else {
1165 const struct usb_device_id *id = wacom_ids;
1166
1167 dev_info(&wacom->intf->dev,
1168 "wireless tablet connected with PID %x\n",
1169 wacom_wac->pid);
1170
1171 while (id->match_flags) {
1172 if (id->idVendor == USB_VENDOR_ID_WACOM &&
1173 id->idProduct == wacom_wac->pid)
1174 break;
1175 id++;
1176 }
1177
1178 if (!id->match_flags) {
1179 dev_info(&wacom->intf->dev,
1180 "ignoring unknown PID.\n");
1181 return;
1182 }
1183
1184
1185 wacom_wac1->features =
1186 *((struct wacom_features *)id->driver_info);
1187 wacom_wac1->features.device_type = BTN_TOOL_PEN;
1188 error = wacom_register_input(wacom1);
1189 if (error)
1190 goto fail1;
1191
1192
1193 wacom_wac2->features =
1194 *((struct wacom_features *)id->driver_info);
1195 wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3;
1196 wacom_wac2->features.device_type = BTN_TOOL_FINGER;
1197 wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096;
1198 error = wacom_register_input(wacom2);
1199 if (error)
1200 goto fail2;
1201
1202 error = wacom_initialize_battery(wacom);
1203 if (error)
1204 goto fail3;
1205 }
1206
1207 return;
1208
1209fail3:
1210 input_unregister_device(wacom_wac2->input);
1211 wacom_wac2->input = NULL;
1212fail2:
1213 input_unregister_device(wacom_wac1->input);
1214 wacom_wac1->input = NULL;
1215fail1:
1216 return;
1217}
1218
1219
1220
1221
1222
1223
1224static void wacom_set_default_phy(struct wacom_features *features)
1225{
1226 if (features->x_resolution) {
1227 features->x_phy = (features->x_max * 100) /
1228 features->x_resolution;
1229 features->y_phy = (features->y_max * 100) /
1230 features->y_resolution;
1231 }
1232}
1233
1234static void wacom_calculate_res(struct wacom_features *features)
1235{
1236 features->x_resolution = wacom_calc_hid_res(features->x_max,
1237 features->x_phy,
1238 features->unit,
1239 features->unitExpo);
1240 features->y_resolution = wacom_calc_hid_res(features->y_max,
1241 features->y_phy,
1242 features->unit,
1243 features->unitExpo);
1244}
1245
1246static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *id)
1247{
1248 struct usb_device *dev = interface_to_usbdev(intf);
1249 struct usb_endpoint_descriptor *endpoint;
1250 struct wacom *wacom;
1251 struct wacom_wac *wacom_wac;
1252 struct wacom_features *features;
1253 int error;
1254
1255 if (!id->driver_info)
1256 return -EINVAL;
1257
1258 wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
1259 if (!wacom)
1260 return -ENOMEM;
1261
1262 wacom_wac = &wacom->wacom_wac;
1263 wacom_wac->features = *((struct wacom_features *)id->driver_info);
1264 features = &wacom_wac->features;
1265 if (features->pktlen > WACOM_PKGLEN_MAX) {
1266 error = -EINVAL;
1267 goto fail1;
1268 }
1269
1270 wacom_wac->data = usb_alloc_coherent(dev, WACOM_PKGLEN_MAX,
1271 GFP_KERNEL, &wacom->data_dma);
1272 if (!wacom_wac->data) {
1273 error = -ENOMEM;
1274 goto fail1;
1275 }
1276
1277 wacom->irq = usb_alloc_urb(0, GFP_KERNEL);
1278 if (!wacom->irq) {
1279 error = -ENOMEM;
1280 goto fail2;
1281 }
1282
1283 wacom->usbdev = dev;
1284 wacom->intf = intf;
1285 mutex_init(&wacom->lock);
1286 INIT_WORK(&wacom->work, wacom_wireless_work);
1287 usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
1288 strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
1289
1290 endpoint = &intf->cur_altsetting->endpoint[0].desc;
1291
1292
1293 wacom_set_default_phy(features);
1294
1295
1296 error = wacom_retrieve_hid_descriptor(intf, features);
1297 if (error)
1298 goto fail3;
1299
1300
1301
1302
1303
1304
1305 if (features->type >= INTUOS5S && features->type <= INTUOS5L) {
1306 if (endpoint->wMaxPacketSize == WACOM_PKGLEN_BBTOUCH3) {
1307 features->device_type = BTN_TOOL_FINGER;
1308 features->pktlen = WACOM_PKGLEN_BBTOUCH3;
1309
1310 features->x_max = 4096;
1311 features->y_max = 4096;
1312 } else {
1313 features->device_type = BTN_TOOL_PEN;
1314 }
1315 }
1316
1317 wacom_setup_device_quirks(features);
1318
1319
1320 if (!features->unit) {
1321 features->unit = 0x11;
1322 features->unitExpo = 16 - 3;
1323 }
1324 wacom_calculate_res(features);
1325
1326 strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
1327
1328 if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
1329 struct usb_device *other_dev;
1330
1331
1332 strlcat(wacom_wac->name,
1333 features->device_type == BTN_TOOL_PEN ?
1334 " Pen" : " Finger",
1335 sizeof(wacom_wac->name));
1336
1337 other_dev = wacom_get_sibling(dev, features->oVid, features->oPid);
1338 if (other_dev == NULL || wacom_get_usbdev_data(other_dev) == NULL)
1339 other_dev = dev;
1340 error = wacom_add_shared_data(wacom_wac, other_dev);
1341 if (error)
1342 goto fail3;
1343 }
1344
1345 usb_fill_int_urb(wacom->irq, dev,
1346 usb_rcvintpipe(dev, endpoint->bEndpointAddress),
1347 wacom_wac->data, features->pktlen,
1348 wacom_sys_irq, wacom, endpoint->bInterval);
1349 wacom->irq->transfer_dma = wacom->data_dma;
1350 wacom->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1351
1352 error = wacom_initialize_leds(wacom);
1353 if (error)
1354 goto fail4;
1355
1356 if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
1357 error = wacom_register_input(wacom);
1358 if (error)
1359 goto fail5;
1360 }
1361
1362
1363 wacom_query_tablet_data(intf, features);
1364
1365 usb_set_intfdata(intf, wacom);
1366
1367 if (features->quirks & WACOM_QUIRK_MONITOR) {
1368 if (usb_submit_urb(wacom->irq, GFP_KERNEL)) {
1369 error = -EIO;
1370 goto fail5;
1371 }
1372 }
1373
1374 return 0;
1375
1376 fail5: wacom_destroy_leds(wacom);
1377 fail4: wacom_remove_shared_data(wacom_wac);
1378 fail3: usb_free_urb(wacom->irq);
1379 fail2: usb_free_coherent(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma);
1380 fail1: kfree(wacom);
1381 return error;
1382}
1383
1384static void wacom_disconnect(struct usb_interface *intf)
1385{
1386 struct wacom *wacom = usb_get_intfdata(intf);
1387
1388 usb_set_intfdata(intf, NULL);
1389
1390 usb_kill_urb(wacom->irq);
1391 cancel_work_sync(&wacom->work);
1392 if (wacom->wacom_wac.input)
1393 input_unregister_device(wacom->wacom_wac.input);
1394 wacom_destroy_battery(wacom);
1395 wacom_destroy_leds(wacom);
1396 usb_free_urb(wacom->irq);
1397 usb_free_coherent(interface_to_usbdev(intf), WACOM_PKGLEN_MAX,
1398 wacom->wacom_wac.data, wacom->data_dma);
1399 wacom_remove_shared_data(&wacom->wacom_wac);
1400 kfree(wacom);
1401}
1402
1403static int wacom_suspend(struct usb_interface *intf, pm_message_t message)
1404{
1405 struct wacom *wacom = usb_get_intfdata(intf);
1406
1407 mutex_lock(&wacom->lock);
1408 usb_kill_urb(wacom->irq);
1409 mutex_unlock(&wacom->lock);
1410
1411 return 0;
1412}
1413
1414static int wacom_resume(struct usb_interface *intf)
1415{
1416 struct wacom *wacom = usb_get_intfdata(intf);
1417 struct wacom_features *features = &wacom->wacom_wac.features;
1418 int rv = 0;
1419
1420 mutex_lock(&wacom->lock);
1421
1422
1423 wacom_query_tablet_data(intf, features);
1424 wacom_led_control(wacom);
1425
1426 if ((wacom->open || (features->quirks & WACOM_QUIRK_MONITOR)) &&
1427 usb_submit_urb(wacom->irq, GFP_NOIO) < 0)
1428 rv = -EIO;
1429
1430 mutex_unlock(&wacom->lock);
1431
1432 return rv;
1433}
1434
1435static int wacom_reset_resume(struct usb_interface *intf)
1436{
1437 return wacom_resume(intf);
1438}
1439
1440static struct usb_driver wacom_driver = {
1441 .name = "wacom",
1442 .id_table = wacom_ids,
1443 .probe = wacom_probe,
1444 .disconnect = wacom_disconnect,
1445 .suspend = wacom_suspend,
1446 .resume = wacom_resume,
1447 .reset_resume = wacom_reset_resume,
1448 .supports_autosuspend = 1,
1449};
1450
1451module_usb_driver(wacom_driver);
1452