blob: a545c2451156dd7f54a81b072c6a2e95f757fa1e [file] [log] [blame]
Ping Cheng3bea7332006-07-13 18:01:36 -07001/*
Dmitry Torokhov4104d132007-05-07 16:16:29 -04002 * drivers/input/tablet/wacom_wac.c
Ping Cheng3bea7332006-07-13 18:01:36 -07003 *
Ping Chengee545002009-12-15 00:35:24 -08004 * USB Wacom tablet support - Wacom specific code
Ping Cheng3bea7332006-07-13 18:01:36 -07005 *
6 */
7
8/*
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 */
Dmitry Torokhov51269fe2010-03-19 22:18:15 -070014
Ping Cheng3bea7332006-07-13 18:01:36 -070015#include "wacom_wac.h"
Dmitry Torokhov51269fe2010-03-19 22:18:15 -070016#include "wacom.h"
Henrik Rydberg47c78e82010-11-27 09:16:48 +010017#include <linux/input/mt.h>
Ping Cheng3bea7332006-07-13 18:01:36 -070018
Ping Chenge35fb8c2011-03-26 21:16:05 -070019/* resolution for penabled devices */
20#define WACOM_PL_RES 20
21#define WACOM_PENPRTN_RES 40
22#define WACOM_VOLITO_RES 50
23#define WACOM_GRAPHIRE_RES 80
24#define WACOM_INTUOS_RES 100
25#define WACOM_INTUOS3_RES 200
26
Ping Chengfa770342014-12-01 13:44:28 -080027/* Newer Cintiq and DTU have an offset between tablet and screen areas */
28#define WACOM_DTU_OFFSET 200
29#define WACOM_CINTIQ_OFFSET 400
30
Benjamin Tissoires387142b2014-08-06 13:52:56 -070031/*
32 * Scale factor relating reported contact size to logical contact area.
Jason Gerecke4e904952012-10-03 17:19:11 -070033 * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
34 */
35#define WACOM_CONTACT_AREA_SCALE 2607
36
Jason Gereckec7f05222015-11-30 17:13:47 -080037static void wacom_report_numbered_buttons(struct input_dev *input_dev,
38 int button_count, int mask);
39
Benjamin Tissoires387142b2014-08-06 13:52:56 -070040/*
41 * Percent of battery capacity for Graphire.
42 * 8th value means AC online and show 100% capacity.
43 */
44static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
45
Benjamin Tissoires81af7e62014-08-06 13:55:56 -070046/*
47 * Percent of battery capacity for Intuos4 WL, AC has a separate bit.
48 */
49static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
50
Benjamin Tissoires59d69bc2016-07-13 18:06:08 +020051static void __wacom_notify_battery(struct wacom_battery *battery,
52 int bat_capacity, bool bat_charging,
53 bool bat_connected, bool ps_connected)
54{
55 bool changed = battery->battery_capacity != bat_capacity ||
56 battery->bat_charging != bat_charging ||
57 battery->bat_connected != bat_connected ||
58 battery->ps_connected != ps_connected;
59
60 if (changed) {
61 battery->battery_capacity = bat_capacity;
62 battery->bat_charging = bat_charging;
63 battery->bat_connected = bat_connected;
64 battery->ps_connected = ps_connected;
65
66 if (battery->battery)
67 power_supply_changed(battery->battery);
68 }
69}
70
Jason Gerecke953f2c52015-03-06 11:47:39 -080071static void wacom_notify_battery(struct wacom_wac *wacom_wac,
Jason Gerecke71fa6412015-03-11 10:25:41 -070072 int bat_capacity, bool bat_charging, bool bat_connected,
73 bool ps_connected)
Jason Gerecke953f2c52015-03-06 11:47:39 -080074{
75 struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
Jason Gerecke953f2c52015-03-06 11:47:39 -080076
Benjamin Tissoires59d69bc2016-07-13 18:06:08 +020077 __wacom_notify_battery(&wacom->battery, bat_capacity, bat_charging,
78 bat_connected, ps_connected);
Jason Gerecke953f2c52015-03-06 11:47:39 -080079}
80
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -070081static int wacom_penpartner_irq(struct wacom_wac *wacom)
Ping Cheng3bea7332006-07-13 18:01:36 -070082{
83 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -070084 struct input_dev *input = wacom->pen_input;
Ping Cheng3bea7332006-07-13 18:01:36 -070085
86 switch (data[0]) {
Dmitry Torokhov73a97f42010-03-19 22:18:15 -070087 case 1:
88 if (data[5] & 0x80) {
89 wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
90 wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -070091 input_report_key(input, wacom->tool[0], 1);
92 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
Dmitry Torokhov252f7762010-03-19 22:33:38 -070093 input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
94 input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -070095 input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
96 input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
97 input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
Dmitry Torokhov73a97f42010-03-19 22:18:15 -070098 } else {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -070099 input_report_key(input, wacom->tool[0], 0);
100 input_report_abs(input, ABS_MISC, 0); /* report tool id */
101 input_report_abs(input, ABS_PRESSURE, -1);
102 input_report_key(input, BTN_TOUCH, 0);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700103 }
104 break;
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700105
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700106 case 2:
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700107 input_report_key(input, BTN_TOOL_PEN, 1);
108 input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
Dmitry Torokhov252f7762010-03-19 22:33:38 -0700109 input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
110 input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700111 input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
112 input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
113 input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700114 break;
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700115
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700116 default:
Dmitry Torokhoveb71d1b2012-05-02 00:13:38 -0700117 dev_dbg(input->dev.parent,
118 "%s: received unknown report #%d\n", __func__, data[0]);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700119 return 0;
Ping Cheng3bea7332006-07-13 18:01:36 -0700120 }
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700121
Ping Cheng3bea7332006-07-13 18:01:36 -0700122 return 1;
123}
124
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -0700125static int wacom_pl_irq(struct wacom_wac *wacom)
Ping Cheng3bea7332006-07-13 18:01:36 -0700126{
Jason Childse33da8a2010-02-17 22:38:31 -0800127 struct wacom_features *features = &wacom->features;
Ping Cheng3bea7332006-07-13 18:01:36 -0700128 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -0700129 struct input_dev *input = wacom->pen_input;
Ping Chenge34b9d22008-05-05 11:36:41 -0400130 int prox, pressure;
Ping Cheng3bea7332006-07-13 18:01:36 -0700131
Ping Chengcad74702009-12-15 00:35:25 -0800132 if (data[0] != WACOM_REPORT_PENABLED) {
Dmitry Torokhoveb71d1b2012-05-02 00:13:38 -0700133 dev_dbg(input->dev.parent,
134 "%s: received unknown report #%d\n", __func__, data[0]);
Ping Cheng3bea7332006-07-13 18:01:36 -0700135 return 0;
136 }
137
138 prox = data[1] & 0x40;
139
Jason Gerecke025bcc12015-08-03 10:18:10 -0700140 if (!wacom->id[0]) {
141 if ((data[0] & 0x10) || (data[4] & 0x20)) {
142 wacom->tool[0] = BTN_TOOL_RUBBER;
143 wacom->id[0] = ERASER_DEVICE_ID;
Ping Cheng3bea7332006-07-13 18:01:36 -0700144 }
Jason Gerecke025bcc12015-08-03 10:18:10 -0700145 else {
146 wacom->tool[0] = BTN_TOOL_PEN;
Ping Chenge34b9d22008-05-05 11:36:41 -0400147 wacom->id[0] = STYLUS_DEVICE_ID;
Ping Cheng3bea7332006-07-13 18:01:36 -0700148 }
Ping Cheng3bea7332006-07-13 18:01:36 -0700149 }
150
Jason Gerecke025bcc12015-08-03 10:18:10 -0700151 /* If the eraser is in prox, STYLUS2 is always set. If we
152 * mis-detected the type and notice that STYLUS2 isn't set
153 * then force the eraser out of prox and let the pen in.
154 */
155 if (wacom->tool[0] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
156 input_report_key(input, BTN_TOOL_RUBBER, 0);
157 input_report_abs(input, ABS_MISC, 0);
158 input_sync(input);
159 wacom->tool[0] = BTN_TOOL_PEN;
160 wacom->id[0] = STYLUS_DEVICE_ID;
161 }
162
163 pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
164 if (features->pressure_max > 255)
165 pressure = (pressure << 1) | ((data[4] >> 6) & 1);
166 pressure += (features->pressure_max + 1) / 2;
167
168 input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
169 input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
170 input_report_abs(input, ABS_PRESSURE, pressure);
171
172 input_report_key(input, BTN_TOUCH, data[4] & 0x08);
173 input_report_key(input, BTN_STYLUS, data[4] & 0x10);
174 /* Only allow the stylus2 button to be reported for the pen tool. */
175 input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));
176
177 if (!prox)
178 wacom->id[0] = 0;
179 input_report_key(input, wacom->tool[0], prox);
180 input_report_abs(input, ABS_MISC, wacom->id[0]);
Ping Cheng3bea7332006-07-13 18:01:36 -0700181 return 1;
182}
183
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -0700184static int wacom_ptu_irq(struct wacom_wac *wacom)
Ping Cheng3bea7332006-07-13 18:01:36 -0700185{
186 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -0700187 struct input_dev *input = wacom->pen_input;
Ping Cheng3bea7332006-07-13 18:01:36 -0700188
Ping Chengcad74702009-12-15 00:35:25 -0800189 if (data[0] != WACOM_REPORT_PENABLED) {
Dmitry Torokhoveb71d1b2012-05-02 00:13:38 -0700190 dev_dbg(input->dev.parent,
191 "%s: received unknown report #%d\n", __func__, data[0]);
Ping Cheng3bea7332006-07-13 18:01:36 -0700192 return 0;
193 }
194
Ping Cheng3bea7332006-07-13 18:01:36 -0700195 if (data[1] & 0x04) {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700196 input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
197 input_report_key(input, BTN_TOUCH, data[1] & 0x08);
Ping Chenge34b9d22008-05-05 11:36:41 -0400198 wacom->id[0] = ERASER_DEVICE_ID;
Ping Cheng3bea7332006-07-13 18:01:36 -0700199 } else {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700200 input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
201 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
Ping Chenge34b9d22008-05-05 11:36:41 -0400202 wacom->id[0] = STYLUS_DEVICE_ID;
Ping Cheng3bea7332006-07-13 18:01:36 -0700203 }
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700204 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
Dmitry Torokhov252f7762010-03-19 22:33:38 -0700205 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
206 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
207 input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700208 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
209 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
Ping Cheng3bea7332006-07-13 18:01:36 -0700210 return 1;
211}
212
Ping Chengc8f2edc2010-06-28 01:10:51 -0700213static int wacom_dtu_irq(struct wacom_wac *wacom)
214{
Jason Gerecke74b63412014-04-19 13:50:22 -0700215 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -0700216 struct input_dev *input = wacom->pen_input;
Jason Gerecke74b63412014-04-19 13:50:22 -0700217 int prox = data[1] & 0x20;
Ping Chengc8f2edc2010-06-28 01:10:51 -0700218
Dmitry Torokhoveb71d1b2012-05-02 00:13:38 -0700219 dev_dbg(input->dev.parent,
220 "%s: received report #%d", __func__, data[0]);
Ping Chengc8f2edc2010-06-28 01:10:51 -0700221
222 if (prox) {
223 /* Going into proximity select tool */
224 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
225 if (wacom->tool[0] == BTN_TOOL_PEN)
226 wacom->id[0] = STYLUS_DEVICE_ID;
227 else
228 wacom->id[0] = ERASER_DEVICE_ID;
229 }
230 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
231 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
232 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
233 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
Jason Gerecke74b63412014-04-19 13:50:22 -0700234 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x01) << 8) | data[6]);
Ping Chengc8f2edc2010-06-28 01:10:51 -0700235 input_report_key(input, BTN_TOUCH, data[1] & 0x05);
236 if (!prox) /* out-prox */
237 wacom->id[0] = 0;
238 input_report_key(input, wacom->tool[0], prox);
239 input_report_abs(input, ABS_MISC, wacom->id[0]);
240 return 1;
241}
242
Ping Cheng497ab1f2014-01-20 20:18:04 -0800243static int wacom_dtus_irq(struct wacom_wac *wacom)
244{
245 char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -0700246 struct input_dev *input = wacom->pen_input;
Ping Cheng497ab1f2014-01-20 20:18:04 -0800247 unsigned short prox, pressure = 0;
248
249 if (data[0] != WACOM_REPORT_DTUS && data[0] != WACOM_REPORT_DTUSPAD) {
250 dev_dbg(input->dev.parent,
251 "%s: received unknown report #%d", __func__, data[0]);
252 return 0;
253 } else if (data[0] == WACOM_REPORT_DTUSPAD) {
Benjamin Tissoires422b0312014-07-24 12:50:39 -0700254 input = wacom->pad_input;
Ping Cheng497ab1f2014-01-20 20:18:04 -0800255 input_report_key(input, BTN_0, (data[1] & 0x01));
256 input_report_key(input, BTN_1, (data[1] & 0x02));
257 input_report_key(input, BTN_2, (data[1] & 0x04));
258 input_report_key(input, BTN_3, (data[1] & 0x08));
259 input_report_abs(input, ABS_MISC,
260 data[1] & 0x0f ? PAD_DEVICE_ID : 0);
Ping Cheng497ab1f2014-01-20 20:18:04 -0800261 return 1;
262 } else {
263 prox = data[1] & 0x80;
264 if (prox) {
265 switch ((data[1] >> 3) & 3) {
266 case 1: /* Rubber */
267 wacom->tool[0] = BTN_TOOL_RUBBER;
268 wacom->id[0] = ERASER_DEVICE_ID;
269 break;
270
271 case 2: /* Pen */
272 wacom->tool[0] = BTN_TOOL_PEN;
273 wacom->id[0] = STYLUS_DEVICE_ID;
274 break;
275 }
276 }
277
278 input_report_key(input, BTN_STYLUS, data[1] & 0x20);
279 input_report_key(input, BTN_STYLUS2, data[1] & 0x40);
280 input_report_abs(input, ABS_X, get_unaligned_be16(&data[3]));
281 input_report_abs(input, ABS_Y, get_unaligned_be16(&data[5]));
282 pressure = ((data[1] & 0x03) << 8) | (data[2] & 0xff);
283 input_report_abs(input, ABS_PRESSURE, pressure);
284 input_report_key(input, BTN_TOUCH, pressure > 10);
285
286 if (!prox) /* out-prox */
287 wacom->id[0] = 0;
288 input_report_key(input, wacom->tool[0], prox);
289 input_report_abs(input, ABS_MISC, wacom->id[0]);
Ping Cheng497ab1f2014-01-20 20:18:04 -0800290 return 1;
291 }
292}
293
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -0700294static int wacom_graphire_irq(struct wacom_wac *wacom)
Ping Cheng3bea7332006-07-13 18:01:36 -0700295{
Jason Childse33da8a2010-02-17 22:38:31 -0800296 struct wacom_features *features = &wacom->features;
Ping Cheng3bea7332006-07-13 18:01:36 -0700297 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -0700298 struct input_dev *input = wacom->pen_input;
Benjamin Tissoires38138102014-07-24 12:51:03 -0700299 struct input_dev *pad_input = wacom->pad_input;
Benjamin Tissoires387142b2014-08-06 13:52:56 -0700300 int battery_capacity, ps_connected;
Dmitry Torokhov252f7762010-03-19 22:33:38 -0700301 int prox;
Ping Cheng3b57ca02010-03-04 21:50:59 -0800302 int rw = 0;
303 int retval = 0;
Ping Cheng3bea7332006-07-13 18:01:36 -0700304
Benjamin Tissoires387142b2014-08-06 13:52:56 -0700305 if (features->type == GRAPHIRE_BT) {
306 if (data[0] != WACOM_REPORT_PENABLED_BT) {
307 dev_dbg(input->dev.parent,
308 "%s: received unknown report #%d\n", __func__,
309 data[0]);
310 goto exit;
311 }
312 } else if (data[0] != WACOM_REPORT_PENABLED) {
Dmitry Torokhoveb71d1b2012-05-02 00:13:38 -0700313 dev_dbg(input->dev.parent,
314 "%s: received unknown report #%d\n", __func__, data[0]);
Ping Cheng3b57ca02010-03-04 21:50:59 -0800315 goto exit;
Ping Cheng3bea7332006-07-13 18:01:36 -0700316 }
317
Ping Cheng3b57ca02010-03-04 21:50:59 -0800318 prox = data[1] & 0x80;
319 if (prox || wacom->id[0]) {
320 if (prox) {
321 switch ((data[1] >> 5) & 3) {
Ping Cheng3bea7332006-07-13 18:01:36 -0700322
323 case 0: /* Pen */
324 wacom->tool[0] = BTN_TOOL_PEN;
Ping Chenge34b9d22008-05-05 11:36:41 -0400325 wacom->id[0] = STYLUS_DEVICE_ID;
Ping Cheng3bea7332006-07-13 18:01:36 -0700326 break;
327
328 case 1: /* Rubber */
329 wacom->tool[0] = BTN_TOOL_RUBBER;
Ping Chenge34b9d22008-05-05 11:36:41 -0400330 wacom->id[0] = ERASER_DEVICE_ID;
Ping Cheng3bea7332006-07-13 18:01:36 -0700331 break;
332
333 case 2: /* Mouse with wheel */
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700334 input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
Ping Cheng3bea7332006-07-13 18:01:36 -0700335 /* fall through */
336
337 case 3: /* Mouse without wheel */
338 wacom->tool[0] = BTN_TOOL_MOUSE;
Ping Chenge34b9d22008-05-05 11:36:41 -0400339 wacom->id[0] = CURSOR_DEVICE_ID;
Ping Cheng3bea7332006-07-13 18:01:36 -0700340 break;
Ping Cheng3b57ca02010-03-04 21:50:59 -0800341 }
Ping Cheng3bea7332006-07-13 18:01:36 -0700342 }
Dmitry Torokhov252f7762010-03-19 22:33:38 -0700343 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
344 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
Ping Cheng3bea7332006-07-13 18:01:36 -0700345 if (wacom->tool[0] != BTN_TOOL_MOUSE) {
Benjamin Tissoires387142b2014-08-06 13:52:56 -0700346 if (features->type == GRAPHIRE_BT)
347 input_report_abs(input, ABS_PRESSURE, data[6] |
348 (((__u16) (data[1] & 0x08)) << 5));
349 else
350 input_report_abs(input, ABS_PRESSURE, data[6] |
351 ((data[7] & 0x03) << 8));
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700352 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
353 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
354 input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
Dmitry Torokhovafb567e2010-04-13 23:08:58 -0700355 } else {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700356 input_report_key(input, BTN_LEFT, data[1] & 0x01);
357 input_report_key(input, BTN_RIGHT, data[1] & 0x02);
Ping Cheng3b57ca02010-03-04 21:50:59 -0800358 if (features->type == WACOM_G4 ||
359 features->type == WACOM_MO) {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700360 input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
Mike Autyd9f66c12010-08-28 20:35:17 -0700361 rw = (data[7] & 0x04) - (data[7] & 0x03);
Benjamin Tissoires387142b2014-08-06 13:52:56 -0700362 } else if (features->type == GRAPHIRE_BT) {
363 /* Compute distance between mouse and tablet */
364 rw = 44 - (data[6] >> 2);
365 rw = clamp_val(rw, 0, 31);
366 input_report_abs(input, ABS_DISTANCE, rw);
367 if (((data[1] >> 5) & 3) == 2) {
368 /* Mouse with wheel */
369 input_report_key(input, BTN_MIDDLE,
370 data[1] & 0x04);
371 rw = (data[6] & 0x01) ? -1 :
372 (data[6] & 0x02) ? 1 : 0;
373 } else {
374 rw = 0;
375 }
Ping Cheng3b57ca02010-03-04 21:50:59 -0800376 } else {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700377 input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
Mike Autyd9f66c12010-08-28 20:35:17 -0700378 rw = -(signed char)data[6];
Ping Cheng3b57ca02010-03-04 21:50:59 -0800379 }
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700380 input_report_rel(input, REL_WHEEL, rw);
Dmitry Torokhovafb567e2010-04-13 23:08:58 -0700381 }
Ping Cheng3b57ca02010-03-04 21:50:59 -0800382
383 if (!prox)
384 wacom->id[0] = 0;
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700385 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
386 input_report_key(input, wacom->tool[0], prox);
387 input_sync(input); /* sync last event */
Ping Cheng80d4e8e2007-02-23 12:22:48 -0800388 }
Ping Cheng3bea7332006-07-13 18:01:36 -0700389
390 /* send pad data */
Jason Childse33da8a2010-02-17 22:38:31 -0800391 switch (features->type) {
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700392 case WACOM_G4:
Ping Cheng3b57ca02010-03-04 21:50:59 -0800393 prox = data[7] & 0xf8;
394 if (prox || wacom->id[1]) {
Ping Chenge34b9d22008-05-05 11:36:41 -0400395 wacom->id[1] = PAD_DEVICE_ID;
Benjamin Tissoires38138102014-07-24 12:51:03 -0700396 input_report_key(pad_input, BTN_BACK, (data[7] & 0x40));
397 input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x80));
Ping Cheng3bea7332006-07-13 18:01:36 -0700398 rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
Benjamin Tissoires38138102014-07-24 12:51:03 -0700399 input_report_rel(pad_input, REL_WHEEL, rw);
Ping Cheng3b57ca02010-03-04 21:50:59 -0800400 if (!prox)
401 wacom->id[1] = 0;
Benjamin Tissoires38138102014-07-24 12:51:03 -0700402 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
Ping Chengab687b12010-04-05 23:07:41 -0700403 retval = 1;
Ping Cheng3bea7332006-07-13 18:01:36 -0700404 }
Ping Cheng7ecfbfd2007-06-14 23:32:48 -0400405 break;
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700406
407 case WACOM_MO:
Ping Cheng3b57ca02010-03-04 21:50:59 -0800408 prox = (data[7] & 0xf8) || data[8];
409 if (prox || wacom->id[1]) {
Ping Chenge34b9d22008-05-05 11:36:41 -0400410 wacom->id[1] = PAD_DEVICE_ID;
Benjamin Tissoires38138102014-07-24 12:51:03 -0700411 input_report_key(pad_input, BTN_BACK, (data[7] & 0x08));
412 input_report_key(pad_input, BTN_LEFT, (data[7] & 0x20));
413 input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x10));
414 input_report_key(pad_input, BTN_RIGHT, (data[7] & 0x40));
415 input_report_abs(pad_input, ABS_WHEEL, (data[8] & 0x7f));
Ping Cheng3b57ca02010-03-04 21:50:59 -0800416 if (!prox)
417 wacom->id[1] = 0;
Benjamin Tissoires38138102014-07-24 12:51:03 -0700418 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
Ping Cheng84460012011-07-06 18:05:43 -0700419 retval = 1;
Ping Cheng7ecfbfd2007-06-14 23:32:48 -0400420 }
421 break;
Benjamin Tissoires387142b2014-08-06 13:52:56 -0700422 case GRAPHIRE_BT:
423 prox = data[7] & 0x03;
424 if (prox || wacom->id[1]) {
425 wacom->id[1] = PAD_DEVICE_ID;
426 input_report_key(pad_input, BTN_0, (data[7] & 0x02));
427 input_report_key(pad_input, BTN_1, (data[7] & 0x01));
428 if (!prox)
429 wacom->id[1] = 0;
430 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
431 retval = 1;
432 }
433 break;
434 }
435
436 /* Store current battery capacity and power supply state */
437 if (features->type == GRAPHIRE_BT) {
438 rw = (data[7] >> 2 & 0x07);
439 battery_capacity = batcap_gr[rw];
440 ps_connected = rw == 7;
Jason Gerecke953f2c52015-03-06 11:47:39 -0800441 wacom_notify_battery(wacom, battery_capacity, ps_connected,
Jason Gerecke71fa6412015-03-11 10:25:41 -0700442 1, ps_connected);
Ping Cheng3bea7332006-07-13 18:01:36 -0700443 }
Ping Cheng3b57ca02010-03-04 21:50:59 -0800444exit:
445 return retval;
Ping Cheng3bea7332006-07-13 18:01:36 -0700446}
447
Benjamin Tissoires5fcad162015-03-05 17:36:54 -0500448static void wacom_intuos_schedule_prox_event(struct wacom_wac *wacom_wac)
449{
450 struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
Jason Gerecke0bbfe282016-01-06 13:25:53 -0800451 struct wacom_features *features = &wacom_wac->features;
Benjamin Tissoires5fcad162015-03-05 17:36:54 -0500452 struct hid_report *r;
453 struct hid_report_enum *re;
454
455 re = &(wacom->hdev->report_enum[HID_FEATURE_REPORT]);
Jason Gerecke0bbfe282016-01-06 13:25:53 -0800456 if (features->type == INTUOSHT2)
457 r = re->report_id_hash[WACOM_REPORT_INTUOSHT2_ID];
458 else
459 r = re->report_id_hash[WACOM_REPORT_INTUOS_ID1];
Benjamin Tissoires5fcad162015-03-05 17:36:54 -0500460 if (r) {
461 hid_hw_request(wacom->hdev, r, HID_REQ_GET_REPORT);
462 }
463}
464
Jason Gereckefb013a02015-11-30 17:13:46 -0800465static int wacom_intuos_pad(struct wacom_wac *wacom)
466{
467 struct wacom_features *features = &wacom->features;
468 unsigned char *data = wacom->data;
469 struct input_dev *input = wacom->pad_input;
Jason Gereckec7f05222015-11-30 17:13:47 -0800470 int i;
471 int buttons = 0, nbuttons = features->numbered_buttons;
472 int keys = 0, nkeys = 0;
473 int ring1 = 0, ring2 = 0;
474 int strip1 = 0, strip2 = 0;
475 bool prox = false;
Jason Gereckefb013a02015-11-30 17:13:46 -0800476
477 /* pad packets. Works as a second tool and is always in prox */
478 if (!(data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD ||
479 data[0] == WACOM_REPORT_CINTIQPAD))
480 return 0;
481
482 if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800483 buttons = (data[3] << 1) | (data[2] & 0x01);
484 ring1 = data[1];
Jason Gereckefb013a02015-11-30 17:13:46 -0800485 } else if (features->type == DTK) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800486 buttons = data[6];
Jason Gereckefb013a02015-11-30 17:13:46 -0800487 } else if (features->type == WACOM_13HD) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800488 buttons = (data[4] << 1) | (data[3] & 0x01);
Jason Gereckefb013a02015-11-30 17:13:46 -0800489 } else if (features->type == WACOM_24HD) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800490 buttons = (data[8] << 8) | data[6];
491 ring1 = data[1];
492 ring2 = data[2];
Jason Gereckefb013a02015-11-30 17:13:46 -0800493
494 /*
495 * Three "buttons" are available on the 24HD which are
496 * physically implemented as a touchstrip. Each button
497 * is approximately 3 bits wide with a 2 bit spacing.
498 * The raw touchstrip bits are stored at:
499 * ((data[3] & 0x1f) << 8) | data[4])
500 */
Jason Gereckec7f05222015-11-30 17:13:47 -0800501 nkeys = 3;
502 keys = ((data[3] & 0x1C) ? 1<<2 : 0) |
503 ((data[4] & 0xE0) ? 1<<1 : 0) |
504 ((data[4] & 0x07) ? 1<<0 : 0);
Jason Gereckefb013a02015-11-30 17:13:46 -0800505 } else if (features->type == WACOM_27QHD) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800506 nkeys = 3;
507 keys = data[2] & 0x07;
Jason Gereckefb013a02015-11-30 17:13:46 -0800508
509 input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[4]));
510 input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[6]));
511 input_report_abs(input, ABS_Z, be16_to_cpup((__be16 *)&data[8]));
Jason Gereckefb013a02015-11-30 17:13:46 -0800512 } else if (features->type == CINTIQ_HYBRID) {
513 /*
514 * Do not send hardware buttons under Android. They
515 * are already sent to the system through GPIO (and
516 * have different meaning).
Jason Gereckec7f05222015-11-30 17:13:47 -0800517 *
518 * d-pad right -> data[4] & 0x10
519 * d-pad up -> data[4] & 0x20
520 * d-pad left -> data[4] & 0x40
521 * d-pad down -> data[4] & 0x80
522 * d-pad center -> data[3] & 0x01
Jason Gereckefb013a02015-11-30 17:13:46 -0800523 */
Jason Gereckec7f05222015-11-30 17:13:47 -0800524 buttons = (data[4] << 1) | (data[3] & 0x01);
Jason Gereckefb013a02015-11-30 17:13:46 -0800525 } else if (features->type == CINTIQ_COMPANION_2) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800526 /* d-pad right -> data[4] & 0x10
527 * d-pad up -> data[4] & 0x20
528 * d-pad left -> data[4] & 0x40
529 * d-pad down -> data[4] & 0x80
530 * d-pad center -> data[3] & 0x01
531 */
Jason Gerecke0402b6b2015-12-16 13:37:36 -0800532 buttons = ((data[2] >> 4) << 7) |
Jason Gereckec7f05222015-11-30 17:13:47 -0800533 ((data[1] & 0x04) << 6) |
534 ((data[2] & 0x0F) << 2) |
535 (data[1] & 0x03);
Jason Gereckefb013a02015-11-30 17:13:46 -0800536 } else if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
Jason Gereckefb013a02015-11-30 17:13:46 -0800537 /*
538 * ExpressKeys on Intuos5/Intuos Pro have a capacitive sensor in
539 * addition to the mechanical switch. Switch data is
540 * stored in data[4], capacitive data in data[5].
Jason Gereckec7f05222015-11-30 17:13:47 -0800541 *
542 * Touch ring mode switch (data[3]) has no capacitive sensor
Jason Gereckefb013a02015-11-30 17:13:46 -0800543 */
Jason Gereckec7f05222015-11-30 17:13:47 -0800544 buttons = (data[4] << 1) | (data[3] & 0x01);
545 ring1 = data[2];
Jason Gereckefb013a02015-11-30 17:13:46 -0800546 } else {
547 if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800548 buttons = (data[8] << 10) | ((data[7] & 0x01) << 9) |
549 (data[6] << 1) | (data[5] & 0x01);
Jason Gereckefb013a02015-11-30 17:13:46 -0800550
551 if (features->type == WACOM_22HD) {
Jason Gereckec7f05222015-11-30 17:13:47 -0800552 nkeys = 3;
553 keys = data[9] & 0x07;
Jason Gereckefb013a02015-11-30 17:13:46 -0800554 }
555 } else {
Jason Gereckec7f05222015-11-30 17:13:47 -0800556 buttons = ((data[6] & 0x10) << 10) |
557 ((data[5] & 0x10) << 9) |
558 ((data[6] & 0x0F) << 4) |
559 (data[5] & 0x0F);
Jason Gereckefb013a02015-11-30 17:13:46 -0800560 }
Jason Gereckef73d08d2015-12-16 13:37:33 -0800561 strip1 = ((data[1] & 0x1f) << 8) | data[2];
562 strip2 = ((data[3] & 0x1f) << 8) | data[4];
Jason Gereckefb013a02015-11-30 17:13:46 -0800563 }
Jason Gereckec7f05222015-11-30 17:13:47 -0800564
Dan Carpenter8f9cfdd2015-12-09 13:22:05 +0300565 prox = (buttons & ~(~0 << nbuttons)) | (keys & ~(~0 << nkeys)) |
566 (ring1 & 0x80) | (ring2 & 0x80) | strip1 | strip2;
Jason Gereckec7f05222015-11-30 17:13:47 -0800567
568 wacom_report_numbered_buttons(input, nbuttons, buttons);
569
570 for (i = 0; i < nkeys; i++)
571 input_report_key(input, KEY_PROG1 + i, keys & (1 << i));
572
573 input_report_abs(input, ABS_RX, strip1);
Jason Gerecke03a0dc52015-12-16 13:37:34 -0800574 input_report_abs(input, ABS_RY, strip2);
Jason Gereckec7f05222015-11-30 17:13:47 -0800575
Jason Gereckeaaae03e2015-12-16 13:37:35 -0800576 input_report_abs(input, ABS_WHEEL, (ring1 & 0x80) ? (ring1 & 0x7f) : 0);
577 input_report_abs(input, ABS_THROTTLE, (ring2 & 0x80) ? (ring2 & 0x7f) : 0);
Jason Gereckec7f05222015-11-30 17:13:47 -0800578
579 input_report_key(input, wacom->tool[1], prox ? 1 : 0);
580 input_report_abs(input, ABS_MISC, prox ? PAD_DEVICE_ID : 0);
581
582 input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
583
Jason Gereckefb013a02015-11-30 17:13:46 -0800584 return 1;
585}
586
Benjamin Tissoires7e129782016-02-12 17:27:40 +0100587static int wacom_intuos_get_tool_type(int tool_id)
588{
589 int tool_type;
590
591 switch (tool_id) {
592 case 0x812: /* Inking pen */
593 case 0x801: /* Intuos3 Inking pen */
594 case 0x120802: /* Intuos4/5 Inking Pen */
595 case 0x012:
596 tool_type = BTN_TOOL_PENCIL;
597 break;
598
599 case 0x822: /* Pen */
600 case 0x842:
601 case 0x852:
602 case 0x823: /* Intuos3 Grip Pen */
603 case 0x813: /* Intuos3 Classic Pen */
604 case 0x885: /* Intuos3 Marker Pen */
605 case 0x802: /* Intuos4/5 13HD/24HD General Pen */
606 case 0x804: /* Intuos4/5 13HD/24HD Marker Pen */
607 case 0x8e2: /* IntuosHT2 pen */
608 case 0x022:
609 case 0x100804: /* Intuos4/5 13HD/24HD Art Pen */
610 case 0x140802: /* Intuos4/5 13HD/24HD Classic Pen */
611 case 0x160802: /* Cintiq 13HD Pro Pen */
612 case 0x180802: /* DTH2242 Pen */
613 case 0x100802: /* Intuos4/5 13HD/24HD General Pen */
614 tool_type = BTN_TOOL_PEN;
615 break;
616
617 case 0x832: /* Stroke pen */
618 case 0x032:
619 tool_type = BTN_TOOL_BRUSH;
620 break;
621
622 case 0x007: /* Mouse 4D and 2D */
623 case 0x09c:
624 case 0x094:
625 case 0x017: /* Intuos3 2D Mouse */
626 case 0x806: /* Intuos4 Mouse */
627 tool_type = BTN_TOOL_MOUSE;
628 break;
629
630 case 0x096: /* Lens cursor */
631 case 0x097: /* Intuos3 Lens cursor */
632 case 0x006: /* Intuos4 Lens cursor */
633 tool_type = BTN_TOOL_LENS;
634 break;
635
636 case 0x82a: /* Eraser */
637 case 0x85a:
638 case 0x91a:
639 case 0xd1a:
640 case 0x0fa:
641 case 0x82b: /* Intuos3 Grip Pen Eraser */
642 case 0x81b: /* Intuos3 Classic Pen Eraser */
643 case 0x91b: /* Intuos3 Airbrush Eraser */
644 case 0x80c: /* Intuos4/5 13HD/24HD Marker Pen Eraser */
645 case 0x80a: /* Intuos4/5 13HD/24HD General Pen Eraser */
646 case 0x90a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
647 case 0x14080a: /* Intuos4/5 13HD/24HD Classic Pen Eraser */
648 case 0x10090a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
649 case 0x10080c: /* Intuos4/5 13HD/24HD Art Pen Eraser */
650 case 0x16080a: /* Cintiq 13HD Pro Pen Eraser */
651 case 0x18080a: /* DTH2242 Eraser */
652 case 0x10080a: /* Intuos4/5 13HD/24HD General Pen Eraser */
653 tool_type = BTN_TOOL_RUBBER;
654 break;
655
656 case 0xd12:
657 case 0x912:
658 case 0x112:
659 case 0x913: /* Intuos3 Airbrush */
660 case 0x902: /* Intuos4/5 13HD/24HD Airbrush */
661 case 0x100902: /* Intuos4/5 13HD/24HD Airbrush */
662 tool_type = BTN_TOOL_AIRBRUSH;
663 break;
664
665 default: /* Unknown tool */
666 tool_type = BTN_TOOL_PEN;
667 break;
668 }
669 return tool_type;
670}
671
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -0700672static int wacom_intuos_inout(struct wacom_wac *wacom)
Ping Cheng3bea7332006-07-13 18:01:36 -0700673{
Jason Childse33da8a2010-02-17 22:38:31 -0800674 struct wacom_features *features = &wacom->features;
Ping Cheng3bea7332006-07-13 18:01:36 -0700675 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -0700676 struct input_dev *input = wacom->pen_input;
Ping Cheng4750f5f2016-01-08 17:15:48 -0800677 int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
Ping Cheng3bea7332006-07-13 18:01:36 -0700678
Ping Cheng4750f5f2016-01-08 17:15:48 -0800679 if (!(((data[1] & 0xfc) == 0xc0) || /* in prox */
680 ((data[1] & 0xfe) == 0x20) || /* in range */
681 ((data[1] & 0xfe) == 0x80))) /* out prox */
682 return 0;
Ping Cheng3bea7332006-07-13 18:01:36 -0700683
684 /* Enter report */
685 if ((data[1] & 0xfc) == 0xc0) {
686 /* serial number of the tool */
687 wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
688 (data[4] << 20) + (data[5] << 12) +
689 (data[6] << 4) + (data[7] >> 4);
690
Ping Cheng493630b2010-06-22 11:21:34 -0700691 wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
692 ((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700693
Benjamin Tissoires7e129782016-02-12 17:27:40 +0100694 wacom->tool[idx] = wacom_intuos_get_tool_type(wacom->id[idx]);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -0700695
Ping Chengeff6ca92016-05-02 21:17:34 -0700696 wacom->shared->stylus_in_proximity = true;
Ping Cheng3bea7332006-07-13 18:01:36 -0700697 return 1;
698 }
699
Ping Chengc1b03f52016-01-08 17:16:06 -0800700 /* in Range */
701 if ((data[1] & 0xfe) == 0x20) {
Ping Cheng526d6e72016-01-08 17:16:25 -0800702 if (features->type != INTUOSHT2)
703 wacom->shared->stylus_in_proximity = true;
Ping Cheng486b9082015-02-20 14:25:58 -0800704
Ping Chengc1b03f52016-01-08 17:16:06 -0800705 /* in Range while exiting */
706 if (wacom->reporting_data) {
707 input_report_key(input, BTN_TOUCH, 0);
708 input_report_abs(input, ABS_PRESSURE, 0);
709 input_report_abs(input, ABS_DISTANCE, wacom->features.distance_max);
710 return 2;
711 }
712 return 1;
Jason Gerecke4eb18302013-09-20 09:48:46 -0700713 }
714
Ping Cheng3bea7332006-07-13 18:01:36 -0700715 /* Exit report */
716 if ((data[1] & 0xfe) == 0x80) {
Ping Chengf3586d22015-03-20 14:57:00 -0700717 wacom->shared->stylus_in_proximity = false;
Ping Chengb3bd7ef2015-01-09 11:05:13 -0800718 wacom->reporting_data = false;
Jason Gereckeae584ca2012-04-03 15:50:40 -0700719
Ping Cheng373a5352015-01-09 11:04:50 -0800720 /* don't report exit if we don't know the ID */
721 if (!wacom->id[idx])
722 return 1;
723
Ping Cheng6f660f12009-05-08 18:30:33 -0700724 /*
725 * Reset all states otherwise we lose the initial states
726 * when in-prox next time
727 */
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700728 input_report_abs(input, ABS_X, 0);
729 input_report_abs(input, ABS_Y, 0);
730 input_report_abs(input, ABS_DISTANCE, 0);
731 input_report_abs(input, ABS_TILT_X, 0);
732 input_report_abs(input, ABS_TILT_Y, 0);
Ping Cheng80d4e8e2007-02-23 12:22:48 -0800733 if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700734 input_report_key(input, BTN_LEFT, 0);
735 input_report_key(input, BTN_MIDDLE, 0);
736 input_report_key(input, BTN_RIGHT, 0);
737 input_report_key(input, BTN_SIDE, 0);
738 input_report_key(input, BTN_EXTRA, 0);
739 input_report_abs(input, ABS_THROTTLE, 0);
740 input_report_abs(input, ABS_RZ, 0);
Ping Cheng7ecfbfd2007-06-14 23:32:48 -0400741 } else {
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700742 input_report_abs(input, ABS_PRESSURE, 0);
743 input_report_key(input, BTN_STYLUS, 0);
744 input_report_key(input, BTN_STYLUS2, 0);
745 input_report_key(input, BTN_TOUCH, 0);
746 input_report_abs(input, ABS_WHEEL, 0);
Jason Childse33da8a2010-02-17 22:38:31 -0800747 if (features->type >= INTUOS3S)
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700748 input_report_abs(input, ABS_Z, 0);
Ping Cheng8d32e3a2006-09-26 13:34:47 -0700749 }
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700750 input_report_key(input, wacom->tool[idx], 0);
751 input_report_abs(input, ABS_MISC, 0); /* reset tool id */
752 input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
Ping Cheng6f660f12009-05-08 18:30:33 -0700753 wacom->id[idx] = 0;
Ping Cheng80d4e8e2007-02-23 12:22:48 -0800754 return 2;
Ping Cheng3bea7332006-07-13 18:01:36 -0700755 }
Ping Cheng373a5352015-01-09 11:04:50 -0800756
Ping Cheng3bea7332006-07-13 18:01:36 -0700757 return 0;
758}
759
Aaron Skomra72b236d2015-08-20 16:05:17 -0700760static int wacom_remote_irq(struct wacom_wac *wacom_wac, size_t len)
761{
762 unsigned char *data = wacom_wac->data;
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +0200763 struct input_dev *input;
Aaron Skomra72b236d2015-08-20 16:05:17 -0700764 struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
Benjamin Tissoires83e6b402016-07-13 18:06:02 +0200765 struct wacom_remote *remote = wacom->remote;
Aaron Skomra72b236d2015-08-20 16:05:17 -0700766 int bat_charging, bat_percent, touch_ring_mode;
767 __u32 serial;
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +0200768 int i, index = -1;
769 unsigned long flags;
Aaron Skomra72b236d2015-08-20 16:05:17 -0700770
771 if (data[0] != WACOM_REPORT_REMOTE) {
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +0200772 hid_dbg(wacom->hdev, "%s: received unknown report #%d",
773 __func__, data[0]);
Aaron Skomra72b236d2015-08-20 16:05:17 -0700774 return 0;
775 }
776
777 serial = data[3] + (data[4] << 8) + (data[5] << 16);
778 wacom_wac->id[0] = PAD_DEVICE_ID;
779
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +0200780 spin_lock_irqsave(&remote->remote_lock, flags);
781
782 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
783 if (remote->remotes[i].serial == serial) {
784 index = i;
785 break;
786 }
787 }
788
789 if (index < 0 || !remote->remotes[index].registered)
790 goto out;
791
792 input = remote->remotes[index].input;
793
Aaron Skomra72b236d2015-08-20 16:05:17 -0700794 input_report_key(input, BTN_0, (data[9] & 0x01));
795 input_report_key(input, BTN_1, (data[9] & 0x02));
796 input_report_key(input, BTN_2, (data[9] & 0x04));
797 input_report_key(input, BTN_3, (data[9] & 0x08));
798 input_report_key(input, BTN_4, (data[9] & 0x10));
799 input_report_key(input, BTN_5, (data[9] & 0x20));
800 input_report_key(input, BTN_6, (data[9] & 0x40));
801 input_report_key(input, BTN_7, (data[9] & 0x80));
802
803 input_report_key(input, BTN_8, (data[10] & 0x01));
804 input_report_key(input, BTN_9, (data[10] & 0x02));
805 input_report_key(input, BTN_A, (data[10] & 0x04));
806 input_report_key(input, BTN_B, (data[10] & 0x08));
807 input_report_key(input, BTN_C, (data[10] & 0x10));
808 input_report_key(input, BTN_X, (data[10] & 0x20));
809 input_report_key(input, BTN_Y, (data[10] & 0x40));
810 input_report_key(input, BTN_Z, (data[10] & 0x80));
811
812 input_report_key(input, BTN_BASE, (data[11] & 0x01));
813 input_report_key(input, BTN_BASE2, (data[11] & 0x02));
814
815 if (data[12] & 0x80)
816 input_report_abs(input, ABS_WHEEL, (data[12] & 0x7f));
817 else
818 input_report_abs(input, ABS_WHEEL, 0);
819
820 bat_percent = data[7] & 0x7f;
821 bat_charging = !!(data[7] & 0x80);
822
823 if (data[9] | data[10] | (data[11] & 0x03) | data[12])
824 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
825 else
826 input_report_abs(input, ABS_MISC, 0);
827
828 input_event(input, EV_MSC, MSC_SERIAL, serial);
829
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +0200830 input_sync(input);
831
Aaron Skomra72b236d2015-08-20 16:05:17 -0700832 /*Which mode select (LED light) is currently on?*/
833 touch_ring_mode = (data[11] & 0xC0) >> 6;
834
835 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
Benjamin Tissoirese7749f62016-07-13 18:06:06 +0200836 if (remote->remotes[i].serial == serial)
Benjamin Tissoiresa50aac72016-07-13 18:06:00 +0200837 wacom->led.groups[i].select = touch_ring_mode;
Aaron Skomra72b236d2015-08-20 16:05:17 -0700838 }
839
Benjamin Tissoires59d69bc2016-07-13 18:06:08 +0200840 __wacom_notify_battery(&remote->remotes[index].battery, bat_percent,
841 bat_charging, 1, bat_charging);
Aaron Skomra72b236d2015-08-20 16:05:17 -0700842
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +0200843out:
844 spin_unlock_irqrestore(&remote->remote_lock, flags);
845 return 0;
Aaron Skomra72b236d2015-08-20 16:05:17 -0700846}
847
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200848static void wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
Aaron Skomra72b236d2015-08-20 16:05:17 -0700849{
850 struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
851 unsigned char *data = wacom_wac->data;
Benjamin Tissoires83e6b402016-07-13 18:06:02 +0200852 struct wacom_remote *remote = wacom->remote;
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200853 struct wacom_remote_data remote_data;
854 unsigned long flags;
855 int i, ret;
Aaron Skomra72b236d2015-08-20 16:05:17 -0700856
857 if (data[0] != WACOM_REPORT_DEVICE_LIST)
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200858 return;
859
860 memset(&remote_data, 0, sizeof(struct wacom_remote_data));
Aaron Skomra72b236d2015-08-20 16:05:17 -0700861
862 for (i = 0; i < WACOM_MAX_REMOTES; i++) {
863 int j = i * 6;
864 int serial = (data[j+6] << 16) + (data[j+5] << 8) + data[j+4];
865 bool connected = data[j+2];
866
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200867 remote_data.remote[i].serial = serial;
868 remote_data.remote[i].connected = connected;
Aaron Skomra72b236d2015-08-20 16:05:17 -0700869 }
870
Benjamin Tissoires83e6b402016-07-13 18:06:02 +0200871 spin_lock_irqsave(&remote->remote_lock, flags);
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200872
Benjamin Tissoires83e6b402016-07-13 18:06:02 +0200873 ret = kfifo_in(&remote->remote_fifo, &remote_data, sizeof(remote_data));
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200874 if (ret != sizeof(remote_data)) {
Benjamin Tissoires83e6b402016-07-13 18:06:02 +0200875 spin_unlock_irqrestore(&remote->remote_lock, flags);
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200876 hid_err(wacom->hdev, "Can't queue Remote status event.\n");
877 return;
878 }
879
Benjamin Tissoires83e6b402016-07-13 18:06:02 +0200880 spin_unlock_irqrestore(&remote->remote_lock, flags);
Benjamin Tissoirese6f28132016-07-13 18:06:01 +0200881
882 wacom_schedule_work(wacom_wac, WACOM_WORKER_REMOTE);
Aaron Skomra72b236d2015-08-20 16:05:17 -0700883}
884
Jason Gerecke16e0a6a2015-11-30 17:13:48 -0800885static int wacom_intuos_general(struct wacom_wac *wacom)
Ping Cheng3bea7332006-07-13 18:01:36 -0700886{
Jason Childse33da8a2010-02-17 22:38:31 -0800887 struct wacom_features *features = &wacom->features;
Ping Cheng3bea7332006-07-13 18:01:36 -0700888 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -0700889 struct input_dev *input = wacom->pen_input;
Jason Gerecke16e0a6a2015-11-30 17:13:48 -0800890 int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
Jason Gereckea8a09c82015-11-30 17:13:49 -0800891 unsigned char type = (data[1] >> 1) & 0x0F;
Jason Gerecke5f33f432015-11-30 17:13:51 -0800892 unsigned int x, y, distance, t;
Ping Cheng3bea7332006-07-13 18:01:36 -0700893
Jason Gerecke16e0a6a2015-11-30 17:13:48 -0800894 if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_CINTIQ &&
895 data[0] != WACOM_REPORT_INTUOS_PEN)
896 return 0;
897
Ping Chengc1b03f52016-01-08 17:16:06 -0800898 if (wacom->shared->touch_down)
899 return 1;
900
Ping Cheng599b0822016-01-08 17:14:54 -0800901 /* don't report events if we don't know the tool ID */
902 if (!wacom->id[idx]) {
903 /* but reschedule a read of the current tool */
904 wacom_intuos_schedule_prox_event(wacom);
905 return 1;
906 }
907
Ping Cheng4750f5f2016-01-08 17:15:48 -0800908 /*
909 * don't report events for invalid data
910 */
911 /* older I4 styli don't work with new Cintiqs */
912 if ((!((wacom->id[idx] >> 20) & 0x01) &&
913 (features->type == WACOM_21UX2)) ||
914 /* Only large Intuos support Lense Cursor */
915 (wacom->tool[idx] == BTN_TOOL_LENS &&
916 (features->type == INTUOS3 ||
917 features->type == INTUOS3S ||
918 features->type == INTUOS4 ||
919 features->type == INTUOS4S ||
920 features->type == INTUOS5 ||
921 features->type == INTUOS5S ||
922 features->type == INTUOSPM ||
923 features->type == INTUOSPS)) ||
924 /* Cintiq doesn't send data when RDY bit isn't set */
925 (features->type == CINTIQ && !(data[1] & 0x40)))
926 return 1;
927
Jason Gerecke5f33f432015-11-30 17:13:51 -0800928 x = (be16_to_cpup((__be16 *)&data[2]) << 1) | ((data[9] >> 1) & 1);
929 y = (be16_to_cpup((__be16 *)&data[4]) << 1) | (data[9] & 1);
930 distance = data[9] >> 2;
931 if (features->type < INTUOS3S) {
932 x >>= 1;
933 y >>= 1;
934 distance >>= 1;
Jason Gerecke16e0a6a2015-11-30 17:13:48 -0800935 }
Jason Gerecke5f33f432015-11-30 17:13:51 -0800936 input_report_abs(input, ABS_X, x);
937 input_report_abs(input, ABS_Y, y);
938 input_report_abs(input, ABS_DISTANCE, distance);
Jason Gerecke16e0a6a2015-11-30 17:13:48 -0800939
Jason Gereckea8a09c82015-11-30 17:13:49 -0800940 switch (type) {
941 case 0x00:
942 case 0x01:
943 case 0x02:
944 case 0x03:
945 /* general pen packet */
Jason Gerecke5f33f432015-11-30 17:13:51 -0800946 t = (data[6] << 3) | ((data[7] & 0xC0) >> 5) | (data[1] & 1);
947 if (features->pressure_max < 2047)
948 t >>= 1;
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700949 input_report_abs(input, ABS_PRESSURE, t);
Ping Chengeda01da2015-09-23 13:51:15 -0700950 if (features->type != INTUOSHT2) {
951 input_report_abs(input, ABS_TILT_X,
Jason Gereckeec5fc1c2014-11-18 16:50:08 -0800952 (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
Ping Chengeda01da2015-09-23 13:51:15 -0700953 input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
954 }
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700955 input_report_key(input, BTN_STYLUS, data[1] & 2);
956 input_report_key(input, BTN_STYLUS2, data[1] & 4);
957 input_report_key(input, BTN_TOUCH, t > 10);
Jason Gereckea8a09c82015-11-30 17:13:49 -0800958 break;
Ping Cheng3bea7332006-07-13 18:01:36 -0700959
Jason Gereckea8a09c82015-11-30 17:13:49 -0800960 case 0x0a:
Jason Gereckea8a09c82015-11-30 17:13:49 -0800961 /* airbrush second packet */
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700962 input_report_abs(input, ABS_WHEEL,
Ping Cheng3bea7332006-07-13 18:01:36 -0700963 (data[6] << 2) | ((data[7] >> 6) & 3));
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -0700964 input_report_abs(input, ABS_TILT_X,
Jason Gereckeec5fc1c2014-11-18 16:50:08 -0800965 (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
966 input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
Jason Gereckea8a09c82015-11-30 17:13:49 -0800967 break;
968
969 case 0x05:
Jason Gereckea8a09c82015-11-30 17:13:49 -0800970 /* Rotation packet */
971 if (features->type >= INTUOS3S) {
972 /* I3 marker pen rotation */
973 t = (data[6] << 3) | ((data[7] >> 5) & 7);
974 t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
975 ((t-1) / 2 + 450)) : (450 - t / 2) ;
976 input_report_abs(input, ABS_Z, t);
977 } else {
Jason Gerecke571f5722015-11-30 17:13:50 -0800978 /* 4D mouse 2nd packet */
Jason Gereckea8a09c82015-11-30 17:13:49 -0800979 t = (data[6] << 3) | ((data[7] >> 5) & 7);
980 input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
981 ((t - 1) / 2) : -t / 2);
982 }
983 break;
Ping Cheng3bea7332006-07-13 18:01:36 -0700984
Jason Gereckea8a09c82015-11-30 17:13:49 -0800985 case 0x04:
Jason Gerecke571f5722015-11-30 17:13:50 -0800986 /* 4D mouse 1st packet */
987 input_report_key(input, BTN_LEFT, data[8] & 0x01);
988 input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
989 input_report_key(input, BTN_RIGHT, data[8] & 0x04);
990
991 input_report_key(input, BTN_SIDE, data[8] & 0x20);
992 input_report_key(input, BTN_EXTRA, data[8] & 0x10);
993 t = (data[6] << 2) | ((data[7] >> 6) & 3);
994 input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
995 break;
996
Jason Gereckea8a09c82015-11-30 17:13:49 -0800997 case 0x06:
Jason Gerecke571f5722015-11-30 17:13:50 -0800998 /* I4 mouse */
999 input_report_key(input, BTN_LEFT, data[6] & 0x01);
1000 input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
1001 input_report_key(input, BTN_RIGHT, data[6] & 0x04);
1002 input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
1003 - ((data[7] & 0x40) >> 6));
1004 input_report_key(input, BTN_SIDE, data[6] & 0x08);
1005 input_report_key(input, BTN_EXTRA, data[6] & 0x10);
1006
1007 input_report_abs(input, ABS_TILT_X,
1008 (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
1009 input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
1010 break;
1011
Jason Gereckea8a09c82015-11-30 17:13:49 -08001012 case 0x08:
Jason Gerecke571f5722015-11-30 17:13:50 -08001013 if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
1014 /* 2D mouse packet */
1015 input_report_key(input, BTN_LEFT, data[8] & 0x04);
1016 input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
1017 input_report_key(input, BTN_RIGHT, data[8] & 0x10);
1018 input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
1019 - ((data[8] & 0x02) >> 1));
Ping Cheng3bea7332006-07-13 18:01:36 -07001020
Jason Gerecke571f5722015-11-30 17:13:50 -08001021 /* I3 2D mouse side buttons */
1022 if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
1023 input_report_key(input, BTN_SIDE, data[8] & 0x40);
1024 input_report_key(input, BTN_EXTRA, data[8] & 0x20);
Ping Cheng3bea7332006-07-13 18:01:36 -07001025 }
Jason Gereckea8a09c82015-11-30 17:13:49 -08001026 }
Jason Gerecke571f5722015-11-30 17:13:50 -08001027 else if (wacom->tool[idx] == BTN_TOOL_LENS) {
Ping Cheng3bea7332006-07-13 18:01:36 -07001028 /* Lens cursor packets */
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07001029 input_report_key(input, BTN_LEFT, data[8] & 0x01);
1030 input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
1031 input_report_key(input, BTN_RIGHT, data[8] & 0x04);
1032 input_report_key(input, BTN_SIDE, data[8] & 0x10);
1033 input_report_key(input, BTN_EXTRA, data[8] & 0x08);
Ping Cheng3bea7332006-07-13 18:01:36 -07001034 }
Jason Gereckea8a09c82015-11-30 17:13:49 -08001035 break;
1036
Jason Gerecke571f5722015-11-30 17:13:50 -08001037 case 0x07:
Jason Gereckea8a09c82015-11-30 17:13:49 -08001038 case 0x09:
Jason Gerecke571f5722015-11-30 17:13:50 -08001039 case 0x0b:
Jason Gereckea8a09c82015-11-30 17:13:49 -08001040 case 0x0c:
1041 case 0x0d:
1042 case 0x0e:
1043 case 0x0f:
1044 /* unhandled */
1045 break;
Ping Cheng3bea7332006-07-13 18:01:36 -07001046 }
Ping Cheng3bea7332006-07-13 18:01:36 -07001047
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07001048 input_report_abs(input, ABS_MISC, wacom->id[idx]); /* report tool id */
1049 input_report_key(input, wacom->tool[idx], 1);
1050 input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
Ping Chengb3bd7ef2015-01-09 11:05:13 -08001051 wacom->reporting_data = true;
Jason Gerecke16e0a6a2015-11-30 17:13:48 -08001052 return 2;
Ping Cheng3bea7332006-07-13 18:01:36 -07001053}
1054
1055static int wacom_intuos_irq(struct wacom_wac *wacom)
1056{
Ping Cheng3bea7332006-07-13 18:01:36 -07001057 unsigned char *data = wacom->data;
1058 struct input_dev *input = wacom->pen_input;
Jason Gerecke16e0a6a2015-11-30 17:13:48 -08001059 int result;
Ping Cheng3bea7332006-07-13 18:01:36 -07001060
1061 if (data[0] != WACOM_REPORT_PENABLED &&
Jason Gerecke06109992015-11-30 17:13:52 -08001062 data[0] != WACOM_REPORT_INTUOS_ID1 &&
1063 data[0] != WACOM_REPORT_INTUOS_ID2 &&
Ping Cheng3bea7332006-07-13 18:01:36 -07001064 data[0] != WACOM_REPORT_INTUOSPAD &&
1065 data[0] != WACOM_REPORT_INTUOS_PEN &&
1066 data[0] != WACOM_REPORT_CINTIQ &&
1067 data[0] != WACOM_REPORT_CINTIQPAD &&
1068 data[0] != WACOM_REPORT_INTUOS5PAD) {
1069 dev_dbg(input->dev.parent,
1070 "%s: received unknown report #%d\n", __func__, data[0]);
1071 return 0;
1072 }
1073
Jason Gerecke16e0a6a2015-11-30 17:13:48 -08001074 /* process pad events */
1075 result = wacom_intuos_pad(wacom);
1076 if (result)
1077 return result;
Ping Cheng3bea7332006-07-13 18:01:36 -07001078
1079 /* process in/out prox events */
1080 result = wacom_intuos_inout(wacom);
1081 if (result)
Jason Gerecke16e0a6a2015-11-30 17:13:48 -08001082 return result - 1;
Ping Cheng3bea7332006-07-13 18:01:36 -07001083
1084 /* process general packets */
Jason Gerecke16e0a6a2015-11-30 17:13:48 -08001085 result = wacom_intuos_general(wacom);
1086 if (result)
1087 return result - 1;
Ping Cheng3bea7332006-07-13 18:01:36 -07001088
Jason Gerecke16e0a6a2015-11-30 17:13:48 -08001089 return 0;
Ping Cheng3bea7332006-07-13 18:01:36 -07001090}
1091
Jason Gereckeb1e42792012-10-21 00:38:04 -07001092static int int_dist(int x1, int y1, int x2, int y2)
1093{
1094 int x = x2 - x1;
1095 int y = y2 - y1;
1096
1097 return int_sqrt(x*x + y*y);
1098}
1099
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07001100static void wacom_intuos_bt_process_data(struct wacom_wac *wacom,
1101 unsigned char *data)
1102{
1103 memcpy(wacom->data, data, 10);
1104 wacom_intuos_irq(wacom);
1105
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001106 input_sync(wacom->pen_input);
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07001107 if (wacom->pad_input)
1108 input_sync(wacom->pad_input);
1109}
1110
1111static int wacom_intuos_bt_irq(struct wacom_wac *wacom, size_t len)
1112{
1113 unsigned char data[WACOM_PKGLEN_MAX];
1114 int i = 1;
1115 unsigned power_raw, battery_capacity, bat_charging, ps_connected;
1116
1117 memcpy(data, wacom->data, len);
1118
1119 switch (data[0]) {
1120 case 0x04:
1121 wacom_intuos_bt_process_data(wacom, data + i);
1122 i += 10;
1123 /* fall through */
1124 case 0x03:
1125 wacom_intuos_bt_process_data(wacom, data + i);
1126 i += 10;
1127 wacom_intuos_bt_process_data(wacom, data + i);
1128 i += 10;
1129 power_raw = data[i];
1130 bat_charging = (power_raw & 0x08) ? 1 : 0;
1131 ps_connected = (power_raw & 0x10) ? 1 : 0;
1132 battery_capacity = batcap_i4[power_raw & 0x07];
Jason Gerecke953f2c52015-03-06 11:47:39 -08001133 wacom_notify_battery(wacom, battery_capacity, bat_charging,
Jason Gerecke71fa6412015-03-11 10:25:41 -07001134 battery_capacity || bat_charging,
Jason Gerecke953f2c52015-03-06 11:47:39 -08001135 ps_connected);
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07001136 break;
1137 default:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001138 dev_dbg(wacom->pen_input->dev.parent,
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07001139 "Unknown report: %d,%d size:%zu\n",
1140 data[0], data[1], len);
1141 return 0;
1142 }
1143 return 0;
1144}
1145
Ping Cheng7d059ed2015-03-20 14:57:21 -07001146static int wacom_wac_finger_count_touches(struct wacom_wac *wacom)
1147{
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001148 struct input_dev *input = wacom->touch_input;
Ping Cheng7d059ed2015-03-20 14:57:21 -07001149 unsigned touch_max = wacom->features.touch_max;
1150 int count = 0;
1151 int i;
1152
Ping Cheng26ba61f2015-05-19 17:42:02 -07001153 if (!touch_max)
1154 return 0;
1155
Jason Gerecke71b5c472015-04-15 17:22:32 -07001156 if (touch_max == 1)
1157 return test_bit(BTN_TOUCH, input->key) &&
Ping Cheng7d059ed2015-03-20 14:57:21 -07001158 !wacom->shared->stylus_in_proximity;
1159
1160 for (i = 0; i < input->mt->num_slots; i++) {
1161 struct input_mt_slot *ps = &input->mt->slots[i];
1162 int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
1163 if (id >= 0)
1164 count++;
1165 }
1166
1167 return count;
1168}
1169
Jason Gereckeb1e42792012-10-21 00:38:04 -07001170static int wacom_24hdt_irq(struct wacom_wac *wacom)
1171{
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001172 struct input_dev *input = wacom->touch_input;
Jason Gerecke74b63412014-04-19 13:50:22 -07001173 unsigned char *data = wacom->data;
Jason Gereckeb1e42792012-10-21 00:38:04 -07001174 int i;
Ping Chenge0d41fd2015-02-20 14:27:30 -08001175 int current_num_contacts = data[61];
Jason Gereckeb1e42792012-10-21 00:38:04 -07001176 int contacts_to_send = 0;
Ping Cheng500d4162015-01-27 13:30:03 -08001177 int num_contacts_left = 4; /* maximum contacts per packet */
1178 int byte_per_packet = WACOM_BYTES_PER_24HDT_PACKET;
1179 int y_offset = 2;
1180
1181 if (wacom->features.type == WACOM_27QHDT) {
1182 current_num_contacts = data[63];
1183 num_contacts_left = 10;
1184 byte_per_packet = WACOM_BYTES_PER_QHDTHID_PACKET;
1185 y_offset = 0;
Ping Cheng500d4162015-01-27 13:30:03 -08001186 }
Jason Gereckeb1e42792012-10-21 00:38:04 -07001187
1188 /*
1189 * First packet resets the counter since only the first
1190 * packet in series will have non-zero current_num_contacts.
1191 */
Ping Cheng7d059ed2015-03-20 14:57:21 -07001192 if (current_num_contacts)
Jason Gereckeb1e42792012-10-21 00:38:04 -07001193 wacom->num_contacts_left = current_num_contacts;
1194
Ping Cheng500d4162015-01-27 13:30:03 -08001195 contacts_to_send = min(num_contacts_left, wacom->num_contacts_left);
Jason Gereckeb1e42792012-10-21 00:38:04 -07001196
1197 for (i = 0; i < contacts_to_send; i++) {
Ping Cheng500d4162015-01-27 13:30:03 -08001198 int offset = (byte_per_packet * i) + 1;
Ping Cheng9b61aa82015-01-28 09:42:59 -08001199 bool touch = (data[offset] & 0x1) && !wacom->shared->stylus_in_proximity;
Ping Cheng02295e62013-01-04 23:56:00 -08001200 int slot = input_mt_get_slot_by_key(input, data[offset + 1]);
Jason Gereckeb1e42792012-10-21 00:38:04 -07001201
1202 if (slot < 0)
1203 continue;
1204 input_mt_slot(input, slot);
1205 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1206
1207 if (touch) {
Jason Gereckeedc8e20a2014-05-14 16:53:30 -07001208 int t_x = get_unaligned_le16(&data[offset + 2]);
Ping Cheng500d4162015-01-27 13:30:03 -08001209 int t_y = get_unaligned_le16(&data[offset + 4 + y_offset]);
Jason Gereckeb1e42792012-10-21 00:38:04 -07001210
1211 input_report_abs(input, ABS_MT_POSITION_X, t_x);
1212 input_report_abs(input, ABS_MT_POSITION_Y, t_y);
Ping Cheng500d4162015-01-27 13:30:03 -08001213
1214 if (wacom->features.type != WACOM_27QHDT) {
1215 int c_x = get_unaligned_le16(&data[offset + 4]);
1216 int c_y = get_unaligned_le16(&data[offset + 8]);
1217 int w = get_unaligned_le16(&data[offset + 10]);
1218 int h = get_unaligned_le16(&data[offset + 12]);
1219
1220 input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
1221 input_report_abs(input, ABS_MT_WIDTH_MAJOR,
1222 min(w, h) + int_dist(t_x, t_y, c_x, c_y));
1223 input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
1224 input_report_abs(input, ABS_MT_ORIENTATION, w > h);
1225 }
Jason Gereckeb1e42792012-10-21 00:38:04 -07001226 }
Jason Gereckeb1e42792012-10-21 00:38:04 -07001227 }
Benjamin Tissoires9a1c0012015-02-17 14:19:46 -05001228 input_mt_sync_frame(input);
Jason Gereckeb1e42792012-10-21 00:38:04 -07001229
1230 wacom->num_contacts_left -= contacts_to_send;
Ping Chenge0d41fd2015-02-20 14:27:30 -08001231 if (wacom->num_contacts_left <= 0) {
Jason Gereckeb1e42792012-10-21 00:38:04 -07001232 wacom->num_contacts_left = 0;
Ping Cheng7d059ed2015-03-20 14:57:21 -07001233 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
Ping Chenge0d41fd2015-02-20 14:27:30 -08001234 }
Jason Gereckeb1e42792012-10-21 00:38:04 -07001235 return 1;
1236}
1237
Ping Cheng19635182012-04-29 21:09:18 -07001238static int wacom_mt_touch(struct wacom_wac *wacom)
1239{
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001240 struct input_dev *input = wacom->touch_input;
Jason Gerecke74b63412014-04-19 13:50:22 -07001241 unsigned char *data = wacom->data;
Ping Cheng19635182012-04-29 21:09:18 -07001242 int i;
1243 int current_num_contacts = data[2];
1244 int contacts_to_send = 0;
Ping Cheng6afdc282012-11-03 12:16:15 -07001245 int x_offset = 0;
1246
1247 /* MTTPC does not support Height and Width */
Jason Gerecked51ddb22014-05-14 17:14:29 -07001248 if (wacom->features.type == MTTPC || wacom->features.type == MTTPC_B)
Ping Cheng6afdc282012-11-03 12:16:15 -07001249 x_offset = -4;
Ping Cheng19635182012-04-29 21:09:18 -07001250
1251 /*
1252 * First packet resets the counter since only the first
1253 * packet in series will have non-zero current_num_contacts.
1254 */
Ping Cheng7d059ed2015-03-20 14:57:21 -07001255 if (current_num_contacts)
Ping Cheng19635182012-04-29 21:09:18 -07001256 wacom->num_contacts_left = current_num_contacts;
1257
1258 /* There are at most 5 contacts per packet */
1259 contacts_to_send = min(5, wacom->num_contacts_left);
1260
1261 for (i = 0; i < contacts_to_send; i++) {
Ping Cheng6afdc282012-11-03 12:16:15 -07001262 int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
Ping Cheng9b61aa82015-01-28 09:42:59 -08001263 bool touch = (data[offset] & 0x1) && !wacom->shared->stylus_in_proximity;
Jason Gereckeedc8e20a2014-05-14 16:53:30 -07001264 int id = get_unaligned_le16(&data[offset + 1]);
Ping Cheng02295e62013-01-04 23:56:00 -08001265 int slot = input_mt_get_slot_by_key(input, id);
Ping Cheng19635182012-04-29 21:09:18 -07001266
1267 if (slot < 0)
1268 continue;
1269
1270 input_mt_slot(input, slot);
1271 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1272 if (touch) {
Jason Gereckeedc8e20a2014-05-14 16:53:30 -07001273 int x = get_unaligned_le16(&data[offset + x_offset + 7]);
1274 int y = get_unaligned_le16(&data[offset + x_offset + 9]);
Ping Cheng19635182012-04-29 21:09:18 -07001275 input_report_abs(input, ABS_MT_POSITION_X, x);
1276 input_report_abs(input, ABS_MT_POSITION_Y, y);
1277 }
Ping Cheng19635182012-04-29 21:09:18 -07001278 }
Benjamin Tissoires9a1c0012015-02-17 14:19:46 -05001279 input_mt_sync_frame(input);
Ping Cheng19635182012-04-29 21:09:18 -07001280
1281 wacom->num_contacts_left -= contacts_to_send;
Ping Chenge0d41fd2015-02-20 14:27:30 -08001282 if (wacom->num_contacts_left <= 0) {
Ping Cheng19635182012-04-29 21:09:18 -07001283 wacom->num_contacts_left = 0;
Ping Cheng7d059ed2015-03-20 14:57:21 -07001284 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
Ping Chenge0d41fd2015-02-20 14:27:30 -08001285 }
Ping Cheng19635182012-04-29 21:09:18 -07001286 return 1;
1287}
1288
Ping Cheng84eb5aa2011-03-12 20:35:18 -08001289static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
1290{
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001291 struct input_dev *input = wacom->touch_input;
Ping Cheng84eb5aa2011-03-12 20:35:18 -08001292 unsigned char *data = wacom->data;
Ping Cheng84eb5aa2011-03-12 20:35:18 -08001293 int i;
1294
1295 for (i = 0; i < 2; i++) {
1296 int p = data[1] & (1 << i);
1297 bool touch = p && !wacom->shared->stylus_in_proximity;
1298
1299 input_mt_slot(input, i);
1300 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1301 if (touch) {
1302 int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
1303 int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
1304
1305 input_report_abs(input, ABS_MT_POSITION_X, x);
1306 input_report_abs(input, ABS_MT_POSITION_Y, y);
Ping Cheng84eb5aa2011-03-12 20:35:18 -08001307 }
1308 }
Benjamin Tissoires9a1c0012015-02-17 14:19:46 -05001309 input_mt_sync_frame(input);
Ping Cheng84eb5aa2011-03-12 20:35:18 -08001310
1311 /* keep touch state for pen event */
Ping Cheng7d059ed2015-03-20 14:57:21 -07001312 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
Ping Cheng84eb5aa2011-03-12 20:35:18 -08001313
Ping Cheng84eb5aa2011-03-12 20:35:18 -08001314 return 1;
1315}
1316
Ping Chenga43c7c52011-03-12 20:34:42 -08001317static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
Ping Chengec67bbe2009-12-15 00:35:24 -08001318{
Jason Gerecke74b63412014-04-19 13:50:22 -07001319 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001320 struct input_dev *input = wacom->touch_input;
Ping Chenge0d41fd2015-02-20 14:27:30 -08001321 bool prox = !wacom->shared->stylus_in_proximity;
Ping Chenga43c7c52011-03-12 20:34:42 -08001322 int x = 0, y = 0;
Ping Chengec67bbe2009-12-15 00:35:24 -08001323
Ping Cheng19635182012-04-29 21:09:18 -07001324 if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
1325 return 0;
1326
Ping Chenge0d41fd2015-02-20 14:27:30 -08001327 if (len == WACOM_PKGLEN_TPC1FG) {
1328 prox = prox && (data[0] & 0x01);
1329 x = get_unaligned_le16(&data[1]);
1330 y = get_unaligned_le16(&data[3]);
1331 } else if (len == WACOM_PKGLEN_TPC1FG_B) {
1332 prox = prox && (data[2] & 0x01);
1333 x = get_unaligned_le16(&data[3]);
1334 y = get_unaligned_le16(&data[5]);
1335 } else {
1336 prox = prox && (data[1] & 0x01);
1337 x = le16_to_cpup((__le16 *)&data[2]);
1338 y = le16_to_cpup((__le16 *)&data[4]);
1339 }
Ping Chenga43c7c52011-03-12 20:34:42 -08001340
1341 if (prox) {
1342 input_report_abs(input, ABS_X, x);
1343 input_report_abs(input, ABS_Y, y);
Ping Chengec67bbe2009-12-15 00:35:24 -08001344 }
Ping Chenga43c7c52011-03-12 20:34:42 -08001345 input_report_key(input, BTN_TOUCH, prox);
1346
1347 /* keep touch state for pen events */
1348 wacom->shared->touch_down = prox;
1349
1350 return 1;
Ping Chengec67bbe2009-12-15 00:35:24 -08001351}
1352
Ping Cheng8aa9a9a2011-03-12 20:34:11 -08001353static int wacom_tpc_pen(struct wacom_wac *wacom)
Ping Cheng545f4e92008-11-24 11:44:27 -05001354{
Jason Gerecke74b63412014-04-19 13:50:22 -07001355 unsigned char *data = wacom->data;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001356 struct input_dev *input = wacom->pen_input;
Ping Chenga43c7c52011-03-12 20:34:42 -08001357 bool prox = data[1] & 0x20;
Ping Cheng8aa9a9a2011-03-12 20:34:11 -08001358
Ping Chenga43c7c52011-03-12 20:34:42 -08001359 if (!wacom->shared->stylus_in_proximity) /* first in prox */
Ping Cheng8aa9a9a2011-03-12 20:34:11 -08001360 /* Going into proximity select tool */
1361 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
Ping Cheng8aa9a9a2011-03-12 20:34:11 -08001362
Ping Chenga43c7c52011-03-12 20:34:42 -08001363 /* keep pen state for touch events */
1364 wacom->shared->stylus_in_proximity = prox;
Ping Cheng8aa9a9a2011-03-12 20:34:11 -08001365
Ping Chenga43c7c52011-03-12 20:34:42 -08001366 /* send pen events only when touch is up or forced out */
1367 if (!wacom->shared->touch_down) {
1368 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
1369 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
1370 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
1371 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
Jason Gerecke0b335ca2014-07-24 13:15:31 -07001372 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x07) << 8) | data[6]);
Ping Chenga43c7c52011-03-12 20:34:42 -08001373 input_report_key(input, BTN_TOUCH, data[1] & 0x05);
1374 input_report_key(input, wacom->tool[0], prox);
1375 return 1;
1376 }
1377
1378 return 0;
Ping Cheng8aa9a9a2011-03-12 20:34:11 -08001379}
1380
1381static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
1382{
Jason Gerecke74b63412014-04-19 13:50:22 -07001383 unsigned char *data = wacom->data;
Ping Cheng545f4e92008-11-24 11:44:27 -05001384
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001385 if (wacom->pen_input)
1386 dev_dbg(wacom->pen_input->dev.parent,
1387 "%s: received report #%d\n", __func__, data[0]);
1388 else if (wacom->touch_input)
1389 dev_dbg(wacom->touch_input->dev.parent,
1390 "%s: received report #%d\n", __func__, data[0]);
Ping Cheng545f4e92008-11-24 11:44:27 -05001391
Ping Cheng31175a82012-01-31 00:07:33 -08001392 switch (len) {
1393 case WACOM_PKGLEN_TPC1FG:
Ping Cheng19635182012-04-29 21:09:18 -07001394 return wacom_tpc_single_touch(wacom, len);
Ping Cheng31175a82012-01-31 00:07:33 -08001395
1396 case WACOM_PKGLEN_TPC2FG:
Ping Cheng19635182012-04-29 21:09:18 -07001397 return wacom_tpc_mt_touch(wacom);
Ping Cheng31175a82012-01-31 00:07:33 -08001398
Jason Gerecked51ddb22014-05-14 17:14:29 -07001399 case WACOM_PKGLEN_PENABLED:
1400 return wacom_tpc_pen(wacom);
1401
Ping Cheng31175a82012-01-31 00:07:33 -08001402 default:
1403 switch (data[0]) {
1404 case WACOM_REPORT_TPC1FG:
1405 case WACOM_REPORT_TPCHID:
1406 case WACOM_REPORT_TPCST:
Ping Chengac173832012-06-12 00:15:06 -07001407 case WACOM_REPORT_TPC1FGE:
Ping Cheng31175a82012-01-31 00:07:33 -08001408 return wacom_tpc_single_touch(wacom, len);
1409
Ping Cheng19635182012-04-29 21:09:18 -07001410 case WACOM_REPORT_TPCMT:
Jason Gerecked51ddb22014-05-14 17:14:29 -07001411 case WACOM_REPORT_TPCMT2:
Ping Cheng19635182012-04-29 21:09:18 -07001412 return wacom_mt_touch(wacom);
1413
Ping Cheng31175a82012-01-31 00:07:33 -08001414 case WACOM_REPORT_PENABLED:
1415 return wacom_tpc_pen(wacom);
1416 }
1417 }
Ping Cheng545f4e92008-11-24 11:44:27 -05001418
Ping Cheng8aa9a9a2011-03-12 20:34:11 -08001419 return 0;
Ping Cheng545f4e92008-11-24 11:44:27 -05001420}
1421
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001422static void wacom_map_usage(struct input_dev *input, struct hid_usage *usage,
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001423 struct hid_field *field, __u8 type, __u16 code, int fuzz)
1424{
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001425 int fmin = field->logical_minimum;
1426 int fmax = field->logical_maximum;
1427
1428 usage->type = type;
1429 usage->code = code;
1430
1431 set_bit(type, input->evbit);
1432
1433 switch (type) {
1434 case EV_ABS:
1435 input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
1436 input_abs_set_res(input, code,
1437 hidinput_calc_abs_res(field, code));
1438 break;
1439 case EV_KEY:
1440 input_set_capability(input, EV_KEY, code);
1441 break;
1442 case EV_MSC:
1443 input_set_capability(input, EV_MSC, code);
1444 break;
1445 }
1446}
1447
1448static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
1449 struct hid_field *field, struct hid_usage *usage)
1450{
1451 struct wacom *wacom = hid_get_drvdata(hdev);
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001452 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1453 struct input_dev *input = wacom_wac->pen_input;
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001454
1455 switch (usage->hid) {
1456 case HID_GD_X:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001457 wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001458 break;
1459 case HID_GD_Y:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001460 wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001461 break;
1462 case HID_DG_TIPPRESSURE:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001463 wacom_map_usage(input, usage, field, EV_ABS, ABS_PRESSURE, 0);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001464 break;
1465 case HID_DG_INRANGE:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001466 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001467 break;
1468 case HID_DG_INVERT:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001469 wacom_map_usage(input, usage, field, EV_KEY,
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001470 BTN_TOOL_RUBBER, 0);
1471 break;
1472 case HID_DG_ERASER:
1473 case HID_DG_TIPSWITCH:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001474 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001475 break;
1476 case HID_DG_BARRELSWITCH:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001477 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS, 0);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001478 break;
1479 case HID_DG_BARRELSWITCH2:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001480 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS2, 0);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001481 break;
1482 case HID_DG_TOOLSERIALNUMBER:
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001483 wacom_map_usage(input, usage, field, EV_MSC, MSC_SERIAL, 0);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001484 break;
1485 }
1486}
1487
1488static int wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
1489 struct hid_usage *usage, __s32 value)
1490{
1491 struct wacom *wacom = hid_get_drvdata(hdev);
1492 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001493 struct input_dev *input = wacom_wac->pen_input;
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001494
1495 /* checking which Tool / tip switch to send */
1496 switch (usage->hid) {
1497 case HID_DG_INRANGE:
1498 wacom_wac->hid_data.inrange_state = value;
1499 return 0;
1500 case HID_DG_INVERT:
1501 wacom_wac->hid_data.invert_state = value;
1502 return 0;
1503 case HID_DG_ERASER:
1504 case HID_DG_TIPSWITCH:
1505 wacom_wac->hid_data.tipswitch |= value;
1506 return 0;
1507 }
1508
1509 /* send pen events only when touch is up or forced out */
1510 if (!usage->type || wacom_wac->shared->touch_down)
1511 return 0;
1512
1513 input_event(input, usage->type, usage->code, value);
1514
1515 return 0;
1516}
1517
Jason Gerecke06324e02015-07-21 11:07:23 -07001518static void wacom_wac_pen_pre_report(struct hid_device *hdev,
1519 struct hid_report *report)
1520{
1521 return;
1522}
1523
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001524static void wacom_wac_pen_report(struct hid_device *hdev,
1525 struct hid_report *report)
1526{
1527 struct wacom *wacom = hid_get_drvdata(hdev);
1528 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001529 struct input_dev *input = wacom_wac->pen_input;
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001530 bool prox = wacom_wac->hid_data.inrange_state;
1531
1532 if (!wacom_wac->shared->stylus_in_proximity) /* first in prox */
1533 /* Going into proximity select tool */
1534 wacom_wac->tool[0] = wacom_wac->hid_data.invert_state ?
1535 BTN_TOOL_RUBBER : BTN_TOOL_PEN;
1536
1537 /* keep pen state for touch events */
1538 wacom_wac->shared->stylus_in_proximity = prox;
1539
1540 /* send pen events only when touch is up or forced out */
1541 if (!wacom_wac->shared->touch_down) {
1542 input_report_key(input, BTN_TOUCH,
1543 wacom_wac->hid_data.tipswitch);
1544 input_report_key(input, wacom_wac->tool[0], prox);
1545
1546 wacom_wac->hid_data.tipswitch = false;
1547
1548 input_sync(input);
1549 }
1550}
1551
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001552static void wacom_wac_finger_usage_mapping(struct hid_device *hdev,
1553 struct hid_field *field, struct hid_usage *usage)
1554{
1555 struct wacom *wacom = hid_get_drvdata(hdev);
1556 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
Jason Gerecke601a22f2014-12-10 16:26:04 -08001557 struct wacom_features *features = &wacom_wac->features;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001558 struct input_dev *input = wacom_wac->touch_input;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001559 unsigned touch_max = wacom_wac->features.touch_max;
1560
1561 switch (usage->hid) {
1562 case HID_GD_X:
Jason Gerecke601a22f2014-12-10 16:26:04 -08001563 features->last_slot_field = usage->hid;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001564 if (touch_max == 1)
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001565 wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001566 else
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001567 wacom_map_usage(input, usage, field, EV_ABS,
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001568 ABS_MT_POSITION_X, 4);
1569 break;
1570 case HID_GD_Y:
Jason Gerecke601a22f2014-12-10 16:26:04 -08001571 features->last_slot_field = usage->hid;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001572 if (touch_max == 1)
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001573 wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001574 else
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001575 wacom_map_usage(input, usage, field, EV_ABS,
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001576 ABS_MT_POSITION_Y, 4);
1577 break;
Jason Gerecke488abb52015-07-21 11:07:25 -07001578 case HID_DG_WIDTH:
1579 case HID_DG_HEIGHT:
1580 features->last_slot_field = usage->hid;
1581 wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MAJOR, 0);
1582 wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MINOR, 0);
1583 input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0);
1584 break;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001585 case HID_DG_CONTACTID:
Jason Gerecke601a22f2014-12-10 16:26:04 -08001586 features->last_slot_field = usage->hid;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001587 break;
1588 case HID_DG_INRANGE:
Jason Gerecke601a22f2014-12-10 16:26:04 -08001589 features->last_slot_field = usage->hid;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001590 break;
1591 case HID_DG_INVERT:
Jason Gerecke601a22f2014-12-10 16:26:04 -08001592 features->last_slot_field = usage->hid;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001593 break;
1594 case HID_DG_TIPSWITCH:
Jason Gerecke601a22f2014-12-10 16:26:04 -08001595 features->last_slot_field = usage->hid;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001596 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001597 break;
Jason Gerecke1b5d514a2015-07-21 11:07:24 -07001598 case HID_DG_CONTACTCOUNT:
Jason Gerecke499522c2015-10-07 16:54:21 -07001599 wacom_wac->hid_data.cc_report = field->report->id;
Jason Gerecke1b5d514a2015-07-21 11:07:24 -07001600 wacom_wac->hid_data.cc_index = field->index;
1601 wacom_wac->hid_data.cc_value_index = usage->usage_index;
1602 break;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001603 }
1604}
1605
Jason Gerecke601a22f2014-12-10 16:26:04 -08001606static void wacom_wac_finger_slot(struct wacom_wac *wacom_wac,
1607 struct input_dev *input)
1608{
1609 struct hid_data *hid_data = &wacom_wac->hid_data;
1610 bool mt = wacom_wac->features.touch_max > 1;
1611 bool prox = hid_data->tipswitch &&
1612 !wacom_wac->shared->stylus_in_proximity;
1613
Jason Gerecke1b5d514a2015-07-21 11:07:24 -07001614 wacom_wac->hid_data.num_received++;
1615 if (wacom_wac->hid_data.num_received > wacom_wac->hid_data.num_expected)
1616 return;
1617
Jason Gerecke601a22f2014-12-10 16:26:04 -08001618 if (mt) {
1619 int slot;
1620
1621 slot = input_mt_get_slot_by_key(input, hid_data->id);
1622 input_mt_slot(input, slot);
1623 input_mt_report_slot_state(input, MT_TOOL_FINGER, prox);
1624 }
1625 else {
1626 input_report_key(input, BTN_TOUCH, prox);
1627 }
1628
1629 if (prox) {
1630 input_report_abs(input, mt ? ABS_MT_POSITION_X : ABS_X,
1631 hid_data->x);
1632 input_report_abs(input, mt ? ABS_MT_POSITION_Y : ABS_Y,
1633 hid_data->y);
Jason Gerecke488abb52015-07-21 11:07:25 -07001634
1635 if (test_bit(ABS_MT_TOUCH_MAJOR, input->absbit)) {
1636 input_report_abs(input, ABS_MT_TOUCH_MAJOR, max(hid_data->width, hid_data->height));
1637 input_report_abs(input, ABS_MT_TOUCH_MINOR, min(hid_data->width, hid_data->height));
1638 if (hid_data->width != hid_data->height)
1639 input_report_abs(input, ABS_MT_ORIENTATION, hid_data->width <= hid_data->height ? 0 : 1);
1640 }
Jason Gerecke601a22f2014-12-10 16:26:04 -08001641 }
1642}
1643
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001644static int wacom_wac_finger_event(struct hid_device *hdev,
1645 struct hid_field *field, struct hid_usage *usage, __s32 value)
1646{
1647 struct wacom *wacom = hid_get_drvdata(hdev);
1648 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1649
1650 switch (usage->hid) {
1651 case HID_GD_X:
1652 wacom_wac->hid_data.x = value;
1653 break;
1654 case HID_GD_Y:
1655 wacom_wac->hid_data.y = value;
1656 break;
Jason Gerecke488abb52015-07-21 11:07:25 -07001657 case HID_DG_WIDTH:
1658 wacom_wac->hid_data.width = value;
1659 break;
1660 case HID_DG_HEIGHT:
1661 wacom_wac->hid_data.height = value;
1662 break;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001663 case HID_DG_CONTACTID:
1664 wacom_wac->hid_data.id = value;
1665 break;
1666 case HID_DG_TIPSWITCH:
1667 wacom_wac->hid_data.tipswitch = value;
1668 break;
1669 }
1670
1671
Jason Gerecke601a22f2014-12-10 16:26:04 -08001672 if (usage->usage_index + 1 == field->report_count) {
1673 if (usage->hid == wacom_wac->features.last_slot_field)
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001674 wacom_wac_finger_slot(wacom_wac, wacom_wac->touch_input);
Jason Gerecke601a22f2014-12-10 16:26:04 -08001675 }
1676
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001677 return 0;
1678}
1679
Jason Gerecke06324e02015-07-21 11:07:23 -07001680static void wacom_wac_finger_pre_report(struct hid_device *hdev,
1681 struct hid_report *report)
1682{
Jason Gerecke1b5d514a2015-07-21 11:07:24 -07001683 struct wacom *wacom = hid_get_drvdata(hdev);
1684 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1685 struct hid_data* hid_data = &wacom_wac->hid_data;
1686
Jason Gerecke499522c2015-10-07 16:54:21 -07001687 if (hid_data->cc_report != 0 &&
1688 hid_data->cc_report != report->id) {
1689 int i;
1690
1691 hid_data->cc_report = report->id;
1692 hid_data->cc_index = -1;
1693 hid_data->cc_value_index = -1;
1694
1695 for (i = 0; i < report->maxfield; i++) {
1696 struct hid_field *field = report->field[i];
1697 int j;
1698
1699 for (j = 0; j < field->maxusage; j++) {
1700 if (field->usage[j].hid == HID_DG_CONTACTCOUNT) {
1701 hid_data->cc_index = i;
1702 hid_data->cc_value_index = j;
1703
1704 /* break */
1705 i = report->maxfield;
1706 j = field->maxusage;
1707 }
1708 }
1709 }
1710 }
Jason Gereckedf707932015-10-07 16:54:22 -07001711 if (hid_data->cc_report != 0 &&
1712 hid_data->cc_index >= 0) {
Jason Gerecke1b5d514a2015-07-21 11:07:24 -07001713 struct hid_field *field = report->field[hid_data->cc_index];
1714 int value = field->value[hid_data->cc_value_index];
1715 if (value)
1716 hid_data->num_expected = value;
1717 }
1718 else {
1719 hid_data->num_expected = wacom_wac->features.touch_max;
1720 }
Jason Gerecke06324e02015-07-21 11:07:23 -07001721}
1722
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001723static void wacom_wac_finger_report(struct hid_device *hdev,
1724 struct hid_report *report)
1725{
1726 struct wacom *wacom = hid_get_drvdata(hdev);
1727 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001728 struct input_dev *input = wacom_wac->touch_input;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001729 unsigned touch_max = wacom_wac->features.touch_max;
1730
Jason Gerecke1b5d514a2015-07-21 11:07:24 -07001731 /* If more packets of data are expected, give us a chance to
1732 * process them rather than immediately syncing a partial
1733 * update.
1734 */
1735 if (wacom_wac->hid_data.num_received < wacom_wac->hid_data.num_expected)
1736 return;
1737
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001738 if (touch_max > 1)
Jason Gerecke601a22f2014-12-10 16:26:04 -08001739 input_mt_sync_frame(input);
1740
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001741 input_sync(input);
Jason Gerecke1b5d514a2015-07-21 11:07:24 -07001742 wacom_wac->hid_data.num_received = 0;
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001743
1744 /* keep touch state for pen event */
Ping Cheng7d059ed2015-03-20 14:57:21 -07001745 wacom_wac->shared->touch_down = wacom_wac_finger_count_touches(wacom_wac);
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001746}
1747
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001748void wacom_wac_usage_mapping(struct hid_device *hdev,
1749 struct hid_field *field, struct hid_usage *usage)
1750{
1751 struct wacom *wacom = hid_get_drvdata(hdev);
1752 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
Jason Gereckee5bc8eb2016-08-08 12:06:29 -07001753 struct wacom_features *features = &wacom_wac->features;
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001754
1755 /* currently, only direct devices have proper hid report descriptors */
Jason Gereckee5bc8eb2016-08-08 12:06:29 -07001756 features->device_type |= WACOM_DEVICETYPE_DIRECT;
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001757
1758 if (WACOM_PEN_FIELD(field))
1759 return wacom_wac_pen_usage_mapping(hdev, field, usage);
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001760
1761 if (WACOM_FINGER_FIELD(field))
1762 return wacom_wac_finger_usage_mapping(hdev, field, usage);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001763}
1764
1765int wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
1766 struct hid_usage *usage, __s32 value)
1767{
1768 struct wacom *wacom = hid_get_drvdata(hdev);
1769
1770 if (wacom->wacom_wac.features.type != HID_GENERIC)
1771 return 0;
1772
1773 if (WACOM_PEN_FIELD(field))
1774 return wacom_wac_pen_event(hdev, field, usage, value);
1775
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001776 if (WACOM_FINGER_FIELD(field))
1777 return wacom_wac_finger_event(hdev, field, usage, value);
1778
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001779 return 0;
1780}
1781
Jason Gerecke06324e02015-07-21 11:07:23 -07001782static void wacom_report_events(struct hid_device *hdev, struct hid_report *report)
1783{
1784 int r;
1785
1786 for (r = 0; r < report->maxfield; r++) {
1787 struct hid_field *field;
1788 unsigned count, n;
1789
1790 field = report->field[r];
1791 count = field->report_count;
1792
1793 if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
1794 continue;
1795
1796 for (n = 0; n < count; n++)
1797 wacom_wac_event(hdev, field, &field->usage[n], field->value[n]);
1798 }
1799}
1800
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001801void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
1802{
1803 struct wacom *wacom = hid_get_drvdata(hdev);
1804 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1805 struct hid_field *field = report->field[0];
1806
1807 if (wacom_wac->features.type != HID_GENERIC)
1808 return;
1809
1810 if (WACOM_PEN_FIELD(field))
Jason Gerecke06324e02015-07-21 11:07:23 -07001811 wacom_wac_pen_pre_report(hdev, report);
1812
1813 if (WACOM_FINGER_FIELD(field))
1814 wacom_wac_finger_pre_report(hdev, report);
1815
1816 wacom_report_events(hdev, report);
1817
1818 if (WACOM_PEN_FIELD(field))
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001819 return wacom_wac_pen_report(hdev, report);
Benjamin Tissoires5ae6e892014-09-23 12:08:09 -04001820
1821 if (WACOM_FINGER_FIELD(field))
1822 return wacom_wac_finger_report(hdev, report);
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04001823}
1824
Chris Bagwelle1d38e42010-09-12 00:09:27 -07001825static int wacom_bpt_touch(struct wacom_wac *wacom)
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001826{
Henrik Rydbergf4ccbef2010-09-05 12:57:13 -07001827 struct wacom_features *features = &wacom->features;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001828 struct input_dev *input = wacom->touch_input;
Benjamin Tissoires31168712014-07-24 12:50:10 -07001829 struct input_dev *pad_input = wacom->pad_input;
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001830 unsigned char *data = wacom->data;
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001831 int i;
1832
Chris Bagwell5a6c8652011-11-07 19:52:42 -08001833 if (data[0] != 0x02)
1834 return 0;
1835
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001836 for (i = 0; i < 2; i++) {
Chris Bagwell8f906862011-09-09 13:38:10 -07001837 int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
1838 bool touch = data[offset + 3] & 0x80;
Henrik Rydbergc5f4dec2010-12-15 13:50:34 +01001839
Chris Bagwell33d5f712010-09-12 00:12:28 -07001840 /*
1841 * Touch events need to be disabled while stylus is
1842 * in proximity because user's hand is resting on touchpad
1843 * and sending unwanted events. User expects tablet buttons
1844 * to continue working though.
1845 */
Chris Bagwell8f906862011-09-09 13:38:10 -07001846 touch = touch && !wacom->shared->stylus_in_proximity;
1847
1848 input_mt_slot(input, i);
1849 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
Henrik Rydbergc5f4dec2010-12-15 13:50:34 +01001850 if (touch) {
Chris Bagwell8f906862011-09-09 13:38:10 -07001851 int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
1852 int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
Henrik Rydbergf4ccbef2010-09-05 12:57:13 -07001853 if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
1854 x <<= 5;
1855 y <<= 5;
1856 }
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001857 input_report_abs(input, ABS_MT_POSITION_X, x);
1858 input_report_abs(input, ABS_MT_POSITION_Y, y);
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001859 }
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001860 }
1861
Benjamin Tissoires9a1c0012015-02-17 14:19:46 -05001862 input_mt_sync_frame(input);
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001863
Benjamin Tissoires31168712014-07-24 12:50:10 -07001864 input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
1865 input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
1866 input_report_key(pad_input, BTN_BACK, (data[1] & 0x02) != 0);
1867 input_report_key(pad_input, BTN_RIGHT, (data[1] & 0x01) != 0);
Ping Cheng7d059ed2015-03-20 14:57:21 -07001868 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001869
Benjamin Tissoires31168712014-07-24 12:50:10 -07001870 return 1;
Henrik Rydbergcb734c02010-09-05 12:53:16 -07001871}
1872
Ping Cheng7d059ed2015-03-20 14:57:21 -07001873static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
Chris Bagwell73149ab2011-10-26 22:34:21 -07001874{
Ping Cheng9a35c412013-09-20 09:51:56 -07001875 struct wacom_features *features = &wacom->features;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001876 struct input_dev *input = wacom->touch_input;
Chris Bagwell73149ab2011-10-26 22:34:21 -07001877 bool touch = data[1] & 0x80;
Ping Cheng02295e62013-01-04 23:56:00 -08001878 int slot = input_mt_get_slot_by_key(input, data[0]);
1879
1880 if (slot < 0)
Ping Cheng7d059ed2015-03-20 14:57:21 -07001881 return;
Chris Bagwell73149ab2011-10-26 22:34:21 -07001882
1883 touch = touch && !wacom->shared->stylus_in_proximity;
1884
Ping Cheng02295e62013-01-04 23:56:00 -08001885 input_mt_slot(input, slot);
Chris Bagwell73149ab2011-10-26 22:34:21 -07001886 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1887
1888 if (touch) {
1889 int x = (data[2] << 4) | (data[4] >> 4);
1890 int y = (data[3] << 4) | (data[4] & 0x0f);
Ping Cheng9a35c412013-09-20 09:51:56 -07001891 int width, height;
Jason Gerecke4e904952012-10-03 17:19:11 -07001892
Ping Chengeda01da2015-09-23 13:51:15 -07001893 if (features->type >= INTUOSPS && features->type <= INTUOSHT2) {
Jason Gerecke0b279da2013-11-25 18:43:16 -08001894 width = data[5] * 100;
1895 height = data[6] * 100;
Ping Cheng9a35c412013-09-20 09:51:56 -07001896 } else {
1897 /*
1898 * "a" is a scaled-down area which we assume is
1899 * roughly circular and which can be described as:
1900 * a=(pi*r^2)/C.
1901 */
1902 int a = data[5];
Ping Chengd7da3a32014-06-13 13:37:33 -07001903 int x_res = input_abs_get_res(input, ABS_MT_POSITION_X);
1904 int y_res = input_abs_get_res(input, ABS_MT_POSITION_Y);
1905 width = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
Ping Cheng9a35c412013-09-20 09:51:56 -07001906 height = width * y_res / x_res;
1907 }
Chris Bagwell73149ab2011-10-26 22:34:21 -07001908
1909 input_report_abs(input, ABS_MT_POSITION_X, x);
1910 input_report_abs(input, ABS_MT_POSITION_Y, y);
Jason Gerecke4e904952012-10-03 17:19:11 -07001911 input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
1912 input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
Chris Bagwell73149ab2011-10-26 22:34:21 -07001913 }
1914}
1915
1916static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
1917{
Benjamin Tissoires31168712014-07-24 12:50:10 -07001918 struct input_dev *input = wacom->pad_input;
Ping Chengb5fd2a32013-11-25 18:44:55 -08001919 struct wacom_features *features = &wacom->features;
Chris Bagwell73149ab2011-10-26 22:34:21 -07001920
Ping Chengeda01da2015-09-23 13:51:15 -07001921 if (features->type == INTUOSHT || features->type == INTUOSHT2) {
Ping Chengb5fd2a32013-11-25 18:44:55 -08001922 input_report_key(input, BTN_LEFT, (data[1] & 0x02) != 0);
1923 input_report_key(input, BTN_BACK, (data[1] & 0x08) != 0);
1924 } else {
1925 input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
1926 input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
1927 }
Chris Bagwell73149ab2011-10-26 22:34:21 -07001928 input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
Chris Bagwell73149ab2011-10-26 22:34:21 -07001929 input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
1930}
1931
1932static int wacom_bpt3_touch(struct wacom_wac *wacom)
1933{
Chris Bagwell73149ab2011-10-26 22:34:21 -07001934 unsigned char *data = wacom->data;
Jason Gerecke19d57d32012-03-06 10:19:19 -08001935 int count = data[1] & 0x07;
Ping Chengeda01da2015-09-23 13:51:15 -07001936 int touch_changed = 0, i;
Chris Bagwell73149ab2011-10-26 22:34:21 -07001937
Chris Bagwell5a6c8652011-11-07 19:52:42 -08001938 if (data[0] != 0x02)
1939 return 0;
1940
Chris Bagwell73149ab2011-10-26 22:34:21 -07001941 /* data has up to 7 fixed sized 8-byte messages starting at data[2] */
1942 for (i = 0; i < count; i++) {
1943 int offset = (8 * i) + 2;
1944 int msg_id = data[offset];
1945
Ping Chengeda01da2015-09-23 13:51:15 -07001946 if (msg_id >= 2 && msg_id <= 17) {
Ping Cheng7d059ed2015-03-20 14:57:21 -07001947 wacom_bpt3_touch_msg(wacom, data + offset);
Ping Chengeda01da2015-09-23 13:51:15 -07001948 touch_changed++;
1949 } else if (msg_id == 128)
Chris Bagwell73149ab2011-10-26 22:34:21 -07001950 wacom_bpt3_button_msg(wacom, data + offset);
1951
1952 }
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001953
Ping Chengeda01da2015-09-23 13:51:15 -07001954 /* only update touch if we actually have a touchpad and touch data changed */
Benjamin Tissoires84dfbd72016-07-13 18:05:55 +02001955 if (wacom->touch_input && touch_changed) {
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001956 input_mt_sync_frame(wacom->touch_input);
1957 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1958 }
Chris Bagwell73149ab2011-10-26 22:34:21 -07001959
Benjamin Tissoires31168712014-07-24 12:50:10 -07001960 return 1;
Chris Bagwell73149ab2011-10-26 22:34:21 -07001961}
1962
Chris Bagwell2aaacb12010-09-12 00:11:35 -07001963static int wacom_bpt_pen(struct wacom_wac *wacom)
1964{
Ping Cheng961794a2013-12-05 12:54:53 -08001965 struct wacom_features *features = &wacom->features;
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07001966 struct input_dev *input = wacom->pen_input;
Chris Bagwell2aaacb12010-09-12 00:11:35 -07001967 unsigned char *data = wacom->data;
1968 int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;
1969
Jason Gerecke4ca4ec72015-03-06 11:47:38 -08001970 if (data[0] != WACOM_REPORT_PENABLED)
Chris Bagwell5a6c8652011-11-07 19:52:42 -08001971 return 0;
1972
Chris Bagwellc5981412011-10-26 22:28:34 -07001973 prox = (data[1] & 0x20) == 0x20;
Chris Bagwell2aaacb12010-09-12 00:11:35 -07001974
1975 /*
1976 * All reports shared between PEN and RUBBER tool must be
1977 * forced to a known starting value (zero) when transitioning to
1978 * out-of-prox.
1979 *
1980 * If not reset then, to userspace, it will look like lost events
1981 * if new tool comes in-prox with same values as previous tool sent.
1982 *
1983 * Hardware does report zero in most out-of-prox cases but not all.
1984 */
Ping Cheng01499312015-03-20 14:58:01 -07001985 if (!wacom->shared->stylus_in_proximity) {
1986 if (data[1] & 0x08) {
1987 wacom->tool[0] = BTN_TOOL_RUBBER;
1988 wacom->id[0] = ERASER_DEVICE_ID;
1989 } else {
1990 wacom->tool[0] = BTN_TOOL_PEN;
1991 wacom->id[0] = STYLUS_DEVICE_ID;
Chris Bagwell2aaacb12010-09-12 00:11:35 -07001992 }
Ping Cheng01499312015-03-20 14:58:01 -07001993 }
1994
1995 wacom->shared->stylus_in_proximity = prox;
1996 if (wacom->shared->touch_down)
1997 return 0;
1998
1999 if (prox) {
Chris Bagwell2aaacb12010-09-12 00:11:35 -07002000 x = le16_to_cpup((__le16 *)&data[2]);
2001 y = le16_to_cpup((__le16 *)&data[4]);
2002 p = le16_to_cpup((__le16 *)&data[6]);
Chris Bagwellc18c2ce2011-10-10 08:52:13 -07002003 /*
2004 * Convert distance from out prox to distance from tablet.
2005 * distance will be greater than distance_max once
2006 * touching and applying pressure; do not report negative
2007 * distance.
2008 */
Ping Cheng961794a2013-12-05 12:54:53 -08002009 if (data[8] <= features->distance_max)
2010 d = features->distance_max - data[8];
Chris Bagwellc18c2ce2011-10-10 08:52:13 -07002011
Chris Bagwell2aaacb12010-09-12 00:11:35 -07002012 pen = data[1] & 0x01;
2013 btn1 = data[1] & 0x02;
2014 btn2 = data[1] & 0x04;
Ping Cheng01499312015-03-20 14:58:01 -07002015 } else {
2016 wacom->id[0] = 0;
Chris Bagwell2aaacb12010-09-12 00:11:35 -07002017 }
2018
2019 input_report_key(input, BTN_TOUCH, pen);
2020 input_report_key(input, BTN_STYLUS, btn1);
2021 input_report_key(input, BTN_STYLUS2, btn2);
2022
2023 input_report_abs(input, ABS_X, x);
2024 input_report_abs(input, ABS_Y, y);
2025 input_report_abs(input, ABS_PRESSURE, p);
2026 input_report_abs(input, ABS_DISTANCE, d);
2027
Chris Bagwell2aaacb12010-09-12 00:11:35 -07002028 input_report_key(input, wacom->tool[0], prox); /* PEN or RUBBER */
2029 input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
2030
2031 return 1;
2032}
2033
Chris Bagwelle1d38e42010-09-12 00:09:27 -07002034static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
2035{
Ping Chengeda01da2015-09-23 13:51:15 -07002036 struct wacom_features *features = &wacom->features;
2037
2038 if ((features->type == INTUOSHT2) &&
Ping Chengeda01da2015-09-23 13:51:15 -07002039 (features->device_type & WACOM_DEVICETYPE_PEN))
2040 return wacom_intuos_irq(wacom);
2041 else if (len == WACOM_PKGLEN_BBTOUCH)
Chris Bagwelle1d38e42010-09-12 00:09:27 -07002042 return wacom_bpt_touch(wacom);
Chris Bagwell73149ab2011-10-26 22:34:21 -07002043 else if (len == WACOM_PKGLEN_BBTOUCH3)
2044 return wacom_bpt3_touch(wacom);
2045 else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
Chris Bagwell2aaacb12010-09-12 00:11:35 -07002046 return wacom_bpt_pen(wacom);
Chris Bagwelle1d38e42010-09-12 00:09:27 -07002047
2048 return 0;
2049}
2050
Benjamin Tissoires8c97a762015-02-26 11:28:50 -05002051static void wacom_bamboo_pad_pen_event(struct wacom_wac *wacom,
2052 unsigned char *data)
2053{
2054 unsigned char prefix;
2055
2056 /*
2057 * We need to reroute the event from the debug interface to the
2058 * pen interface.
2059 * We need to add the report ID to the actual pen report, so we
2060 * temporary overwrite the first byte to prevent having to kzalloc/kfree
2061 * and memcpy the report.
2062 */
2063 prefix = data[0];
2064 data[0] = WACOM_REPORT_BPAD_PEN;
2065
2066 /*
2067 * actually reroute the event.
2068 * No need to check if wacom->shared->pen is valid, hid_input_report()
2069 * will check for us.
2070 */
2071 hid_input_report(wacom->shared->pen, HID_INPUT_REPORT, data,
2072 WACOM_PKGLEN_PENABLED, 1);
2073
2074 data[0] = prefix;
2075}
2076
2077static int wacom_bamboo_pad_touch_event(struct wacom_wac *wacom,
2078 unsigned char *data)
2079{
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07002080 struct input_dev *input = wacom->touch_input;
Benjamin Tissoires8c97a762015-02-26 11:28:50 -05002081 unsigned char *finger_data, prefix;
2082 unsigned id;
2083 int x, y;
2084 bool valid;
2085
2086 prefix = data[0];
2087
2088 for (id = 0; id < wacom->features.touch_max; id++) {
2089 valid = !!(prefix & BIT(id)) &&
2090 !wacom->shared->stylus_in_proximity;
2091
2092 input_mt_slot(input, id);
2093 input_mt_report_slot_state(input, MT_TOOL_FINGER, valid);
2094
2095 if (!valid)
2096 continue;
2097
2098 finger_data = data + 1 + id * 3;
2099 x = finger_data[0] | ((finger_data[1] & 0x0f) << 8);
2100 y = (finger_data[2] << 4) | (finger_data[1] >> 4);
2101
2102 input_report_abs(input, ABS_MT_POSITION_X, x);
2103 input_report_abs(input, ABS_MT_POSITION_Y, y);
2104 }
2105
2106 input_mt_sync_frame(input);
2107
2108 input_report_key(input, BTN_LEFT, prefix & 0x40);
2109 input_report_key(input, BTN_RIGHT, prefix & 0x80);
2110
2111 /* keep touch state for pen event */
2112 wacom->shared->touch_down = !!prefix &&
2113 !wacom->shared->stylus_in_proximity;
2114
2115 return 1;
2116}
2117
2118static int wacom_bamboo_pad_irq(struct wacom_wac *wacom, size_t len)
2119{
2120 unsigned char *data = wacom->data;
2121
2122 if (!((len == WACOM_PKGLEN_BPAD_TOUCH) ||
2123 (len == WACOM_PKGLEN_BPAD_TOUCH_USB)) ||
2124 (data[0] != WACOM_REPORT_BPAD_TOUCH))
2125 return 0;
2126
2127 if (data[1] & 0x01)
2128 wacom_bamboo_pad_pen_event(wacom, &data[1]);
2129
2130 if (data[1] & 0x02)
2131 return wacom_bamboo_pad_touch_event(wacom, &data[9]);
2132
2133 return 0;
2134}
2135
Chris Bagwelld3825d52012-03-25 23:26:11 -07002136static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
2137{
Chris Bagwell16bf2882012-03-25 23:26:20 -07002138 unsigned char *data = wacom->data;
2139 int connected;
2140
Ping Chengb5fd2a32013-11-25 18:44:55 -08002141 if (len != WACOM_PKGLEN_WIRELESS || data[0] != WACOM_REPORT_WL)
Chris Bagwelld3825d52012-03-25 23:26:11 -07002142 return 0;
2143
Chris Bagwell16bf2882012-03-25 23:26:20 -07002144 connected = data[1] & 0x01;
2145 if (connected) {
Jason Gereckeb0882cb2015-03-06 11:47:43 -08002146 int pid, battery, charging;
Chris Bagwell16bf2882012-03-25 23:26:20 -07002147
Ping Chengeda01da2015-09-23 13:51:15 -07002148 if ((wacom->shared->type == INTUOSHT ||
2149 wacom->shared->type == INTUOSHT2) &&
Ping Cheng44b96832014-11-06 17:30:51 -08002150 wacom->shared->touch_input &&
2151 wacom->shared->touch_max) {
Ping Cheng961794a2013-12-05 12:54:53 -08002152 input_report_switch(wacom->shared->touch_input,
2153 SW_MUTE_DEVICE, data[5] & 0x40);
2154 input_sync(wacom->shared->touch_input);
2155 }
2156
Chris Bagwell16bf2882012-03-25 23:26:20 -07002157 pid = get_unaligned_be16(&data[6]);
Benjamin Tissoiresac8d1012014-07-25 17:29:48 -07002158 battery = (data[5] & 0x3f) * 100 / 31;
Jason Gereckeb0882cb2015-03-06 11:47:43 -08002159 charging = !!(data[5] & 0x80);
Chris Bagwell16bf2882012-03-25 23:26:20 -07002160 if (wacom->pid != pid) {
2161 wacom->pid = pid;
Benjamin Tissoiresd17d1f12016-07-13 18:05:52 +02002162 wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
Chris Bagwell16bf2882012-03-25 23:26:20 -07002163 }
Benjamin Tissoiresac8d1012014-07-25 17:29:48 -07002164
Benjamin Tissoires59d69bc2016-07-13 18:06:08 +02002165 wacom_notify_battery(wacom, battery, charging, 1, 0);
Jason Gerecke953f2c52015-03-06 11:47:39 -08002166
Chris Bagwell16bf2882012-03-25 23:26:20 -07002167 } else if (wacom->pid != 0) {
2168 /* disconnected while previously connected */
2169 wacom->pid = 0;
Benjamin Tissoiresd17d1f12016-07-13 18:05:52 +02002170 wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
Jason Gerecke71fa6412015-03-11 10:25:41 -07002171 wacom_notify_battery(wacom, 0, 0, 0, 0);
Chris Bagwell16bf2882012-03-25 23:26:20 -07002172 }
2173
Chris Bagwelld3825d52012-03-25 23:26:11 -07002174 return 0;
2175}
2176
Jason Gerecke4ca4ec72015-03-06 11:47:38 -08002177static int wacom_status_irq(struct wacom_wac *wacom_wac, size_t len)
2178{
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002179 struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
Jason Gerecke4ca4ec72015-03-06 11:47:38 -08002180 struct wacom_features *features = &wacom_wac->features;
2181 unsigned char *data = wacom_wac->data;
2182
2183 if (data[0] != WACOM_REPORT_USB)
2184 return 0;
2185
Ping Chengeda01da2015-09-23 13:51:15 -07002186 if ((features->type == INTUOSHT ||
2187 features->type == INTUOSHT2) &&
Jason Gerecke4ca4ec72015-03-06 11:47:38 -08002188 wacom_wac->shared->touch_input &&
2189 features->touch_max) {
2190 input_report_switch(wacom_wac->shared->touch_input,
2191 SW_MUTE_DEVICE, data[8] & 0x40);
2192 input_sync(wacom_wac->shared->touch_input);
2193 }
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002194
2195 if (data[9] & 0x02) { /* wireless module is attached */
2196 int battery = (data[8] & 0x3f) * 100 / 31;
Jason Gereckeb0882cb2015-03-06 11:47:43 -08002197 bool charging = !!(data[8] & 0x80);
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002198
2199 wacom_notify_battery(wacom_wac, battery, charging,
Jason Gerecke71fa6412015-03-11 10:25:41 -07002200 battery || charging, 1);
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002201
Benjamin Tissoires59d69bc2016-07-13 18:06:08 +02002202 if (!wacom->battery.battery &&
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002203 !(features->quirks & WACOM_QUIRK_BATTERY)) {
2204 features->quirks |= WACOM_QUIRK_BATTERY;
Benjamin Tissoiresd17d1f12016-07-13 18:05:52 +02002205 wacom_schedule_work(wacom_wac, WACOM_WORKER_BATTERY);
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002206 }
2207 }
2208 else if ((features->quirks & WACOM_QUIRK_BATTERY) &&
Benjamin Tissoires59d69bc2016-07-13 18:06:08 +02002209 wacom->battery.battery) {
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002210 features->quirks &= ~WACOM_QUIRK_BATTERY;
Benjamin Tissoiresd17d1f12016-07-13 18:05:52 +02002211 wacom_schedule_work(wacom_wac, WACOM_WORKER_BATTERY);
Jason Gerecke71fa6412015-03-11 10:25:41 -07002212 wacom_notify_battery(wacom_wac, 0, 0, 0, 0);
Jason Gerecke8f93b0b2015-03-06 11:47:41 -08002213 }
Jason Gerecke4ca4ec72015-03-06 11:47:38 -08002214 return 0;
2215}
2216
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002217void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
Ping Cheng3bea7332006-07-13 18:01:36 -07002218{
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002219 bool sync;
2220
Jason Childse33da8a2010-02-17 22:38:31 -08002221 switch (wacom_wac->features.type) {
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002222 case PENPARTNER:
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002223 sync = wacom_penpartner_irq(wacom_wac);
2224 break;
Ping Cheng545f4e92008-11-24 11:44:27 -05002225
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002226 case PL:
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002227 sync = wacom_pl_irq(wacom_wac);
2228 break;
Ping Cheng545f4e92008-11-24 11:44:27 -05002229
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002230 case WACOM_G4:
2231 case GRAPHIRE:
Benjamin Tissoires387142b2014-08-06 13:52:56 -07002232 case GRAPHIRE_BT:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002233 case WACOM_MO:
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002234 sync = wacom_graphire_irq(wacom_wac);
2235 break;
Ping Cheng545f4e92008-11-24 11:44:27 -05002236
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002237 case PTU:
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002238 sync = wacom_ptu_irq(wacom_wac);
2239 break;
Ping Cheng545f4e92008-11-24 11:44:27 -05002240
Ping Chengc8f2edc2010-06-28 01:10:51 -07002241 case DTU:
2242 sync = wacom_dtu_irq(wacom_wac);
2243 break;
2244
Ping Cheng497ab1f2014-01-20 20:18:04 -08002245 case DTUS:
Ping Chengfff00bf2014-12-04 18:23:04 -08002246 case DTUSX:
Ping Cheng497ab1f2014-01-20 20:18:04 -08002247 sync = wacom_dtus_irq(wacom_wac);
2248 break;
2249
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002250 case INTUOS:
2251 case INTUOS3S:
2252 case INTUOS3:
2253 case INTUOS3L:
2254 case INTUOS4S:
2255 case INTUOS4:
2256 case INTUOS4L:
2257 case CINTIQ:
2258 case WACOM_BEE:
Ping Cheng56218562013-05-05 19:56:18 -07002259 case WACOM_13HD:
Ping Cheng3a4b4aa2010-06-03 22:10:21 -07002260 case WACOM_21UX2:
Ping Chengd838c642012-07-24 23:54:11 -07002261 case WACOM_22HD:
Jason Gerecke803296b2011-12-12 00:11:45 -08002262 case WACOM_24HD:
Ping Cheng500d4162015-01-27 13:30:03 -08002263 case WACOM_27QHD:
Ping Chenga112e9f2013-02-13 20:20:01 -08002264 case DTK:
Jason Gerecke36d3c512013-09-20 09:47:35 -07002265 case CINTIQ_HYBRID:
Jason Gereckef7acb552015-10-13 10:03:49 -07002266 case CINTIQ_COMPANION_2:
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002267 sync = wacom_intuos_irq(wacom_wac);
2268 break;
Ping Cheng545f4e92008-11-24 11:44:27 -05002269
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07002270 case INTUOS4WL:
2271 sync = wacom_intuos_bt_irq(wacom_wac, len);
2272 break;
2273
Jason Gereckeb1e42792012-10-21 00:38:04 -07002274 case WACOM_24HDT:
Ping Cheng500d4162015-01-27 13:30:03 -08002275 case WACOM_27QHDT:
Jason Gereckeb1e42792012-10-21 00:38:04 -07002276 sync = wacom_24hdt_irq(wacom_wac);
2277 break;
2278
Jason Gereckeae584ca2012-04-03 15:50:40 -07002279 case INTUOS5S:
2280 case INTUOS5:
2281 case INTUOS5L:
Ping Cheng9a35c412013-09-20 09:51:56 -07002282 case INTUOSPS:
2283 case INTUOSPM:
2284 case INTUOSPL:
Jason Gereckeae584ca2012-04-03 15:50:40 -07002285 if (len == WACOM_PKGLEN_BBTOUCH3)
2286 sync = wacom_bpt3_touch(wacom_wac);
Jason Gerecke2d13a432015-03-06 11:47:42 -08002287 else if (wacom_wac->data[0] == WACOM_REPORT_USB)
2288 sync = wacom_status_irq(wacom_wac, len);
Jason Gereckeae584ca2012-04-03 15:50:40 -07002289 else
2290 sync = wacom_intuos_irq(wacom_wac);
2291 break;
2292
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002293 case TABLETPC:
Ping Chengac173832012-06-12 00:15:06 -07002294 case TABLETPCE:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002295 case TABLETPC2FG:
Ping Cheng19635182012-04-29 21:09:18 -07002296 case MTSCREEN:
Ping Cheng6afdc282012-11-03 12:16:15 -07002297 case MTTPC:
Jason Gerecked51ddb22014-05-14 17:14:29 -07002298 case MTTPC_B:
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002299 sync = wacom_tpc_irq(wacom_wac, len);
2300 break;
Ping Cheng545f4e92008-11-24 11:44:27 -05002301
Henrik Rydbergcb734c02010-09-05 12:53:16 -07002302 case BAMBOO_PT:
Ping Cheng3b164a02015-09-23 09:59:10 -07002303 case BAMBOO_PEN:
2304 case BAMBOO_TOUCH:
Ping Chengb5fd2a32013-11-25 18:44:55 -08002305 case INTUOSHT:
Ping Chengeda01da2015-09-23 13:51:15 -07002306 case INTUOSHT2:
Jason Gerecke4ca4ec72015-03-06 11:47:38 -08002307 if (wacom_wac->data[0] == WACOM_REPORT_USB)
2308 sync = wacom_status_irq(wacom_wac, len);
2309 else
2310 sync = wacom_bpt_irq(wacom_wac, len);
Henrik Rydbergcb734c02010-09-05 12:53:16 -07002311 break;
2312
Benjamin Tissoires8c97a762015-02-26 11:28:50 -05002313 case BAMBOO_PAD:
2314 sync = wacom_bamboo_pad_irq(wacom_wac, len);
Ping Cheng3bea7332006-07-13 18:01:36 -07002315 break;
2316
Chris Bagwelld3825d52012-03-25 23:26:11 -07002317 case WIRELESS:
2318 sync = wacom_wireless_irq(wacom_wac, len);
2319 break;
2320
Aaron Skomra72b236d2015-08-20 16:05:17 -07002321 case REMOTE:
Benjamin Tissoirese6f28132016-07-13 18:06:01 +02002322 sync = false;
Aaron Skomra72b236d2015-08-20 16:05:17 -07002323 if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
Benjamin Tissoirese6f28132016-07-13 18:06:01 +02002324 wacom_remote_status_irq(wacom_wac, len);
Aaron Skomra72b236d2015-08-20 16:05:17 -07002325 else
2326 sync = wacom_remote_irq(wacom_wac, len);
2327 break;
2328
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002329 default:
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002330 sync = false;
2331 break;
Ping Cheng3bea7332006-07-13 18:01:36 -07002332 }
Dmitry Torokhov95dd3b32010-03-19 22:18:15 -07002333
Benjamin Tissoiresd2d13f12014-07-24 12:48:28 -07002334 if (sync) {
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07002335 if (wacom_wac->pen_input)
2336 input_sync(wacom_wac->pen_input);
2337 if (wacom_wac->touch_input)
2338 input_sync(wacom_wac->touch_input);
Benjamin Tissoiresd2d13f12014-07-24 12:48:28 -07002339 if (wacom_wac->pad_input)
2340 input_sync(wacom_wac->pad_input);
2341 }
Ping Cheng3bea7332006-07-13 18:01:36 -07002342}
2343
Ping Chengeda01da2015-09-23 13:51:15 -07002344static void wacom_setup_basic_pro_pen(struct wacom_wac *wacom_wac)
Ping Cheng3bea7332006-07-13 18:01:36 -07002345{
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07002346 struct input_dev *input_dev = wacom_wac->pen_input;
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002347
2348 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002349
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002350 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002351 __set_bit(BTN_STYLUS, input_dev->keybit);
2352 __set_bit(BTN_STYLUS2, input_dev->keybit);
2353
2354 input_set_abs_params(input_dev, ABS_DISTANCE,
Jason Gereckebef7e202016-04-22 14:30:53 -07002355 0, wacom_wac->features.distance_max, wacom_wac->features.distance_fuzz, 0);
Ping Chengeda01da2015-09-23 13:51:15 -07002356}
2357
2358static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
2359{
2360 struct input_dev *input_dev = wacom_wac->pen_input;
Jason Gereckebef7e202016-04-22 14:30:53 -07002361 struct wacom_features *features = &wacom_wac->features;
Ping Chengeda01da2015-09-23 13:51:15 -07002362
2363 wacom_setup_basic_pro_pen(wacom_wac);
2364
2365 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2366 __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
2367 __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
2368 __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
2369
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002370 input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
Jason Gereckebef7e202016-04-22 14:30:53 -07002371 input_set_abs_params(input_dev, ABS_TILT_X, -64, 63, features->tilt_fuzz, 0);
Jason Gerecke26fe4122014-11-18 16:50:09 -08002372 input_abs_set_res(input_dev, ABS_TILT_X, 57);
Jason Gereckebef7e202016-04-22 14:30:53 -07002373 input_set_abs_params(input_dev, ABS_TILT_Y, -64, 63, features->tilt_fuzz, 0);
Jason Gerecke26fe4122014-11-18 16:50:09 -08002374 input_abs_set_res(input_dev, ABS_TILT_Y, 57);
Ping Cheng6521d0b2010-10-24 21:53:40 -07002375}
2376
2377static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
2378{
Jason Gerecke2a6cdbd2015-06-15 18:01:45 -07002379 struct input_dev *input_dev = wacom_wac->pen_input;
Ping Cheng6521d0b2010-10-24 21:53:40 -07002380
2381 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2382
2383 wacom_setup_cintiq(wacom_wac);
2384
2385 __set_bit(BTN_LEFT, input_dev->keybit);
2386 __set_bit(BTN_RIGHT, input_dev->keybit);
2387 __set_bit(BTN_MIDDLE, input_dev->keybit);
2388 __set_bit(BTN_SIDE, input_dev->keybit);
2389 __set_bit(BTN_EXTRA, input_dev->keybit);
2390 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
2391 __set_bit(BTN_TOOL_LENS, input_dev->keybit);
2392
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002393 input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
Jason Gerecke26fe4122014-11-18 16:50:09 -08002394 input_abs_set_res(input_dev, ABS_RZ, 287);
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002395 input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
2396}
2397
Ping Cheng42f4f272015-04-15 16:53:54 -07002398void wacom_setup_device_quirks(struct wacom *wacom)
Henrik Rydbergbc73dd32010-09-05 12:26:16 -07002399{
Ping Cheng42f4f272015-04-15 16:53:54 -07002400 struct wacom_features *features = &wacom->wacom_wac.features;
Henrik Rydbergbc73dd32010-09-05 12:26:16 -07002401
Jason Gerecke862cf552015-06-15 18:01:43 -07002402 /* The pen and pad share the same interface on most devices */
2403 if (features->type == GRAPHIRE_BT || features->type == WACOM_G4 ||
Ping Cheng3b164a02015-09-23 09:59:10 -07002404 features->type == DTUS ||
2405 (features->type >= INTUOS3S && features->type <= WACOM_MO)) {
Jason Gerecke862cf552015-06-15 18:01:43 -07002406 if (features->device_type & WACOM_DEVICETYPE_PEN)
2407 features->device_type |= WACOM_DEVICETYPE_PAD;
2408 }
Henrik Rydbergbc73dd32010-09-05 12:26:16 -07002409
2410 /* touch device found but size is not defined. use default */
Jason Gereckeaa86b182015-06-15 18:01:42 -07002411 if (features->device_type & WACOM_DEVICETYPE_TOUCH && !features->x_max) {
Henrik Rydbergbc73dd32010-09-05 12:26:16 -07002412 features->x_max = 1023;
2413 features->y_max = 1023;
2414 }
2415
Ping Cheng42f4f272015-04-15 16:53:54 -07002416 /*
2417 * Intuos5/Pro and Bamboo 3rd gen have no useful data about its
2418 * touch interface in its HID descriptor. If this is the touch
2419 * interface (PacketSize of WACOM_PKGLEN_BBTOUCH3), override the
2420 * tablet values.
2421 */
Ping Cheng3b164a02015-09-23 09:59:10 -07002422 if ((features->type >= INTUOS5S && features->type <= INTUOSPL) ||
2423 (features->type >= INTUOSHT && features->type <= BAMBOO_PT)) {
Ping Cheng42f4f272015-04-15 16:53:54 -07002424 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
Jason Gerecke862cf552015-06-15 18:01:43 -07002425 if (features->touch_max)
2426 features->device_type |= WACOM_DEVICETYPE_TOUCH;
Jiri Kosinaa3088ab2015-11-17 00:24:14 +01002427 if (features->type >= INTUOSHT && features->type <= BAMBOO_PT)
Jason Gerecke862cf552015-06-15 18:01:43 -07002428 features->device_type |= WACOM_DEVICETYPE_PAD;
Ping Cheng42f4f272015-04-15 16:53:54 -07002429
2430 features->x_max = 4096;
2431 features->y_max = 4096;
Ping Cheng42f4f272015-04-15 16:53:54 -07002432 }
Jason Gerecke96339202015-07-01 13:01:00 -07002433 else if (features->pktlen == WACOM_PKGLEN_BBTOUCH) {
2434 features->device_type |= WACOM_DEVICETYPE_PAD;
2435 }
Ping Cheng42f4f272015-04-15 16:53:54 -07002436 }
2437
2438 /*
Benjamin Tissoires580549e2016-03-25 15:26:55 +01002439 * Hack for the Bamboo One:
2440 * the device presents a PAD/Touch interface as most Bamboos and even
2441 * sends ghosts PAD data on it. However, later, we must disable this
2442 * ghost interface, and we can not detect it unless we set it here
2443 * to WACOM_DEVICETYPE_PAD or WACOM_DEVICETYPE_TOUCH.
2444 */
2445 if (features->type == BAMBOO_PEN &&
2446 features->pktlen == WACOM_PKGLEN_BBTOUCH3)
2447 features->device_type |= WACOM_DEVICETYPE_PAD;
2448
2449 /*
Jason Gerecke042628a2015-04-30 17:51:54 -07002450 * Raw Wacom-mode pen and touch events both come from interface
2451 * 0, whose HID descriptor has an application usage of 0xFF0D
2452 * (i.e., WACOM_VENDORDEFINED_PEN). We route pen packets back
2453 * out through the HID_GENERIC device created for interface 1,
Benjamin Tissoires70caee02015-07-09 14:11:51 -04002454 * so rewrite this one to be of type WACOM_DEVICETYPE_TOUCH.
Ping Cheng42f4f272015-04-15 16:53:54 -07002455 */
2456 if (features->type == BAMBOO_PAD)
Benjamin Tissoires70caee02015-07-09 14:11:51 -04002457 features->device_type = WACOM_DEVICETYPE_TOUCH;
Ping Cheng42f4f272015-04-15 16:53:54 -07002458
Aaron Skomra72b236d2015-08-20 16:05:17 -07002459 if (features->type == REMOTE)
2460 features->device_type = WACOM_DEVICETYPE_PAD;
Ping Cheng42f4f272015-04-15 16:53:54 -07002461
Jason Gereckee5bc8eb2016-08-08 12:06:29 -07002462 switch (features->type) {
2463 case PL:
2464 case DTU:
2465 case DTUS:
2466 case DTUSX:
2467 case WACOM_21UX2:
2468 case WACOM_22HD:
2469 case DTK:
2470 case WACOM_24HD:
2471 case WACOM_27QHD:
2472 case CINTIQ_HYBRID:
2473 case CINTIQ_COMPANION_2:
2474 case CINTIQ:
2475 case WACOM_BEE:
2476 case WACOM_13HD:
2477 case WACOM_24HDT:
2478 case WACOM_27QHDT:
2479 case TABLETPC:
2480 case TABLETPCE:
2481 case TABLETPC2FG:
2482 case MTSCREEN:
2483 case MTTPC:
2484 case MTTPC_B:
2485 features->device_type |= WACOM_DEVICETYPE_DIRECT;
2486 break;
2487 }
2488
Ping Cheng42f4f272015-04-15 16:53:54 -07002489 if (wacom->hdev->bus == BUS_BLUETOOTH)
2490 features->quirks |= WACOM_QUIRK_BATTERY;
2491
Chris Bagwell73149ab2011-10-26 22:34:21 -07002492 /* quirk for bamboo touch with 2 low res touches */
Jason Gereckebe853fd2015-12-04 14:45:27 -08002493 if ((features->type == BAMBOO_PT || features->type == BAMBOO_TOUCH) &&
Chris Bagwell73149ab2011-10-26 22:34:21 -07002494 features->pktlen == WACOM_PKGLEN_BBTOUCH) {
Henrik Rydbergf4ccbef2010-09-05 12:57:13 -07002495 features->x_max <<= 5;
2496 features->y_max <<= 5;
2497 features->x_fuzz <<= 5;
2498 features->y_fuzz <<= 5;
Henrik Rydbergf4ccbef2010-09-05 12:57:13 -07002499 features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
Henrik Rydbergcb734c02010-09-05 12:53:16 -07002500 }
Chris Bagwelld3825d52012-03-25 23:26:11 -07002501
2502 if (features->type == WIRELESS) {
Jason Gereckeccad85c2015-08-03 10:17:04 -07002503 if (features->device_type == WACOM_DEVICETYPE_WL_MONITOR) {
Benjamin Tissoiresac8d1012014-07-25 17:29:48 -07002504 features->quirks |= WACOM_QUIRK_BATTERY;
2505 }
Chris Bagwelld3825d52012-03-25 23:26:11 -07002506 }
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +02002507
2508 if (features->type == REMOTE)
2509 features->device_type |= WACOM_DEVICETYPE_WL_MONITOR;
Henrik Rydbergbc73dd32010-09-05 12:26:16 -07002510}
2511
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002512int wacom_setup_pen_input_capabilities(struct input_dev *input_dev,
Ping Cheng19635182012-04-29 21:09:18 -07002513 struct wacom_wac *wacom_wac)
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002514{
2515 struct wacom_features *features = &wacom_wac->features;
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002516
2517 input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2518
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002519 if (!(features->device_type & WACOM_DEVICETYPE_PEN))
2520 return -ENODEV;
2521
Jason Gereckee5bc8eb2016-08-08 12:06:29 -07002522 if (features->device_type & WACOM_DEVICETYPE_DIRECT)
2523 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2524 else
2525 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2526
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04002527 if (features->type == HID_GENERIC)
2528 /* setup has already been done */
2529 return 0;
2530
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002531 __set_bit(BTN_TOUCH, input_dev->keybit);
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002532 __set_bit(ABS_MISC, input_dev->absbit);
2533
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002534 input_set_abs_params(input_dev, ABS_X, features->x_min,
2535 features->x_max, features->x_fuzz, 0);
2536 input_set_abs_params(input_dev, ABS_Y, features->y_min,
2537 features->y_max, features->y_fuzz, 0);
2538 input_set_abs_params(input_dev, ABS_PRESSURE, 0,
2539 features->pressure_max, features->pressure_fuzz, 0);
2540
2541 /* penabled devices have fixed resolution for each model */
2542 input_abs_set_res(input_dev, ABS_X, features->x_resolution);
2543 input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
2544
Ping Cheng497ab1f2014-01-20 20:18:04 -08002545 switch (features->type) {
Ping Chenga2f71c62015-01-27 13:29:36 -08002546 case GRAPHIRE_BT:
2547 __clear_bit(ABS_MISC, input_dev->absbit);
2548
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002549 case WACOM_MO:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002550 case WACOM_G4:
Ping Chenga2f71c62015-01-27 13:29:36 -08002551 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2552 features->distance_max,
Jason Gereckebef7e202016-04-22 14:30:53 -07002553 features->distance_fuzz, 0);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002554 /* fall through */
2555
2556 case GRAPHIRE:
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002557 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2558
2559 __set_bit(BTN_LEFT, input_dev->keybit);
2560 __set_bit(BTN_RIGHT, input_dev->keybit);
2561 __set_bit(BTN_MIDDLE, input_dev->keybit);
2562
2563 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2564 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2565 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
2566 __set_bit(BTN_STYLUS, input_dev->keybit);
2567 __set_bit(BTN_STYLUS2, input_dev->keybit);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002568 break;
2569
Ping Cheng500d4162015-01-27 13:30:03 -08002570 case WACOM_27QHD:
Jason Gerecke803296b2011-12-12 00:11:45 -08002571 case WACOM_24HD:
Ping Chenga112e9f2013-02-13 20:20:01 -08002572 case DTK:
Ping Chengd838c642012-07-24 23:54:11 -07002573 case WACOM_22HD:
Ping Cheng3a4b4aa2010-06-03 22:10:21 -07002574 case WACOM_21UX2:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002575 case WACOM_BEE:
Ping Cheng6521d0b2010-10-24 21:53:40 -07002576 case CINTIQ:
Ping Cheng56218562013-05-05 19:56:18 -07002577 case WACOM_13HD:
Ping Chenga2f71c62015-01-27 13:29:36 -08002578 case CINTIQ_HYBRID:
Jason Gereckef7acb552015-10-13 10:03:49 -07002579 case CINTIQ_COMPANION_2:
Ping Cheng56218562013-05-05 19:56:18 -07002580 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
Jason Gerecke26fe4122014-11-18 16:50:09 -08002581 input_abs_set_res(input_dev, ABS_Z, 287);
Ping Cheng56218562013-05-05 19:56:18 -07002582 wacom_setup_cintiq(wacom_wac);
2583 break;
2584
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002585 case INTUOS3:
2586 case INTUOS3L:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002587 case INTUOS3S:
Ping Chenga2f71c62015-01-27 13:29:36 -08002588 case INTUOS4:
2589 case INTUOS4WL:
2590 case INTUOS4L:
2591 case INTUOS4S:
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002592 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
Jason Gerecke26fe4122014-11-18 16:50:09 -08002593 input_abs_set_res(input_dev, ABS_Z, 287);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002594 /* fall through */
2595
2596 case INTUOS:
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002597 wacom_setup_intuos(wacom_wac);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002598 break;
2599
Jason Gerecke9fee6192012-04-03 15:47:22 -07002600 case INTUOS5:
2601 case INTUOS5L:
Ping Cheng9a35c412013-09-20 09:51:56 -07002602 case INTUOSPM:
2603 case INTUOSPL:
Jason Gereckeae584ca2012-04-03 15:50:40 -07002604 case INTUOS5S:
Ping Cheng9a35c412013-09-20 09:51:56 -07002605 case INTUOSPS:
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002606 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2607 features->distance_max,
Jason Gereckebef7e202016-04-22 14:30:53 -07002608 features->distance_fuzz, 0);
Jason Gereckeae584ca2012-04-03 15:50:40 -07002609
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002610 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
2611 input_abs_set_res(input_dev, ABS_Z, 287);
Jason Gereckeae584ca2012-04-03 15:50:40 -07002612
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002613 wacom_setup_intuos(wacom_wac);
Jason Gereckeae584ca2012-04-03 15:50:40 -07002614 break;
2615
Jason Gereckeb1e42792012-10-21 00:38:04 -07002616 case WACOM_24HDT:
Ping Cheng500d4162015-01-27 13:30:03 -08002617 case WACOM_27QHDT:
Ping Cheng19635182012-04-29 21:09:18 -07002618 case MTSCREEN:
Ping Cheng6afdc282012-11-03 12:16:15 -07002619 case MTTPC:
Jason Gerecked51ddb22014-05-14 17:14:29 -07002620 case MTTPC_B:
Ping Cheng6795a522012-06-28 16:49:00 -07002621 case TABLETPC2FG:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002622 case TABLETPC:
Ping Chengac173832012-06-12 00:15:06 -07002623 case TABLETPCE:
Ping Chenga43c7c52011-03-12 20:34:42 -08002624 __clear_bit(ABS_MISC, input_dev->absbit);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002625 /* fall through */
2626
Ping Cheng497ab1f2014-01-20 20:18:04 -08002627 case DTUS:
Ping Chengfff00bf2014-12-04 18:23:04 -08002628 case DTUSX:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002629 case PL:
Ping Chengc8f2edc2010-06-28 01:10:51 -07002630 case DTU:
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002631 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
Jason Gerecke35120692011-09-08 09:38:14 -07002632 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002633 __set_bit(BTN_STYLUS, input_dev->keybit);
2634 __set_bit(BTN_STYLUS2, input_dev->keybit);
Jason Gerecke35120692011-09-08 09:38:14 -07002635 break;
2636
2637 case PTU:
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002638 __set_bit(BTN_STYLUS2, input_dev->keybit);
2639 /* fall through */
2640
2641 case PENPARTNER:
Jason Gerecke1fab84a2011-08-26 23:18:22 -07002642 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
Dmitry Torokhov8da23fc2010-03-19 22:18:15 -07002643 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
Jason Gerecke1fab84a2011-08-26 23:18:22 -07002644 __set_bit(BTN_STYLUS, input_dev->keybit);
Dmitry Torokhov73a97f42010-03-19 22:18:15 -07002645 break;
Henrik Rydbergcb734c02010-09-05 12:53:16 -07002646
Ping Chengb5fd2a32013-11-25 18:44:55 -08002647 case INTUOSHT:
Henrik Rydbergcb734c02010-09-05 12:53:16 -07002648 case BAMBOO_PT:
Ping Cheng3b164a02015-09-23 09:59:10 -07002649 case BAMBOO_PEN:
Ping Chengeda01da2015-09-23 13:51:15 -07002650 case INTUOSHT2:
Ping Chengeda01da2015-09-23 13:51:15 -07002651 if (features->type == INTUOSHT2) {
2652 wacom_setup_basic_pro_pen(wacom_wac);
2653 } else {
2654 __clear_bit(ABS_MISC, input_dev->absbit);
2655 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2656 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2657 __set_bit(BTN_STYLUS, input_dev->keybit);
2658 __set_bit(BTN_STYLUS2, input_dev->keybit);
2659 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002660 features->distance_max,
Jason Gereckebef7e202016-04-22 14:30:53 -07002661 features->distance_fuzz, 0);
Ping Chengeda01da2015-09-23 13:51:15 -07002662 }
Henrik Rydbergcb734c02010-09-05 12:53:16 -07002663 break;
Benjamin Tissoires8c97a762015-02-26 11:28:50 -05002664 case BAMBOO_PAD:
2665 __clear_bit(ABS_MISC, input_dev->absbit);
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002666 break;
2667 }
2668 return 0;
2669}
2670
2671int wacom_setup_touch_input_capabilities(struct input_dev *input_dev,
2672 struct wacom_wac *wacom_wac)
2673{
2674 struct wacom_features *features = &wacom_wac->features;
2675
2676 input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2677
2678 if (!(features->device_type & WACOM_DEVICETYPE_TOUCH))
2679 return -ENODEV;
2680
Jason Gereckee5bc8eb2016-08-08 12:06:29 -07002681 if (features->device_type & WACOM_DEVICETYPE_DIRECT)
2682 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2683 else
2684 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2685
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002686 if (features->type == HID_GENERIC)
2687 /* setup has already been done */
2688 return 0;
2689
2690 __set_bit(BTN_TOUCH, input_dev->keybit);
2691
2692 if (features->touch_max == 1) {
2693 input_set_abs_params(input_dev, ABS_X, 0,
2694 features->x_max, features->x_fuzz, 0);
2695 input_set_abs_params(input_dev, ABS_Y, 0,
2696 features->y_max, features->y_fuzz, 0);
2697 input_abs_set_res(input_dev, ABS_X,
2698 features->x_resolution);
2699 input_abs_set_res(input_dev, ABS_Y,
2700 features->y_resolution);
2701 }
2702 else if (features->touch_max > 1) {
2703 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
2704 features->x_max, features->x_fuzz, 0);
2705 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
2706 features->y_max, features->y_fuzz, 0);
2707 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
2708 features->x_resolution);
2709 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
2710 features->y_resolution);
2711 }
2712
2713 switch (features->type) {
2714 case INTUOS5:
2715 case INTUOS5L:
2716 case INTUOSPM:
2717 case INTUOSPL:
2718 case INTUOS5S:
2719 case INTUOSPS:
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002720 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
2721 input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, features->y_max, 0, 0);
2722 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
2723 break;
2724
2725 case WACOM_24HDT:
2726 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
2727 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
2728 input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
2729 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
2730 /* fall through */
2731
2732 case WACOM_27QHDT:
2733 case MTSCREEN:
2734 case MTTPC:
2735 case MTTPC_B:
2736 case TABLETPC2FG:
2737 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_DIRECT);
2738 /*fall through */
2739
2740 case TABLETPC:
2741 case TABLETPCE:
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002742 break;
2743
2744 case INTUOSHT:
Ping Chengeda01da2015-09-23 13:51:15 -07002745 case INTUOSHT2:
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002746 input_dev->evbit[0] |= BIT_MASK(EV_SW);
2747 __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
2748 /* fall through */
2749
2750 case BAMBOO_PT:
Ping Cheng3b164a02015-09-23 09:59:10 -07002751 case BAMBOO_TOUCH:
Jason Gerecke2636a3f2015-06-15 18:01:44 -07002752 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
2753 input_set_abs_params(input_dev,
2754 ABS_MT_TOUCH_MAJOR,
2755 0, features->x_max, 0, 0);
2756 input_set_abs_params(input_dev,
2757 ABS_MT_TOUCH_MINOR,
2758 0, features->y_max, 0, 0);
2759 }
2760 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
2761 break;
2762
2763 case BAMBOO_PAD:
Benjamin Tissoires8c97a762015-02-26 11:28:50 -05002764 input_mt_init_slots(input_dev, features->touch_max,
2765 INPUT_MT_POINTER);
2766 __set_bit(BTN_LEFT, input_dev->keybit);
2767 __set_bit(BTN_RIGHT, input_dev->keybit);
2768 break;
Ping Cheng3bea7332006-07-13 18:01:36 -07002769 }
Ping Cheng19635182012-04-29 21:09:18 -07002770 return 0;
Ping Cheng3bea7332006-07-13 18:01:36 -07002771}
2772
Jiri Kosina5397df12015-08-28 20:46:42 +02002773static void wacom_setup_numbered_buttons(struct input_dev *input_dev,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07002774 int button_count)
2775{
2776 int i;
2777
2778 for (i = 0; i < button_count && i < 10; i++)
2779 __set_bit(BTN_0 + i, input_dev->keybit);
2780 for (i = 10; i < button_count && i < 16; i++)
2781 __set_bit(BTN_A + (i-10), input_dev->keybit);
2782 for (i = 16; i < button_count && i < 18; i++)
2783 __set_bit(BTN_BASE + (i-16), input_dev->keybit);
2784}
2785
Benjamin Tissoires6a062812016-07-13 18:06:14 +02002786static void wacom_24hd_update_leds(struct wacom *wacom, int mask, int group)
2787{
2788 struct wacom_led *led;
2789 int i;
2790 bool updated = false;
2791
2792 /*
2793 * 24HD has LED group 1 to the left and LED group 0 to the right.
2794 * So group 0 matches the second half of the buttons and thus the mask
2795 * needs to be shifted.
2796 */
2797 if (group == 0)
2798 mask >>= 8;
2799
2800 for (i = 0; i < 3; i++) {
2801 led = wacom_led_find(wacom, group, i);
2802 if (!led) {
2803 hid_err(wacom->hdev, "can't find LED %d in group %d\n",
2804 i, group);
2805 continue;
2806 }
2807 if (!updated && mask & BIT(i)) {
2808 led->held = true;
2809 led_trigger_event(&led->trigger, LED_FULL);
2810 } else {
2811 led->held = false;
2812 }
2813 }
2814}
2815
Benjamin Tissoires34736aa2016-07-13 18:06:12 +02002816static bool wacom_is_led_toggled(struct wacom *wacom, int button_count,
2817 int mask, int group)
2818{
2819 int button_per_group;
2820
Benjamin Tissoires5a0fe8ab2016-07-13 18:06:13 +02002821 /*
Benjamin Tissoires6a062812016-07-13 18:06:14 +02002822 * 21UX2 has LED group 1 to the left and LED group 0
Benjamin Tissoires5a0fe8ab2016-07-13 18:06:13 +02002823 * to the right. We need to reverse the group to match this
2824 * historical behavior.
2825 */
Benjamin Tissoires6a062812016-07-13 18:06:14 +02002826 if (wacom->wacom_wac.features.type == WACOM_21UX2)
Benjamin Tissoires5a0fe8ab2016-07-13 18:06:13 +02002827 group = 1 - group;
2828
Benjamin Tissoires34736aa2016-07-13 18:06:12 +02002829 button_per_group = button_count/wacom->led.count;
2830
2831 return mask & (1 << (group * button_per_group));
2832}
2833
2834static void wacom_update_led(struct wacom *wacom, int button_count, int mask,
2835 int group)
2836{
2837 struct wacom_led *led, *next_led;
2838 int cur;
2839 bool pressed;
2840
Benjamin Tissoires6a062812016-07-13 18:06:14 +02002841 if (wacom->wacom_wac.features.type == WACOM_24HD)
2842 return wacom_24hd_update_leds(wacom, mask, group);
2843
Benjamin Tissoires34736aa2016-07-13 18:06:12 +02002844 pressed = wacom_is_led_toggled(wacom, button_count, mask, group);
2845 cur = wacom->led.groups[group].select;
2846
2847 led = wacom_led_find(wacom, group, cur);
2848 if (!led) {
2849 hid_err(wacom->hdev, "can't find current LED %d in group %d\n",
2850 cur, group);
2851 return;
2852 }
2853
2854 if (!pressed) {
2855 led->held = false;
2856 return;
2857 }
2858
2859 if (led->held && pressed)
2860 return;
2861
2862 next_led = wacom_led_next(wacom, led);
2863 if (!next_led) {
2864 hid_err(wacom->hdev, "can't find next LED in group %d\n",
2865 group);
2866 return;
2867 }
2868 if (next_led == led)
2869 return;
2870
2871 next_led->held = true;
2872 led_trigger_event(&next_led->trigger,
2873 wacom_leds_brightness_get(next_led));
2874}
2875
Jason Gereckec7f05222015-11-30 17:13:47 -08002876static void wacom_report_numbered_buttons(struct input_dev *input_dev,
2877 int button_count, int mask)
2878{
Benjamin Tissoires34736aa2016-07-13 18:06:12 +02002879 struct wacom *wacom = input_get_drvdata(input_dev);
Jason Gereckec7f05222015-11-30 17:13:47 -08002880 int i;
2881
Benjamin Tissoires34736aa2016-07-13 18:06:12 +02002882 for (i = 0; i < wacom->led.count; i++)
2883 wacom_update_led(wacom, button_count, mask, i);
2884
Jason Gereckec7f05222015-11-30 17:13:47 -08002885 for (i = 0; i < button_count && i < 10; i++)
2886 input_report_key(input_dev, BTN_0 + i, mask & (1 << i));
2887 for (i = 10; i < button_count && i < 16; i++)
2888 input_report_key(input_dev, BTN_A + (i-10), mask & (1 << i));
2889 for (i = 16; i < button_count && i < 18; i++)
2890 input_report_key(input_dev, BTN_BASE + (i-16), mask & (1 << i));
2891}
2892
Benjamin Tissoiresd2d13f12014-07-24 12:48:28 -07002893int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
2894 struct wacom_wac *wacom_wac)
2895{
2896 struct wacom_features *features = &wacom_wac->features;
2897
Jason Gerecke862cf552015-06-15 18:01:43 -07002898 if (!(features->device_type & WACOM_DEVICETYPE_PAD))
2899 return -ENODEV;
2900
Benjamin Tissoires7c35dc32016-07-13 18:06:07 +02002901 if (features->type == REMOTE && input_dev == wacom_wac->pad_input)
2902 return -ENODEV;
2903
Benjamin Tissoiresd2d13f12014-07-24 12:48:28 -07002904 input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2905
2906 /* kept for making legacy xf86-input-wacom working with the wheels */
2907 __set_bit(ABS_MISC, input_dev->absbit);
2908
2909 /* kept for making legacy xf86-input-wacom accepting the pad */
2910 input_set_abs_params(input_dev, ABS_X, 0, 1, 0, 0);
2911 input_set_abs_params(input_dev, ABS_Y, 0, 1, 0, 0);
2912
Benjamin Tissoires12969e32014-09-11 13:14:04 -04002913 /* kept for making udev and libwacom accepting the pad */
2914 __set_bit(BTN_STYLUS, input_dev->keybit);
2915
Aaron Skomra70ee06c2015-08-20 16:05:16 -07002916 wacom_setup_numbered_buttons(input_dev, features->numbered_buttons);
2917
Benjamin Tissoiresd2d13f12014-07-24 12:48:28 -07002918 switch (features->type) {
Aaron Skomra70ee06c2015-08-20 16:05:16 -07002919
2920 case CINTIQ_HYBRID:
Jason Gereckef7acb552015-10-13 10:03:49 -07002921 case CINTIQ_COMPANION_2:
Aaron Skomra70ee06c2015-08-20 16:05:16 -07002922 case DTK:
2923 case DTUS:
Benjamin Tissoires387142b2014-08-06 13:52:56 -07002924 case GRAPHIRE_BT:
Benjamin Tissoires387142b2014-08-06 13:52:56 -07002925 break;
2926
Benjamin Tissoires38138102014-07-24 12:51:03 -07002927 case WACOM_MO:
2928 __set_bit(BTN_BACK, input_dev->keybit);
2929 __set_bit(BTN_LEFT, input_dev->keybit);
2930 __set_bit(BTN_FORWARD, input_dev->keybit);
2931 __set_bit(BTN_RIGHT, input_dev->keybit);
2932 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2933 break;
2934
2935 case WACOM_G4:
2936 __set_bit(BTN_BACK, input_dev->keybit);
Benjamin Tissoires38138102014-07-24 12:51:03 -07002937 __set_bit(BTN_FORWARD, input_dev->keybit);
Benjamin Tissoires38138102014-07-24 12:51:03 -07002938 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2939 break;
2940
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002941 case WACOM_24HD:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002942 __set_bit(KEY_PROG1, input_dev->keybit);
2943 __set_bit(KEY_PROG2, input_dev->keybit);
2944 __set_bit(KEY_PROG3, input_dev->keybit);
2945
2946 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2947 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
2948 break;
2949
Ping Cheng500d4162015-01-27 13:30:03 -08002950 case WACOM_27QHD:
2951 __set_bit(KEY_PROG1, input_dev->keybit);
2952 __set_bit(KEY_PROG2, input_dev->keybit);
2953 __set_bit(KEY_PROG3, input_dev->keybit);
2954 input_set_abs_params(input_dev, ABS_X, -2048, 2048, 0, 0);
2955 input_abs_set_res(input_dev, ABS_X, 1024); /* points/g */
2956 input_set_abs_params(input_dev, ABS_Y, -2048, 2048, 0, 0);
2957 input_abs_set_res(input_dev, ABS_Y, 1024);
2958 input_set_abs_params(input_dev, ABS_Z, -2048, 2048, 0, 0);
2959 input_abs_set_res(input_dev, ABS_Z, 1024);
2960 __set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit);
2961 break;
2962
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002963 case WACOM_22HD:
2964 __set_bit(KEY_PROG1, input_dev->keybit);
2965 __set_bit(KEY_PROG2, input_dev->keybit);
2966 __set_bit(KEY_PROG3, input_dev->keybit);
2967 /* fall through */
2968
2969 case WACOM_21UX2:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002970 case WACOM_BEE:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002971 case CINTIQ:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002972 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2973 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2974 break;
2975
2976 case WACOM_13HD:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002977 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2978 break;
2979
2980 case INTUOS3:
2981 case INTUOS3L:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002982 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2983 /* fall through */
2984
2985 case INTUOS3S:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002986 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2987 break;
2988
2989 case INTUOS5:
2990 case INTUOS5L:
2991 case INTUOSPM:
2992 case INTUOSPL:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002993 case INTUOS5S:
2994 case INTUOSPS:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07002995 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2996 break;
2997
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07002998 case INTUOS4WL:
2999 /*
3000 * For Bluetooth devices, the udev rule does not work correctly
3001 * for pads unless we add a stylus capability, which forces
3002 * ID_INPUT_TABLET to be set.
3003 */
3004 __set_bit(BTN_STYLUS, input_dev->keybit);
3005 /* fall through */
3006
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07003007 case INTUOS4:
3008 case INTUOS4L:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07003009 case INTUOS4S:
Benjamin Tissoires10059cdc2014-07-24 12:49:08 -07003010 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
3011 break;
3012
Benjamin Tissoires31168712014-07-24 12:50:10 -07003013 case INTUOSHT:
3014 case BAMBOO_PT:
Ping Cheng3b164a02015-09-23 09:59:10 -07003015 case BAMBOO_TOUCH:
Ping Chengeda01da2015-09-23 13:51:15 -07003016 case INTUOSHT2:
Benjamin Tissoires31168712014-07-24 12:50:10 -07003017 __clear_bit(ABS_MISC, input_dev->absbit);
3018
3019 __set_bit(BTN_LEFT, input_dev->keybit);
3020 __set_bit(BTN_FORWARD, input_dev->keybit);
3021 __set_bit(BTN_BACK, input_dev->keybit);
3022 __set_bit(BTN_RIGHT, input_dev->keybit);
3023
3024 break;
3025
Aaron Skomra72b236d2015-08-20 16:05:17 -07003026 case REMOTE:
3027 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
3028 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
3029 break;
3030
Benjamin Tissoiresd2d13f12014-07-24 12:48:28 -07003031 default:
3032 /* no pad supported */
Ping Chengb3c8e932014-11-18 13:27:48 -08003033 return -ENODEV;
Benjamin Tissoiresd2d13f12014-07-24 12:48:28 -07003034 }
3035 return 0;
3036}
3037
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003038static const struct wacom_features wacom_features_0x00 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003039 { "Wacom Penpartner", 5040, 3780, 255, 0,
3040 PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003041static const struct wacom_features wacom_features_0x10 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003042 { "Wacom Graphire", 10206, 7422, 511, 63,
3043 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Benjamin Tissoires387142b2014-08-06 13:52:56 -07003044static const struct wacom_features wacom_features_0x81 =
3045 { "Wacom Graphire BT", 16704, 12064, 511, 32,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003046 GRAPHIRE_BT, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES, 2 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003047static const struct wacom_features wacom_features_0x11 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003048 { "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
3049 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003050static const struct wacom_features wacom_features_0x12 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003051 { "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
3052 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003053static const struct wacom_features wacom_features_0x13 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003054 { "Wacom Graphire3", 10208, 7424, 511, 63,
3055 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003056static const struct wacom_features wacom_features_0x14 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003057 { "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
3058 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003059static const struct wacom_features wacom_features_0x15 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003060 { "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
3061 WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003062static const struct wacom_features wacom_features_0x16 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003063 { "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
3064 WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003065static const struct wacom_features wacom_features_0x17 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003066 { "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
3067 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003068static const struct wacom_features wacom_features_0x18 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003069 { "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
3070 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003071static const struct wacom_features wacom_features_0x19 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003072 { "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
3073 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003074static const struct wacom_features wacom_features_0x60 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003075 { "Wacom Volito", 5104, 3712, 511, 63,
3076 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003077static const struct wacom_features wacom_features_0x61 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003078 { "Wacom PenStation2", 3250, 2320, 255, 63,
3079 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003080static const struct wacom_features wacom_features_0x62 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003081 { "Wacom Volito2 4x5", 5104, 3712, 511, 63,
3082 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003083static const struct wacom_features wacom_features_0x63 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003084 { "Wacom Volito2 2x3", 3248, 2320, 511, 63,
3085 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003086static const struct wacom_features wacom_features_0x64 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003087 { "Wacom PenPartner2", 3250, 2320, 511, 63,
3088 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003089static const struct wacom_features wacom_features_0x65 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003090 { "Wacom Bamboo", 14760, 9225, 511, 63,
3091 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003092static const struct wacom_features wacom_features_0x69 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003093 { "Wacom Bamboo1", 5104, 3712, 511, 63,
3094 GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
Ping Cheng11d0cf82011-06-27 12:57:58 -07003095static const struct wacom_features wacom_features_0x6A =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003096 { "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
3097 GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Cheng11d0cf82011-06-27 12:57:58 -07003098static const struct wacom_features wacom_features_0x6B =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003099 { "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
3100 GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003101static const struct wacom_features wacom_features_0x20 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003102 { "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
3103 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003104static const struct wacom_features wacom_features_0x21 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003105 { "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
3106 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003107static const struct wacom_features wacom_features_0x22 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003108 { "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
3109 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003110static const struct wacom_features wacom_features_0x23 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003111 { "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
3112 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003113static const struct wacom_features wacom_features_0x24 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003114 { "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
3115 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003116static const struct wacom_features wacom_features_0x30 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003117 { "Wacom PL400", 5408, 4056, 255, 0,
3118 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003119static const struct wacom_features wacom_features_0x31 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003120 { "Wacom PL500", 6144, 4608, 255, 0,
3121 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003122static const struct wacom_features wacom_features_0x32 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003123 { "Wacom PL600", 6126, 4604, 255, 0,
3124 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003125static const struct wacom_features wacom_features_0x33 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003126 { "Wacom PL600SX", 6260, 5016, 255, 0,
3127 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003128static const struct wacom_features wacom_features_0x34 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003129 { "Wacom PL550", 6144, 4608, 511, 0,
3130 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003131static const struct wacom_features wacom_features_0x35 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003132 { "Wacom PL800", 7220, 5780, 511, 0,
3133 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003134static const struct wacom_features wacom_features_0x37 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003135 { "Wacom PL700", 6758, 5406, 511, 0,
3136 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003137static const struct wacom_features wacom_features_0x38 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003138 { "Wacom PL510", 6282, 4762, 511, 0,
3139 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003140static const struct wacom_features wacom_features_0x39 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003141 { "Wacom DTU710", 34080, 27660, 511, 0,
3142 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003143static const struct wacom_features wacom_features_0xC4 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003144 { "Wacom DTF521", 6282, 4762, 511, 0,
3145 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003146static const struct wacom_features wacom_features_0xC0 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003147 { "Wacom DTF720", 6858, 5506, 511, 0,
3148 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003149static const struct wacom_features wacom_features_0xC2 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003150 { "Wacom DTF720a", 6858, 5506, 511, 0,
3151 PL, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003152static const struct wacom_features wacom_features_0x03 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003153 { "Wacom Cintiq Partner", 20480, 15360, 511, 0,
3154 PTU, WACOM_PL_RES, WACOM_PL_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003155static const struct wacom_features wacom_features_0x41 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003156 { "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
3157 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003158static const struct wacom_features wacom_features_0x42 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003159 { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
3160 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003161static const struct wacom_features wacom_features_0x43 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003162 { "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
3163 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003164static const struct wacom_features wacom_features_0x44 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003165 { "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
3166 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003167static const struct wacom_features wacom_features_0x45 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003168 { "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
3169 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003170static const struct wacom_features wacom_features_0xB0 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003171 { "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003172 INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003173static const struct wacom_features wacom_features_0xB1 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003174 { "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003175 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003176static const struct wacom_features wacom_features_0xB2 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003177 { "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003178 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003179static const struct wacom_features wacom_features_0xB3 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003180 { "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003181 INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003182static const struct wacom_features wacom_features_0xB4 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003183 { "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003184 INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003185static const struct wacom_features wacom_features_0xB5 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003186 { "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003187 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003188static const struct wacom_features wacom_features_0xB7 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003189 { "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003190 INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003191static const struct wacom_features wacom_features_0xB8 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003192 { "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003193 INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003194static const struct wacom_features wacom_features_0xB9 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003195 { "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003196 INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003197static const struct wacom_features wacom_features_0xBA =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003198 { "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003199 INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003200static const struct wacom_features wacom_features_0xBB =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003201 { "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003202 INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
Ping Cheng3a4b4aa2010-06-03 22:10:21 -07003203static const struct wacom_features wacom_features_0xBC =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003204 { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003205 INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07003206static const struct wacom_features wacom_features_0xBD =
3207 { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003208 INTUOS4WL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
Jason Gerecke9fee6192012-04-03 15:47:22 -07003209static const struct wacom_features wacom_features_0x26 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003210 { "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003211 INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16 };
Jason Gerecke9fee6192012-04-03 15:47:22 -07003212static const struct wacom_features wacom_features_0x27 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003213 { "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003214 INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
Jason Gerecke9fee6192012-04-03 15:47:22 -07003215static const struct wacom_features wacom_features_0x28 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003216 { "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003217 INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
Jason Gerecke9fee6192012-04-03 15:47:22 -07003218static const struct wacom_features wacom_features_0x29 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003219 { "Wacom Intuos5 S", 31496, 19685, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003220 INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
Jason Gerecke9fee6192012-04-03 15:47:22 -07003221static const struct wacom_features wacom_features_0x2A =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003222 { "Wacom Intuos5 M", 44704, 27940, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003223 INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
Ping Cheng9a35c412013-09-20 09:51:56 -07003224static const struct wacom_features wacom_features_0x314 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003225 { "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003226 INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003227 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ping Cheng9a35c412013-09-20 09:51:56 -07003228static const struct wacom_features wacom_features_0x315 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003229 { "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003230 INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003231 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ping Cheng9a35c412013-09-20 09:51:56 -07003232static const struct wacom_features wacom_features_0x317 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003233 { "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003234 INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003235 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Jason Gerecke803296b2011-12-12 00:11:45 -08003236static const struct wacom_features wacom_features_0xF4 =
Ping Chengecd618d2014-12-04 18:25:07 -08003237 { "Wacom Cintiq 24HD", 104080, 65200, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003238 WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
Ping Chengfa770342014-12-01 13:44:28 -08003239 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
Jason Gerecke6f4d0382012-08-21 22:11:59 -07003240static const struct wacom_features wacom_features_0xF8 =
Ping Chengecd618d2014-12-04 18:25:07 -08003241 { "Wacom Cintiq 24HD touch", 104080, 65200, 2047, 63, /* Pen */
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003242 WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
Ping Chengfa770342014-12-01 13:44:28 -08003243 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
Ping Cheng3bd1f7e2013-05-23 10:22:33 -07003244 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
Jason Gereckeb1e42792012-10-21 00:38:04 -07003245static const struct wacom_features wacom_features_0xF6 =
3246 { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003247 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
3248 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ping Cheng500d4162015-01-27 13:30:03 -08003249static const struct wacom_features wacom_features_0x32A =
Ping Chenga7e66452015-02-04 16:01:54 -08003250 { "Wacom Cintiq 27QHD", 119740, 67520, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003251 WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
Ping Chenga7e66452015-02-04 16:01:54 -08003252 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
Ping Cheng500d4162015-01-27 13:30:03 -08003253static const struct wacom_features wacom_features_0x32B =
3254 { "Wacom Cintiq 27QHD touch", 119740, 67520, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003255 WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
Ping Cheng500d4162015-01-27 13:30:03 -08003256 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3257 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32C };
3258static const struct wacom_features wacom_features_0x32C =
3259 { "Wacom Cintiq 27QHD touch", .type = WACOM_27QHDT,
3260 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32B, .touch_max = 10 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003261static const struct wacom_features wacom_features_0x3F =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003262 { "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003263 CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003264static const struct wacom_features wacom_features_0xC5 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003265 { "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003266 WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003267static const struct wacom_features wacom_features_0xC6 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003268 { "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003269 WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
Ping Cheng56218562013-05-05 19:56:18 -07003270static const struct wacom_features wacom_features_0x304 =
Ping Chengecd618d2014-12-04 18:25:07 -08003271 { "Wacom Cintiq 13HD", 59152, 33448, 1023, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003272 WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
Ping Chengfa770342014-12-01 13:44:28 -08003273 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
Ping Chengb4bf2122015-03-25 17:08:13 -07003274static const struct wacom_features wacom_features_0x333 =
3275 { "Wacom Cintiq 13HD touch", 59152, 33448, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003276 WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
Ping Chengb4bf2122015-03-25 17:08:13 -07003277 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3278 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x335 };
3279static const struct wacom_features wacom_features_0x335 =
3280 { "Wacom Cintiq 13HD touch", .type = WACOM_24HDT, /* Touch */
3281 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x333, .touch_max = 10,
3282 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003283static const struct wacom_features wacom_features_0xC7 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003284 { "Wacom DTU1931", 37832, 30305, 511, 0,
3285 PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Chengc8f2edc2010-06-28 01:10:51 -07003286static const struct wacom_features wacom_features_0xCE =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003287 { "Wacom DTU2231", 47864, 27011, 511, 0,
3288 DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003289 .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
Ping Chengc8f2edc2010-06-28 01:10:51 -07003290static const struct wacom_features wacom_features_0xF0 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003291 { "Wacom DTU1631", 34623, 19553, 511, 0,
3292 DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Cheng497ab1f2014-01-20 20:18:04 -08003293static const struct wacom_features wacom_features_0xFB =
Ping Chengecd618d2014-12-04 18:25:07 -08003294 { "Wacom DTU1031", 21896, 13760, 511, 0,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003295 DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
Ping Chengfa770342014-12-01 13:44:28 -08003296 WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
Ping Chengfff00bf2014-12-04 18:23:04 -08003297static const struct wacom_features wacom_features_0x32F =
3298 { "Wacom DTU1031X", 22472, 12728, 511, 0,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003299 DTUSX, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 0,
Ping Chengfff00bf2014-12-04 18:23:04 -08003300 WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
Aaron Skomra007760c2015-04-16 15:01:14 -07003301static const struct wacom_features wacom_features_0x336 =
3302 { "Wacom DTU1141", 23472, 13203, 1023, 0,
Ping Chengff38e822015-11-12 17:21:14 -08003303 DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
3304 WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
Ping Cheng56218562013-05-05 19:56:18 -07003305static const struct wacom_features wacom_features_0x57 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003306 { "Wacom DTK2241", 95640, 54060, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003307 DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
Ping Chengfa770342014-12-01 13:44:28 -08003308 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
Ping Chenga112e9f2013-02-13 20:20:01 -08003309static const struct wacom_features wacom_features_0x59 = /* Pen */
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003310 { "Wacom DTH2242", 95640, 54060, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003311 DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
Ping Chengfa770342014-12-01 13:44:28 -08003312 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
Ping Chenga112e9f2013-02-13 20:20:01 -08003313 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
3314static const struct wacom_features wacom_features_0x5D = /* Touch */
3315 { "Wacom DTH2242", .type = WACOM_24HDT,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003316 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
3317 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ping Cheng3a4b4aa2010-06-03 22:10:21 -07003318static const struct wacom_features wacom_features_0xCC =
Ping Chengecd618d2014-12-04 18:25:07 -08003319 { "Wacom Cintiq 21UX2", 86800, 65200, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003320 WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
Ping Chengfa770342014-12-01 13:44:28 -08003321 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
Ping Chengd838c642012-07-24 23:54:11 -07003322static const struct wacom_features wacom_features_0xFA =
Ping Chengecd618d2014-12-04 18:25:07 -08003323 { "Wacom Cintiq 22HD", 95440, 53860, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003324 WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
Ping Chengfa770342014-12-01 13:44:28 -08003325 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
Ping Cheng56218562013-05-05 19:56:18 -07003326static const struct wacom_features wacom_features_0x5B =
Ping Chengecd618d2014-12-04 18:25:07 -08003327 { "Wacom Cintiq 22HDT", 95440, 53860, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003328 WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
Ping Chengfa770342014-12-01 13:44:28 -08003329 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
Ping Cheng3bd1f7e2013-05-23 10:22:33 -07003330 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
Ping Cheng56218562013-05-05 19:56:18 -07003331static const struct wacom_features wacom_features_0x5E =
3332 { "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003333 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
3334 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003335static const struct wacom_features wacom_features_0x90 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003336 { "Wacom ISDv4 90", 26202, 16325, 255, 0,
3337 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003338static const struct wacom_features wacom_features_0x93 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003339 { "Wacom ISDv4 93", 26202, 16325, 255, 0,
3340 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Cheng11d0cf82011-06-27 12:57:58 -07003341static const struct wacom_features wacom_features_0x97 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003342 { "Wacom ISDv4 97", 26202, 16325, 511, 0,
3343 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003344static const struct wacom_features wacom_features_0x9A =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003345 { "Wacom ISDv4 9A", 26202, 16325, 255, 0,
3346 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003347static const struct wacom_features wacom_features_0x9F =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003348 { "Wacom ISDv4 9F", 26202, 16325, 255, 0,
3349 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003350static const struct wacom_features wacom_features_0xE2 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003351 { "Wacom ISDv4 E2", 26202, 16325, 255, 0,
3352 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003353static const struct wacom_features wacom_features_0xE3 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003354 { "Wacom ISDv4 E3", 26202, 16325, 255, 0,
3355 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Cheng19635182012-04-29 21:09:18 -07003356static const struct wacom_features wacom_features_0xE5 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003357 { "Wacom ISDv4 E5", 26202, 16325, 255, 0,
3358 MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Manoj Iyer26fcd2a2011-03-31 22:39:43 -07003359static const struct wacom_features wacom_features_0xE6 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003360 { "Wacom ISDv4 E6", 27760, 15694, 255, 0,
3361 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Chris Bagwell0d0e3062011-12-11 23:50:59 -08003362static const struct wacom_features wacom_features_0xEC =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003363 { "Wacom ISDv4 EC", 25710, 14500, 255, 0,
3364 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Chengac173832012-06-12 00:15:06 -07003365static const struct wacom_features wacom_features_0xED =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003366 { "Wacom ISDv4 ED", 26202, 16325, 255, 0,
3367 TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Chengac173832012-06-12 00:15:06 -07003368static const struct wacom_features wacom_features_0xEF =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003369 { "Wacom ISDv4 EF", 26202, 16325, 255, 0,
3370 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Cheng6afdc282012-11-03 12:16:15 -07003371static const struct wacom_features wacom_features_0x100 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003372 { "Wacom ISDv4 100", 26202, 16325, 255, 0,
3373 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Cheng6afdc282012-11-03 12:16:15 -07003374static const struct wacom_features wacom_features_0x101 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003375 { "Wacom ISDv4 101", 26202, 16325, 255, 0,
3376 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Stephan Frank58694832013-03-07 14:08:50 -08003377static const struct wacom_features wacom_features_0x10D =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003378 { "Wacom ISDv4 10D", 26202, 16325, 255, 0,
3379 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Jason Gerecke2d3163f2013-10-22 15:35:30 -07003380static const struct wacom_features wacom_features_0x10E =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003381 { "Wacom ISDv4 10E", 27760, 15694, 255, 0,
3382 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Jason Gerecke9b4f60e2013-10-15 23:46:34 -07003383static const struct wacom_features wacom_features_0x10F =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003384 { "Wacom ISDv4 10F", 27760, 15694, 255, 0,
3385 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Jason Gerecke61616ed2014-05-14 11:42:22 -07003386static const struct wacom_features wacom_features_0x116 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003387 { "Wacom ISDv4 116", 26202, 16325, 255, 0,
3388 TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Jason Gereckeaeaf50d2014-07-28 10:53:16 -07003389static const struct wacom_features wacom_features_0x12C =
3390 { "Wacom ISDv4 12C", 27848, 15752, 2047, 0,
3391 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Chengedbe2652012-11-21 13:12:50 -08003392static const struct wacom_features wacom_features_0x4001 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003393 { "Wacom ISDv4 4001", 26202, 16325, 255, 0,
3394 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Jason Gerecked51ddb22014-05-14 17:14:29 -07003395static const struct wacom_features wacom_features_0x4004 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003396 { "Wacom ISDv4 4004", 11060, 6220, 255, 0,
3397 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Jason Gerecked51ddb22014-05-14 17:14:29 -07003398static const struct wacom_features wacom_features_0x5000 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003399 { "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
3400 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Jason Gerecked51ddb22014-05-14 17:14:29 -07003401static const struct wacom_features wacom_features_0x5002 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003402 { "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
3403 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Dmitry Torokhove87a3442010-02-18 01:51:47 -08003404static const struct wacom_features wacom_features_0x47 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003405 { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
3406 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Chris Bagwelld3825d52012-03-25 23:26:11 -07003407static const struct wacom_features wacom_features_0x84 =
Ping Cheng3b164a02015-09-23 09:59:10 -07003408 { "Wacom Wireless Receiver", .type = WIRELESS, .touch_max = 16 };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003409static const struct wacom_features wacom_features_0xD0 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003410 { "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
Ping Cheng3b164a02015-09-23 09:59:10 -07003411 BAMBOO_TOUCH, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003412static const struct wacom_features wacom_features_0xD1 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003413 { "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
3414 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003415static const struct wacom_features wacom_features_0xD2 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003416 { "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
3417 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003418static const struct wacom_features wacom_features_0xD3 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003419 { "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
3420 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Kevin Granade57a78722010-12-10 23:04:02 -08003421static const struct wacom_features wacom_features_0xD4 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003422 { "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
Ping Cheng3b164a02015-09-23 09:59:10 -07003423 BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Gerard Braad18adad12011-08-16 00:17:56 -07003424static const struct wacom_features wacom_features_0xD5 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003425 { "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
Ping Cheng3b164a02015-09-23 09:59:10 -07003426 BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003427static const struct wacom_features wacom_features_0xD6 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003428 { "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
3429 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003430static const struct wacom_features wacom_features_0xD7 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003431 { "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
3432 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003433static const struct wacom_features wacom_features_0xD8 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003434 { "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
3435 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Cheng7b824bb2011-03-26 21:16:04 -07003436static const struct wacom_features wacom_features_0xDA =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003437 { "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
3438 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Ping Chengf41a64e2013-08-21 09:14:49 -07003439static const struct wacom_features wacom_features_0xDB =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003440 { "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
3441 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
Chris Bagwell73149ab2011-10-26 22:34:21 -07003442static const struct wacom_features wacom_features_0xDD =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003443 { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
3444 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Chris Bagwell73149ab2011-10-26 22:34:21 -07003445static const struct wacom_features wacom_features_0xDE =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003446 { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
3447 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
Chris Bagwell73149ab2011-10-26 22:34:21 -07003448static const struct wacom_features wacom_features_0xDF =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003449 { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
3450 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
Ping Chengf41a64e2013-08-21 09:14:49 -07003451static const struct wacom_features wacom_features_0x300 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003452 { "Wacom Bamboo One S", 14720, 9225, 1023, 31,
Ping Cheng3b164a02015-09-23 09:59:10 -07003453 BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Chengf41a64e2013-08-21 09:14:49 -07003454static const struct wacom_features wacom_features_0x301 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003455 { "Wacom Bamboo One M", 21648, 13530, 1023, 31,
3456 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Ping Chengb5fd2a32013-11-25 18:44:55 -08003457static const struct wacom_features wacom_features_0x302 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003458 { "Wacom Intuos PT S", 15200, 9500, 1023, 31,
3459 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003460 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ping Chengb5fd2a32013-11-25 18:44:55 -08003461static const struct wacom_features wacom_features_0x303 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003462 { "Wacom Intuos PT M", 21600, 13500, 1023, 31,
3463 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003464 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ping Chengb5fd2a32013-11-25 18:44:55 -08003465static const struct wacom_features wacom_features_0x30E =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003466 { "Wacom Intuos S", 15200, 9500, 1023, 31,
3467 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003468 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ajay Ramaswamy7b4b3062010-12-23 01:19:39 -08003469static const struct wacom_features wacom_features_0x6004 =
Benjamin Tissoires80befa92014-07-24 13:05:19 -07003470 { "ISD-V4", 12800, 8000, 255, 0,
3471 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003472static const struct wacom_features wacom_features_0x307 =
Ping Chengecd618d2014-12-04 18:25:07 -08003473 { "Wacom ISDv5 307", 59152, 33448, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003474 CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
Ping Chengfa770342014-12-01 13:44:28 -08003475 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
Jason Gerecke36d3c512013-09-20 09:47:35 -07003476 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003477static const struct wacom_features wacom_features_0x309 =
Jason Gerecke36d3c512013-09-20 09:47:35 -07003478 { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003479 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
3480 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Benjamin Tissoires89f2ab52014-09-03 15:43:25 -04003481static const struct wacom_features wacom_features_0x30A =
Ping Chengecd618d2014-12-04 18:25:07 -08003482 { "Wacom ISDv5 30A", 59152, 33448, 2047, 63,
Aaron Skomra70ee06c2015-08-20 16:05:16 -07003483 CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
Ping Chengfa770342014-12-01 13:44:28 -08003484 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
Benjamin Tissoires89f2ab52014-09-03 15:43:25 -04003485 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30C };
3486static const struct wacom_features wacom_features_0x30C =
3487 { "Wacom ISDv5 30C", .type = WACOM_24HDT, /* Touch */
3488 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30A, .touch_max = 10,
3489 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Benjamin Tissoires8c97a762015-02-26 11:28:50 -05003490static const struct wacom_features wacom_features_0x318 =
3491 { "Wacom USB Bamboo PAD", 4095, 4095, /* Touch */
3492 .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
3493static const struct wacom_features wacom_features_0x319 =
3494 { "Wacom Wireless Bamboo PAD", 4095, 4095, /* Touch */
3495 .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
Jason Gereckef7acb552015-10-13 10:03:49 -07003496static const struct wacom_features wacom_features_0x325 =
3497 { "Wacom ISDv5 325", 59552, 33848, 2047, 63,
3498 CINTIQ_COMPANION_2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 11,
3499 WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3500 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x326 };
3501static const struct wacom_features wacom_features_0x326 = /* Touch */
3502 { "Wacom ISDv5 326", .type = HID_GENERIC, .oVid = USB_VENDOR_ID_WACOM,
3503 .oPid = 0x325 };
Ping Chengfefb3912014-11-11 12:52:08 -08003504static const struct wacom_features wacom_features_0x323 =
3505 { "Wacom Intuos P M", 21600, 13500, 1023, 31,
3506 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3507 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Aaron Skomra72b236d2015-08-20 16:05:17 -07003508static const struct wacom_features wacom_features_0x331 =
Ping Cheng3b164a02015-09-23 09:59:10 -07003509 { "Wacom Express Key Remote", .type = REMOTE,
3510 .numbered_buttons = 18, .check_for_hid_type = true,
Aaron Skomra72b236d2015-08-20 16:05:17 -07003511 .hid_type = HID_TYPE_USBNONE };
Ping Chengeda01da2015-09-23 13:51:15 -07003512static const struct wacom_features wacom_features_0x33B =
3513 { "Wacom Intuos S 2", 15200, 9500, 2047, 63,
3514 INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3515 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3516static const struct wacom_features wacom_features_0x33C =
3517 { "Wacom Intuos PT S 2", 15200, 9500, 2047, 63,
3518 INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3519 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3520static const struct wacom_features wacom_features_0x33D =
3521 { "Wacom Intuos P M 2", 21600, 13500, 2047, 63,
3522 INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3523 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3524static const struct wacom_features wacom_features_0x33E =
3525 { "Wacom Intuos PT M 2", 21600, 13500, 2047, 63,
3526 INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3527 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
Ping Chenge1123fe2016-04-12 13:37:45 -07003528static const struct wacom_features wacom_features_0x343 =
3529 { "Wacom DTK1651", 34616, 19559, 1023, 0,
3530 DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
3531 WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
Bastian Blankb036f6f2010-02-10 23:06:23 -08003532
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04003533static const struct wacom_features wacom_features_HID_ANY_ID =
3534 { "Wacom HID", .type = HID_GENERIC };
3535
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003536#define USB_DEVICE_WACOM(prod) \
3537 HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3538 .driver_data = (kernel_ulong_t)&wacom_features_##prod
Bastian Blankb036f6f2010-02-10 23:06:23 -08003539
Benjamin Tissoires387142b2014-08-06 13:52:56 -07003540#define BT_DEVICE_WACOM(prod) \
3541 HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3542 .driver_data = (kernel_ulong_t)&wacom_features_##prod
Aristeu Rozanski1483f552011-06-22 01:17:17 -07003543
Mika Westerbergeef23a82015-02-23 15:52:43 +02003544#define I2C_DEVICE_WACOM(prod) \
3545 HID_DEVICE(BUS_I2C, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3546 .driver_data = (kernel_ulong_t)&wacom_features_##prod
3547
Ajay Ramaswamy7b4b3062010-12-23 01:19:39 -08003548#define USB_DEVICE_LENOVO(prod) \
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003549 HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod), \
3550 .driver_data = (kernel_ulong_t)&wacom_features_##prod
Ajay Ramaswamy7b4b3062010-12-23 01:19:39 -08003551
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003552const struct hid_device_id wacom_ids[] = {
Bastian Blankb036f6f2010-02-10 23:06:23 -08003553 { USB_DEVICE_WACOM(0x00) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003554 { USB_DEVICE_WACOM(0x03) },
Bastian Blankb036f6f2010-02-10 23:06:23 -08003555 { USB_DEVICE_WACOM(0x10) },
3556 { USB_DEVICE_WACOM(0x11) },
3557 { USB_DEVICE_WACOM(0x12) },
3558 { USB_DEVICE_WACOM(0x13) },
3559 { USB_DEVICE_WACOM(0x14) },
3560 { USB_DEVICE_WACOM(0x15) },
3561 { USB_DEVICE_WACOM(0x16) },
3562 { USB_DEVICE_WACOM(0x17) },
3563 { USB_DEVICE_WACOM(0x18) },
3564 { USB_DEVICE_WACOM(0x19) },
Bastian Blankb036f6f2010-02-10 23:06:23 -08003565 { USB_DEVICE_WACOM(0x20) },
3566 { USB_DEVICE_WACOM(0x21) },
3567 { USB_DEVICE_WACOM(0x22) },
3568 { USB_DEVICE_WACOM(0x23) },
3569 { USB_DEVICE_WACOM(0x24) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003570 { USB_DEVICE_WACOM(0x26) },
3571 { USB_DEVICE_WACOM(0x27) },
3572 { USB_DEVICE_WACOM(0x28) },
3573 { USB_DEVICE_WACOM(0x29) },
3574 { USB_DEVICE_WACOM(0x2A) },
Bastian Blankb036f6f2010-02-10 23:06:23 -08003575 { USB_DEVICE_WACOM(0x30) },
3576 { USB_DEVICE_WACOM(0x31) },
3577 { USB_DEVICE_WACOM(0x32) },
3578 { USB_DEVICE_WACOM(0x33) },
3579 { USB_DEVICE_WACOM(0x34) },
3580 { USB_DEVICE_WACOM(0x35) },
3581 { USB_DEVICE_WACOM(0x37) },
3582 { USB_DEVICE_WACOM(0x38) },
3583 { USB_DEVICE_WACOM(0x39) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003584 { USB_DEVICE_WACOM(0x3F) },
Bastian Blankb036f6f2010-02-10 23:06:23 -08003585 { USB_DEVICE_WACOM(0x41) },
3586 { USB_DEVICE_WACOM(0x42) },
3587 { USB_DEVICE_WACOM(0x43) },
3588 { USB_DEVICE_WACOM(0x44) },
3589 { USB_DEVICE_WACOM(0x45) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003590 { USB_DEVICE_WACOM(0x47) },
Ping Cheng56218562013-05-05 19:56:18 -07003591 { USB_DEVICE_WACOM(0x57) },
Ping Chenga112e9f2013-02-13 20:20:01 -08003592 { USB_DEVICE_WACOM(0x59) },
Ping Cheng56218562013-05-05 19:56:18 -07003593 { USB_DEVICE_WACOM(0x5B) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003594 { USB_DEVICE_WACOM(0x5D) },
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003595 { USB_DEVICE_WACOM(0x5E) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003596 { USB_DEVICE_WACOM(0x60) },
3597 { USB_DEVICE_WACOM(0x61) },
3598 { USB_DEVICE_WACOM(0x62) },
3599 { USB_DEVICE_WACOM(0x63) },
3600 { USB_DEVICE_WACOM(0x64) },
3601 { USB_DEVICE_WACOM(0x65) },
3602 { USB_DEVICE_WACOM(0x69) },
3603 { USB_DEVICE_WACOM(0x6A) },
3604 { USB_DEVICE_WACOM(0x6B) },
Benjamin Tissoires387142b2014-08-06 13:52:56 -07003605 { BT_DEVICE_WACOM(0x81) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003606 { USB_DEVICE_WACOM(0x84) },
3607 { USB_DEVICE_WACOM(0x90) },
3608 { USB_DEVICE_WACOM(0x93) },
3609 { USB_DEVICE_WACOM(0x97) },
3610 { USB_DEVICE_WACOM(0x9A) },
3611 { USB_DEVICE_WACOM(0x9F) },
Bastian Blankb036f6f2010-02-10 23:06:23 -08003612 { USB_DEVICE_WACOM(0xB0) },
3613 { USB_DEVICE_WACOM(0xB1) },
3614 { USB_DEVICE_WACOM(0xB2) },
3615 { USB_DEVICE_WACOM(0xB3) },
3616 { USB_DEVICE_WACOM(0xB4) },
3617 { USB_DEVICE_WACOM(0xB5) },
3618 { USB_DEVICE_WACOM(0xB7) },
3619 { USB_DEVICE_WACOM(0xB8) },
3620 { USB_DEVICE_WACOM(0xB9) },
3621 { USB_DEVICE_WACOM(0xBA) },
3622 { USB_DEVICE_WACOM(0xBB) },
Ping Cheng3a4b4aa2010-06-03 22:10:21 -07003623 { USB_DEVICE_WACOM(0xBC) },
Benjamin Tissoires81af7e62014-08-06 13:55:56 -07003624 { BT_DEVICE_WACOM(0xBD) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003625 { USB_DEVICE_WACOM(0xC0) },
3626 { USB_DEVICE_WACOM(0xC2) },
3627 { USB_DEVICE_WACOM(0xC4) },
Bastian Blankb036f6f2010-02-10 23:06:23 -08003628 { USB_DEVICE_WACOM(0xC5) },
3629 { USB_DEVICE_WACOM(0xC6) },
3630 { USB_DEVICE_WACOM(0xC7) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003631 { USB_DEVICE_WACOM(0xCC) },
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003632 { USB_DEVICE_WACOM(0xCE) },
Henrik Rydbergcb734c02010-09-05 12:53:16 -07003633 { USB_DEVICE_WACOM(0xD0) },
Chris Bagwell2aaacb12010-09-12 00:11:35 -07003634 { USB_DEVICE_WACOM(0xD1) },
3635 { USB_DEVICE_WACOM(0xD2) },
3636 { USB_DEVICE_WACOM(0xD3) },
Kevin Granade57a78722010-12-10 23:04:02 -08003637 { USB_DEVICE_WACOM(0xD4) },
Gerard Braad18adad12011-08-16 00:17:56 -07003638 { USB_DEVICE_WACOM(0xD5) },
Ping Chengd38acb42011-01-24 09:32:50 -08003639 { USB_DEVICE_WACOM(0xD6) },
3640 { USB_DEVICE_WACOM(0xD7) },
David Foleya318e6b2010-11-30 23:45:46 -08003641 { USB_DEVICE_WACOM(0xD8) },
3642 { USB_DEVICE_WACOM(0xDA) },
David Foley47d09232010-12-07 21:05:59 -08003643 { USB_DEVICE_WACOM(0xDB) },
Chris Bagwell73149ab2011-10-26 22:34:21 -07003644 { USB_DEVICE_WACOM(0xDD) },
3645 { USB_DEVICE_WACOM(0xDE) },
3646 { USB_DEVICE_WACOM(0xDF) },
Bastian Blankb036f6f2010-02-10 23:06:23 -08003647 { USB_DEVICE_WACOM(0xE2) },
3648 { USB_DEVICE_WACOM(0xE3) },
Ping Cheng19635182012-04-29 21:09:18 -07003649 { USB_DEVICE_WACOM(0xE5) },
Manoj Iyer26fcd2a2011-03-31 22:39:43 -07003650 { USB_DEVICE_WACOM(0xE6) },
Chris Bagwell0d0e3062011-12-11 23:50:59 -08003651 { USB_DEVICE_WACOM(0xEC) },
Ping Chengac173832012-06-12 00:15:06 -07003652 { USB_DEVICE_WACOM(0xED) },
3653 { USB_DEVICE_WACOM(0xEF) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003654 { USB_DEVICE_WACOM(0xF0) },
3655 { USB_DEVICE_WACOM(0xF4) },
3656 { USB_DEVICE_WACOM(0xF6) },
3657 { USB_DEVICE_WACOM(0xF8) },
3658 { USB_DEVICE_WACOM(0xFA) },
3659 { USB_DEVICE_WACOM(0xFB) },
Ping Cheng6afdc282012-11-03 12:16:15 -07003660 { USB_DEVICE_WACOM(0x100) },
3661 { USB_DEVICE_WACOM(0x101) },
Stephan Frank58694832013-03-07 14:08:50 -08003662 { USB_DEVICE_WACOM(0x10D) },
Jason Gerecke2d3163f2013-10-22 15:35:30 -07003663 { USB_DEVICE_WACOM(0x10E) },
Jason Gerecke9b4f60e2013-10-15 23:46:34 -07003664 { USB_DEVICE_WACOM(0x10F) },
Jason Gerecke61616ed2014-05-14 11:42:22 -07003665 { USB_DEVICE_WACOM(0x116) },
Jason Gereckeaeaf50d2014-07-28 10:53:16 -07003666 { USB_DEVICE_WACOM(0x12C) },
Ping Chengf41a64e2013-08-21 09:14:49 -07003667 { USB_DEVICE_WACOM(0x300) },
3668 { USB_DEVICE_WACOM(0x301) },
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003669 { USB_DEVICE_WACOM(0x302) },
3670 { USB_DEVICE_WACOM(0x303) },
Ping Cheng56218562013-05-05 19:56:18 -07003671 { USB_DEVICE_WACOM(0x304) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003672 { USB_DEVICE_WACOM(0x307) },
3673 { USB_DEVICE_WACOM(0x309) },
Benjamin Tissoires89f2ab52014-09-03 15:43:25 -04003674 { USB_DEVICE_WACOM(0x30A) },
3675 { USB_DEVICE_WACOM(0x30C) },
Benjamin Tissoiresa3e6f652014-07-24 13:05:49 -07003676 { USB_DEVICE_WACOM(0x30E) },
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003677 { USB_DEVICE_WACOM(0x314) },
3678 { USB_DEVICE_WACOM(0x315) },
3679 { USB_DEVICE_WACOM(0x317) },
Benjamin Tissoires8c97a762015-02-26 11:28:50 -05003680 { USB_DEVICE_WACOM(0x318) },
3681 { USB_DEVICE_WACOM(0x319) },
Ping Chengfefb3912014-11-11 12:52:08 -08003682 { USB_DEVICE_WACOM(0x323) },
Jason Gereckef7acb552015-10-13 10:03:49 -07003683 { USB_DEVICE_WACOM(0x325) },
3684 { USB_DEVICE_WACOM(0x326) },
Ping Cheng500d4162015-01-27 13:30:03 -08003685 { USB_DEVICE_WACOM(0x32A) },
3686 { USB_DEVICE_WACOM(0x32B) },
3687 { USB_DEVICE_WACOM(0x32C) },
Ping Chengfff00bf2014-12-04 18:23:04 -08003688 { USB_DEVICE_WACOM(0x32F) },
Aaron Skomra72b236d2015-08-20 16:05:17 -07003689 { USB_DEVICE_WACOM(0x331) },
Ping Chengb4bf2122015-03-25 17:08:13 -07003690 { USB_DEVICE_WACOM(0x333) },
3691 { USB_DEVICE_WACOM(0x335) },
Aaron Skomra007760c2015-04-16 15:01:14 -07003692 { USB_DEVICE_WACOM(0x336) },
Ping Chengeda01da2015-09-23 13:51:15 -07003693 { USB_DEVICE_WACOM(0x33B) },
3694 { USB_DEVICE_WACOM(0x33C) },
3695 { USB_DEVICE_WACOM(0x33D) },
3696 { USB_DEVICE_WACOM(0x33E) },
Ping Chenge1123fe2016-04-12 13:37:45 -07003697 { USB_DEVICE_WACOM(0x343) },
Ping Chengedbe2652012-11-21 13:12:50 -08003698 { USB_DEVICE_WACOM(0x4001) },
Jason Gerecked51ddb22014-05-14 17:14:29 -07003699 { USB_DEVICE_WACOM(0x4004) },
3700 { USB_DEVICE_WACOM(0x5000) },
3701 { USB_DEVICE_WACOM(0x5002) },
Benjamin Tissoires00d6f222014-12-01 11:52:39 -05003702 { USB_DEVICE_LENOVO(0x6004) },
Benjamin Tissoires7704ac92014-09-23 12:08:08 -04003703
3704 { USB_DEVICE_WACOM(HID_ANY_ID) },
Mika Westerbergeef23a82015-02-23 15:52:43 +02003705 { I2C_DEVICE_WACOM(HID_ANY_ID) },
Ping Cheng3bea7332006-07-13 18:01:36 -07003706 { }
3707};
Benjamin Tissoires29b47392014-07-24 12:52:23 -07003708MODULE_DEVICE_TABLE(hid, wacom_ids);