Lines Matching +full:serial +full:- +full:leds
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * USB Wacom tablet support - system specific code
25 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries); in wacom_get_report()
42 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries); in wacom_set_report()
89 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_wac_pen_serial_enforce()
90 struct wacom_features *features = &wacom_wac->features; in wacom_wac_pen_serial_enforce()
95 if (wacom_wac->serial[0] || !(features->quirks & WACOM_QUIRK_TOOLSERIAL)) in wacom_wac_pen_serial_enforce()
98 /* Queue events which have invalid tool type or serial number */ in wacom_wac_pen_serial_enforce()
99 for (i = 0; i < report->maxfield; i++) { in wacom_wac_pen_serial_enforce()
100 for (j = 0; j < report->field[i]->maxusage; j++) { in wacom_wac_pen_serial_enforce()
101 struct hid_field *field = report->field[i]; in wacom_wac_pen_serial_enforce()
102 struct hid_usage *usage = &field->usage[j]; in wacom_wac_pen_serial_enforce()
103 unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid); in wacom_wac_pen_serial_enforce()
114 offset = field->report_offset; in wacom_wac_pen_serial_enforce()
115 size = field->report_size; in wacom_wac_pen_serial_enforce()
126 wacom_wac->serial[0] = value; in wacom_wac_pen_serial_enforce()
130 wacom_wac->serial[0] |= ((__u64)value) << 32; in wacom_wac_pen_serial_enforce()
134 wacom_wac->id[0] = value; in wacom_wac_pen_serial_enforce()
145 wacom_wac_queue_flush(hdev, wacom_wac->pen_fifo); in wacom_wac_pen_serial_enforce()
147 wacom_wac_queue_insert(hdev, wacom_wac->pen_fifo, in wacom_wac_pen_serial_enforce()
158 if (wacom->wacom_wac.features.type == BOOTLOADER) in wacom_raw_event()
165 return -1; in wacom_raw_event()
167 memcpy(wacom->wacom_wac.data, raw_data, size); in wacom_raw_event()
169 wacom_wac_irq(&wacom->wacom_wac, size); in wacom_raw_event()
178 return hid_hw_open(wacom->hdev); in wacom_open()
186 * wacom->hdev should never be null, but surprisingly, I had the case in wacom_close()
189 if (wacom->hdev) in wacom_close()
190 hid_hw_close(wacom->hdev); in wacom_close()
213 struct wacom_features *features = &wacom->wacom_wac.features; in wacom_hid_usage_quirk()
214 unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid); in wacom_hid_usage_quirk()
217 * The Dell Canvas 27 needs to be switched to its vendor-defined in wacom_hid_usage_quirk()
220 if (hdev->vendor == USB_VENDOR_ID_WACOM && in wacom_hid_usage_quirk()
221 hdev->product == 0x4200 && in wacom_hid_usage_quirk()
222 field->application == HID_UP_MSVENDOR) { in wacom_hid_usage_quirk()
223 wacom->wacom_wac.mode_report = field->report->id; in wacom_hid_usage_quirk()
224 wacom->wacom_wac.mode_value = 2; in wacom_hid_usage_quirk()
235 if (features->type == HID_GENERIC && in wacom_hid_usage_quirk()
236 usage->hid == 0x000D0000 && in wacom_hid_usage_quirk()
237 field->application == HID_DG_PEN && in wacom_hid_usage_quirk()
238 field->physical == HID_DG_STYLUS) { in wacom_hid_usage_quirk()
239 int i = usage->usage_index; in wacom_hid_usage_quirk()
241 if (i-4 >= 0 && i+1 < field->maxusage && in wacom_hid_usage_quirk()
242 field->usage[i-4].hid == HID_DG_TIPSWITCH && in wacom_hid_usage_quirk()
243 field->usage[i-3].hid == HID_DG_BARRELSWITCH && in wacom_hid_usage_quirk()
244 field->usage[i-2].hid == HID_DG_ERASER && in wacom_hid_usage_quirk()
245 field->usage[i-1].hid == HID_DG_INVERT && in wacom_hid_usage_quirk()
246 field->usage[i+1].hid == HID_DG_INRANGE) { in wacom_hid_usage_quirk()
247 usage->hid = HID_DG_BARRELSWITCH2; in wacom_hid_usage_quirk()
252 * Wacom's AES devices use different vendor-defined usages to in wacom_hid_usage_quirk()
253 * report serial number information compared to their branded in wacom_hid_usage_quirk()
254 * hardware. The usages are also sometimes ill-defined and do in wacom_hid_usage_quirk()
259 if (usage->hid == WACOM_HID_WT_SERIALNUMBER && in wacom_hid_usage_quirk()
260 field->report_size == 16 && in wacom_hid_usage_quirk()
261 field->index + 2 < field->report->maxfield) { in wacom_hid_usage_quirk()
262 struct hid_field *a = field->report->field[field->index + 1]; in wacom_hid_usage_quirk()
263 struct hid_field *b = field->report->field[field->index + 2]; in wacom_hid_usage_quirk()
265 if (a->maxusage > 0 && in wacom_hid_usage_quirk()
266 a->usage[0].hid == HID_DG_TOOLSERIALNUMBER && in wacom_hid_usage_quirk()
267 a->report_size == 32 && in wacom_hid_usage_quirk()
268 b->maxusage > 0 && in wacom_hid_usage_quirk()
269 b->usage[0].hid == 0xFF000000 && in wacom_hid_usage_quirk()
270 b->report_size == 8) { in wacom_hid_usage_quirk()
271 features->quirks |= WACOM_QUIRK_AESPEN; in wacom_hid_usage_quirk()
272 usage->hid = WACOM_HID_WD_TOOLTYPE; in wacom_hid_usage_quirk()
273 field->logical_minimum = S16_MIN; in wacom_hid_usage_quirk()
274 field->logical_maximum = S16_MAX; in wacom_hid_usage_quirk()
275 a->logical_minimum = S32_MIN; in wacom_hid_usage_quirk()
276 a->logical_maximum = S32_MAX; in wacom_hid_usage_quirk()
277 b->usage[0].hid = WACOM_HID_WD_SERIALHI; in wacom_hid_usage_quirk()
278 b->logical_minimum = 0; in wacom_hid_usage_quirk()
279 b->logical_maximum = U8_MAX; in wacom_hid_usage_quirk()
283 /* 2nd-generation Intuos Pro Large has incorrect Y maximum */ in wacom_hid_usage_quirk()
284 if (hdev->vendor == USB_VENDOR_ID_WACOM && in wacom_hid_usage_quirk()
285 hdev->product == 0x0358 && in wacom_hid_usage_quirk()
288 field->logical_maximum = 43200; in wacom_hid_usage_quirk()
296 struct wacom_features *features = &wacom->wacom_wac.features; in wacom_feature_mapping()
297 struct hid_data *hid_data = &wacom->wacom_wac.hid_data; in wacom_feature_mapping()
298 unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid); in wacom_feature_mapping()
307 wacom->generic_has_leds = true; in wacom_feature_mapping()
311 if (!features->touch_max) { in wacom_feature_mapping()
313 n = hid_report_len(field->report); in wacom_feature_mapping()
314 data = hid_alloc_report_buf(field->report, GFP_KERNEL); in wacom_feature_mapping()
317 data[0] = field->report->id; in wacom_feature_mapping()
320 if (ret == n && features->type == HID_GENERIC) { in wacom_feature_mapping()
323 } else if (ret == 2 && features->type != HID_GENERIC) { in wacom_feature_mapping()
324 features->touch_max = data[1]; in wacom_feature_mapping()
326 features->touch_max = 16; in wacom_feature_mapping()
330 features->touch_max); in wacom_feature_mapping()
337 if (usage->usage_index >= field->report_count) { in wacom_feature_mapping()
338 dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n"); in wacom_feature_mapping()
342 hid_data->inputmode = field->report->id; in wacom_feature_mapping()
343 hid_data->inputmode_index = usage->usage_index; in wacom_feature_mapping()
347 if (field->report->id == 0x0B && in wacom_feature_mapping()
348 (field->application == WACOM_HID_G9_PEN || in wacom_feature_mapping()
349 field->application == WACOM_HID_G11_PEN)) { in wacom_feature_mapping()
350 wacom->wacom_wac.mode_report = field->report->id; in wacom_feature_mapping()
351 wacom->wacom_wac.mode_value = 0; in wacom_feature_mapping()
356 wacom->wacom_wac.mode_report = field->report->id; in wacom_feature_mapping()
357 wacom->wacom_wac.mode_value = 2; in wacom_feature_mapping()
362 if (field->report->id == 0x03 && in wacom_feature_mapping()
363 (field->application == WACOM_HID_G9_TOUCHSCREEN || in wacom_feature_mapping()
364 field->application == WACOM_HID_G11_TOUCHSCREEN)) { in wacom_feature_mapping()
365 wacom->wacom_wac.mode_report = field->report->id; in wacom_feature_mapping()
366 wacom->wacom_wac.mode_value = 0; in wacom_feature_mapping()
374 n = hid_report_len(field->report); in wacom_feature_mapping()
375 data = hid_alloc_report_buf(field->report, GFP_KERNEL); in wacom_feature_mapping()
378 data[0] = field->report->id; in wacom_feature_mapping()
413 * If it happens to define a Digitizer-Stylus Physical Collection then
417 * Digitizer-Finger Physical Collection which will define both logical
429 struct wacom_features *features = &wacom->wacom_wac.features; in wacom_usage_mapping()
432 unsigned equivalent_usage = wacom_equivalent_usage(usage->hid); in wacom_usage_mapping()
440 features->device_type |= WACOM_DEVICETYPE_PEN; in wacom_usage_mapping()
442 features->device_type |= WACOM_DEVICETYPE_TOUCH; in wacom_usage_mapping()
450 features->x_max = field->logical_maximum; in wacom_usage_mapping()
452 features->x_phy = field->physical_maximum; in wacom_usage_mapping()
453 if ((features->type != BAMBOO_PT) && in wacom_usage_mapping()
454 (features->type != BAMBOO_TOUCH)) { in wacom_usage_mapping()
455 features->unit = field->unit; in wacom_usage_mapping()
456 features->unitExpo = field->unit_exponent; in wacom_usage_mapping()
461 features->y_max = field->logical_maximum; in wacom_usage_mapping()
463 features->y_phy = field->physical_maximum; in wacom_usage_mapping()
464 if ((features->type != BAMBOO_PT) && in wacom_usage_mapping()
465 (features->type != BAMBOO_TOUCH)) { in wacom_usage_mapping()
466 features->unit = field->unit; in wacom_usage_mapping()
467 features->unitExpo = field->unit_exponent; in wacom_usage_mapping()
473 features->pressure_max = field->logical_maximum; in wacom_usage_mapping()
477 if (features->type == HID_GENERIC) in wacom_usage_mapping()
485 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_post_parse_hid()
487 if (features->type == HID_GENERIC) { in wacom_post_parse_hid()
488 /* Any last-minute generic device setup */ in wacom_post_parse_hid()
489 if (wacom_wac->has_mode_change) { in wacom_post_parse_hid()
490 if (wacom_wac->is_direct_mode) in wacom_post_parse_hid()
491 features->device_type |= WACOM_DEVICETYPE_DIRECT; in wacom_post_parse_hid()
493 features->device_type &= ~WACOM_DEVICETYPE_DIRECT; in wacom_post_parse_hid()
496 if (features->touch_max > 1) { in wacom_post_parse_hid()
497 if (features->device_type & WACOM_DEVICETYPE_DIRECT) in wacom_post_parse_hid()
498 input_mt_init_slots(wacom_wac->touch_input, in wacom_post_parse_hid()
499 wacom_wac->features.touch_max, in wacom_post_parse_hid()
502 input_mt_init_slots(wacom_wac->touch_input, in wacom_post_parse_hid()
503 wacom_wac->features.touch_max, in wacom_post_parse_hid()
517 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT]; in wacom_parse_hid()
518 list_for_each_entry(hreport, &rep_enum->report_list, list) { in wacom_parse_hid()
519 for (i = 0; i < hreport->maxfield; i++) { in wacom_parse_hid()
521 if (hreport->field[i]->report_count < 1) in wacom_parse_hid()
524 for (j = 0; j < hreport->field[i]->maxusage; j++) { in wacom_parse_hid()
525 wacom_feature_mapping(hdev, hreport->field[i], in wacom_parse_hid()
526 hreport->field[i]->usage + j); in wacom_parse_hid()
532 rep_enum = &hdev->report_enum[HID_INPUT_REPORT]; in wacom_parse_hid()
533 list_for_each_entry(hreport, &rep_enum->report_list, list) { in wacom_parse_hid()
535 if (!hreport->maxfield) in wacom_parse_hid()
538 for (i = 0; i < hreport->maxfield; i++) in wacom_parse_hid()
539 for (j = 0; j < hreport->field[i]->maxusage; j++) in wacom_parse_hid()
540 wacom_usage_mapping(hdev, hreport->field[i], in wacom_parse_hid()
541 hreport->field[i]->usage + j); in wacom_parse_hid()
550 struct hid_data *hid_data = &wacom->wacom_wac.hid_data; in wacom_hid_set_device_mode()
554 if (hid_data->inputmode < 0) in wacom_hid_set_device_mode()
557 re = &(hdev->report_enum[HID_FEATURE_REPORT]); in wacom_hid_set_device_mode()
558 r = re->report_id_hash[hid_data->inputmode]; in wacom_hid_set_device_mode()
560 r->field[0]->value[hid_data->inputmode_index] = 2; in wacom_hid_set_device_mode()
573 int error = -ENOMEM, limit = 0; in wacom_set_device_mode()
575 if (wacom_wac->mode_report < 0) in wacom_set_device_mode()
578 re = &(hdev->report_enum[HID_FEATURE_REPORT]); in wacom_set_device_mode()
579 r = re->report_id_hash[wacom_wac->mode_report]; in wacom_set_device_mode()
581 return -EINVAL; in wacom_set_device_mode()
585 return -ENOMEM; in wacom_set_device_mode()
590 rep_data[0] = wacom_wac->mode_report; in wacom_set_device_mode()
591 rep_data[1] = wacom_wac->mode_value; in wacom_set_device_mode()
599 rep_data[1] != wacom_wac->mode_report && in wacom_set_device_mode()
614 switch (features->type) { in wacom_bt_query_tablet_data()
629 wacom->wacom_wac.bt_high_speed = speed; in wacom_bt_query_tablet_data()
643 wacom->wacom_wac.bt_features &= ~0x20; in wacom_bt_query_tablet_data()
645 wacom->wacom_wac.bt_features |= 0x20; in wacom_bt_query_tablet_data()
648 rep_data[1] = wacom->wacom_wac.bt_features; in wacom_bt_query_tablet_data()
653 wacom->wacom_wac.bt_high_speed = speed; in wacom_bt_query_tablet_data()
661 * Switch the tablet into its most-capable mode. Wacom tablets are
662 * typically configured to power-up in a mode which sends mouse-like
669 struct hid_device *hdev = wacom->hdev; in _wacom_query_tablet_data()
670 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in _wacom_query_tablet_data()
671 struct wacom_features *features = &wacom_wac->features; in _wacom_query_tablet_data()
673 if (hdev->bus == BUS_BLUETOOTH) in _wacom_query_tablet_data()
676 if (features->type != HID_GENERIC) { in _wacom_query_tablet_data()
677 if (features->device_type & WACOM_DEVICETYPE_TOUCH) { in _wacom_query_tablet_data()
678 if (features->type > TABLETPC) { in _wacom_query_tablet_data()
680 wacom_wac->mode_report = 3; in _wacom_query_tablet_data()
681 wacom_wac->mode_value = 4; in _wacom_query_tablet_data()
682 } else if (features->type == WACOM_24HDT) { in _wacom_query_tablet_data()
683 wacom_wac->mode_report = 18; in _wacom_query_tablet_data()
684 wacom_wac->mode_value = 2; in _wacom_query_tablet_data()
685 } else if (features->type == WACOM_27QHDT) { in _wacom_query_tablet_data()
686 wacom_wac->mode_report = 131; in _wacom_query_tablet_data()
687 wacom_wac->mode_value = 2; in _wacom_query_tablet_data()
688 } else if (features->type == BAMBOO_PAD) { in _wacom_query_tablet_data()
689 wacom_wac->mode_report = 2; in _wacom_query_tablet_data()
690 wacom_wac->mode_value = 2; in _wacom_query_tablet_data()
692 } else if (features->device_type & WACOM_DEVICETYPE_PEN) { in _wacom_query_tablet_data()
693 if (features->type <= BAMBOO_PT) { in _wacom_query_tablet_data()
694 wacom_wac->mode_report = 2; in _wacom_query_tablet_data()
695 wacom_wac->mode_value = 2; in _wacom_query_tablet_data()
702 if (features->type == HID_GENERIC) in _wacom_query_tablet_data()
712 struct usb_interface *intf = wacom->intf; in wacom_retrieve_hid_descriptor()
715 features->x_fuzz = 4; in wacom_retrieve_hid_descriptor()
716 features->y_fuzz = 4; in wacom_retrieve_hid_descriptor()
717 features->pressure_fuzz = 0; in wacom_retrieve_hid_descriptor()
718 features->distance_fuzz = 1; in wacom_retrieve_hid_descriptor()
719 features->tilt_fuzz = 1; in wacom_retrieve_hid_descriptor()
727 if (features->type == WIRELESS && intf) { in wacom_retrieve_hid_descriptor()
728 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) in wacom_retrieve_hid_descriptor()
729 features->device_type = WACOM_DEVICETYPE_WL_MONITOR; in wacom_retrieve_hid_descriptor()
731 features->device_type = WACOM_DEVICETYPE_NONE; in wacom_retrieve_hid_descriptor()
752 struct wacom_features *features = &wacom->wacom_wac.features; in wacom_are_sibling()
754 struct wacom_features *sibling_features = &sibling_wacom->wacom_wac.features; in wacom_are_sibling()
755 __u32 oVid = features->oVid ? features->oVid : hdev->vendor; in wacom_are_sibling()
756 __u32 oPid = features->oPid ? features->oPid : hdev->product; in wacom_are_sibling()
759 if (features->oVid != HID_ANY_ID && sibling->vendor != oVid) in wacom_are_sibling()
761 if (features->oPid != HID_ANY_ID && sibling->product != oPid) in wacom_are_sibling()
769 if (hdev->vendor == sibling->vendor && hdev->product == sibling->product) { in wacom_are_sibling()
778 if (features->type != HID_GENERIC) in wacom_are_sibling()
782 * Direct-input devices may not be siblings of indirect-input in wacom_are_sibling()
785 if ((features->device_type & WACOM_DEVICETYPE_DIRECT) && in wacom_are_sibling()
786 !(sibling_features->device_type & WACOM_DEVICETYPE_DIRECT)) in wacom_are_sibling()
790 * Indirect-input devices may not be siblings of direct-input in wacom_are_sibling()
793 if (!(features->device_type & WACOM_DEVICETYPE_DIRECT) && in wacom_are_sibling()
794 (sibling_features->device_type & WACOM_DEVICETYPE_DIRECT)) in wacom_are_sibling()
798 if ((features->device_type & WACOM_DEVICETYPE_PEN) && in wacom_are_sibling()
799 !(sibling_features->device_type & WACOM_DEVICETYPE_TOUCH)) in wacom_are_sibling()
803 if ((features->device_type & WACOM_DEVICETYPE_TOUCH) && in wacom_are_sibling()
804 !(sibling_features->device_type & WACOM_DEVICETYPE_PEN)) in wacom_are_sibling()
818 /* Try to find an already-probed interface from the same device */ in wacom_get_hdev_data()
820 if (hid_compare_device_paths(hdev, data->dev, '/')) { in wacom_get_hdev_data()
821 kref_get(&data->kref); in wacom_get_hdev_data()
828 if (wacom_are_sibling(hdev, data->dev)) { in wacom_get_hdev_data()
829 kref_get(&data->kref); in wacom_get_hdev_data()
843 list_del(&data->list); in wacom_release_shared_data()
853 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_remove_shared_data()
855 if (wacom_wac->shared) { in wacom_remove_shared_data()
856 data = container_of(wacom_wac->shared, struct wacom_hdev_data, in wacom_remove_shared_data()
859 if (wacom_wac->shared->touch == wacom->hdev) in wacom_remove_shared_data()
860 wacom_wac->shared->touch = NULL; in wacom_remove_shared_data()
861 else if (wacom_wac->shared->pen == wacom->hdev) in wacom_remove_shared_data()
862 wacom_wac->shared->pen = NULL; in wacom_remove_shared_data()
864 kref_put(&data->kref, wacom_release_shared_data); in wacom_remove_shared_data()
865 wacom_wac->shared = NULL; in wacom_remove_shared_data()
872 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_add_shared_data()
883 return -ENOMEM; in wacom_add_shared_data()
886 kref_init(&data->kref); in wacom_add_shared_data()
887 data->dev = hdev; in wacom_add_shared_data()
888 list_add_tail(&data->list, &wacom_udev_list); in wacom_add_shared_data()
893 wacom_wac->shared = &data->shared; in wacom_add_shared_data()
895 retval = devm_add_action_or_reset(&hdev->dev, wacom_remove_shared_data, wacom); in wacom_add_shared_data()
899 if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH) in wacom_add_shared_data()
900 wacom_wac->shared->touch = hdev; in wacom_add_shared_data()
901 else if (wacom_wac->features.device_type & WACOM_DEVICETYPE_PEN) in wacom_add_shared_data()
902 wacom_wac->shared->pen = hdev; in wacom_add_shared_data()
914 if (!wacom->led.groups) in wacom_led_control()
915 return -ENOTSUPP; in wacom_led_control()
917 if (wacom->wacom_wac.features.type == REMOTE) in wacom_led_control()
918 return -ENOTSUPP; in wacom_led_control()
920 if (wacom->wacom_wac.pid) { /* wireless connected */ in wacom_led_control()
924 else if (wacom->wacom_wac.features.type == INTUOSP2_BT) { in wacom_led_control()
930 return -ENOMEM; in wacom_led_control()
932 if (wacom->wacom_wac.features.type == HID_GENERIC) { in wacom_led_control()
934 buf[1] = wacom->led.llv; in wacom_led_control()
935 buf[2] = wacom->led.groups[0].select & 0x03; in wacom_led_control()
937 } else if ((wacom->wacom_wac.features.type >= INTUOS5S && in wacom_led_control()
938 wacom->wacom_wac.features.type <= INTUOSPL)) { in wacom_led_control()
944 int ring_led = wacom->led.groups[0].select & 0x03; in wacom_led_control()
945 int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03; in wacom_led_control()
950 if (wacom->wacom_wac.pid) { in wacom_led_control()
951 wacom_get_report(wacom->hdev, HID_FEATURE_REPORT, in wacom_led_control()
958 else if (wacom->wacom_wac.features.type == INTUOSP2_BT) { in wacom_led_control()
965 buf[9] = wacom->led.llv; in wacom_led_control()
966 buf[10] = wacom->led.groups[0].select & 0x03; in wacom_led_control()
969 int led = wacom->led.groups[0].select | 0x4; in wacom_led_control()
971 if (wacom->wacom_wac.features.type == WACOM_21UX2 || in wacom_led_control()
972 wacom->wacom_wac.features.type == WACOM_24HD) in wacom_led_control()
973 led |= (wacom->led.groups[1].select << 4) | 0x40; in wacom_led_control()
977 buf[2] = wacom->led.llv; in wacom_led_control()
978 buf[3] = wacom->led.hlv; in wacom_led_control()
979 buf[4] = wacom->led.img_lum; in wacom_led_control()
982 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, buf_size, in wacom_led_control()
998 return -ENOMEM; in wacom_led_putimage()
1003 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2, in wacom_led_putimage()
1014 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, in wacom_led_putimage()
1023 wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2, in wacom_led_putimage()
1043 mutex_lock(&wacom->lock); in wacom_led_select_store()
1045 wacom->led.groups[set_id].select = id & 0x3; in wacom_led_select_store()
1048 mutex_unlock(&wacom->lock); in wacom_led_select_store()
1065 wacom->led.groups[SET_ID].select); \
1084 mutex_lock(&wacom->lock); in wacom_luminance_store()
1089 mutex_unlock(&wacom->lock); in wacom_luminance_store()
1101 return wacom_luminance_store(wacom, &wacom->led.field, \
1108 return scnprintf(buf, PAGE_SIZE, "%d\n", wacom->led.field); \
1127 if (hdev->bus == BUS_BLUETOOTH) { in wacom_button_image_store()
1136 return -EINVAL; in wacom_button_image_store()
1138 mutex_lock(&wacom->lock); in wacom_button_image_store()
1142 mutex_unlock(&wacom->lock); in wacom_button_image_store()
1227 struct kobject *kobj = devres->root; in wacom_devm_sysfs_group_release()
1230 __func__, devres->group->name); in wacom_devm_sysfs_group_release()
1231 sysfs_remove_group(kobj, devres->group); in wacom_devm_sysfs_group_release()
1245 return -ENOMEM; in __wacom_devm_sysfs_create_group()
1247 devres->group = group; in __wacom_devm_sysfs_create_group()
1248 devres->root = root; in __wacom_devm_sysfs_create_group()
1250 error = sysfs_create_group(devres->root, group); in __wacom_devm_sysfs_create_group()
1256 devres_add(&wacom->hdev->dev, devres); in __wacom_devm_sysfs_create_group()
1264 return __wacom_devm_sysfs_create_group(wacom, &wacom->hdev->dev.kobj, in wacom_devm_sysfs_create_group()
1277 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_devm_kfifo_alloc()
1286 return -ENOMEM; in wacom_devm_kfifo_alloc()
1294 devres_add(&wacom->hdev->dev, pen_fifo); in wacom_devm_kfifo_alloc()
1295 wacom_wac->pen_fifo = pen_fifo; in wacom_devm_kfifo_alloc()
1302 struct wacom *wacom = led->wacom; in wacom_leds_brightness_get()
1304 if (wacom->led.max_hlv) in wacom_leds_brightness_get()
1305 return led->hlv * LED_FULL / wacom->led.max_hlv; in wacom_leds_brightness_get()
1307 if (wacom->led.max_llv) in wacom_leds_brightness_get()
1308 return led->llv * LED_FULL / wacom->led.max_llv; in wacom_leds_brightness_get()
1317 struct wacom *wacom = led->wacom; in __wacom_led_brightness_get()
1319 if (wacom->led.groups[led->group].select != led->id) in __wacom_led_brightness_get()
1329 struct wacom *wacom = led->wacom; in wacom_led_brightness_set()
1332 mutex_lock(&wacom->lock); in wacom_led_brightness_set()
1334 if (!wacom->led.groups || (brightness == LED_OFF && in wacom_led_brightness_set()
1335 wacom->led.groups[led->group].select != led->id)) { in wacom_led_brightness_set()
1340 led->llv = wacom->led.llv = wacom->led.max_llv * brightness / LED_FULL; in wacom_led_brightness_set()
1341 led->hlv = wacom->led.hlv = wacom->led.max_hlv * brightness / LED_FULL; in wacom_led_brightness_set()
1343 wacom->led.groups[led->group].select = led->id; in wacom_led_brightness_set()
1348 mutex_unlock(&wacom->lock); in wacom_led_brightness_set()
1366 "%s::wacom-%d.%d", in wacom_led_register_one()
1371 return -ENOMEM; in wacom_led_register_one()
1374 led->trigger.name = name; in wacom_led_register_one()
1375 error = devm_led_trigger_register(dev, &led->trigger); in wacom_led_register_one()
1377 hid_err(wacom->hdev, in wacom_led_register_one()
1379 led->cdev.name, error); in wacom_led_register_one()
1384 led->group = group; in wacom_led_register_one()
1385 led->id = id; in wacom_led_register_one()
1386 led->wacom = wacom; in wacom_led_register_one()
1387 led->llv = wacom->led.llv; in wacom_led_register_one()
1388 led->hlv = wacom->led.hlv; in wacom_led_register_one()
1389 led->cdev.name = name; in wacom_led_register_one()
1390 led->cdev.max_brightness = LED_FULL; in wacom_led_register_one()
1391 led->cdev.flags = LED_HW_PLUGGABLE; in wacom_led_register_one()
1392 led->cdev.brightness_get = __wacom_led_brightness_get; in wacom_led_register_one()
1394 led->cdev.brightness_set_blocking = wacom_led_brightness_set; in wacom_led_register_one()
1395 led->cdev.default_trigger = led->cdev.name; in wacom_led_register_one()
1397 led->cdev.brightness_set = wacom_led_readonly_brightness_set; in wacom_led_register_one()
1400 error = devm_led_classdev_register(dev, &led->cdev); in wacom_led_register_one()
1402 hid_err(wacom->hdev, in wacom_led_register_one()
1404 led->cdev.name, error); in wacom_led_register_one()
1405 led->cdev.name = NULL; in wacom_led_register_one()
1416 devres_release_group(group->dev, group); in wacom_led_groups_release_one()
1424 struct wacom_led *leds; in wacom_led_groups_alloc_and_register_one() local
1427 if (group_id >= wacom->led.count || count <= 0) in wacom_led_groups_alloc_and_register_one()
1428 return -EINVAL; in wacom_led_groups_alloc_and_register_one()
1430 if (!devres_open_group(dev, &wacom->led.groups[group_id], GFP_KERNEL)) in wacom_led_groups_alloc_and_register_one()
1431 return -ENOMEM; in wacom_led_groups_alloc_and_register_one()
1433 leds = devm_kcalloc(dev, count, sizeof(struct wacom_led), GFP_KERNEL); in wacom_led_groups_alloc_and_register_one()
1434 if (!leds) { in wacom_led_groups_alloc_and_register_one()
1435 error = -ENOMEM; in wacom_led_groups_alloc_and_register_one()
1439 wacom->led.groups[group_id].leds = leds; in wacom_led_groups_alloc_and_register_one()
1440 wacom->led.groups[group_id].count = count; in wacom_led_groups_alloc_and_register_one()
1443 error = wacom_led_register_one(dev, wacom, &leds[i], in wacom_led_groups_alloc_and_register_one()
1449 wacom->led.groups[group_id].dev = dev; in wacom_led_groups_alloc_and_register_one()
1451 devres_close_group(dev, &wacom->led.groups[group_id]); in wacom_led_groups_alloc_and_register_one()
1458 * This means that the LEDs are still there after disconnect. in wacom_led_groups_alloc_and_register_one()
1459 * Manually force the release of the group so that the leds are released in wacom_led_groups_alloc_and_register_one()
1462 error = devm_add_action_or_reset(&wacom->hdev->dev, in wacom_led_groups_alloc_and_register_one()
1464 &wacom->led.groups[group_id]); in wacom_led_groups_alloc_and_register_one()
1471 devres_release_group(dev, &wacom->led.groups[group_id]); in wacom_led_groups_alloc_and_register_one()
1480 if (group_id >= wacom->led.count) in wacom_led_find()
1483 group = &wacom->led.groups[group_id]; in wacom_led_find()
1485 if (!group->leds) in wacom_led_find()
1488 id %= group->count; in wacom_led_find()
1490 return &group->leds[id]; in wacom_led_find()
1507 group = cur->group; in wacom_led_next()
1508 next = cur->id; in wacom_led_next()
1514 } while (next_led->cdev.trigger != &next_led->trigger); in wacom_led_next()
1523 wacom->led.groups = NULL; in wacom_led_groups_release()
1524 wacom->led.count = 0; in wacom_led_groups_release()
1529 struct device *dev = &wacom->hdev->dev; in wacom_led_groups_allocate()
1536 return -ENOMEM; in wacom_led_groups_allocate()
1542 wacom->led.groups = groups; in wacom_led_groups_allocate()
1543 wacom->led.count = count; in wacom_led_groups_allocate()
1554 if (!wacom->wacom_wac.pad_input) in wacom_leds_alloc_and_register()
1555 return -EINVAL; in wacom_leds_alloc_and_register()
1557 dev = &wacom->wacom_wac.pad_input->dev; in wacom_leds_alloc_and_register()
1578 if (!(wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD)) in wacom_initialize_leds()
1582 switch (wacom->wacom_wac.features.type) { in wacom_initialize_leds()
1584 if (!wacom->generic_has_leds) in wacom_initialize_leds()
1586 wacom->led.llv = 100; in wacom_initialize_leds()
1587 wacom->led.max_llv = 100; in wacom_initialize_leds()
1591 hid_err(wacom->hdev, in wacom_initialize_leds()
1592 "cannot create leds err: %d\n", error); in wacom_initialize_leds()
1604 wacom->led.llv = 10; in wacom_initialize_leds()
1605 wacom->led.hlv = 20; in wacom_initialize_leds()
1606 wacom->led.max_llv = 127; in wacom_initialize_leds()
1607 wacom->led.max_hlv = 127; in wacom_initialize_leds()
1608 wacom->led.img_lum = 10; in wacom_initialize_leds()
1612 hid_err(wacom->hdev, in wacom_initialize_leds()
1613 "cannot create leds err: %d\n", error); in wacom_initialize_leds()
1623 wacom->led.llv = 0; in wacom_initialize_leds()
1624 wacom->led.hlv = 0; in wacom_initialize_leds()
1625 wacom->led.img_lum = 0; in wacom_initialize_leds()
1629 hid_err(wacom->hdev, in wacom_initialize_leds()
1630 "cannot create leds err: %d\n", error); in wacom_initialize_leds()
1644 wacom->led.llv = 32; in wacom_initialize_leds()
1645 wacom->led.max_llv = 96; in wacom_initialize_leds()
1649 hid_err(wacom->hdev, in wacom_initialize_leds()
1650 "cannot create leds err: %d\n", error); in wacom_initialize_leds()
1659 wacom->led.llv = 50; in wacom_initialize_leds()
1660 wacom->led.max_llv = 100; in wacom_initialize_leds()
1663 hid_err(wacom->hdev, in wacom_initialize_leds()
1664 "cannot create leds err: %d\n", error); in wacom_initialize_leds()
1670 wacom->led.llv = 255; in wacom_initialize_leds()
1671 wacom->led.max_llv = 255; in wacom_initialize_leds()
1674 hid_err(wacom->hdev, in wacom_initialize_leds()
1675 "cannot create leds err: %d\n", error); in wacom_initialize_leds()
1685 hid_err(wacom->hdev, in wacom_initialize_leds()
1703 schedule_delayed_work(&wacom->init_work, msecs_to_jiffies(1000)); in wacom_query_tablet_data()
1723 val->strval = battery->wacom->wacom_wac.name; in wacom_battery_get_property()
1726 val->intval = battery->bat_connected; in wacom_battery_get_property()
1729 val->intval = POWER_SUPPLY_SCOPE_DEVICE; in wacom_battery_get_property()
1732 val->intval = battery->battery_capacity; in wacom_battery_get_property()
1735 if (battery->bat_status != WACOM_POWER_SUPPLY_STATUS_AUTO) in wacom_battery_get_property()
1736 val->intval = battery->bat_status; in wacom_battery_get_property()
1737 else if (battery->bat_charging) in wacom_battery_get_property()
1738 val->intval = POWER_SUPPLY_STATUS_CHARGING; in wacom_battery_get_property()
1739 else if (battery->battery_capacity == 100 && in wacom_battery_get_property()
1740 battery->ps_connected) in wacom_battery_get_property()
1741 val->intval = POWER_SUPPLY_STATUS_FULL; in wacom_battery_get_property()
1742 else if (battery->ps_connected) in wacom_battery_get_property()
1743 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; in wacom_battery_get_property()
1745 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; in wacom_battery_get_property()
1748 ret = -EINVAL; in wacom_battery_get_property()
1759 struct device *dev = &wacom->hdev->dev; in __wacom_initialize_battery()
1762 struct power_supply_desc *bat_desc = &battery->bat_desc; in __wacom_initialize_battery()
1767 return -ENOMEM; in __wacom_initialize_battery()
1769 battery->wacom = wacom; in __wacom_initialize_battery()
1771 n = atomic_inc_return(&battery_no) - 1; in __wacom_initialize_battery()
1773 bat_desc->properties = wacom_battery_props; in __wacom_initialize_battery()
1774 bat_desc->num_properties = ARRAY_SIZE(wacom_battery_props); in __wacom_initialize_battery()
1775 bat_desc->get_property = wacom_battery_get_property; in __wacom_initialize_battery()
1776 sprintf(battery->bat_name, "wacom_battery_%ld", n); in __wacom_initialize_battery()
1777 bat_desc->name = battery->bat_name; in __wacom_initialize_battery()
1778 bat_desc->type = POWER_SUPPLY_TYPE_BATTERY; in __wacom_initialize_battery()
1779 bat_desc->use_for_apm = 0; in __wacom_initialize_battery()
1787 power_supply_powers(ps_bat, &wacom->hdev->dev); in __wacom_initialize_battery()
1789 battery->battery = ps_bat; in __wacom_initialize_battery()
1801 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) in wacom_initialize_battery()
1802 return __wacom_initialize_battery(wacom, &wacom->battery); in wacom_initialize_battery()
1809 if (wacom->battery.battery) { in wacom_destroy_battery()
1810 devres_release_group(&wacom->hdev->dev, in wacom_destroy_battery()
1811 &wacom->battery.bat_desc); in wacom_destroy_battery()
1812 wacom->battery.battery = NULL; in wacom_destroy_battery()
1830 return sysfs_emit(buf, "%i\n", wacom->wacom_wac.bt_high_speed); in wacom_show_speed()
1842 return -EINVAL; in wacom_store_speed()
1845 return -EINVAL; in wacom_store_speed()
1847 wacom_bt_query_tablet_data(hdev, new_speed, &wacom->wacom_wac.features); in wacom_store_speed()
1860 struct device *dev = kobj_to_dev(kobj->parent); in wacom_show_remote_mode()
1865 mode = wacom->led.groups[index].select; in wacom_show_remote_mode()
1866 return sprintf(buf, "%d\n", mode < 3 ? mode : -1); in wacom_show_remote_mode()
1895 static int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial, in wacom_remote_create_attr_group() argument
1899 struct wacom_remote *remote = wacom->remote; in wacom_remote_create_attr_group()
1901 remote->remotes[index].group.name = devm_kasprintf(&wacom->hdev->dev, in wacom_remote_create_attr_group()
1903 "%d", serial); in wacom_remote_create_attr_group()
1904 if (!remote->remotes[index].group.name) in wacom_remote_create_attr_group()
1905 return -ENOMEM; in wacom_remote_create_attr_group()
1907 error = __wacom_devm_sysfs_create_group(wacom, remote->remote_dir, in wacom_remote_create_attr_group()
1908 &remote->remotes[index].group); in wacom_remote_create_attr_group()
1910 remote->remotes[index].group.name = NULL; in wacom_remote_create_attr_group()
1911 hid_err(wacom->hdev, in wacom_remote_create_attr_group()
1927 return -ENOMEM; in wacom_cmd_unpair_remote()
1932 retval = wacom_set_report(wacom->hdev, HID_OUTPUT_REPORT, buf, in wacom_cmd_unpair_remote()
1944 struct device *dev = kobj_to_dev(kobj->parent); in wacom_store_unpair_remote()
1952 hid_info(wacom->hdev, "remote: unrecognized unpair code: %s\n", in wacom_store_unpair_remote()
1954 return -1; in wacom_store_unpair_remote()
1957 mutex_lock(&wacom->lock); in wacom_store_unpair_remote()
1960 mutex_unlock(&wacom->lock); in wacom_store_unpair_remote()
1978 struct wacom_remote *remote = wacom->remote; in wacom_remotes_destroy()
1983 kobject_put(remote->remote_dir); in wacom_remotes_destroy()
1984 kfifo_free(&remote->remote_fifo); in wacom_remotes_destroy()
1985 wacom->remote = NULL; in wacom_remotes_destroy()
1994 if (wacom->wacom_wac.features.type != REMOTE) in wacom_initialize_remotes()
1997 remote = devm_kzalloc(&wacom->hdev->dev, sizeof(*wacom->remote), in wacom_initialize_remotes()
2000 return -ENOMEM; in wacom_initialize_remotes()
2002 wacom->remote = remote; in wacom_initialize_remotes()
2004 spin_lock_init(&remote->remote_lock); in wacom_initialize_remotes()
2006 error = kfifo_alloc(&remote->remote_fifo, in wacom_initialize_remotes()
2010 hid_err(wacom->hdev, "failed allocating remote_fifo\n"); in wacom_initialize_remotes()
2011 return -ENOMEM; in wacom_initialize_remotes()
2014 remote->remotes[0].group = remote0_serial_group; in wacom_initialize_remotes()
2015 remote->remotes[1].group = remote1_serial_group; in wacom_initialize_remotes()
2016 remote->remotes[2].group = remote2_serial_group; in wacom_initialize_remotes()
2017 remote->remotes[3].group = remote3_serial_group; in wacom_initialize_remotes()
2018 remote->remotes[4].group = remote4_serial_group; in wacom_initialize_remotes()
2020 remote->remote_dir = kobject_create_and_add("wacom_remote", in wacom_initialize_remotes()
2021 &wacom->hdev->dev.kobj); in wacom_initialize_remotes()
2022 if (!remote->remote_dir) in wacom_initialize_remotes()
2023 return -ENOMEM; in wacom_initialize_remotes()
2025 error = sysfs_create_files(remote->remote_dir, remote_unpair_attrs); in wacom_initialize_remotes()
2028 hid_err(wacom->hdev, in wacom_initialize_remotes()
2034 wacom->led.groups[i].select = WACOM_STATUS_UNKNOWN; in wacom_initialize_remotes()
2035 remote->remotes[i].serial = 0; in wacom_initialize_remotes()
2038 error = devm_add_action_or_reset(&wacom->hdev->dev, in wacom_initialize_remotes()
2049 struct hid_device *hdev = wacom->hdev; in wacom_allocate_input()
2050 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); in wacom_allocate_input()
2052 input_dev = devm_input_allocate_device(&hdev->dev); in wacom_allocate_input()
2056 input_dev->name = wacom_wac->features.name; in wacom_allocate_input()
2057 input_dev->phys = hdev->phys; in wacom_allocate_input()
2058 input_dev->dev.parent = &hdev->dev; in wacom_allocate_input()
2059 input_dev->open = wacom_open; in wacom_allocate_input()
2060 input_dev->close = wacom_close; in wacom_allocate_input()
2061 input_dev->uniq = hdev->uniq; in wacom_allocate_input()
2062 input_dev->id.bustype = hdev->bus; in wacom_allocate_input()
2063 input_dev->id.vendor = hdev->vendor; in wacom_allocate_input()
2064 input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product; in wacom_allocate_input()
2065 input_dev->id.version = hdev->version; in wacom_allocate_input()
2073 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); in wacom_allocate_inputs()
2075 wacom_wac->pen_input = wacom_allocate_input(wacom); in wacom_allocate_inputs()
2076 wacom_wac->touch_input = wacom_allocate_input(wacom); in wacom_allocate_inputs()
2077 wacom_wac->pad_input = wacom_allocate_input(wacom); in wacom_allocate_inputs()
2078 if (!wacom_wac->pen_input || in wacom_allocate_inputs()
2079 !wacom_wac->touch_input || in wacom_allocate_inputs()
2080 !wacom_wac->pad_input) in wacom_allocate_inputs()
2081 return -ENOMEM; in wacom_allocate_inputs()
2083 wacom_wac->pen_input->name = wacom_wac->pen_name; in wacom_allocate_inputs()
2084 wacom_wac->touch_input->name = wacom_wac->touch_name; in wacom_allocate_inputs()
2085 wacom_wac->pad_input->name = wacom_wac->pad_name; in wacom_allocate_inputs()
2093 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); in wacom_setup_inputs()
2096 pen_input_dev = wacom_wac->pen_input; in wacom_setup_inputs()
2097 touch_input_dev = wacom_wac->touch_input; in wacom_setup_inputs()
2098 pad_input_dev = wacom_wac->pad_input; in wacom_setup_inputs()
2101 return -EINVAL; in wacom_setup_inputs()
2107 wacom_wac->pen_input = NULL; in wacom_setup_inputs()
2115 wacom_wac->touch_input = NULL; in wacom_setup_inputs()
2123 wacom_wac->pad_input = NULL; in wacom_setup_inputs()
2133 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); in wacom_register_inputs()
2136 pen_input_dev = wacom_wac->pen_input; in wacom_register_inputs()
2137 touch_input_dev = wacom_wac->touch_input; in wacom_register_inputs()
2138 pad_input_dev = wacom_wac->pad_input; in wacom_register_inputs()
2161 wacom_wac->pad_input = NULL; in wacom_register_inputs()
2162 wacom_wac->touch_input = NULL; in wacom_register_inputs()
2163 wacom_wac->pen_input = NULL; in wacom_register_inputs()
2174 if (features->x_resolution) { in wacom_set_default_phy()
2175 features->x_phy = (features->x_max * 100) / in wacom_set_default_phy()
2176 features->x_resolution; in wacom_set_default_phy()
2177 features->y_phy = (features->y_max * 100) / in wacom_set_default_phy()
2178 features->y_resolution; in wacom_set_default_phy()
2185 if (!features->unit) { in wacom_calculate_res()
2186 features->unit = 0x11; in wacom_calculate_res()
2187 features->unitExpo = -3; in wacom_calculate_res()
2190 features->x_resolution = wacom_calc_hid_res(features->x_max, in wacom_calculate_res()
2191 features->x_phy, in wacom_calculate_res()
2192 features->unit, in wacom_calculate_res()
2193 features->unitExpo); in wacom_calculate_res()
2194 features->y_resolution = wacom_calc_hid_res(features->y_max, in wacom_calculate_res()
2195 features->y_phy, in wacom_calculate_res()
2196 features->unit, in wacom_calculate_res()
2197 features->unitExpo); in wacom_calculate_res()
2204 if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) && in wacom_battery_work()
2205 !wacom->battery.battery) { in wacom_battery_work()
2208 else if (!(wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) && in wacom_battery_work()
2209 wacom->battery.battery) { in wacom_battery_work()
2220 report_enum = hdev->report_enum + HID_INPUT_REPORT; in wacom_compute_pktlen()
2222 list_for_each_entry(report, &report_enum->report_list, list) { in wacom_compute_pktlen()
2233 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_update_name()
2234 struct wacom_features *features = &wacom_wac->features; in wacom_update_name()
2235 char name[WACOM_NAME_MAX - 20]; /* Leave some room for suffixes */ in wacom_update_name()
2238 if ((features->type == HID_GENERIC) && !strcmp("Wacom HID", features->name)) { in wacom_update_name()
2239 char *product_name = wacom->hdev->name; in wacom_update_name()
2241 if (hid_is_usb(wacom->hdev)) { in wacom_update_name()
2242 struct usb_interface *intf = to_usb_interface(wacom->hdev->dev.parent); in wacom_update_name()
2244 if (dev->product != NULL) in wacom_update_name()
2245 product_name = dev->product; in wacom_update_name()
2248 if (wacom->hdev->bus == BUS_I2C) { in wacom_update_name()
2250 features->name, wacom->hdev->product); in wacom_update_name()
2255 hid_warn(wacom->hdev, "String overflow while assembling device name"); in wacom_update_name()
2271 if (name[strlen(name)-1] == ' ') in wacom_update_name()
2272 name[strlen(name)-1] = '\0'; in wacom_update_name()
2274 if (strscpy(name, features->name, sizeof(name)) < 0) { in wacom_update_name()
2275 hid_warn(wacom->hdev, "String overflow while assembling device name"); in wacom_update_name()
2279 snprintf(wacom_wac->name, sizeof(wacom_wac->name), "%s%s", in wacom_update_name()
2283 snprintf(wacom_wac->pen_name, sizeof(wacom_wac->pen_name), in wacom_update_name()
2285 snprintf(wacom_wac->touch_name, sizeof(wacom_wac->touch_name), in wacom_update_name()
2287 snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name), in wacom_update_name()
2293 struct hid_device *hdev = wacom->hdev; in wacom_release_resources()
2295 if (!wacom->resources) in wacom_release_resources()
2298 devres_release_group(&hdev->dev, wacom); in wacom_release_resources()
2300 wacom->resources = false; in wacom_release_resources()
2302 wacom->wacom_wac.pen_input = NULL; in wacom_release_resources()
2303 wacom->wacom_wac.touch_input = NULL; in wacom_release_resources()
2304 wacom->wacom_wac.pad_input = NULL; in wacom_release_resources()
2309 if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH) { in wacom_set_shared_values()
2310 wacom_wac->shared->type = wacom_wac->features.type; in wacom_set_shared_values()
2311 wacom_wac->shared->touch_input = wacom_wac->touch_input; in wacom_set_shared_values()
2314 if (wacom_wac->has_mute_touch_switch) { in wacom_set_shared_values()
2315 wacom_wac->shared->has_mute_touch_switch = true; in wacom_set_shared_values()
2321 if (wacom_wac->is_soft_touch_switch) in wacom_set_shared_values()
2322 wacom_wac->shared->is_touch_on = true; in wacom_set_shared_values()
2325 if (wacom_wac->shared->has_mute_touch_switch && in wacom_set_shared_values()
2326 wacom_wac->shared->touch_input) { in wacom_set_shared_values()
2327 set_bit(EV_SW, wacom_wac->shared->touch_input->evbit); in wacom_set_shared_values()
2328 input_set_capability(wacom_wac->shared->touch_input, EV_SW, in wacom_set_shared_values()
2335 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_parse_and_register()
2336 struct wacom_features *features = &wacom_wac->features; in wacom_parse_and_register()
2337 struct hid_device *hdev = wacom->hdev; in wacom_parse_and_register()
2341 features->pktlen = wacom_compute_pktlen(hdev); in wacom_parse_and_register()
2342 if (features->pktlen > WACOM_PKGLEN_MAX) in wacom_parse_and_register()
2343 return -EINVAL; in wacom_parse_and_register()
2345 if (!devres_open_group(&hdev->dev, wacom, GFP_KERNEL)) in wacom_parse_and_register()
2346 return -ENOMEM; in wacom_parse_and_register()
2348 wacom->resources = true; in wacom_parse_and_register()
2359 if (features->type == BAMBOO_PAD) { in wacom_parse_and_register()
2360 if (features->pktlen == WACOM_PKGLEN_PENABLED) { in wacom_parse_and_register()
2361 features->type = HID_GENERIC; in wacom_parse_and_register()
2362 } else if ((features->pktlen != WACOM_PKGLEN_BPAD_TOUCH) && in wacom_parse_and_register()
2363 (features->pktlen != WACOM_PKGLEN_BPAD_TOUCH_USB)) { in wacom_parse_and_register()
2364 error = -ENODEV; in wacom_parse_and_register()
2376 if (features->device_type == WACOM_DEVICETYPE_NONE && in wacom_parse_and_register()
2377 features->type != WIRELESS) { in wacom_parse_and_register()
2378 error = features->type == HID_GENERIC ? -ENODEV : 0; in wacom_parse_and_register()
2380 dev_warn(&hdev->dev, "Unknown device_type for '%s'. %s.", in wacom_parse_and_register()
2381 hdev->name, in wacom_parse_and_register()
2387 features->device_type |= WACOM_DEVICETYPE_PEN; in wacom_parse_and_register()
2395 if ((features->type == BAMBOO_PEN) && in wacom_parse_and_register()
2396 ((features->device_type & WACOM_DEVICETYPE_TOUCH) || in wacom_parse_and_register()
2397 (features->device_type & WACOM_DEVICETYPE_PAD))) { in wacom_parse_and_register()
2398 error = -ENODEV; in wacom_parse_and_register()
2410 if (features->type == HID_GENERIC) in wacom_parse_and_register()
2424 if (wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD) { in wacom_parse_and_register()
2440 if ((features->type == BAMBOO_TOUCH) && in wacom_parse_and_register()
2441 (features->device_type & WACOM_DEVICETYPE_PEN)) { in wacom_parse_and_register()
2442 cancel_delayed_work_sync(&wacom->init_work); in wacom_parse_and_register()
2444 error = -ENODEV; in wacom_parse_and_register()
2448 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR) { in wacom_parse_and_register()
2457 devres_close_group(&hdev->dev, wacom); in wacom_parse_and_register()
2471 struct usb_device *usbdev = wacom->usbdev; in wacom_wireless_work()
2472 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_wireless_work()
2489 hdev1 = usb_get_intfdata(usbdev->config->interface[1]); in wacom_wireless_work()
2491 wacom_wac1 = &(wacom1->wacom_wac); in wacom_wireless_work()
2495 hdev2 = usb_get_intfdata(usbdev->config->interface[2]); in wacom_wireless_work()
2497 wacom_wac2 = &(wacom2->wacom_wac); in wacom_wireless_work()
2500 if (wacom_wac->pid == 0) { in wacom_wireless_work()
2501 hid_info(wacom->hdev, "wireless tablet disconnected\n"); in wacom_wireless_work()
2505 hid_info(wacom->hdev, "wireless tablet connected with PID %x\n", in wacom_wireless_work()
2506 wacom_wac->pid); in wacom_wireless_work()
2508 while (id->bus) { in wacom_wireless_work()
2509 if (id->vendor == USB_VENDOR_ID_WACOM && in wacom_wireless_work()
2510 id->product == wacom_wac->pid) in wacom_wireless_work()
2515 if (!id->bus) { in wacom_wireless_work()
2516 hid_info(wacom->hdev, "ignoring unknown PID.\n"); in wacom_wireless_work()
2521 wacom_wac1->features = in wacom_wireless_work()
2522 *((struct wacom_features *)id->driver_data); in wacom_wireless_work()
2524 wacom_wac1->pid = wacom_wac->pid; in wacom_wireless_work()
2531 if (wacom_wac1->features.touch_max || in wacom_wireless_work()
2532 (wacom_wac1->features.type >= INTUOSHT && in wacom_wireless_work()
2533 wacom_wac1->features.type <= BAMBOO_PT)) { in wacom_wireless_work()
2534 wacom_wac2->features = in wacom_wireless_work()
2535 *((struct wacom_features *)id->driver_data); in wacom_wireless_work()
2536 wacom_wac2->pid = wacom_wac->pid; in wacom_wireless_work()
2543 if (strscpy(wacom_wac->name, wacom_wac1->name, in wacom_wireless_work()
2544 sizeof(wacom_wac->name)) < 0) { in wacom_wireless_work()
2545 hid_warn(wacom->hdev, "String overflow while assembling device name"); in wacom_wireless_work()
2559 struct wacom_remote *remote = wacom->remote; in wacom_remote_destroy_battery()
2561 if (remote->remotes[index].battery.battery) { in wacom_remote_destroy_battery()
2562 devres_release_group(&wacom->hdev->dev, in wacom_remote_destroy_battery()
2563 &remote->remotes[index].battery.bat_desc); in wacom_remote_destroy_battery()
2564 remote->remotes[index].battery.battery = NULL; in wacom_remote_destroy_battery()
2565 remote->remotes[index].active_time = 0; in wacom_remote_destroy_battery()
2571 struct wacom_remote *remote = wacom->remote; in wacom_remote_destroy_one()
2572 u32 serial = remote->remotes[index].serial; in wacom_remote_destroy_one() local
2577 if (remote->remotes[i].serial == serial) { in wacom_remote_destroy_one()
2579 spin_lock_irqsave(&remote->remote_lock, flags); in wacom_remote_destroy_one()
2580 remote->remotes[i].registered = false; in wacom_remote_destroy_one()
2581 spin_unlock_irqrestore(&remote->remote_lock, flags); in wacom_remote_destroy_one()
2585 if (remote->remotes[i].group.name) in wacom_remote_destroy_one()
2586 devres_release_group(&wacom->hdev->dev, in wacom_remote_destroy_one()
2587 &remote->remotes[i]); in wacom_remote_destroy_one()
2589 remote->remotes[i].serial = 0; in wacom_remote_destroy_one()
2590 remote->remotes[i].group.name = NULL; in wacom_remote_destroy_one()
2591 wacom->led.groups[i].select = WACOM_STATUS_UNKNOWN; in wacom_remote_destroy_one()
2596 static int wacom_remote_create_one(struct wacom *wacom, u32 serial, in wacom_remote_create_one() argument
2599 struct wacom_remote *remote = wacom->remote; in wacom_remote_create_one()
2600 struct device *dev = &wacom->hdev->dev; in wacom_remote_create_one()
2604 * check to make sure this serial isn't already paired. in wacom_remote_create_one()
2607 if (remote->remotes[k].serial == serial) in wacom_remote_create_one()
2612 remote->remotes[index].serial = serial; in wacom_remote_create_one()
2616 if (!devres_open_group(dev, &remote->remotes[index], GFP_KERNEL)) in wacom_remote_create_one()
2617 return -ENOMEM; in wacom_remote_create_one()
2619 error = wacom_remote_create_attr_group(wacom, serial, index); in wacom_remote_create_one()
2623 remote->remotes[index].input = wacom_allocate_input(wacom); in wacom_remote_create_one()
2624 if (!remote->remotes[index].input) { in wacom_remote_create_one()
2625 error = -ENOMEM; in wacom_remote_create_one()
2628 remote->remotes[index].input->uniq = remote->remotes[index].group.name; in wacom_remote_create_one()
2629 remote->remotes[index].input->name = wacom->wacom_wac.pad_name; in wacom_remote_create_one()
2631 if (!remote->remotes[index].input->name) { in wacom_remote_create_one()
2632 error = -EINVAL; in wacom_remote_create_one()
2636 error = wacom_setup_pad_input_capabilities(remote->remotes[index].input, in wacom_remote_create_one()
2637 &wacom->wacom_wac); in wacom_remote_create_one()
2641 remote->remotes[index].serial = serial; in wacom_remote_create_one()
2643 error = input_register_device(remote->remotes[index].input); in wacom_remote_create_one()
2648 &remote->remotes[index].input->dev, in wacom_remote_create_one()
2653 remote->remotes[index].registered = true; in wacom_remote_create_one()
2655 devres_close_group(dev, &remote->remotes[index]); in wacom_remote_create_one()
2659 devres_release_group(dev, &remote->remotes[index]); in wacom_remote_create_one()
2660 remote->remotes[index].serial = 0; in wacom_remote_create_one()
2666 struct wacom_remote *remote = wacom->remote; in wacom_remote_attach_battery()
2669 if (!remote->remotes[index].registered) in wacom_remote_attach_battery()
2672 if (remote->remotes[index].battery.battery) in wacom_remote_attach_battery()
2675 if (!remote->remotes[index].active_time) in wacom_remote_attach_battery()
2678 if (wacom->led.groups[index].select == WACOM_STATUS_UNKNOWN) in wacom_remote_attach_battery()
2682 &wacom->remote->remotes[index].battery); in wacom_remote_attach_battery()
2692 struct wacom_remote *remote = wacom->remote; in wacom_remote_work()
2700 spin_lock_irqsave(&remote->remote_lock, flags); in wacom_remote_work()
2702 count = kfifo_out(&remote->remote_fifo, &remote_work_data, in wacom_remote_work()
2706 hid_err(wacom->hdev, in wacom_remote_work()
2708 spin_unlock_irqrestore(&remote->remote_lock, flags); in wacom_remote_work()
2712 if (!kfifo_is_empty(&remote->remote_fifo)) in wacom_remote_work()
2713 wacom_schedule_work(&wacom->wacom_wac, WACOM_WORKER_REMOTE); in wacom_remote_work()
2715 spin_unlock_irqrestore(&remote->remote_lock, flags); in wacom_remote_work()
2718 work_serial = remote_work_data.remote[i].serial; in wacom_remote_work()
2721 if (kt - remote->remotes[i].active_time > WACOM_REMOTE_BATTERY_TIMEOUT in wacom_remote_work()
2722 && remote->remotes[i].active_time != 0) in wacom_remote_work()
2725 if (remote->remotes[i].serial == work_serial) { in wacom_remote_work()
2730 if (remote->remotes[i].serial) in wacom_remote_work()
2735 } else if (remote->remotes[i].serial) { in wacom_remote_work()
2744 struct wacom_shared *shared = wacom->wacom_wac.shared; in wacom_mode_change_work()
2747 bool is_direct = wacom->wacom_wac.is_direct_mode; in wacom_mode_change_work()
2750 if (shared->pen) { in wacom_mode_change_work()
2751 wacom1 = hid_get_drvdata(shared->pen); in wacom_mode_change_work()
2753 hid_hw_stop(wacom1->hdev); in wacom_mode_change_work()
2754 wacom1->wacom_wac.has_mode_change = true; in wacom_mode_change_work()
2755 wacom1->wacom_wac.is_direct_mode = is_direct; in wacom_mode_change_work()
2758 if (shared->touch) { in wacom_mode_change_work()
2759 wacom2 = hid_get_drvdata(shared->touch); in wacom_mode_change_work()
2761 hid_hw_stop(wacom2->hdev); in wacom_mode_change_work()
2762 wacom2->wacom_wac.has_mode_change = true; in wacom_mode_change_work()
2763 wacom2->wacom_wac.is_direct_mode = is_direct; in wacom_mode_change_work()
2789 if (!id->driver_data) in wacom_probe()
2790 return -EINVAL; in wacom_probe()
2792 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; in wacom_probe()
2794 /* hid-core sets this quirk for the boot interface */ in wacom_probe()
2795 hdev->quirks &= ~HID_QUIRK_NOGET; in wacom_probe()
2797 wacom = devm_kzalloc(&hdev->dev, sizeof(struct wacom), GFP_KERNEL); in wacom_probe()
2799 return -ENOMEM; in wacom_probe()
2802 wacom->hdev = hdev; in wacom_probe()
2804 wacom_wac = &wacom->wacom_wac; in wacom_probe()
2805 wacom_wac->features = *((struct wacom_features *)id->driver_data); in wacom_probe()
2806 features = &wacom_wac->features; in wacom_probe()
2808 if (features->check_for_hid_type && features->hid_type != hdev->type) in wacom_probe()
2809 return -ENODEV; in wacom_probe()
2815 wacom_wac->hid_data.inputmode = -1; in wacom_probe()
2816 wacom_wac->mode_report = -1; in wacom_probe()
2819 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); in wacom_probe()
2822 wacom->usbdev = dev; in wacom_probe()
2823 wacom->intf = intf; in wacom_probe()
2826 mutex_init(&wacom->lock); in wacom_probe()
2827 INIT_DELAYED_WORK(&wacom->init_work, wacom_init_work); in wacom_probe()
2828 INIT_DELAYED_WORK(&wacom->aes_battery_work, wacom_aes_battery_handler); in wacom_probe()
2829 INIT_WORK(&wacom->wireless_work, wacom_wireless_work); in wacom_probe()
2830 INIT_WORK(&wacom->battery_work, wacom_battery_work); in wacom_probe()
2831 INIT_WORK(&wacom->remote_work, wacom_remote_work); in wacom_probe()
2832 INIT_WORK(&wacom->mode_change_work, wacom_mode_change_work); in wacom_probe()
2833 timer_setup(&wacom->idleprox_timer, &wacom_idleprox_timeout, TIMER_DEFERRABLE); in wacom_probe()
2842 if (features->type == BOOTLOADER) { in wacom_probe()
2843 hid_warn(hdev, "Using device in hidraw-only mode"); in wacom_probe()
2851 if (hdev->bus == BUS_BLUETOOTH) { in wacom_probe()
2852 error = device_create_file(&hdev->dev, &dev_attr_speed); in wacom_probe()
2859 wacom_wac->probe_complete = true; in wacom_probe()
2866 struct wacom_wac *wacom_wac = &wacom->wacom_wac; in wacom_remove()
2867 struct wacom_features *features = &wacom_wac->features; in wacom_remove()
2869 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR) in wacom_remove()
2874 cancel_delayed_work_sync(&wacom->init_work); in wacom_remove()
2875 cancel_work_sync(&wacom->wireless_work); in wacom_remove()
2876 cancel_work_sync(&wacom->battery_work); in wacom_remove()
2877 cancel_work_sync(&wacom->remote_work); in wacom_remove()
2878 cancel_work_sync(&wacom->mode_change_work); in wacom_remove()
2879 del_timer_sync(&wacom->idleprox_timer); in wacom_remove()
2880 if (hdev->bus == BUS_BLUETOOTH) in wacom_remove()
2881 device_remove_file(&hdev->dev, &dev_attr_speed); in wacom_remove()
2883 /* make sure we don't trigger the LEDs */ in wacom_remove()
2886 if (wacom->wacom_wac.features.type != REMOTE) in wacom_remove()
2895 mutex_lock(&wacom->lock); in wacom_resume()
2901 mutex_unlock(&wacom->lock); in wacom_resume()