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 ssize_t wacom_show_speed(struct device *dev,
1817	struct device_attribute
1818	*attr, char *buf)
1819	{
1820	struct hid_device *hdev = to_hid_device(dev);
1821	struct wacom *wacom = hid_get_drvdata(hdev);
1822
1823	return sysfs_emit(buf, fmt: "%i\n", wacom->wacom_wac.bt_high_speed);
1824	}
1825
1826	static ssize_t wacom_store_speed(struct device *dev,
1827	struct device_attribute *attr,
1828	const char *buf, size_t count)
1829	{
1830	struct hid_device *hdev = to_hid_device(dev);
1831	struct wacom *wacom = hid_get_drvdata(hdev);
1832	u8 new_speed;
1833
1834	if (kstrtou8(s: buf, base: 0, res: &new_speed))
1835	return -EINVAL;
1836
1837	if (new_speed != 0 && new_speed != 1)
1838	return -EINVAL;
1839
1840	wacom_bt_query_tablet_data(hdev, speed: new_speed, features: &wacom->wacom_wac.features);
1841
1842	return count;
1843	}
1844
1845	static DEVICE_ATTR(speed, DEV_ATTR_RW_PERM,
1846	wacom_show_speed, wacom_store_speed);
1847
1848
1849	static ssize_t wacom_show_remote_mode(struct kobject *kobj,
1850	struct kobj_attribute *kattr,
1851	char *buf, int index)
1852	{
1853	struct device *dev = kobj_to_dev(kobj->parent);
1854	struct hid_device *hdev = to_hid_device(dev);
1855	struct wacom *wacom = hid_get_drvdata(hdev);
1856	u8 mode;
1857
1858	mode = wacom->led.groups[index].select;
1859	return sprintf(buf, fmt: "%d\n", mode < 3 ? mode : -1);
1860	}
1861
1862	#define DEVICE_EKR_ATTR_GROUP(SET_ID) \
1863	static ssize_t wacom_show_remote##SET_ID##_mode(struct kobject *kobj, \
1864	struct kobj_attribute *kattr, char *buf) \
1865	{ \
1866	return wacom_show_remote_mode(kobj, kattr, buf, SET_ID); \
1867	} \
1868	static struct kobj_attribute remote##SET_ID##_mode_attr = { \
1869	.attr = {.name = "remote_mode", \
1870	.mode = DEV_ATTR_RO_PERM}, \
1871	.show = wacom_show_remote##SET_ID##_mode, \
1872	}; \
1873	static struct attribute *remote##SET_ID##_serial_attrs[] = { \
1874	&remote##SET_ID##_mode_attr.attr, \
1875	NULL \
1876	}; \
1877	static const struct attribute_group remote##SET_ID##_serial_group = { \
1878	.name = NULL, \
1879	.attrs = remote##SET_ID##_serial_attrs, \
1880	}
1881
1882	DEVICE_EKR_ATTR_GROUP(0);
1883	DEVICE_EKR_ATTR_GROUP(1);
1884	DEVICE_EKR_ATTR_GROUP(2);
1885	DEVICE_EKR_ATTR_GROUP(3);
1886	DEVICE_EKR_ATTR_GROUP(4);
1887
1888	static int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
1889	int index)
1890	{
1891	int error = 0;
1892	struct wacom_remote *remote = wacom->remote;
1893
1894	remote->remotes[index].group.name = devm_kasprintf(dev: &wacom->hdev->dev,
1895	GFP_KERNEL,
1896	fmt: "%d", serial);
1897	if (!remote->remotes[index].group.name)
1898	return -ENOMEM;
1899
1900	error = __wacom_devm_sysfs_create_group(wacom, root: remote->remote_dir,
1901	group: &remote->remotes[index].group);
1902	if (error) {
1903	remote->remotes[index].group.name = NULL;
1904	hid_err(wacom->hdev,
1905	"cannot create sysfs group err: %d\n", error);
1906	return error;
1907	}
1908
1909	return 0;
1910	}
1911
1912	static int wacom_cmd_unpair_remote(struct wacom *wacom, unsigned char selector)
1913	{
1914	const size_t buf_size = 2;
1915	unsigned char *buf;
1916	int retval;
1917
1918	buf = kzalloc(size: buf_size, GFP_KERNEL);
1919	if (!buf)
1920	return -ENOMEM;
1921
1922	buf[0] = WAC_CMD_DELETE_PAIRING;
1923	buf[1] = selector;
1924
1925	retval = wacom_set_report(hdev: wacom->hdev, type: HID_OUTPUT_REPORT, buf,
1926	size: buf_size, WAC_CMD_RETRIES);
1927	kfree(objp: buf);
1928
1929	return retval;
1930	}
1931
1932	static ssize_t wacom_store_unpair_remote(struct kobject *kobj,
1933	struct kobj_attribute *attr,
1934	const char *buf, size_t count)
1935	{
1936	unsigned char selector = 0;
1937	struct device *dev = kobj_to_dev(kobj->parent);
1938	struct hid_device *hdev = to_hid_device(dev);
1939	struct wacom *wacom = hid_get_drvdata(hdev);
1940	int err;
1941
1942	if (!strncmp(buf, "*\n", 2)) {
1943	selector = WAC_CMD_UNPAIR_ALL;
1944	} else {
1945	hid_info(wacom->hdev, "remote: unrecognized unpair code: %s\n",
1946	buf);
1947	return -1;
1948	}
1949
1950	mutex_lock(&wacom->lock);
1951
1952	err = wacom_cmd_unpair_remote(wacom, selector);
1953	mutex_unlock(lock: &wacom->lock);
1954
1955	return err < 0 ? err : count;
1956	}
1957
1958	static struct kobj_attribute unpair_remote_attr = {
1959	.attr = {.name = "unpair_remote", .mode = 0200},
1960	.store = wacom_store_unpair_remote,
1961	};
1962
1963	static const struct attribute *remote_unpair_attrs[] = {
1964	&unpair_remote_attr.attr,
1965	NULL
1966	};
1967
1968	static void wacom_remotes_destroy(void *data)
1969	{
1970	struct wacom *wacom = data;
1971	struct wacom_remote *remote = wacom->remote;
1972
1973	if (!remote)
1974	return;
1975
1976	kobject_put(kobj: remote->remote_dir);
1977	kfifo_free(&remote->remote_fifo);
1978	wacom->remote = NULL;
1979	}
1980
1981	static int wacom_initialize_remotes(struct wacom *wacom)
1982	{
1983	int error = 0;
1984	struct wacom_remote *remote;
1985	int i;
1986
1987	if (wacom->wacom_wac.features.type != REMOTE)
1988	return 0;
1989
1990	remote = devm_kzalloc(dev: &wacom->hdev->dev, size: sizeof(*wacom->remote),
1991	GFP_KERNEL);
1992	if (!remote)
1993	return -ENOMEM;
1994
1995	wacom->remote = remote;
1996
1997	spin_lock_init(&remote->remote_lock);
1998
1999	error = kfifo_alloc(&remote->remote_fifo,
2000	5 * sizeof(struct wacom_remote_work_data),
2001	GFP_KERNEL);
2002	if (error) {
2003	hid_err(wacom->hdev, "failed allocating remote_fifo\n");
2004	return -ENOMEM;
2005	}
2006
2007	remote->remotes[0].group = remote0_serial_group;
2008	remote->remotes[1].group = remote1_serial_group;
2009	remote->remotes[2].group = remote2_serial_group;
2010	remote->remotes[3].group = remote3_serial_group;
2011	remote->remotes[4].group = remote4_serial_group;
2012
2013	remote->remote_dir = kobject_create_and_add(name: "wacom_remote",
2014	parent: &wacom->hdev->dev.kobj);
2015	if (!remote->remote_dir)
2016	return -ENOMEM;
2017
2018	error = sysfs_create_files(kobj: remote->remote_dir, attr: remote_unpair_attrs);
2019
2020	if (error) {
2021	hid_err(wacom->hdev,
2022	"cannot create sysfs group err: %d\n", error);
2023	return error;
2024	}
2025
2026	for (i = 0; i < WACOM_MAX_REMOTES; i++) {
2027	wacom->led.groups[i].select = WACOM_STATUS_UNKNOWN;
2028	remote->remotes[i].serial = 0;
2029	}
2030
2031	error = devm_add_action_or_reset(&wacom->hdev->dev,
2032	wacom_remotes_destroy, wacom);
2033	if (error)
2034	return error;
2035
2036	return 0;
2037	}
2038
2039	static struct input_dev *wacom_allocate_input(struct wacom *wacom)
2040	{
2041	struct input_dev *input_dev;
2042	struct hid_device *hdev = wacom->hdev;
2043	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
2044
2045	input_dev = devm_input_allocate_device(&hdev->dev);
2046	if (!input_dev)
2047	return NULL;
2048
2049	input_dev->name = wacom_wac->features.name;
2050	input_dev->phys = hdev->phys;
2051	input_dev->dev.parent = &hdev->dev;
2052	input_dev->open = wacom_open;
2053	input_dev->close = wacom_close;
2054	input_dev->uniq = hdev->uniq;
2055	input_dev->id.bustype = hdev->bus;
2056	input_dev->id.vendor = hdev->vendor;
2057	input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product;
2058	input_dev->id.version = hdev->version;
2059	input_set_drvdata(dev: input_dev, data: wacom);
2060
2061	return input_dev;
2062	}
2063
2064	static int wacom_allocate_inputs(struct wacom *wacom)
2065	{
2066	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
2067
2068	wacom_wac->pen_input = wacom_allocate_input(wacom);
2069	wacom_wac->touch_input = wacom_allocate_input(wacom);
2070	wacom_wac->pad_input = wacom_allocate_input(wacom);
2071	if (!wacom_wac->pen_input ||
2072	!wacom_wac->touch_input ||
2073	!wacom_wac->pad_input)
2074	return -ENOMEM;
2075
2076	wacom_wac->pen_input->name = wacom_wac->pen_name;
2077	wacom_wac->touch_input->name = wacom_wac->touch_name;
2078	wacom_wac->pad_input->name = wacom_wac->pad_name;
2079
2080	return 0;
2081	}
2082
2083	static int wacom_register_inputs(struct wacom *wacom)
2084	{
2085	struct input_dev *pen_input_dev, *touch_input_dev, *pad_input_dev;
2086	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
2087	int error = 0;
2088
2089	pen_input_dev = wacom_wac->pen_input;
2090	touch_input_dev = wacom_wac->touch_input;
2091	pad_input_dev = wacom_wac->pad_input;
2092
2093	if (!pen_input_dev || !touch_input_dev || !pad_input_dev)
2094	return -EINVAL;
2095
2096	error = wacom_setup_pen_input_capabilities(input_dev: pen_input_dev, wacom_wac);
2097	if (error) {
2098	/* no pen in use on this interface */
2099	input_free_device(dev: pen_input_dev);
2100	wacom_wac->pen_input = NULL;
2101	pen_input_dev = NULL;
2102	} else {
2103	error = input_register_device(pen_input_dev);
2104	if (error)
2105	goto fail;
2106	}
2107
2108	error = wacom_setup_touch_input_capabilities(input_dev: touch_input_dev, wacom_wac);
2109	if (error) {
2110	/* no touch in use on this interface */
2111	input_free_device(dev: touch_input_dev);
2112	wacom_wac->touch_input = NULL;
2113	touch_input_dev = NULL;
2114	} else {
2115	error = input_register_device(touch_input_dev);
2116	if (error)
2117	goto fail;
2118	}
2119
2120	error = wacom_setup_pad_input_capabilities(input_dev: pad_input_dev, wacom_wac);
2121	if (error) {
2122	/* no pad events using this interface */
2123	input_free_device(dev: pad_input_dev);
2124	wacom_wac->pad_input = NULL;
2125	pad_input_dev = NULL;
2126	} else {
2127	error = input_register_device(pad_input_dev);
2128	if (error)
2129	goto fail;
2130	}
2131
2132	return 0;
2133
2134	fail:
2135	wacom_wac->pad_input = NULL;
2136	wacom_wac->touch_input = NULL;
2137	wacom_wac->pen_input = NULL;
2138	return error;
2139	}
2140
2141	/*
2142	* Not all devices report physical dimensions from HID.
2143	* Compute the default from hardcoded logical dimension
2144	* and resolution before driver overwrites them.
2145	*/
2146	static void wacom_set_default_phy(struct wacom_features *features)
2147	{
2148	if (features->x_resolution) {
2149	features->x_phy = (features->x_max * 100) /
2150	features->x_resolution;
2151	features->y_phy = (features->y_max * 100) /
2152	features->y_resolution;
2153	}
2154	}
2155
2156	static void wacom_calculate_res(struct wacom_features *features)
2157	{
2158	/* set unit to "100th of a mm" for devices not reported by HID */
2159	if (!features->unit) {
2160	features->unit = 0x11;
2161	features->unitExpo = -3;
2162	}
2163
2164	features->x_resolution = wacom_calc_hid_res(logical_extents: features->x_max,
2165	physical_extents: features->x_phy,
2166	unit: features->unit,
2167	exponent: features->unitExpo);
2168	features->y_resolution = wacom_calc_hid_res(logical_extents: features->y_max,
2169	physical_extents: features->y_phy,
2170	unit: features->unit,
2171	exponent: features->unitExpo);
2172	}
2173
2174	void wacom_battery_work(struct work_struct *work)
2175	{
2176	struct wacom *wacom = container_of(work, struct wacom, battery_work);
2177
2178	if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
2179	!wacom->battery.battery) {
2180	wacom_initialize_battery(wacom);
2181	}
2182	else if (!(wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
2183	wacom->battery.battery) {
2184	wacom_destroy_battery(wacom);
2185	}
2186	}
2187
2188	static size_t wacom_compute_pktlen(struct hid_device *hdev)
2189	{
2190	struct hid_report_enum *report_enum;
2191	struct hid_report *report;
2192	size_t size = 0;
2193
2194	report_enum = hdev->report_enum + HID_INPUT_REPORT;
2195
2196	list_for_each_entry(report, &report_enum->report_list, list) {
2197	size_t report_size = hid_report_len(report);
2198	if (report_size > size)
2199	size = report_size;
2200	}
2201
2202	return size;
2203	}
2204
2205	static void wacom_update_name(struct wacom *wacom, const char *suffix)
2206	{
2207	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2208	struct wacom_features *features = &wacom_wac->features;
2209	char name[WACOM_NAME_MAX - 20]; /* Leave some room for suffixes */
2210
2211	/* Generic devices name unspecified */
2212	if ((features->type == HID_GENERIC) && !strcmp("Wacom HID", features->name)) {
2213	char *product_name = wacom->hdev->name;
2214
2215	if (hid_is_usb(hdev: wacom->hdev)) {
2216	struct usb_interface *intf = to_usb_interface(wacom->hdev->dev.parent);
2217	struct usb_device *dev = interface_to_usbdev(intf);
2218	product_name = dev->product;
2219	}
2220
2221	if (wacom->hdev->bus == BUS_I2C) {
2222	snprintf(buf: name, size: sizeof(name), fmt: "%s %X",
2223	features->name, wacom->hdev->product);
2224	} else if (strstr(product_name, "Wacom") ||
2225	strstr(product_name, "wacom") ||
2226	strstr(product_name, "WACOM")) {
2227	if (strscpy(p: name, q: product_name, size: sizeof(name)) < 0) {
2228	hid_warn(wacom->hdev, "String overflow while assembling device name");
2229	}
2230	} else {
2231	snprintf(buf: name, size: sizeof(name), fmt: "Wacom %s", product_name);
2232	}
2233
2234	/* strip out excess whitespaces */
2235	while (1) {
2236	char *gap = strstr(name, " ");
2237	if (gap == NULL)
2238	break;
2239	/* shift everything including the terminator */
2240	memmove(gap, gap+1, strlen(gap));
2241	}
2242
2243	/* get rid of trailing whitespace */
2244	if (name[strlen(name)-1] == ' ')
2245	name[strlen(name)-1] = '\0';
2246	} else {
2247	if (strscpy(p: name, q: features->name, size: sizeof(name)) < 0) {
2248	hid_warn(wacom->hdev, "String overflow while assembling device name");
2249	}
2250	}
2251
2252	snprintf(buf: wacom_wac->name, size: sizeof(wacom_wac->name), fmt: "%s%s",
2253	name, suffix);
2254
2255	/* Append the device type to the name */
2256	snprintf(buf: wacom_wac->pen_name, size: sizeof(wacom_wac->pen_name),
2257	fmt: "%s%s Pen", name, suffix);
2258	snprintf(buf: wacom_wac->touch_name, size: sizeof(wacom_wac->touch_name),
2259	fmt: "%s%s Finger", name, suffix);
2260	snprintf(buf: wacom_wac->pad_name, size: sizeof(wacom_wac->pad_name),
2261	fmt: "%s%s Pad", name, suffix);
2262	}
2263
2264	static void wacom_release_resources(struct wacom *wacom)
2265	{
2266	struct hid_device *hdev = wacom->hdev;
2267
2268	if (!wacom->resources)
2269	return;
2270
2271	devres_release_group(dev: &hdev->dev, id: wacom);
2272
2273	wacom->resources = false;
2274
2275	wacom->wacom_wac.pen_input = NULL;
2276	wacom->wacom_wac.touch_input = NULL;
2277	wacom->wacom_wac.pad_input = NULL;
2278	}
2279
2280	static void wacom_set_shared_values(struct wacom_wac *wacom_wac)
2281	{
2282	if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH) {
2283	wacom_wac->shared->type = wacom_wac->features.type;
2284	wacom_wac->shared->touch_input = wacom_wac->touch_input;
2285	}
2286
2287	if (wacom_wac->has_mute_touch_switch) {
2288	wacom_wac->shared->has_mute_touch_switch = true;
2289	/* Hardware touch switch may be off. Wait until
2290	* we know the switch state to decide is_touch_on.
2291	* Softkey state should be initialized to "on" to
2292	* match historic default.
2293	*/
2294	if (wacom_wac->is_soft_touch_switch)
2295	wacom_wac->shared->is_touch_on = true;
2296	}
2297
2298	if (wacom_wac->shared->has_mute_touch_switch &&
2299	wacom_wac->shared->touch_input) {
2300	set_bit(EV_SW, addr: wacom_wac->shared->touch_input->evbit);
2301	input_set_capability(dev: wacom_wac->shared->touch_input, EV_SW,
2302	SW_MUTE_DEVICE);
2303	}
2304	}
2305
2306	static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
2307	{
2308	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2309	struct wacom_features *features = &wacom_wac->features;
2310	struct hid_device *hdev = wacom->hdev;
2311	int error;
2312	unsigned int connect_mask = HID_CONNECT_HIDRAW;
2313
2314	features->pktlen = wacom_compute_pktlen(hdev);
2315	if (features->pktlen > WACOM_PKGLEN_MAX)
2316	return -EINVAL;
2317
2318	if (!devres_open_group(dev: &hdev->dev, id: wacom, GFP_KERNEL))
2319	return -ENOMEM;
2320
2321	wacom->resources = true;
2322
2323	error = wacom_allocate_inputs(wacom);
2324	if (error)
2325	goto fail;
2326
2327	/*
2328	* Bamboo Pad has a generic hid handling for the Pen, and we switch it
2329	* into debug mode for the touch part.
2330	* We ignore the other interfaces.
2331	*/
2332	if (features->type == BAMBOO_PAD) {
2333	if (features->pktlen == WACOM_PKGLEN_PENABLED) {
2334	features->type = HID_GENERIC;
2335	} else if ((features->pktlen != WACOM_PKGLEN_BPAD_TOUCH) &&
2336	(features->pktlen != WACOM_PKGLEN_BPAD_TOUCH_USB)) {
2337	error = -ENODEV;
2338	goto fail;
2339	}
2340	}
2341
2342	/* set the default size in case we do not get them from hid */
2343	wacom_set_default_phy(features);
2344
2345	/* Retrieve the physical and logical size for touch devices */
2346	wacom_retrieve_hid_descriptor(hdev, features);
2347	wacom_setup_device_quirks(wacom);
2348
2349	if (features->device_type == WACOM_DEVICETYPE_NONE &&
2350	features->type != WIRELESS) {
2351	error = features->type == HID_GENERIC ? -ENODEV : 0;
2352
2353	dev_warn(&hdev->dev, "Unknown device_type for '%s'. %s.",
2354	hdev->name,
2355	error ? "Ignoring" : "Assuming pen");
2356
2357	if (error)
2358	goto fail;
2359
2360	features->device_type |= WACOM_DEVICETYPE_PEN;
2361	}
2362
2363	wacom_calculate_res(features);
2364
2365	wacom_update_name(wacom, suffix: wireless ? " (WL)" : "");
2366
2367	/* pen only Bamboo neither support touch nor pad */
2368	if ((features->type == BAMBOO_PEN) &&
2369	((features->device_type & WACOM_DEVICETYPE_TOUCH) ||
2370	(features->device_type & WACOM_DEVICETYPE_PAD))) {
2371	error = -ENODEV;
2372	goto fail;
2373	}
2374
2375	error = wacom_add_shared_data(hdev);
2376	if (error)
2377	goto fail;
2378
2379	error = wacom_register_inputs(wacom);
2380	if (error)
2381	goto fail;
2382
2383	if (wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD) {
2384	error = wacom_initialize_leds(wacom);
2385	if (error)
2386	goto fail;
2387
2388	error = wacom_initialize_remotes(wacom);
2389	if (error)
2390	goto fail;
2391	}
2392
2393	if (features->type == HID_GENERIC)
2394	connect_mask |= HID_CONNECT_DRIVER;
2395
2396	/* Regular HID work starts now */
2397	error = hid_hw_start(hdev, connect_mask);
2398	if (error) {
2399	hid_err(hdev, "hw start failed\n");
2400	goto fail;
2401	}
2402
2403	if (!wireless) {
2404	/* Note that if query fails it is not a hard failure */
2405	wacom_query_tablet_data(wacom);
2406	}
2407
2408	/* touch only Bamboo doesn't support pen */
2409	if ((features->type == BAMBOO_TOUCH) &&
2410	(features->device_type & WACOM_DEVICETYPE_PEN)) {
2411	cancel_delayed_work_sync(dwork: &wacom->init_work);
2412	_wacom_query_tablet_data(wacom);
2413	error = -ENODEV;
2414	goto fail_quirks;
2415	}
2416
2417	if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR) {
2418	error = hid_hw_open(hdev);
2419	if (error) {
2420	hid_err(hdev, "hw open failed\n");
2421	goto fail_quirks;
2422	}
2423	}
2424
2425	wacom_set_shared_values(wacom_wac);
2426	devres_close_group(dev: &hdev->dev, id: wacom);
2427
2428	return 0;
2429
2430	fail_quirks:
2431	hid_hw_stop(hdev);
2432	fail:
2433	wacom_release_resources(wacom);
2434	return error;
2435	}
2436
2437	static void wacom_wireless_work(struct work_struct *work)
2438	{
2439	struct wacom *wacom = container_of(work, struct wacom, wireless_work);
2440	struct usb_device *usbdev = wacom->usbdev;
2441	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2442	struct hid_device *hdev1, *hdev2;
2443	struct wacom *wacom1, *wacom2;
2444	struct wacom_wac *wacom_wac1, *wacom_wac2;
2445	int error;
2446
2447	/*
2448	* Regardless if this is a disconnect or a new tablet,
2449	* remove any existing input and battery devices.
2450	*/
2451
2452	wacom_destroy_battery(wacom);
2453
2454	if (!usbdev)
2455	return;
2456
2457	/* Stylus interface */
2458	hdev1 = usb_get_intfdata(intf: usbdev->config->interface[1]);
2459	wacom1 = hid_get_drvdata(hdev: hdev1);
2460	wacom_wac1 = &(wacom1->wacom_wac);
2461	wacom_release_resources(wacom: wacom1);
2462
2463	/* Touch interface */
2464	hdev2 = usb_get_intfdata(intf: usbdev->config->interface[2]);
2465	wacom2 = hid_get_drvdata(hdev: hdev2);
2466	wacom_wac2 = &(wacom2->wacom_wac);
2467	wacom_release_resources(wacom: wacom2);
2468
2469	if (wacom_wac->pid == 0) {
2470	hid_info(wacom->hdev, "wireless tablet disconnected\n");
2471	} else {
2472	const struct hid_device_id *id = wacom_ids;
2473
2474	hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
2475	wacom_wac->pid);
2476
2477	while (id->bus) {
2478	if (id->vendor == USB_VENDOR_ID_WACOM &&
2479	id->product == wacom_wac->pid)
2480	break;
2481	id++;
2482	}
2483
2484	if (!id->bus) {
2485	hid_info(wacom->hdev, "ignoring unknown PID.\n");
2486	return;
2487	}
2488
2489	/* Stylus interface */
2490	wacom_wac1->features =
2491	*((struct wacom_features *)id->driver_data);
2492
2493	wacom_wac1->pid = wacom_wac->pid;
2494	hid_hw_stop(hdev: hdev1);
2495	error = wacom_parse_and_register(wacom: wacom1, wireless: true);
2496	if (error)
2497	goto fail;
2498
2499	/* Touch interface */
2500	if (wacom_wac1->features.touch_max ||
2501	(wacom_wac1->features.type >= INTUOSHT &&
2502	wacom_wac1->features.type <= BAMBOO_PT)) {
2503	wacom_wac2->features =
2504	*((struct wacom_features *)id->driver_data);
2505	wacom_wac2->pid = wacom_wac->pid;
2506	hid_hw_stop(hdev: hdev2);
2507	error = wacom_parse_and_register(wacom: wacom2, wireless: true);
2508	if (error)
2509	goto fail;
2510	}
2511
2512	if (strscpy(p: wacom_wac->name, q: wacom_wac1->name,
2513	size: sizeof(wacom_wac->name)) < 0) {
2514	hid_warn(wacom->hdev, "String overflow while assembling device name");
2515	}
2516	}
2517
2518	return;
2519
2520	fail:
2521	wacom_release_resources(wacom: wacom1);
2522	wacom_release_resources(wacom: wacom2);
2523	return;
2524	}
2525
2526	static void wacom_remote_destroy_battery(struct wacom *wacom, int index)
2527	{
2528	struct wacom_remote *remote = wacom->remote;
2529
2530	if (remote->remotes[index].battery.battery) {
2531	devres_release_group(dev: &wacom->hdev->dev,
2532	id: &remote->remotes[index].battery.bat_desc);
2533	remote->remotes[index].battery.battery = NULL;
2534	remote->remotes[index].active_time = 0;
2535	}
2536	}
2537
2538	static void wacom_remote_destroy_one(struct wacom *wacom, unsigned int index)
2539	{
2540	struct wacom_remote *remote = wacom->remote;
2541	u32 serial = remote->remotes[index].serial;
2542	int i;
2543	unsigned long flags;
2544
2545	for (i = 0; i < WACOM_MAX_REMOTES; i++) {
2546	if (remote->remotes[i].serial == serial) {
2547
2548	spin_lock_irqsave(&remote->remote_lock, flags);
2549	remote->remotes[i].registered = false;
2550	spin_unlock_irqrestore(lock: &remote->remote_lock, flags);
2551
2552	wacom_remote_destroy_battery(wacom, index: i);
2553
2554	if (remote->remotes[i].group.name)
2555	devres_release_group(dev: &wacom->hdev->dev,
2556	id: &remote->remotes[i]);
2557
2558	remote->remotes[i].serial = 0;
2559	remote->remotes[i].group.name = NULL;
2560	wacom->led.groups[i].select = WACOM_STATUS_UNKNOWN;
2561	}
2562	}
2563	}
2564
2565	static int wacom_remote_create_one(struct wacom *wacom, u32 serial,
2566	unsigned int index)
2567	{
2568	struct wacom_remote *remote = wacom->remote;
2569	struct device *dev = &wacom->hdev->dev;
2570	int error, k;
2571
2572	/* A remote can pair more than once with an EKR,
2573	* check to make sure this serial isn't already paired.
2574	*/
2575	for (k = 0; k < WACOM_MAX_REMOTES; k++) {
2576	if (remote->remotes[k].serial == serial)
2577	break;
2578	}
2579
2580	if (k < WACOM_MAX_REMOTES) {
2581	remote->remotes[index].serial = serial;
2582	return 0;
2583	}
2584
2585	if (!devres_open_group(dev, id: &remote->remotes[index], GFP_KERNEL))
2586	return -ENOMEM;
2587
2588	error = wacom_remote_create_attr_group(wacom, serial, index);
2589	if (error)
2590	goto fail;
2591
2592	remote->remotes[index].input = wacom_allocate_input(wacom);
2593	if (!remote->remotes[index].input) {
2594	error = -ENOMEM;
2595	goto fail;
2596	}
2597	remote->remotes[index].input->uniq = remote->remotes[index].group.name;
2598	remote->remotes[index].input->name = wacom->wacom_wac.pad_name;
2599
2600	if (!remote->remotes[index].input->name) {
2601	error = -EINVAL;
2602	goto fail;
2603	}
2604
2605	error = wacom_setup_pad_input_capabilities(input_dev: remote->remotes[index].input,
2606	wacom_wac: &wacom->wacom_wac);
2607	if (error)
2608	goto fail;
2609
2610	remote->remotes[index].serial = serial;
2611
2612	error = input_register_device(remote->remotes[index].input);
2613	if (error)
2614	goto fail;
2615
2616	error = wacom_led_groups_alloc_and_register_one(
2617	dev: &remote->remotes[index].input->dev,
2618	wacom, group_id: index, count: 3, read_only: true);
2619	if (error)
2620	goto fail;
2621
2622	remote->remotes[index].registered = true;
2623
2624	devres_close_group(dev, id: &remote->remotes[index]);
2625	return 0;
2626
2627	fail:
2628	devres_release_group(dev, id: &remote->remotes[index]);
2629	remote->remotes[index].serial = 0;
2630	return error;
2631	}
2632
2633	static int wacom_remote_attach_battery(struct wacom *wacom, int index)
2634	{
2635	struct wacom_remote *remote = wacom->remote;
2636	int error;
2637
2638	if (!remote->remotes[index].registered)
2639	return 0;
2640
2641	if (remote->remotes[index].battery.battery)
2642	return 0;
2643
2644	if (!remote->remotes[index].active_time)
2645	return 0;
2646
2647	if (wacom->led.groups[index].select == WACOM_STATUS_UNKNOWN)
2648	return 0;
2649
2650	error = __wacom_initialize_battery(wacom,
2651	battery: &wacom->remote->remotes[index].battery);
2652	if (error)
2653	return error;
2654
2655	return 0;
2656	}
2657
2658	static void wacom_remote_work(struct work_struct *work)
2659	{
2660	struct wacom *wacom = container_of(work, struct wacom, remote_work);
2661	struct wacom_remote *remote = wacom->remote;
2662	ktime_t kt = ktime_get();
2663	struct wacom_remote_work_data remote_work_data;
2664	unsigned long flags;
2665	unsigned int count;
2666	u32 work_serial;
2667	int i;
2668
2669	spin_lock_irqsave(&remote->remote_lock, flags);
2670
2671	count = kfifo_out(&remote->remote_fifo, &remote_work_data,
2672	sizeof(remote_work_data));
2673
2674	if (count != sizeof(remote_work_data)) {
2675	hid_err(wacom->hdev,
2676	"workitem triggered without status available\n");
2677	spin_unlock_irqrestore(lock: &remote->remote_lock, flags);
2678	return;
2679	}
2680
2681	if (!kfifo_is_empty(&remote->remote_fifo))
2682	wacom_schedule_work(wacom_wac: &wacom->wacom_wac, which: WACOM_WORKER_REMOTE);
2683
2684	spin_unlock_irqrestore(lock: &remote->remote_lock, flags);
2685
2686	for (i = 0; i < WACOM_MAX_REMOTES; i++) {
2687	work_serial = remote_work_data.remote[i].serial;
2688	if (work_serial) {
2689
2690	if (kt - remote->remotes[i].active_time > WACOM_REMOTE_BATTERY_TIMEOUT
2691	&& remote->remotes[i].active_time != 0)
2692	wacom_remote_destroy_battery(wacom, index: i);
2693
2694	if (remote->remotes[i].serial == work_serial) {
2695	wacom_remote_attach_battery(wacom, index: i);
2696	continue;
2697	}
2698
2699	if (remote->remotes[i].serial)
2700	wacom_remote_destroy_one(wacom, index: i);
2701
2702	wacom_remote_create_one(wacom, serial: work_serial, index: i);
2703
2704	} else if (remote->remotes[i].serial) {
2705	wacom_remote_destroy_one(wacom, index: i);
2706	}
2707	}
2708	}
2709
2710	static void wacom_mode_change_work(struct work_struct *work)
2711	{
2712	struct wacom *wacom = container_of(work, struct wacom, mode_change_work);
2713	struct wacom_shared *shared = wacom->wacom_wac.shared;
2714	struct wacom *wacom1 = NULL;
2715	struct wacom *wacom2 = NULL;
2716	bool is_direct = wacom->wacom_wac.is_direct_mode;
2717	int error = 0;
2718
2719	if (shared->pen) {
2720	wacom1 = hid_get_drvdata(hdev: shared->pen);
2721	wacom_release_resources(wacom: wacom1);
2722	hid_hw_stop(hdev: wacom1->hdev);
2723	wacom1->wacom_wac.has_mode_change = true;
2724	wacom1->wacom_wac.is_direct_mode = is_direct;
2725	}
2726
2727	if (shared->touch) {
2728	wacom2 = hid_get_drvdata(hdev: shared->touch);
2729	wacom_release_resources(wacom: wacom2);
2730	hid_hw_stop(hdev: wacom2->hdev);
2731	wacom2->wacom_wac.has_mode_change = true;
2732	wacom2->wacom_wac.is_direct_mode = is_direct;
2733	}
2734
2735	if (wacom1) {
2736	error = wacom_parse_and_register(wacom: wacom1, wireless: false);
2737	if (error)
2738	return;
2739	}
2740
2741	if (wacom2) {
2742	error = wacom_parse_and_register(wacom: wacom2, wireless: false);
2743	if (error)
2744	return;
2745	}
2746
2747	return;
2748	}
2749
2750	static int wacom_probe(struct hid_device *hdev,
2751	const struct hid_device_id *id)
2752	{
2753	struct wacom *wacom;
2754	struct wacom_wac *wacom_wac;
2755	struct wacom_features *features;
2756	int error;
2757
2758	if (!id->driver_data)
2759	return -EINVAL;
2760
2761	hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
2762
2763	/* hid-core sets this quirk for the boot interface */
2764	hdev->quirks &= ~HID_QUIRK_NOGET;
2765
2766	wacom = devm_kzalloc(dev: &hdev->dev, size: sizeof(struct wacom), GFP_KERNEL);
2767	if (!wacom)
2768	return -ENOMEM;
2769
2770	hid_set_drvdata(hdev, data: wacom);
2771	wacom->hdev = hdev;
2772
2773	wacom_wac = &wacom->wacom_wac;
2774	wacom_wac->features = *((struct wacom_features *)id->driver_data);
2775	features = &wacom_wac->features;
2776
2777	if (features->check_for_hid_type && features->hid_type != hdev->type)
2778	return -ENODEV;
2779
2780	error = wacom_devm_kfifo_alloc(wacom);
2781	if (error)
2782	return error;
2783
2784	wacom_wac->hid_data.inputmode = -1;
2785	wacom_wac->mode_report = -1;
2786
2787	if (hid_is_usb(hdev)) {
2788	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
2789	struct usb_device *dev = interface_to_usbdev(intf);
2790
2791	wacom->usbdev = dev;
2792	wacom->intf = intf;
2793	}
2794
2795	mutex_init(&wacom->lock);
2796	INIT_DELAYED_WORK(&wacom->init_work, wacom_init_work);
2797	INIT_WORK(&wacom->wireless_work, wacom_wireless_work);
2798	INIT_WORK(&wacom->battery_work, wacom_battery_work);
2799	INIT_WORK(&wacom->remote_work, wacom_remote_work);
2800	INIT_WORK(&wacom->mode_change_work, wacom_mode_change_work);
2801	timer_setup(&wacom->idleprox_timer, &wacom_idleprox_timeout, TIMER_DEFERRABLE);
2802
2803	/* ask for the report descriptor to be loaded by HID */
2804	error = hid_parse(hdev);
2805	if (error) {
2806	hid_err(hdev, "parse failed\n");
2807	return error;
2808	}
2809
2810	if (features->type == BOOTLOADER) {
2811	hid_warn(hdev, "Using device in hidraw-only mode");
2812	return hid_hw_start(hdev, HID_CONNECT_HIDRAW);
2813	}
2814
2815	error = wacom_parse_and_register(wacom, wireless: false);
2816	if (error)
2817	return error;
2818
2819	if (hdev->bus == BUS_BLUETOOTH) {
2820	error = device_create_file(device: &hdev->dev, entry: &dev_attr_speed);
2821	if (error)
2822	hid_warn(hdev,
2823	"can't create sysfs speed attribute err: %d\n",
2824	error);
2825	}
2826
2827	wacom_wac->probe_complete = true;
2828	return 0;
2829	}
2830
2831	static void wacom_remove(struct hid_device *hdev)
2832	{
2833	struct wacom *wacom = hid_get_drvdata(hdev);
2834	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2835	struct wacom_features *features = &wacom_wac->features;
2836
2837	if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR)
2838	hid_hw_close(hdev);
2839
2840	hid_hw_stop(hdev);
2841
2842	cancel_delayed_work_sync(dwork: &wacom->init_work);
2843	cancel_work_sync(work: &wacom->wireless_work);
2844	cancel_work_sync(work: &wacom->battery_work);
2845	cancel_work_sync(work: &wacom->remote_work);
2846	cancel_work_sync(work: &wacom->mode_change_work);
2847	del_timer_sync(timer: &wacom->idleprox_timer);
2848	if (hdev->bus == BUS_BLUETOOTH)
2849	device_remove_file(dev: &hdev->dev, attr: &dev_attr_speed);
2850
2851	/* make sure we don't trigger the LEDs */
2852	wacom_led_groups_release(data: wacom);
2853
2854	if (wacom->wacom_wac.features.type != REMOTE)
2855	wacom_release_resources(wacom);
2856	}
2857
2858	#ifdef CONFIG_PM
2859	static int wacom_resume(struct hid_device *hdev)
2860	{
2861	struct wacom *wacom = hid_get_drvdata(hdev);
2862
2863	mutex_lock(&wacom->lock);
2864
2865	/* switch to wacom mode first */
2866	_wacom_query_tablet_data(wacom);
2867	wacom_led_control(wacom);
2868
2869	mutex_unlock(lock: &wacom->lock);
2870
2871	return 0;
2872	}
2873
2874	static int wacom_reset_resume(struct hid_device *hdev)
2875	{
2876	return wacom_resume(hdev);
2877	}
2878	#endif /* CONFIG_PM */
2879
2880	static struct hid_driver wacom_driver = {
2881	.name = "wacom",
2882	.id_table = wacom_ids,
2883	.probe = wacom_probe,
2884	.remove = wacom_remove,
2885	.report = wacom_wac_report,
2886	#ifdef CONFIG_PM
2887	.resume = wacom_resume,
2888	.reset_resume = wacom_reset_resume,
2889	#endif
2890	.raw_event = wacom_raw_event,
2891	};
2892	module_hid_driver(wacom_driver);
2893
2894	MODULE_VERSION(DRIVER_VERSION);
2895	MODULE_AUTHOR(DRIVER_AUTHOR);
2896	MODULE_DESCRIPTION(DRIVER_DESC);
2897	MODULE_LICENSE("GPL");
2898