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