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