whiterose

linux unikernel
Log | Files | Refs | README | LICENSE | git clone https://git.ne02ptzero.me/git/whiterose

wacom_wac.c (151723B)


      1 /*
      2  * drivers/input/tablet/wacom_wac.c
      3  *
      4  *  USB Wacom tablet support - Wacom specific code
      5  *
      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  */
     14 
     15 #include "wacom_wac.h"
     16 #include "wacom.h"
     17 #include <linux/input/mt.h>
     18 
     19 /* 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 
     27 /* 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 
     31 /*
     32  * Scale factor relating reported contact size to logical contact area.
     33  * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
     34  */
     35 #define WACOM_CONTACT_AREA_SCALE 2607
     36 
     37 static bool touch_arbitration = 1;
     38 module_param(touch_arbitration, bool, 0644);
     39 MODULE_PARM_DESC(touch_arbitration, " on (Y) off (N)");
     40 
     41 static void wacom_report_numbered_buttons(struct input_dev *input_dev,
     42 				int button_count, int mask);
     43 
     44 static int wacom_numbered_button_to_key(int n);
     45 
     46 static void wacom_update_led(struct wacom *wacom, int button_count, int mask,
     47 			     int group);
     48 /*
     49  * Percent of battery capacity for Graphire.
     50  * 8th value means AC online and show 100% capacity.
     51  */
     52 static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
     53 
     54 /*
     55  * Percent of battery capacity for Intuos4 WL, AC has a separate bit.
     56  */
     57 static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
     58 
     59 static void __wacom_notify_battery(struct wacom_battery *battery,
     60 				   int bat_status, int bat_capacity,
     61 				   bool bat_charging, bool bat_connected,
     62 				   bool ps_connected)
     63 {
     64 	bool changed = battery->bat_status       != bat_status    ||
     65 		       battery->battery_capacity != bat_capacity  ||
     66 		       battery->bat_charging     != bat_charging  ||
     67 		       battery->bat_connected    != bat_connected ||
     68 		       battery->ps_connected     != ps_connected;
     69 
     70 	if (changed) {
     71 		battery->bat_status = bat_status;
     72 		battery->battery_capacity = bat_capacity;
     73 		battery->bat_charging = bat_charging;
     74 		battery->bat_connected = bat_connected;
     75 		battery->ps_connected = ps_connected;
     76 
     77 		if (battery->battery)
     78 			power_supply_changed(battery->battery);
     79 	}
     80 }
     81 
     82 static void wacom_notify_battery(struct wacom_wac *wacom_wac,
     83 	int bat_status, int bat_capacity, bool bat_charging,
     84 	bool bat_connected, bool ps_connected)
     85 {
     86 	struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
     87 
     88 	__wacom_notify_battery(&wacom->battery, bat_status, bat_capacity,
     89 			       bat_charging, bat_connected, ps_connected);
     90 }
     91 
     92 static int wacom_penpartner_irq(struct wacom_wac *wacom)
     93 {
     94 	unsigned char *data = wacom->data;
     95 	struct input_dev *input = wacom->pen_input;
     96 
     97 	switch (data[0]) {
     98 	case 1:
     99 		if (data[5] & 0x80) {
    100 			wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
    101 			wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
    102 			input_report_key(input, wacom->tool[0], 1);
    103 			input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
    104 			input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
    105 			input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
    106 			input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
    107 			input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
    108 			input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
    109 		} else {
    110 			input_report_key(input, wacom->tool[0], 0);
    111 			input_report_abs(input, ABS_MISC, 0); /* report tool id */
    112 			input_report_abs(input, ABS_PRESSURE, -1);
    113 			input_report_key(input, BTN_TOUCH, 0);
    114 		}
    115 		break;
    116 
    117 	case 2:
    118 		input_report_key(input, BTN_TOOL_PEN, 1);
    119 		input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
    120 		input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
    121 		input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
    122 		input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
    123 		input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
    124 		input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
    125 		break;
    126 
    127 	default:
    128 		dev_dbg(input->dev.parent,
    129 			"%s: received unknown report #%d\n", __func__, data[0]);
    130 		return 0;
    131         }
    132 
    133 	return 1;
    134 }
    135 
    136 static int wacom_pl_irq(struct wacom_wac *wacom)
    137 {
    138 	struct wacom_features *features = &wacom->features;
    139 	unsigned char *data = wacom->data;
    140 	struct input_dev *input = wacom->pen_input;
    141 	int prox, pressure;
    142 
    143 	if (data[0] != WACOM_REPORT_PENABLED) {
    144 		dev_dbg(input->dev.parent,
    145 			"%s: received unknown report #%d\n", __func__, data[0]);
    146 		return 0;
    147 	}
    148 
    149 	prox = data[1] & 0x40;
    150 
    151 	if (!wacom->id[0]) {
    152 		if ((data[0] & 0x10) || (data[4] & 0x20)) {
    153 			wacom->tool[0] = BTN_TOOL_RUBBER;
    154 			wacom->id[0] = ERASER_DEVICE_ID;
    155 		}
    156 		else {
    157 			wacom->tool[0] = BTN_TOOL_PEN;
    158 			wacom->id[0] = STYLUS_DEVICE_ID;
    159 		}
    160 	}
    161 
    162 	/* If the eraser is in prox, STYLUS2 is always set. If we
    163 	 * mis-detected the type and notice that STYLUS2 isn't set
    164 	 * then force the eraser out of prox and let the pen in.
    165 	 */
    166 	if (wacom->tool[0] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
    167 		input_report_key(input, BTN_TOOL_RUBBER, 0);
    168 		input_report_abs(input, ABS_MISC, 0);
    169 		input_sync(input);
    170 		wacom->tool[0] = BTN_TOOL_PEN;
    171 		wacom->id[0] = STYLUS_DEVICE_ID;
    172 	}
    173 
    174 	if (prox) {
    175 		pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
    176 		if (features->pressure_max > 255)
    177 			pressure = (pressure << 1) | ((data[4] >> 6) & 1);
    178 		pressure += (features->pressure_max + 1) / 2;
    179 
    180 		input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
    181 		input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
    182 		input_report_abs(input, ABS_PRESSURE, pressure);
    183 
    184 		input_report_key(input, BTN_TOUCH, data[4] & 0x08);
    185 		input_report_key(input, BTN_STYLUS, data[4] & 0x10);
    186 		/* Only allow the stylus2 button to be reported for the pen tool. */
    187 		input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));
    188 	}
    189 
    190 	if (!prox)
    191 		wacom->id[0] = 0;
    192 	input_report_key(input, wacom->tool[0], prox);
    193 	input_report_abs(input, ABS_MISC, wacom->id[0]);
    194 	return 1;
    195 }
    196 
    197 static int wacom_ptu_irq(struct wacom_wac *wacom)
    198 {
    199 	unsigned char *data = wacom->data;
    200 	struct input_dev *input = wacom->pen_input;
    201 
    202 	if (data[0] != WACOM_REPORT_PENABLED) {
    203 		dev_dbg(input->dev.parent,
    204 			"%s: received unknown report #%d\n", __func__, data[0]);
    205 		return 0;
    206 	}
    207 
    208 	if (data[1] & 0x04) {
    209 		input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
    210 		input_report_key(input, BTN_TOUCH, data[1] & 0x08);
    211 		wacom->id[0] = ERASER_DEVICE_ID;
    212 	} else {
    213 		input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
    214 		input_report_key(input, BTN_TOUCH, data[1] & 0x01);
    215 		wacom->id[0] = STYLUS_DEVICE_ID;
    216 	}
    217 	input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
    218 	input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
    219 	input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
    220 	input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
    221 	input_report_key(input, BTN_STYLUS, data[1] & 0x02);
    222 	input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
    223 	return 1;
    224 }
    225 
    226 static int wacom_dtu_irq(struct wacom_wac *wacom)
    227 {
    228 	unsigned char *data = wacom->data;
    229 	struct input_dev *input = wacom->pen_input;
    230 	int prox = data[1] & 0x20;
    231 
    232 	dev_dbg(input->dev.parent,
    233 		"%s: received report #%d", __func__, data[0]);
    234 
    235 	if (prox) {
    236 		/* Going into proximity select tool */
    237 		wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
    238 		if (wacom->tool[0] == BTN_TOOL_PEN)
    239 			wacom->id[0] = STYLUS_DEVICE_ID;
    240 		else
    241 			wacom->id[0] = ERASER_DEVICE_ID;
    242 	}
    243 	input_report_key(input, BTN_STYLUS, data[1] & 0x02);
    244 	input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
    245 	input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
    246 	input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
    247 	input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x01) << 8) | data[6]);
    248 	input_report_key(input, BTN_TOUCH, data[1] & 0x05);
    249 	if (!prox) /* out-prox */
    250 		wacom->id[0] = 0;
    251 	input_report_key(input, wacom->tool[0], prox);
    252 	input_report_abs(input, ABS_MISC, wacom->id[0]);
    253 	return 1;
    254 }
    255 
    256 static int wacom_dtus_irq(struct wacom_wac *wacom)
    257 {
    258 	char *data = wacom->data;
    259 	struct input_dev *input = wacom->pen_input;
    260 	unsigned short prox, pressure = 0;
    261 
    262 	if (data[0] != WACOM_REPORT_DTUS && data[0] != WACOM_REPORT_DTUSPAD) {
    263 		dev_dbg(input->dev.parent,
    264 			"%s: received unknown report #%d", __func__, data[0]);
    265 		return 0;
    266 	} else if (data[0] == WACOM_REPORT_DTUSPAD) {
    267 		input = wacom->pad_input;
    268 		input_report_key(input, BTN_0, (data[1] & 0x01));
    269 		input_report_key(input, BTN_1, (data[1] & 0x02));
    270 		input_report_key(input, BTN_2, (data[1] & 0x04));
    271 		input_report_key(input, BTN_3, (data[1] & 0x08));
    272 		input_report_abs(input, ABS_MISC,
    273 				 data[1] & 0x0f ? PAD_DEVICE_ID : 0);
    274 		return 1;
    275 	} else {
    276 		prox = data[1] & 0x80;
    277 		if (prox) {
    278 			switch ((data[1] >> 3) & 3) {
    279 			case 1: /* Rubber */
    280 				wacom->tool[0] = BTN_TOOL_RUBBER;
    281 				wacom->id[0] = ERASER_DEVICE_ID;
    282 				break;
    283 
    284 			case 2: /* Pen */
    285 				wacom->tool[0] = BTN_TOOL_PEN;
    286 				wacom->id[0] = STYLUS_DEVICE_ID;
    287 				break;
    288 			}
    289 		}
    290 
    291 		input_report_key(input, BTN_STYLUS, data[1] & 0x20);
    292 		input_report_key(input, BTN_STYLUS2, data[1] & 0x40);
    293 		input_report_abs(input, ABS_X, get_unaligned_be16(&data[3]));
    294 		input_report_abs(input, ABS_Y, get_unaligned_be16(&data[5]));
    295 		pressure = ((data[1] & 0x03) << 8) | (data[2] & 0xff);
    296 		input_report_abs(input, ABS_PRESSURE, pressure);
    297 		input_report_key(input, BTN_TOUCH, pressure > 10);
    298 
    299 		if (!prox) /* out-prox */
    300 			wacom->id[0] = 0;
    301 		input_report_key(input, wacom->tool[0], prox);
    302 		input_report_abs(input, ABS_MISC, wacom->id[0]);
    303 		return 1;
    304 	}
    305 }
    306 
    307 static int wacom_graphire_irq(struct wacom_wac *wacom)
    308 {
    309 	struct wacom_features *features = &wacom->features;
    310 	unsigned char *data = wacom->data;
    311 	struct input_dev *input = wacom->pen_input;
    312 	struct input_dev *pad_input = wacom->pad_input;
    313 	int battery_capacity, ps_connected;
    314 	int prox;
    315 	int rw = 0;
    316 	int retval = 0;
    317 
    318 	if (features->type == GRAPHIRE_BT) {
    319 		if (data[0] != WACOM_REPORT_PENABLED_BT) {
    320 			dev_dbg(input->dev.parent,
    321 				"%s: received unknown report #%d\n", __func__,
    322 				data[0]);
    323 			goto exit;
    324 		}
    325 	} else if (data[0] != WACOM_REPORT_PENABLED) {
    326 		dev_dbg(input->dev.parent,
    327 			"%s: received unknown report #%d\n", __func__, data[0]);
    328 		goto exit;
    329 	}
    330 
    331 	prox = data[1] & 0x80;
    332 	if (prox || wacom->id[0]) {
    333 		if (prox) {
    334 			switch ((data[1] >> 5) & 3) {
    335 
    336 			case 0:	/* Pen */
    337 				wacom->tool[0] = BTN_TOOL_PEN;
    338 				wacom->id[0] = STYLUS_DEVICE_ID;
    339 				break;
    340 
    341 			case 1: /* Rubber */
    342 				wacom->tool[0] = BTN_TOOL_RUBBER;
    343 				wacom->id[0] = ERASER_DEVICE_ID;
    344 				break;
    345 
    346 			case 2: /* Mouse with wheel */
    347 				input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
    348 				/* fall through */
    349 
    350 			case 3: /* Mouse without wheel */
    351 				wacom->tool[0] = BTN_TOOL_MOUSE;
    352 				wacom->id[0] = CURSOR_DEVICE_ID;
    353 				break;
    354 			}
    355 		}
    356 		input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
    357 		input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
    358 		if (wacom->tool[0] != BTN_TOOL_MOUSE) {
    359 			if (features->type == GRAPHIRE_BT)
    360 				input_report_abs(input, ABS_PRESSURE, data[6] |
    361 					(((__u16) (data[1] & 0x08)) << 5));
    362 			else
    363 				input_report_abs(input, ABS_PRESSURE, data[6] |
    364 					((data[7] & 0x03) << 8));
    365 			input_report_key(input, BTN_TOUCH, data[1] & 0x01);
    366 			input_report_key(input, BTN_STYLUS, data[1] & 0x02);
    367 			input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
    368 		} else {
    369 			input_report_key(input, BTN_LEFT, data[1] & 0x01);
    370 			input_report_key(input, BTN_RIGHT, data[1] & 0x02);
    371 			if (features->type == WACOM_G4 ||
    372 					features->type == WACOM_MO) {
    373 				input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
    374 				rw = (data[7] & 0x04) - (data[7] & 0x03);
    375 			} else if (features->type == GRAPHIRE_BT) {
    376 				/* Compute distance between mouse and tablet */
    377 				rw = 44 - (data[6] >> 2);
    378 				rw = clamp_val(rw, 0, 31);
    379 				input_report_abs(input, ABS_DISTANCE, rw);
    380 				if (((data[1] >> 5) & 3) == 2) {
    381 					/* Mouse with wheel */
    382 					input_report_key(input, BTN_MIDDLE,
    383 							data[1] & 0x04);
    384 					rw = (data[6] & 0x01) ? -1 :
    385 						(data[6] & 0x02) ? 1 : 0;
    386 				} else {
    387 					rw = 0;
    388 				}
    389 			} else {
    390 				input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
    391 				rw = -(signed char)data[6];
    392 			}
    393 			input_report_rel(input, REL_WHEEL, rw);
    394 		}
    395 
    396 		if (!prox)
    397 			wacom->id[0] = 0;
    398 		input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
    399 		input_report_key(input, wacom->tool[0], prox);
    400 		input_sync(input); /* sync last event */
    401 	}
    402 
    403 	/* send pad data */
    404 	switch (features->type) {
    405 	case WACOM_G4:
    406 		prox = data[7] & 0xf8;
    407 		if (prox || wacom->id[1]) {
    408 			wacom->id[1] = PAD_DEVICE_ID;
    409 			input_report_key(pad_input, BTN_BACK, (data[7] & 0x40));
    410 			input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x80));
    411 			rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
    412 			input_report_rel(pad_input, REL_WHEEL, rw);
    413 			if (!prox)
    414 				wacom->id[1] = 0;
    415 			input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
    416 			retval = 1;
    417 		}
    418 		break;
    419 
    420 	case WACOM_MO:
    421 		prox = (data[7] & 0xf8) || data[8];
    422 		if (prox || wacom->id[1]) {
    423 			wacom->id[1] = PAD_DEVICE_ID;
    424 			input_report_key(pad_input, BTN_BACK, (data[7] & 0x08));
    425 			input_report_key(pad_input, BTN_LEFT, (data[7] & 0x20));
    426 			input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x10));
    427 			input_report_key(pad_input, BTN_RIGHT, (data[7] & 0x40));
    428 			input_report_abs(pad_input, ABS_WHEEL, (data[8] & 0x7f));
    429 			if (!prox)
    430 				wacom->id[1] = 0;
    431 			input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
    432 			retval = 1;
    433 		}
    434 		break;
    435 	case GRAPHIRE_BT:
    436 		prox = data[7] & 0x03;
    437 		if (prox || wacom->id[1]) {
    438 			wacom->id[1] = PAD_DEVICE_ID;
    439 			input_report_key(pad_input, BTN_0, (data[7] & 0x02));
    440 			input_report_key(pad_input, BTN_1, (data[7] & 0x01));
    441 			if (!prox)
    442 				wacom->id[1] = 0;
    443 			input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
    444 			retval = 1;
    445 		}
    446 		break;
    447 	}
    448 
    449 	/* Store current battery capacity and power supply state */
    450 	if (features->type == GRAPHIRE_BT) {
    451 		rw = (data[7] >> 2 & 0x07);
    452 		battery_capacity = batcap_gr[rw];
    453 		ps_connected = rw == 7;
    454 		wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
    455 				     battery_capacity, ps_connected, 1,
    456 				     ps_connected);
    457 	}
    458 exit:
    459 	return retval;
    460 }
    461 
    462 static void wacom_intuos_schedule_prox_event(struct wacom_wac *wacom_wac)
    463 {
    464 	struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
    465 	struct wacom_features *features = &wacom_wac->features;
    466 	struct hid_report *r;
    467 	struct hid_report_enum *re;
    468 
    469 	re = &(wacom->hdev->report_enum[HID_FEATURE_REPORT]);
    470 	if (features->type == INTUOSHT2)
    471 		r = re->report_id_hash[WACOM_REPORT_INTUOSHT2_ID];
    472 	else
    473 		r = re->report_id_hash[WACOM_REPORT_INTUOS_ID1];
    474 	if (r) {
    475 		hid_hw_request(wacom->hdev, r, HID_REQ_GET_REPORT);
    476 	}
    477 }
    478 
    479 static int wacom_intuos_pad(struct wacom_wac *wacom)
    480 {
    481 	struct wacom_features *features = &wacom->features;
    482 	unsigned char *data = wacom->data;
    483 	struct input_dev *input = wacom->pad_input;
    484 	int i;
    485 	int buttons = 0, nbuttons = features->numbered_buttons;
    486 	int keys = 0, nkeys = 0;
    487 	int ring1 = 0, ring2 = 0;
    488 	int strip1 = 0, strip2 = 0;
    489 	bool prox = false;
    490 
    491 	/* pad packets. Works as a second tool and is always in prox */
    492 	if (!(data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD ||
    493 	      data[0] == WACOM_REPORT_CINTIQPAD))
    494 		return 0;
    495 
    496 	if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
    497 		buttons = (data[3] << 1) | (data[2] & 0x01);
    498 		ring1 = data[1];
    499 	} else if (features->type == DTK) {
    500 		buttons = data[6];
    501 	} else if (features->type == WACOM_13HD) {
    502 		buttons = (data[4] << 1) | (data[3] & 0x01);
    503 	} else if (features->type == WACOM_24HD) {
    504 		buttons = (data[8] << 8) | data[6];
    505 		ring1 = data[1];
    506 		ring2 = data[2];
    507 
    508 		/*
    509 		 * Three "buttons" are available on the 24HD which are
    510 		 * physically implemented as a touchstrip. Each button
    511 		 * is approximately 3 bits wide with a 2 bit spacing.
    512 		 * The raw touchstrip bits are stored at:
    513 		 *    ((data[3] & 0x1f) << 8) | data[4])
    514 		 */
    515 		nkeys = 3;
    516 		keys = ((data[3] & 0x1C) ? 1<<2 : 0) |
    517 		       ((data[4] & 0xE0) ? 1<<1 : 0) |
    518 		       ((data[4] & 0x07) ? 1<<0 : 0);
    519 	} else if (features->type == WACOM_27QHD) {
    520 		nkeys = 3;
    521 		keys = data[2] & 0x07;
    522 
    523 		input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[4]));
    524 		input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[6]));
    525 		input_report_abs(input, ABS_Z, be16_to_cpup((__be16 *)&data[8]));
    526 	} else if (features->type == CINTIQ_HYBRID) {
    527 		/*
    528 		 * Do not send hardware buttons under Android. They
    529 		 * are already sent to the system through GPIO (and
    530 		 * have different meaning).
    531 		 *
    532 		 * d-pad right  -> data[4] & 0x10
    533 		 * d-pad up     -> data[4] & 0x20
    534 		 * d-pad left   -> data[4] & 0x40
    535 		 * d-pad down   -> data[4] & 0x80
    536 		 * d-pad center -> data[3] & 0x01
    537 		 */
    538 		buttons = (data[4] << 1) | (data[3] & 0x01);
    539 	} else if (features->type == CINTIQ_COMPANION_2) {
    540 		/* d-pad right  -> data[4] & 0x10
    541 		 * d-pad up     -> data[4] & 0x20
    542 		 * d-pad left   -> data[4] & 0x40
    543 		 * d-pad down   -> data[4] & 0x80
    544 		 * d-pad center -> data[3] & 0x01
    545 		 */
    546 		buttons = ((data[2] >> 4) << 7) |
    547 		          ((data[1] & 0x04) << 6) |
    548 		          ((data[2] & 0x0F) << 2) |
    549 		          (data[1] & 0x03);
    550 	} else if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
    551 		/*
    552 		 * ExpressKeys on Intuos5/Intuos Pro have a capacitive sensor in
    553 		 * addition to the mechanical switch. Switch data is
    554 		 * stored in data[4], capacitive data in data[5].
    555 		 *
    556 		 * Touch ring mode switch (data[3]) has no capacitive sensor
    557 		 */
    558 		buttons = (data[4] << 1) | (data[3] & 0x01);
    559 		ring1 = data[2];
    560 	} else {
    561 		if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
    562 			buttons = (data[8] << 10) | ((data[7] & 0x01) << 9) |
    563 			          (data[6] << 1) | (data[5] & 0x01);
    564 
    565 			if (features->type == WACOM_22HD) {
    566 				nkeys = 3;
    567 				keys = data[9] & 0x07;
    568 			}
    569 		} else {
    570 			buttons = ((data[6] & 0x10) << 5)  |
    571 			          ((data[5] & 0x10) << 4)  |
    572 			          ((data[6] & 0x0F) << 4)  |
    573 			          (data[5] & 0x0F);
    574 		}
    575 		strip1 = ((data[1] & 0x1f) << 8) | data[2];
    576 		strip2 = ((data[3] & 0x1f) << 8) | data[4];
    577 	}
    578 
    579 	prox = (buttons & ~(~0 << nbuttons)) | (keys & ~(~0 << nkeys)) |
    580 	       (ring1 & 0x80) | (ring2 & 0x80) | strip1 | strip2;
    581 
    582 	wacom_report_numbered_buttons(input, nbuttons, buttons);
    583 
    584 	for (i = 0; i < nkeys; i++)
    585 		input_report_key(input, KEY_PROG1 + i, keys & (1 << i));
    586 
    587 	input_report_abs(input, ABS_RX, strip1);
    588 	input_report_abs(input, ABS_RY, strip2);
    589 
    590 	input_report_abs(input, ABS_WHEEL,    (ring1 & 0x80) ? (ring1 & 0x7f) : 0);
    591 	input_report_abs(input, ABS_THROTTLE, (ring2 & 0x80) ? (ring2 & 0x7f) : 0);
    592 
    593 	input_report_key(input, wacom->tool[1], prox ? 1 : 0);
    594 	input_report_abs(input, ABS_MISC, prox ? PAD_DEVICE_ID : 0);
    595 
    596 	input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
    597 
    598 	return 1;
    599 }
    600 
    601 static int wacom_intuos_id_mangle(int tool_id)
    602 {
    603 	return (tool_id & ~0xFFF) << 4 | (tool_id & 0xFFF);
    604 }
    605 
    606 static int wacom_intuos_get_tool_type(int tool_id)
    607 {
    608 	int tool_type;
    609 
    610 	switch (tool_id) {
    611 	case 0x812: /* Inking pen */
    612 	case 0x801: /* Intuos3 Inking pen */
    613 	case 0x12802: /* Intuos4/5 Inking Pen */
    614 	case 0x012:
    615 		tool_type = BTN_TOOL_PENCIL;
    616 		break;
    617 
    618 	case 0x822: /* Pen */
    619 	case 0x842:
    620 	case 0x852:
    621 	case 0x823: /* Intuos3 Grip Pen */
    622 	case 0x813: /* Intuos3 Classic Pen */
    623 	case 0x885: /* Intuos3 Marker Pen */
    624 	case 0x802: /* Intuos4/5 13HD/24HD General Pen */
    625 	case 0x804: /* Intuos4/5 13HD/24HD Marker Pen */
    626 	case 0x8e2: /* IntuosHT2 pen */
    627 	case 0x022:
    628 	case 0x10804: /* Intuos4/5 13HD/24HD Art Pen */
    629 	case 0x10842: /* MobileStudio Pro Pro Pen slim */
    630 	case 0x14802: /* Intuos4/5 13HD/24HD Classic Pen */
    631 	case 0x16802: /* Cintiq 13HD Pro Pen */
    632 	case 0x18802: /* DTH2242 Pen */
    633 	case 0x10802: /* Intuos4/5 13HD/24HD General Pen */
    634 		tool_type = BTN_TOOL_PEN;
    635 		break;
    636 
    637 	case 0x832: /* Stroke pen */
    638 	case 0x032:
    639 		tool_type = BTN_TOOL_BRUSH;
    640 		break;
    641 
    642 	case 0x007: /* Mouse 4D and 2D */
    643 	case 0x09c:
    644 	case 0x094:
    645 	case 0x017: /* Intuos3 2D Mouse */
    646 	case 0x806: /* Intuos4 Mouse */
    647 		tool_type = BTN_TOOL_MOUSE;
    648 		break;
    649 
    650 	case 0x096: /* Lens cursor */
    651 	case 0x097: /* Intuos3 Lens cursor */
    652 	case 0x006: /* Intuos4 Lens cursor */
    653 		tool_type = BTN_TOOL_LENS;
    654 		break;
    655 
    656 	case 0x82a: /* Eraser */
    657 	case 0x84a:
    658 	case 0x85a:
    659 	case 0x91a:
    660 	case 0xd1a:
    661 	case 0x0fa:
    662 	case 0x82b: /* Intuos3 Grip Pen Eraser */
    663 	case 0x81b: /* Intuos3 Classic Pen Eraser */
    664 	case 0x91b: /* Intuos3 Airbrush Eraser */
    665 	case 0x80c: /* Intuos4/5 13HD/24HD Marker Pen Eraser */
    666 	case 0x80a: /* Intuos4/5 13HD/24HD General Pen Eraser */
    667 	case 0x90a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
    668 	case 0x1480a: /* Intuos4/5 13HD/24HD Classic Pen Eraser */
    669 	case 0x1090a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
    670 	case 0x1080c: /* Intuos4/5 13HD/24HD Art Pen Eraser */
    671 	case 0x1084a: /* MobileStudio Pro Pro Pen slim Eraser */
    672 	case 0x1680a: /* Cintiq 13HD Pro Pen Eraser */
    673 	case 0x1880a: /* DTH2242 Eraser */
    674 	case 0x1080a: /* Intuos4/5 13HD/24HD General Pen Eraser */
    675 		tool_type = BTN_TOOL_RUBBER;
    676 		break;
    677 
    678 	case 0xd12:
    679 	case 0x912:
    680 	case 0x112:
    681 	case 0x913: /* Intuos3 Airbrush */
    682 	case 0x902: /* Intuos4/5 13HD/24HD Airbrush */
    683 	case 0x10902: /* Intuos4/5 13HD/24HD Airbrush */
    684 		tool_type = BTN_TOOL_AIRBRUSH;
    685 		break;
    686 
    687 	default: /* Unknown tool */
    688 		tool_type = BTN_TOOL_PEN;
    689 		break;
    690 	}
    691 	return tool_type;
    692 }
    693 
    694 static void wacom_exit_report(struct wacom_wac *wacom)
    695 {
    696 	struct input_dev *input = wacom->pen_input;
    697 	struct wacom_features *features = &wacom->features;
    698 	unsigned char *data = wacom->data;
    699 	int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
    700 
    701 	/*
    702 	 * Reset all states otherwise we lose the initial states
    703 	 * when in-prox next time
    704 	 */
    705 	input_report_abs(input, ABS_X, 0);
    706 	input_report_abs(input, ABS_Y, 0);
    707 	input_report_abs(input, ABS_DISTANCE, 0);
    708 	input_report_abs(input, ABS_TILT_X, 0);
    709 	input_report_abs(input, ABS_TILT_Y, 0);
    710 	if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
    711 		input_report_key(input, BTN_LEFT, 0);
    712 		input_report_key(input, BTN_MIDDLE, 0);
    713 		input_report_key(input, BTN_RIGHT, 0);
    714 		input_report_key(input, BTN_SIDE, 0);
    715 		input_report_key(input, BTN_EXTRA, 0);
    716 		input_report_abs(input, ABS_THROTTLE, 0);
    717 		input_report_abs(input, ABS_RZ, 0);
    718 	} else {
    719 		input_report_abs(input, ABS_PRESSURE, 0);
    720 		input_report_key(input, BTN_STYLUS, 0);
    721 		input_report_key(input, BTN_STYLUS2, 0);
    722 		input_report_key(input, BTN_TOUCH, 0);
    723 		input_report_abs(input, ABS_WHEEL, 0);
    724 		if (features->type >= INTUOS3S)
    725 			input_report_abs(input, ABS_Z, 0);
    726 	}
    727 	input_report_key(input, wacom->tool[idx], 0);
    728 	input_report_abs(input, ABS_MISC, 0); /* reset tool id */
    729 	input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
    730 	wacom->id[idx] = 0;
    731 }
    732 
    733 static int wacom_intuos_inout(struct wacom_wac *wacom)
    734 {
    735 	struct wacom_features *features = &wacom->features;
    736 	unsigned char *data = wacom->data;
    737 	struct input_dev *input = wacom->pen_input;
    738 	int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
    739 
    740 	if (!(((data[1] & 0xfc) == 0xc0) ||  /* in prox */
    741 	    ((data[1] & 0xfe) == 0x20) ||    /* in range */
    742 	    ((data[1] & 0xfe) == 0x80)))     /* out prox */
    743 		return 0;
    744 
    745 	/* Enter report */
    746 	if ((data[1] & 0xfc) == 0xc0) {
    747 		/* serial number of the tool */
    748 		wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
    749 			(data[4] << 20) + (data[5] << 12) +
    750 			(data[6] << 4) + (data[7] >> 4);
    751 
    752 		wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
    753 		     ((data[7] & 0x0f) << 16) | ((data[8] & 0xf0) << 8);
    754 
    755 		wacom->tool[idx] = wacom_intuos_get_tool_type(wacom->id[idx]);
    756 
    757 		wacom->shared->stylus_in_proximity = true;
    758 		return 1;
    759 	}
    760 
    761 	/* in Range */
    762 	if ((data[1] & 0xfe) == 0x20) {
    763 		if (features->type != INTUOSHT2)
    764 			wacom->shared->stylus_in_proximity = true;
    765 
    766 		/* in Range while exiting */
    767 		if (wacom->reporting_data) {
    768 			input_report_key(input, BTN_TOUCH, 0);
    769 			input_report_abs(input, ABS_PRESSURE, 0);
    770 			input_report_abs(input, ABS_DISTANCE, wacom->features.distance_max);
    771 			return 2;
    772 		}
    773 		return 1;
    774 	}
    775 
    776 	/* Exit report */
    777 	if ((data[1] & 0xfe) == 0x80) {
    778 		wacom->shared->stylus_in_proximity = false;
    779 		wacom->reporting_data = false;
    780 
    781 		/* don't report exit if we don't know the ID */
    782 		if (!wacom->id[idx])
    783 			return 1;
    784 
    785 		wacom_exit_report(wacom);
    786 		return 2;
    787 	}
    788 
    789 	return 0;
    790 }
    791 
    792 static inline bool report_touch_events(struct wacom_wac *wacom)
    793 {
    794 	return (touch_arbitration ? !wacom->shared->stylus_in_proximity : 1);
    795 }
    796 
    797 static inline bool delay_pen_events(struct wacom_wac *wacom)
    798 {
    799 	return (wacom->shared->touch_down && touch_arbitration);
    800 }
    801 
    802 static int wacom_intuos_general(struct wacom_wac *wacom)
    803 {
    804 	struct wacom_features *features = &wacom->features;
    805 	unsigned char *data = wacom->data;
    806 	struct input_dev *input = wacom->pen_input;
    807 	int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
    808 	unsigned char type = (data[1] >> 1) & 0x0F;
    809 	unsigned int x, y, distance, t;
    810 
    811 	if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_CINTIQ &&
    812 		data[0] != WACOM_REPORT_INTUOS_PEN)
    813 		return 0;
    814 
    815 	if (delay_pen_events(wacom))
    816 		return 1;
    817 
    818 	/* don't report events if we don't know the tool ID */
    819 	if (!wacom->id[idx]) {
    820 		/* but reschedule a read of the current tool */
    821 		wacom_intuos_schedule_prox_event(wacom);
    822 		return 1;
    823 	}
    824 
    825 	/*
    826 	 * don't report events for invalid data
    827 	 */
    828 	/* older I4 styli don't work with new Cintiqs */
    829 	if ((!((wacom->id[idx] >> 16) & 0x01) &&
    830 			(features->type == WACOM_21UX2)) ||
    831 	    /* Only large Intuos support Lense Cursor */
    832 	    (wacom->tool[idx] == BTN_TOOL_LENS &&
    833 		(features->type == INTUOS3 ||
    834 		 features->type == INTUOS3S ||
    835 		 features->type == INTUOS4 ||
    836 		 features->type == INTUOS4S ||
    837 		 features->type == INTUOS5 ||
    838 		 features->type == INTUOS5S ||
    839 		 features->type == INTUOSPM ||
    840 		 features->type == INTUOSPS)) ||
    841 	   /* Cintiq doesn't send data when RDY bit isn't set */
    842 	   (features->type == CINTIQ && !(data[1] & 0x40)))
    843 		return 1;
    844 
    845 	x = (be16_to_cpup((__be16 *)&data[2]) << 1) | ((data[9] >> 1) & 1);
    846 	y = (be16_to_cpup((__be16 *)&data[4]) << 1) | (data[9] & 1);
    847 	distance = data[9] >> 2;
    848 	if (features->type < INTUOS3S) {
    849 		x >>= 1;
    850 		y >>= 1;
    851 		distance >>= 1;
    852 	}
    853 	input_report_abs(input, ABS_X, x);
    854 	input_report_abs(input, ABS_Y, y);
    855 	input_report_abs(input, ABS_DISTANCE, distance);
    856 
    857 	switch (type) {
    858 	case 0x00:
    859 	case 0x01:
    860 	case 0x02:
    861 	case 0x03:
    862 		/* general pen packet */
    863 		t = (data[6] << 3) | ((data[7] & 0xC0) >> 5) | (data[1] & 1);
    864 		if (features->pressure_max < 2047)
    865 			t >>= 1;
    866 		input_report_abs(input, ABS_PRESSURE, t);
    867 		if (features->type != INTUOSHT2) {
    868 		    input_report_abs(input, ABS_TILT_X,
    869 				 (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
    870 		    input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
    871 		}
    872 		input_report_key(input, BTN_STYLUS, data[1] & 2);
    873 		input_report_key(input, BTN_STYLUS2, data[1] & 4);
    874 		input_report_key(input, BTN_TOUCH, t > 10);
    875 		break;
    876 
    877 	case 0x0a:
    878 		/* airbrush second packet */
    879 		input_report_abs(input, ABS_WHEEL,
    880 				(data[6] << 2) | ((data[7] >> 6) & 3));
    881 		input_report_abs(input, ABS_TILT_X,
    882 				 (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
    883 		input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
    884 		break;
    885 
    886 	case 0x05:
    887 		/* Rotation packet */
    888 		if (features->type >= INTUOS3S) {
    889 			/* I3 marker pen rotation */
    890 			t = (data[6] << 3) | ((data[7] >> 5) & 7);
    891 			t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
    892 				((t-1) / 2 + 450)) : (450 - t / 2) ;
    893 			input_report_abs(input, ABS_Z, t);
    894 		} else {
    895 			/* 4D mouse 2nd packet */
    896 			t = (data[6] << 3) | ((data[7] >> 5) & 7);
    897 			input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
    898 				((t - 1) / 2) : -t / 2);
    899 		}
    900 		break;
    901 
    902 	case 0x04:
    903 		/* 4D mouse 1st packet */
    904 		input_report_key(input, BTN_LEFT,   data[8] & 0x01);
    905 		input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
    906 		input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
    907 
    908 		input_report_key(input, BTN_SIDE,   data[8] & 0x20);
    909 		input_report_key(input, BTN_EXTRA,  data[8] & 0x10);
    910 		t = (data[6] << 2) | ((data[7] >> 6) & 3);
    911 		input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
    912 		break;
    913 
    914 	case 0x06:
    915 		/* I4 mouse */
    916 		input_report_key(input, BTN_LEFT,   data[6] & 0x01);
    917 		input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
    918 		input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
    919 		input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
    920 				 - ((data[7] & 0x40) >> 6));
    921 		input_report_key(input, BTN_SIDE,   data[6] & 0x08);
    922 		input_report_key(input, BTN_EXTRA,  data[6] & 0x10);
    923 
    924 		input_report_abs(input, ABS_TILT_X,
    925 			(((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
    926 		input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
    927 		break;
    928 
    929 	case 0x08:
    930 		if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
    931 			/* 2D mouse packet */
    932 			input_report_key(input, BTN_LEFT,   data[8] & 0x04);
    933 			input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
    934 			input_report_key(input, BTN_RIGHT,  data[8] & 0x10);
    935 			input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
    936 					 - ((data[8] & 0x02) >> 1));
    937 
    938 			/* I3 2D mouse side buttons */
    939 			if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
    940 				input_report_key(input, BTN_SIDE,   data[8] & 0x40);
    941 				input_report_key(input, BTN_EXTRA,  data[8] & 0x20);
    942 			}
    943 		}
    944 		else if (wacom->tool[idx] == BTN_TOOL_LENS) {
    945 			/* Lens cursor packets */
    946 			input_report_key(input, BTN_LEFT,   data[8] & 0x01);
    947 			input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
    948 			input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
    949 			input_report_key(input, BTN_SIDE,   data[8] & 0x10);
    950 			input_report_key(input, BTN_EXTRA,  data[8] & 0x08);
    951 		}
    952 		break;
    953 
    954 	case 0x07:
    955 	case 0x09:
    956 	case 0x0b:
    957 	case 0x0c:
    958 	case 0x0d:
    959 	case 0x0e:
    960 	case 0x0f:
    961 		/* unhandled */
    962 		break;
    963 	}
    964 
    965 	input_report_abs(input, ABS_MISC,
    966 			 wacom_intuos_id_mangle(wacom->id[idx])); /* report tool id */
    967 	input_report_key(input, wacom->tool[idx], 1);
    968 	input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
    969 	wacom->reporting_data = true;
    970 	return 2;
    971 }
    972 
    973 static int wacom_intuos_irq(struct wacom_wac *wacom)
    974 {
    975 	unsigned char *data = wacom->data;
    976 	struct input_dev *input = wacom->pen_input;
    977 	int result;
    978 
    979 	if (data[0] != WACOM_REPORT_PENABLED &&
    980 	    data[0] != WACOM_REPORT_INTUOS_ID1 &&
    981 	    data[0] != WACOM_REPORT_INTUOS_ID2 &&
    982 	    data[0] != WACOM_REPORT_INTUOSPAD &&
    983 	    data[0] != WACOM_REPORT_INTUOS_PEN &&
    984 	    data[0] != WACOM_REPORT_CINTIQ &&
    985 	    data[0] != WACOM_REPORT_CINTIQPAD &&
    986 	    data[0] != WACOM_REPORT_INTUOS5PAD) {
    987 		dev_dbg(input->dev.parent,
    988 			"%s: received unknown report #%d\n", __func__, data[0]);
    989                 return 0;
    990 	}
    991 
    992 	/* process pad events */
    993 	result = wacom_intuos_pad(wacom);
    994 	if (result)
    995 		return result;
    996 
    997 	/* process in/out prox events */
    998 	result = wacom_intuos_inout(wacom);
    999 	if (result)
   1000 		return result - 1;
   1001 
   1002 	/* process general packets */
   1003 	result = wacom_intuos_general(wacom);
   1004 	if (result)
   1005 		return result - 1;
   1006 
   1007 	return 0;
   1008 }
   1009 
   1010 static int wacom_remote_irq(struct wacom_wac *wacom_wac, size_t len)
   1011 {
   1012 	unsigned char *data = wacom_wac->data;
   1013 	struct input_dev *input;
   1014 	struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
   1015 	struct wacom_remote *remote = wacom->remote;
   1016 	int bat_charging, bat_percent, touch_ring_mode;
   1017 	__u32 serial;
   1018 	int i, index = -1;
   1019 	unsigned long flags;
   1020 
   1021 	if (data[0] != WACOM_REPORT_REMOTE) {
   1022 		hid_dbg(wacom->hdev, "%s: received unknown report #%d",
   1023 			__func__, data[0]);
   1024 		return 0;
   1025 	}
   1026 
   1027 	serial = data[3] + (data[4] << 8) + (data[5] << 16);
   1028 	wacom_wac->id[0] = PAD_DEVICE_ID;
   1029 
   1030 	spin_lock_irqsave(&remote->remote_lock, flags);
   1031 
   1032 	for (i = 0; i < WACOM_MAX_REMOTES; i++) {
   1033 		if (remote->remotes[i].serial == serial) {
   1034 			index = i;
   1035 			break;
   1036 		}
   1037 	}
   1038 
   1039 	if (index < 0 || !remote->remotes[index].registered)
   1040 		goto out;
   1041 
   1042 	input = remote->remotes[index].input;
   1043 
   1044 	input_report_key(input, BTN_0, (data[9] & 0x01));
   1045 	input_report_key(input, BTN_1, (data[9] & 0x02));
   1046 	input_report_key(input, BTN_2, (data[9] & 0x04));
   1047 	input_report_key(input, BTN_3, (data[9] & 0x08));
   1048 	input_report_key(input, BTN_4, (data[9] & 0x10));
   1049 	input_report_key(input, BTN_5, (data[9] & 0x20));
   1050 	input_report_key(input, BTN_6, (data[9] & 0x40));
   1051 	input_report_key(input, BTN_7, (data[9] & 0x80));
   1052 
   1053 	input_report_key(input, BTN_8, (data[10] & 0x01));
   1054 	input_report_key(input, BTN_9, (data[10] & 0x02));
   1055 	input_report_key(input, BTN_A, (data[10] & 0x04));
   1056 	input_report_key(input, BTN_B, (data[10] & 0x08));
   1057 	input_report_key(input, BTN_C, (data[10] & 0x10));
   1058 	input_report_key(input, BTN_X, (data[10] & 0x20));
   1059 	input_report_key(input, BTN_Y, (data[10] & 0x40));
   1060 	input_report_key(input, BTN_Z, (data[10] & 0x80));
   1061 
   1062 	input_report_key(input, BTN_BASE, (data[11] & 0x01));
   1063 	input_report_key(input, BTN_BASE2, (data[11] & 0x02));
   1064 
   1065 	if (data[12] & 0x80)
   1066 		input_report_abs(input, ABS_WHEEL, (data[12] & 0x7f));
   1067 	else
   1068 		input_report_abs(input, ABS_WHEEL, 0);
   1069 
   1070 	bat_percent = data[7] & 0x7f;
   1071 	bat_charging = !!(data[7] & 0x80);
   1072 
   1073 	if (data[9] | data[10] | (data[11] & 0x03) | data[12])
   1074 		input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
   1075 	else
   1076 		input_report_abs(input, ABS_MISC, 0);
   1077 
   1078 	input_event(input, EV_MSC, MSC_SERIAL, serial);
   1079 
   1080 	input_sync(input);
   1081 
   1082 	/*Which mode select (LED light) is currently on?*/
   1083 	touch_ring_mode = (data[11] & 0xC0) >> 6;
   1084 
   1085 	for (i = 0; i < WACOM_MAX_REMOTES; i++) {
   1086 		if (remote->remotes[i].serial == serial)
   1087 			wacom->led.groups[i].select = touch_ring_mode;
   1088 	}
   1089 
   1090 	__wacom_notify_battery(&remote->remotes[index].battery,
   1091 				WACOM_POWER_SUPPLY_STATUS_AUTO, bat_percent,
   1092 				bat_charging, 1, bat_charging);
   1093 
   1094 out:
   1095 	spin_unlock_irqrestore(&remote->remote_lock, flags);
   1096 	return 0;
   1097 }
   1098 
   1099 static void wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
   1100 {
   1101 	struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
   1102 	unsigned char *data = wacom_wac->data;
   1103 	struct wacom_remote *remote = wacom->remote;
   1104 	struct wacom_remote_data remote_data;
   1105 	unsigned long flags;
   1106 	int i, ret;
   1107 
   1108 	if (data[0] != WACOM_REPORT_DEVICE_LIST)
   1109 		return;
   1110 
   1111 	memset(&remote_data, 0, sizeof(struct wacom_remote_data));
   1112 
   1113 	for (i = 0; i < WACOM_MAX_REMOTES; i++) {
   1114 		int j = i * 6;
   1115 		int serial = (data[j+6] << 16) + (data[j+5] << 8) + data[j+4];
   1116 		bool connected = data[j+2];
   1117 
   1118 		remote_data.remote[i].serial = serial;
   1119 		remote_data.remote[i].connected = connected;
   1120 	}
   1121 
   1122 	spin_lock_irqsave(&remote->remote_lock, flags);
   1123 
   1124 	ret = kfifo_in(&remote->remote_fifo, &remote_data, sizeof(remote_data));
   1125 	if (ret != sizeof(remote_data)) {
   1126 		spin_unlock_irqrestore(&remote->remote_lock, flags);
   1127 		hid_err(wacom->hdev, "Can't queue Remote status event.\n");
   1128 		return;
   1129 	}
   1130 
   1131 	spin_unlock_irqrestore(&remote->remote_lock, flags);
   1132 
   1133 	wacom_schedule_work(wacom_wac, WACOM_WORKER_REMOTE);
   1134 }
   1135 
   1136 static int int_dist(int x1, int y1, int x2, int y2)
   1137 {
   1138 	int x = x2 - x1;
   1139 	int y = y2 - y1;
   1140 
   1141 	return int_sqrt(x*x + y*y);
   1142 }
   1143 
   1144 static void wacom_intuos_bt_process_data(struct wacom_wac *wacom,
   1145 		unsigned char *data)
   1146 {
   1147 	memcpy(wacom->data, data, 10);
   1148 	wacom_intuos_irq(wacom);
   1149 
   1150 	input_sync(wacom->pen_input);
   1151 	if (wacom->pad_input)
   1152 		input_sync(wacom->pad_input);
   1153 }
   1154 
   1155 static int wacom_intuos_bt_irq(struct wacom_wac *wacom, size_t len)
   1156 {
   1157 	unsigned char data[WACOM_PKGLEN_MAX];
   1158 	int i = 1;
   1159 	unsigned power_raw, battery_capacity, bat_charging, ps_connected;
   1160 
   1161 	memcpy(data, wacom->data, len);
   1162 
   1163 	switch (data[0]) {
   1164 	case 0x04:
   1165 		wacom_intuos_bt_process_data(wacom, data + i);
   1166 		i += 10;
   1167 		/* fall through */
   1168 	case 0x03:
   1169 		wacom_intuos_bt_process_data(wacom, data + i);
   1170 		i += 10;
   1171 		wacom_intuos_bt_process_data(wacom, data + i);
   1172 		i += 10;
   1173 		power_raw = data[i];
   1174 		bat_charging = (power_raw & 0x08) ? 1 : 0;
   1175 		ps_connected = (power_raw & 0x10) ? 1 : 0;
   1176 		battery_capacity = batcap_i4[power_raw & 0x07];
   1177 		wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
   1178 				     battery_capacity, bat_charging,
   1179 				     battery_capacity || bat_charging,
   1180 				     ps_connected);
   1181 		break;
   1182 	default:
   1183 		dev_dbg(wacom->pen_input->dev.parent,
   1184 				"Unknown report: %d,%d size:%zu\n",
   1185 				data[0], data[1], len);
   1186 		return 0;
   1187 	}
   1188 	return 0;
   1189 }
   1190 
   1191 static int wacom_wac_finger_count_touches(struct wacom_wac *wacom)
   1192 {
   1193 	struct input_dev *input = wacom->touch_input;
   1194 	unsigned touch_max = wacom->features.touch_max;
   1195 	int count = 0;
   1196 	int i;
   1197 
   1198 	if (!touch_max)
   1199 		return 0;
   1200 
   1201 	if (touch_max == 1)
   1202 		return test_bit(BTN_TOUCH, input->key) &&
   1203 			report_touch_events(wacom);
   1204 
   1205 	for (i = 0; i < input->mt->num_slots; i++) {
   1206 		struct input_mt_slot *ps = &input->mt->slots[i];
   1207 		int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
   1208 		if (id >= 0)
   1209 			count++;
   1210 	}
   1211 
   1212 	return count;
   1213 }
   1214 
   1215 static void wacom_intuos_pro2_bt_pen(struct wacom_wac *wacom)
   1216 {
   1217 	int pen_frame_len, pen_frames;
   1218 
   1219 	struct input_dev *pen_input = wacom->pen_input;
   1220 	unsigned char *data = wacom->data;
   1221 	int i;
   1222 
   1223 	if (wacom->features.type == INTUOSP2_BT) {
   1224 		wacom->serial[0] = get_unaligned_le64(&data[99]);
   1225 		wacom->id[0]     = get_unaligned_le16(&data[107]);
   1226 		pen_frame_len = 14;
   1227 		pen_frames = 7;
   1228 	} else {
   1229 		wacom->serial[0] = get_unaligned_le64(&data[33]);
   1230 		wacom->id[0]     = get_unaligned_le16(&data[41]);
   1231 		pen_frame_len = 8;
   1232 		pen_frames = 4;
   1233 	}
   1234 
   1235 	if (wacom->serial[0] >> 52 == 1) {
   1236 		/* Add back in missing bits of ID for non-USI pens */
   1237 		wacom->id[0] |= (wacom->serial[0] >> 32) & 0xFFFFF;
   1238 	}
   1239 	wacom->tool[0]   = wacom_intuos_get_tool_type(wacom_intuos_id_mangle(wacom->id[0]));
   1240 
   1241 	for (i = 0; i < pen_frames; i++) {
   1242 		unsigned char *frame = &data[i*pen_frame_len + 1];
   1243 		bool valid = frame[0] & 0x80;
   1244 		bool prox = frame[0] & 0x40;
   1245 		bool range = frame[0] & 0x20;
   1246 
   1247 		if (!valid)
   1248 			continue;
   1249 
   1250 		if (!prox) {
   1251 			wacom->shared->stylus_in_proximity = false;
   1252 			wacom_exit_report(wacom);
   1253 			input_sync(pen_input);
   1254 			return;
   1255 		}
   1256 		if (range) {
   1257 			input_report_abs(pen_input, ABS_X, get_unaligned_le16(&frame[1]));
   1258 			input_report_abs(pen_input, ABS_Y, get_unaligned_le16(&frame[3]));
   1259 
   1260 			if (wacom->features.type == INTUOSP2_BT) {
   1261 				/* Fix rotation alignment: userspace expects zero at left */
   1262 				int16_t rotation =
   1263 					(int16_t)get_unaligned_le16(&frame[9]);
   1264 				rotation += 1800/4;
   1265 
   1266 				if (rotation > 899)
   1267 					rotation -= 1800;
   1268 
   1269 				input_report_abs(pen_input, ABS_TILT_X,
   1270 						 (char)frame[7]);
   1271 				input_report_abs(pen_input, ABS_TILT_Y,
   1272 						 (char)frame[8]);
   1273 				input_report_abs(pen_input, ABS_Z, rotation);
   1274 				input_report_abs(pen_input, ABS_WHEEL,
   1275 						 get_unaligned_le16(&frame[11]));
   1276 			}
   1277 		}
   1278 		input_report_abs(pen_input, ABS_PRESSURE, get_unaligned_le16(&frame[5]));
   1279 		if (wacom->features.type == INTUOSP2_BT) {
   1280 			input_report_abs(pen_input, ABS_DISTANCE,
   1281 					 range ? frame[13] : wacom->features.distance_max);
   1282 		} else {
   1283 			input_report_abs(pen_input, ABS_DISTANCE,
   1284 					 range ? frame[7] : wacom->features.distance_max);
   1285 		}
   1286 
   1287 		input_report_key(pen_input, BTN_TOUCH, frame[0] & 0x01);
   1288 		input_report_key(pen_input, BTN_STYLUS, frame[0] & 0x02);
   1289 		input_report_key(pen_input, BTN_STYLUS2, frame[0] & 0x04);
   1290 
   1291 		input_report_key(pen_input, wacom->tool[0], prox);
   1292 		input_event(pen_input, EV_MSC, MSC_SERIAL, wacom->serial[0]);
   1293 		input_report_abs(pen_input, ABS_MISC,
   1294 				 wacom_intuos_id_mangle(wacom->id[0])); /* report tool id */
   1295 
   1296 		wacom->shared->stylus_in_proximity = prox;
   1297 
   1298 		input_sync(pen_input);
   1299 	}
   1300 }
   1301 
   1302 static void wacom_intuos_pro2_bt_touch(struct wacom_wac *wacom)
   1303 {
   1304 	const int finger_touch_len = 8;
   1305 	const int finger_frames = 4;
   1306 	const int finger_frame_len = 43;
   1307 
   1308 	struct input_dev *touch_input = wacom->touch_input;
   1309 	unsigned char *data = wacom->data;
   1310 	int num_contacts_left = 5;
   1311 	int i, j;
   1312 
   1313 	for (i = 0; i < finger_frames; i++) {
   1314 		unsigned char *frame = &data[i*finger_frame_len + 109];
   1315 		int current_num_contacts = frame[0] & 0x7F;
   1316 		int contacts_to_send;
   1317 
   1318 		if (!(frame[0] & 0x80))
   1319 			continue;
   1320 
   1321 		/*
   1322 		 * First packet resets the counter since only the first
   1323 		 * packet in series will have non-zero current_num_contacts.
   1324 		 */
   1325 		if (current_num_contacts)
   1326 			wacom->num_contacts_left = current_num_contacts;
   1327 
   1328 		contacts_to_send = min(num_contacts_left, wacom->num_contacts_left);
   1329 
   1330 		for (j = 0; j < contacts_to_send; j++) {
   1331 			unsigned char *touch = &frame[j*finger_touch_len + 1];
   1332 			int slot = input_mt_get_slot_by_key(touch_input, touch[0]);
   1333 			int x = get_unaligned_le16(&touch[2]);
   1334 			int y = get_unaligned_le16(&touch[4]);
   1335 			int w = touch[6] * input_abs_get_res(touch_input, ABS_MT_POSITION_X);
   1336 			int h = touch[7] * input_abs_get_res(touch_input, ABS_MT_POSITION_Y);
   1337 
   1338 			if (slot < 0)
   1339 				continue;
   1340 
   1341 			input_mt_slot(touch_input, slot);
   1342 			input_mt_report_slot_state(touch_input, MT_TOOL_FINGER, touch[1] & 0x01);
   1343 			input_report_abs(touch_input, ABS_MT_POSITION_X, x);
   1344 			input_report_abs(touch_input, ABS_MT_POSITION_Y, y);
   1345 			input_report_abs(touch_input, ABS_MT_TOUCH_MAJOR, max(w, h));
   1346 			input_report_abs(touch_input, ABS_MT_TOUCH_MINOR, min(w, h));
   1347 			input_report_abs(touch_input, ABS_MT_ORIENTATION, w > h);
   1348 		}
   1349 
   1350 		input_mt_sync_frame(touch_input);
   1351 
   1352 		wacom->num_contacts_left -= contacts_to_send;
   1353 		if (wacom->num_contacts_left <= 0) {
   1354 			wacom->num_contacts_left = 0;
   1355 			wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
   1356 		}
   1357 	}
   1358 
   1359 	input_report_switch(touch_input, SW_MUTE_DEVICE, !(data[281] >> 7));
   1360 	input_sync(touch_input);
   1361 }
   1362 
   1363 static void wacom_intuos_pro2_bt_pad(struct wacom_wac *wacom)
   1364 {
   1365 	struct input_dev *pad_input = wacom->pad_input;
   1366 	unsigned char *data = wacom->data;
   1367 
   1368 	int buttons = (data[282] << 1) | ((data[281] >> 6) & 0x01);
   1369 	int ring = data[285] & 0x7F;
   1370 	bool ringstatus = data[285] & 0x80;
   1371 	bool prox = buttons || ringstatus;
   1372 
   1373 	/* Fix touchring data: userspace expects 0 at left and increasing clockwise */
   1374 	ring = 71 - ring;
   1375 	ring += 3*72/16;
   1376 	if (ring > 71)
   1377 		ring -= 72;
   1378 
   1379 	wacom_report_numbered_buttons(pad_input, 9, buttons);
   1380 
   1381 	input_report_abs(pad_input, ABS_WHEEL, ringstatus ? ring : 0);
   1382 
   1383 	input_report_key(pad_input, wacom->tool[1], prox ? 1 : 0);
   1384 	input_report_abs(pad_input, ABS_MISC, prox ? PAD_DEVICE_ID : 0);
   1385 	input_event(pad_input, EV_MSC, MSC_SERIAL, 0xffffffff);
   1386 
   1387 	input_sync(pad_input);
   1388 }
   1389 
   1390 static void wacom_intuos_pro2_bt_battery(struct wacom_wac *wacom)
   1391 {
   1392 	unsigned char *data = wacom->data;
   1393 
   1394 	bool chg = data[284] & 0x80;
   1395 	int battery_status = data[284] & 0x7F;
   1396 
   1397 	wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
   1398 			     battery_status, chg, 1, chg);
   1399 }
   1400 
   1401 static void wacom_intuos_gen3_bt_pad(struct wacom_wac *wacom)
   1402 {
   1403 	struct input_dev *pad_input = wacom->pad_input;
   1404 	unsigned char *data = wacom->data;
   1405 
   1406 	int buttons = data[44];
   1407 
   1408 	wacom_report_numbered_buttons(pad_input, 4, buttons);
   1409 
   1410 	input_report_key(pad_input, wacom->tool[1], buttons ? 1 : 0);
   1411 	input_report_abs(pad_input, ABS_MISC, buttons ? PAD_DEVICE_ID : 0);
   1412 	input_event(pad_input, EV_MSC, MSC_SERIAL, 0xffffffff);
   1413 
   1414 	input_sync(pad_input);
   1415 }
   1416 
   1417 static void wacom_intuos_gen3_bt_battery(struct wacom_wac *wacom)
   1418 {
   1419 	unsigned char *data = wacom->data;
   1420 
   1421 	bool chg = data[45] & 0x80;
   1422 	int battery_status = data[45] & 0x7F;
   1423 
   1424 	wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
   1425 			     battery_status, chg, 1, chg);
   1426 }
   1427 
   1428 static int wacom_intuos_pro2_bt_irq(struct wacom_wac *wacom, size_t len)
   1429 {
   1430 	unsigned char *data = wacom->data;
   1431 
   1432 	if (data[0] != 0x80 && data[0] != 0x81) {
   1433 		dev_dbg(wacom->pen_input->dev.parent,
   1434 			"%s: received unknown report #%d\n", __func__, data[0]);
   1435 		return 0;
   1436 	}
   1437 
   1438 	wacom_intuos_pro2_bt_pen(wacom);
   1439 	if (wacom->features.type == INTUOSP2_BT) {
   1440 		wacom_intuos_pro2_bt_touch(wacom);
   1441 		wacom_intuos_pro2_bt_pad(wacom);
   1442 		wacom_intuos_pro2_bt_battery(wacom);
   1443 	} else {
   1444 		wacom_intuos_gen3_bt_pad(wacom);
   1445 		wacom_intuos_gen3_bt_battery(wacom);
   1446 	}
   1447 	return 0;
   1448 }
   1449 
   1450 static int wacom_24hdt_irq(struct wacom_wac *wacom)
   1451 {
   1452 	struct input_dev *input = wacom->touch_input;
   1453 	unsigned char *data = wacom->data;
   1454 	int i;
   1455 	int current_num_contacts = data[61];
   1456 	int contacts_to_send = 0;
   1457 	int num_contacts_left = 4; /* maximum contacts per packet */
   1458 	int byte_per_packet = WACOM_BYTES_PER_24HDT_PACKET;
   1459 	int y_offset = 2;
   1460 
   1461 	if (wacom->features.type == WACOM_27QHDT) {
   1462 		current_num_contacts = data[63];
   1463 		num_contacts_left = 10;
   1464 		byte_per_packet = WACOM_BYTES_PER_QHDTHID_PACKET;
   1465 		y_offset = 0;
   1466 	}
   1467 
   1468 	/*
   1469 	 * First packet resets the counter since only the first
   1470 	 * packet in series will have non-zero current_num_contacts.
   1471 	 */
   1472 	if (current_num_contacts)
   1473 		wacom->num_contacts_left = current_num_contacts;
   1474 
   1475 	contacts_to_send = min(num_contacts_left, wacom->num_contacts_left);
   1476 
   1477 	for (i = 0; i < contacts_to_send; i++) {
   1478 		int offset = (byte_per_packet * i) + 1;
   1479 		bool touch = (data[offset] & 0x1) && report_touch_events(wacom);
   1480 		int slot = input_mt_get_slot_by_key(input, data[offset + 1]);
   1481 
   1482 		if (slot < 0)
   1483 			continue;
   1484 		input_mt_slot(input, slot);
   1485 		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
   1486 
   1487 		if (touch) {
   1488 			int t_x = get_unaligned_le16(&data[offset + 2]);
   1489 			int t_y = get_unaligned_le16(&data[offset + 4 + y_offset]);
   1490 
   1491 			input_report_abs(input, ABS_MT_POSITION_X, t_x);
   1492 			input_report_abs(input, ABS_MT_POSITION_Y, t_y);
   1493 
   1494 			if (wacom->features.type != WACOM_27QHDT) {
   1495 				int c_x = get_unaligned_le16(&data[offset + 4]);
   1496 				int c_y = get_unaligned_le16(&data[offset + 8]);
   1497 				int w = get_unaligned_le16(&data[offset + 10]);
   1498 				int h = get_unaligned_le16(&data[offset + 12]);
   1499 
   1500 				input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
   1501 				input_report_abs(input, ABS_MT_WIDTH_MAJOR,
   1502 						 min(w, h) + int_dist(t_x, t_y, c_x, c_y));
   1503 				input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
   1504 				input_report_abs(input, ABS_MT_ORIENTATION, w > h);
   1505 			}
   1506 		}
   1507 	}
   1508 	input_mt_sync_frame(input);
   1509 
   1510 	wacom->num_contacts_left -= contacts_to_send;
   1511 	if (wacom->num_contacts_left <= 0) {
   1512 		wacom->num_contacts_left = 0;
   1513 		wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
   1514 	}
   1515 	return 1;
   1516 }
   1517 
   1518 static int wacom_mt_touch(struct wacom_wac *wacom)
   1519 {
   1520 	struct input_dev *input = wacom->touch_input;
   1521 	unsigned char *data = wacom->data;
   1522 	int i;
   1523 	int current_num_contacts = data[2];
   1524 	int contacts_to_send = 0;
   1525 	int x_offset = 0;
   1526 
   1527 	/* MTTPC does not support Height and Width */
   1528 	if (wacom->features.type == MTTPC || wacom->features.type == MTTPC_B)
   1529 		x_offset = -4;
   1530 
   1531 	/*
   1532 	 * First packet resets the counter since only the first
   1533 	 * packet in series will have non-zero current_num_contacts.
   1534 	 */
   1535 	if (current_num_contacts)
   1536 		wacom->num_contacts_left = current_num_contacts;
   1537 
   1538 	/* There are at most 5 contacts per packet */
   1539 	contacts_to_send = min(5, wacom->num_contacts_left);
   1540 
   1541 	for (i = 0; i < contacts_to_send; i++) {
   1542 		int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
   1543 		bool touch = (data[offset] & 0x1) && report_touch_events(wacom);
   1544 		int id = get_unaligned_le16(&data[offset + 1]);
   1545 		int slot = input_mt_get_slot_by_key(input, id);
   1546 
   1547 		if (slot < 0)
   1548 			continue;
   1549 
   1550 		input_mt_slot(input, slot);
   1551 		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
   1552 		if (touch) {
   1553 			int x = get_unaligned_le16(&data[offset + x_offset + 7]);
   1554 			int y = get_unaligned_le16(&data[offset + x_offset + 9]);
   1555 			input_report_abs(input, ABS_MT_POSITION_X, x);
   1556 			input_report_abs(input, ABS_MT_POSITION_Y, y);
   1557 		}
   1558 	}
   1559 	input_mt_sync_frame(input);
   1560 
   1561 	wacom->num_contacts_left -= contacts_to_send;
   1562 	if (wacom->num_contacts_left <= 0) {
   1563 		wacom->num_contacts_left = 0;
   1564 		wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
   1565 	}
   1566 	return 1;
   1567 }
   1568 
   1569 static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
   1570 {
   1571 	struct input_dev *input = wacom->touch_input;
   1572 	unsigned char *data = wacom->data;
   1573 	int i;
   1574 
   1575 	for (i = 0; i < 2; i++) {
   1576 		int p = data[1] & (1 << i);
   1577 		bool touch = p && report_touch_events(wacom);
   1578 
   1579 		input_mt_slot(input, i);
   1580 		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
   1581 		if (touch) {
   1582 			int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
   1583 			int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
   1584 
   1585 			input_report_abs(input, ABS_MT_POSITION_X, x);
   1586 			input_report_abs(input, ABS_MT_POSITION_Y, y);
   1587 		}
   1588 	}
   1589 	input_mt_sync_frame(input);
   1590 
   1591 	/* keep touch state for pen event */
   1592 	wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
   1593 
   1594 	return 1;
   1595 }
   1596 
   1597 static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
   1598 {
   1599 	unsigned char *data = wacom->data;
   1600 	struct input_dev *input = wacom->touch_input;
   1601 	bool prox = report_touch_events(wacom);
   1602 	int x = 0, y = 0;
   1603 
   1604 	if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
   1605 		return 0;
   1606 
   1607 	if (len == WACOM_PKGLEN_TPC1FG) {
   1608 		prox = prox && (data[0] & 0x01);
   1609 		x = get_unaligned_le16(&data[1]);
   1610 		y = get_unaligned_le16(&data[3]);
   1611 	} else if (len == WACOM_PKGLEN_TPC1FG_B) {
   1612 		prox = prox && (data[2] & 0x01);
   1613 		x = get_unaligned_le16(&data[3]);
   1614 		y = get_unaligned_le16(&data[5]);
   1615 	} else {
   1616 		prox = prox && (data[1] & 0x01);
   1617 		x = le16_to_cpup((__le16 *)&data[2]);
   1618 		y = le16_to_cpup((__le16 *)&data[4]);
   1619 	}
   1620 
   1621 	if (prox) {
   1622 		input_report_abs(input, ABS_X, x);
   1623 		input_report_abs(input, ABS_Y, y);
   1624 	}
   1625 	input_report_key(input, BTN_TOUCH, prox);
   1626 
   1627 	/* keep touch state for pen events */
   1628 	wacom->shared->touch_down = prox;
   1629 
   1630 	return 1;
   1631 }
   1632 
   1633 static int wacom_tpc_pen(struct wacom_wac *wacom)
   1634 {
   1635 	unsigned char *data = wacom->data;
   1636 	struct input_dev *input = wacom->pen_input;
   1637 	bool prox = data[1] & 0x20;
   1638 
   1639 	if (!wacom->shared->stylus_in_proximity) /* first in prox */
   1640 		/* Going into proximity select tool */
   1641 		wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
   1642 
   1643 	/* keep pen state for touch events */
   1644 	wacom->shared->stylus_in_proximity = prox;
   1645 
   1646 	/* send pen events only when touch is up or forced out
   1647 	 * or touch arbitration is off
   1648 	 */
   1649 	if (!delay_pen_events(wacom)) {
   1650 		input_report_key(input, BTN_STYLUS, data[1] & 0x02);
   1651 		input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
   1652 		input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
   1653 		input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
   1654 		input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x07) << 8) | data[6]);
   1655 		input_report_key(input, BTN_TOUCH, data[1] & 0x05);
   1656 		input_report_key(input, wacom->tool[0], prox);
   1657 		return 1;
   1658 	}
   1659 
   1660 	return 0;
   1661 }
   1662 
   1663 static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
   1664 {
   1665 	unsigned char *data = wacom->data;
   1666 
   1667 	if (wacom->pen_input) {
   1668 		dev_dbg(wacom->pen_input->dev.parent,
   1669 			"%s: received report #%d\n", __func__, data[0]);
   1670 
   1671 		if (len == WACOM_PKGLEN_PENABLED ||
   1672 		    data[0] == WACOM_REPORT_PENABLED)
   1673 			return wacom_tpc_pen(wacom);
   1674 	}
   1675 	else if (wacom->touch_input) {
   1676 		dev_dbg(wacom->touch_input->dev.parent,
   1677 			"%s: received report #%d\n", __func__, data[0]);
   1678 
   1679 		switch (len) {
   1680 		case WACOM_PKGLEN_TPC1FG:
   1681 			return wacom_tpc_single_touch(wacom, len);
   1682 
   1683 		case WACOM_PKGLEN_TPC2FG:
   1684 			return wacom_tpc_mt_touch(wacom);
   1685 
   1686 		default:
   1687 			switch (data[0]) {
   1688 			case WACOM_REPORT_TPC1FG:
   1689 			case WACOM_REPORT_TPCHID:
   1690 			case WACOM_REPORT_TPCST:
   1691 			case WACOM_REPORT_TPC1FGE:
   1692 				return wacom_tpc_single_touch(wacom, len);
   1693 
   1694 			case WACOM_REPORT_TPCMT:
   1695 			case WACOM_REPORT_TPCMT2:
   1696 				return wacom_mt_touch(wacom);
   1697 
   1698 			}
   1699 		}
   1700 	}
   1701 
   1702 	return 0;
   1703 }
   1704 
   1705 static int wacom_offset_rotation(struct input_dev *input, struct hid_usage *usage,
   1706 				 int value, int num, int denom)
   1707 {
   1708 	struct input_absinfo *abs = &input->absinfo[usage->code];
   1709 	int range = (abs->maximum - abs->minimum + 1);
   1710 
   1711 	value += num*range/denom;
   1712 	if (value > abs->maximum)
   1713 		value -= range;
   1714 	else if (value < abs->minimum)
   1715 		value += range;
   1716 	return value;
   1717 }
   1718 
   1719 int wacom_equivalent_usage(int usage)
   1720 {
   1721 	if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMDIGITIZER) {
   1722 		int subpage = (usage & 0xFF00) << 8;
   1723 		int subusage = (usage & 0xFF);
   1724 
   1725 		if (subpage == WACOM_HID_SP_PAD ||
   1726 		    subpage == WACOM_HID_SP_BUTTON ||
   1727 		    subpage == WACOM_HID_SP_DIGITIZER ||
   1728 		    subpage == WACOM_HID_SP_DIGITIZERINFO ||
   1729 		    usage == WACOM_HID_WD_SENSE ||
   1730 		    usage == WACOM_HID_WD_SERIALHI ||
   1731 		    usage == WACOM_HID_WD_TOOLTYPE ||
   1732 		    usage == WACOM_HID_WD_DISTANCE ||
   1733 		    usage == WACOM_HID_WD_TOUCHSTRIP ||
   1734 		    usage == WACOM_HID_WD_TOUCHSTRIP2 ||
   1735 		    usage == WACOM_HID_WD_TOUCHRING ||
   1736 		    usage == WACOM_HID_WD_TOUCHRINGSTATUS ||
   1737 		    usage == WACOM_HID_WD_REPORT_VALID) {
   1738 			return usage;
   1739 		}
   1740 
   1741 		if (subpage == HID_UP_UNDEFINED)
   1742 			subpage = HID_UP_DIGITIZER;
   1743 
   1744 		return subpage | subusage;
   1745 	}
   1746 
   1747 	if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMTOUCH) {
   1748 		int subpage = (usage & 0xFF00) << 8;
   1749 		int subusage = (usage & 0xFF);
   1750 
   1751 		if (subpage == HID_UP_UNDEFINED)
   1752 			subpage = WACOM_HID_SP_DIGITIZER;
   1753 
   1754 		return subpage | subusage;
   1755 	}
   1756 
   1757 	return usage;
   1758 }
   1759 
   1760 static void wacom_map_usage(struct input_dev *input, struct hid_usage *usage,
   1761 		struct hid_field *field, __u8 type, __u16 code, int fuzz)
   1762 {
   1763 	struct wacom *wacom = input_get_drvdata(input);
   1764 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   1765 	struct wacom_features *features = &wacom_wac->features;
   1766 	int fmin = field->logical_minimum;
   1767 	int fmax = field->logical_maximum;
   1768 	unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
   1769 	int resolution_code = code;
   1770 
   1771 	if (equivalent_usage == HID_DG_TWIST) {
   1772 		resolution_code = ABS_RZ;
   1773 	}
   1774 
   1775 	if (equivalent_usage == HID_GD_X) {
   1776 		fmin += features->offset_left;
   1777 		fmax -= features->offset_right;
   1778 	}
   1779 	if (equivalent_usage == HID_GD_Y) {
   1780 		fmin += features->offset_top;
   1781 		fmax -= features->offset_bottom;
   1782 	}
   1783 
   1784 	usage->type = type;
   1785 	usage->code = code;
   1786 
   1787 	set_bit(type, input->evbit);
   1788 
   1789 	switch (type) {
   1790 	case EV_ABS:
   1791 		input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
   1792 		input_abs_set_res(input, code,
   1793 				  hidinput_calc_abs_res(field, resolution_code));
   1794 		break;
   1795 	case EV_KEY:
   1796 		input_set_capability(input, EV_KEY, code);
   1797 		break;
   1798 	case EV_MSC:
   1799 		input_set_capability(input, EV_MSC, code);
   1800 		break;
   1801 	case EV_SW:
   1802 		input_set_capability(input, EV_SW, code);
   1803 		break;
   1804 	}
   1805 }
   1806 
   1807 static void wacom_wac_battery_usage_mapping(struct hid_device *hdev,
   1808 		struct hid_field *field, struct hid_usage *usage)
   1809 {
   1810 	struct wacom *wacom = hid_get_drvdata(hdev);
   1811 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   1812 	struct wacom_features *features = &wacom_wac->features;
   1813 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   1814 
   1815 	switch (equivalent_usage) {
   1816 	case HID_DG_BATTERYSTRENGTH:
   1817 	case WACOM_HID_WD_BATTERY_LEVEL:
   1818 	case WACOM_HID_WD_BATTERY_CHARGING:
   1819 		features->quirks |= WACOM_QUIRK_BATTERY;
   1820 		break;
   1821 	}
   1822 }
   1823 
   1824 static void wacom_wac_battery_event(struct hid_device *hdev, struct hid_field *field,
   1825 		struct hid_usage *usage, __s32 value)
   1826 {
   1827 	struct wacom *wacom = hid_get_drvdata(hdev);
   1828 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   1829 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   1830 
   1831 	switch (equivalent_usage) {
   1832 	case HID_DG_BATTERYSTRENGTH:
   1833 		if (value == 0) {
   1834 			wacom_wac->hid_data.bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
   1835 		}
   1836 		else {
   1837 			value = value * 100 / (field->logical_maximum - field->logical_minimum);
   1838 			wacom_wac->hid_data.battery_capacity = value;
   1839 			wacom_wac->hid_data.bat_connected = 1;
   1840 			wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
   1841 		}
   1842 		break;
   1843 	case WACOM_HID_WD_BATTERY_LEVEL:
   1844 		value = value * 100 / (field->logical_maximum - field->logical_minimum);
   1845 		wacom_wac->hid_data.battery_capacity = value;
   1846 		wacom_wac->hid_data.bat_connected = 1;
   1847 		wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
   1848 		break;
   1849 	case WACOM_HID_WD_BATTERY_CHARGING:
   1850 		wacom_wac->hid_data.bat_charging = value;
   1851 		wacom_wac->hid_data.ps_connected = value;
   1852 		wacom_wac->hid_data.bat_connected = 1;
   1853 		wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
   1854 		break;
   1855 	}
   1856 }
   1857 
   1858 static void wacom_wac_battery_pre_report(struct hid_device *hdev,
   1859 		struct hid_report *report)
   1860 {
   1861 	return;
   1862 }
   1863 
   1864 static void wacom_wac_battery_report(struct hid_device *hdev,
   1865 		struct hid_report *report)
   1866 {
   1867 	struct wacom *wacom = hid_get_drvdata(hdev);
   1868 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   1869 	struct wacom_features *features = &wacom_wac->features;
   1870 
   1871 	if (features->quirks & WACOM_QUIRK_BATTERY) {
   1872 		int status = wacom_wac->hid_data.bat_status;
   1873 		int capacity = wacom_wac->hid_data.battery_capacity;
   1874 		bool charging = wacom_wac->hid_data.bat_charging;
   1875 		bool connected = wacom_wac->hid_data.bat_connected;
   1876 		bool powered = wacom_wac->hid_data.ps_connected;
   1877 
   1878 		wacom_notify_battery(wacom_wac, status, capacity, charging,
   1879 				     connected, powered);
   1880 	}
   1881 }
   1882 
   1883 static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
   1884 		struct hid_field *field, struct hid_usage *usage)
   1885 {
   1886 	struct wacom *wacom = hid_get_drvdata(hdev);
   1887 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   1888 	struct wacom_features *features = &wacom_wac->features;
   1889 	struct input_dev *input = wacom_wac->pad_input;
   1890 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   1891 
   1892 	switch (equivalent_usage) {
   1893 	case WACOM_HID_WD_ACCELEROMETER_X:
   1894 		__set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
   1895 		wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 0);
   1896 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1897 		break;
   1898 	case WACOM_HID_WD_ACCELEROMETER_Y:
   1899 		__set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
   1900 		wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 0);
   1901 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1902 		break;
   1903 	case WACOM_HID_WD_ACCELEROMETER_Z:
   1904 		__set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
   1905 		wacom_map_usage(input, usage, field, EV_ABS, ABS_Z, 0);
   1906 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1907 		break;
   1908 	case WACOM_HID_WD_BUTTONCENTER:
   1909 		wacom->generic_has_leds = true;
   1910 		/* fall through */
   1911 	case WACOM_HID_WD_BUTTONHOME:
   1912 	case WACOM_HID_WD_BUTTONUP:
   1913 	case WACOM_HID_WD_BUTTONDOWN:
   1914 	case WACOM_HID_WD_BUTTONLEFT:
   1915 	case WACOM_HID_WD_BUTTONRIGHT:
   1916 		wacom_map_usage(input, usage, field, EV_KEY,
   1917 				wacom_numbered_button_to_key(features->numbered_buttons),
   1918 				0);
   1919 		features->numbered_buttons++;
   1920 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1921 		break;
   1922 	case WACOM_HID_WD_TOUCHONOFF:
   1923 	case WACOM_HID_WD_MUTE_DEVICE:
   1924 		/*
   1925 		 * This usage, which is used to mute touch events, comes
   1926 		 * from the pad packet, but is reported on the touch
   1927 		 * interface. Because the touch interface may not have
   1928 		 * been created yet, we cannot call wacom_map_usage(). In
   1929 		 * order to process this usage when we receive it, we set
   1930 		 * the usage type and code directly.
   1931 		 */
   1932 		wacom_wac->has_mute_touch_switch = true;
   1933 		usage->type = EV_SW;
   1934 		usage->code = SW_MUTE_DEVICE;
   1935 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1936 		break;
   1937 	case WACOM_HID_WD_TOUCHSTRIP:
   1938 		wacom_map_usage(input, usage, field, EV_ABS, ABS_RX, 0);
   1939 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1940 		break;
   1941 	case WACOM_HID_WD_TOUCHSTRIP2:
   1942 		wacom_map_usage(input, usage, field, EV_ABS, ABS_RY, 0);
   1943 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1944 		break;
   1945 	case WACOM_HID_WD_TOUCHRING:
   1946 		wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0);
   1947 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1948 		break;
   1949 	case WACOM_HID_WD_TOUCHRINGSTATUS:
   1950 		/*
   1951 		 * Only set up type/code association. Completely mapping
   1952 		 * this usage may overwrite the axis resolution and range.
   1953 		 */
   1954 		usage->type = EV_ABS;
   1955 		usage->code = ABS_WHEEL;
   1956 		set_bit(EV_ABS, input->evbit);
   1957 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1958 		break;
   1959 	case WACOM_HID_WD_BUTTONCONFIG:
   1960 		wacom_map_usage(input, usage, field, EV_KEY, KEY_BUTTONCONFIG, 0);
   1961 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1962 		break;
   1963 	case WACOM_HID_WD_ONSCREEN_KEYBOARD:
   1964 		wacom_map_usage(input, usage, field, EV_KEY, KEY_ONSCREEN_KEYBOARD, 0);
   1965 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1966 		break;
   1967 	case WACOM_HID_WD_CONTROLPANEL:
   1968 		wacom_map_usage(input, usage, field, EV_KEY, KEY_CONTROLPANEL, 0);
   1969 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1970 		break;
   1971 	case WACOM_HID_WD_MODE_CHANGE:
   1972 		/* do not overwrite previous data */
   1973 		if (!wacom_wac->has_mode_change) {
   1974 			wacom_wac->has_mode_change = true;
   1975 			wacom_wac->is_direct_mode = true;
   1976 		}
   1977 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1978 		break;
   1979 	}
   1980 
   1981 	switch (equivalent_usage & 0xfffffff0) {
   1982 	case WACOM_HID_WD_EXPRESSKEY00:
   1983 		wacom_map_usage(input, usage, field, EV_KEY,
   1984 				wacom_numbered_button_to_key(features->numbered_buttons),
   1985 				0);
   1986 		features->numbered_buttons++;
   1987 		features->device_type |= WACOM_DEVICETYPE_PAD;
   1988 		break;
   1989 	}
   1990 }
   1991 
   1992 static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
   1993 		struct hid_usage *usage, __s32 value)
   1994 {
   1995 	struct wacom *wacom = hid_get_drvdata(hdev);
   1996 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   1997 	struct input_dev *input = wacom_wac->pad_input;
   1998 	struct wacom_features *features = &wacom_wac->features;
   1999 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   2000 	int i;
   2001 	bool do_report = false;
   2002 
   2003 	/*
   2004 	 * Avoid reporting this event and setting inrange_state if this usage
   2005 	 * hasn't been mapped.
   2006 	 */
   2007 	if (!usage->type && equivalent_usage != WACOM_HID_WD_MODE_CHANGE)
   2008 		return;
   2009 
   2010 	if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) {
   2011 		if (usage->hid != WACOM_HID_WD_TOUCHRING)
   2012 			wacom_wac->hid_data.inrange_state |= value;
   2013 	}
   2014 
   2015 	switch (equivalent_usage) {
   2016 	case WACOM_HID_WD_TOUCHRING:
   2017 		/*
   2018 		 * Userspace expects touchrings to increase in value with
   2019 		 * clockwise gestures and have their zero point at the
   2020 		 * tablet's left. HID events "should" be clockwise-
   2021 		 * increasing and zero at top, though the MobileStudio
   2022 		 * Pro and 2nd-gen Intuos Pro don't do this...
   2023 		 */
   2024 		if (hdev->vendor == 0x56a &&
   2025 		    (hdev->product == 0x34d || hdev->product == 0x34e ||  /* MobileStudio Pro */
   2026 		     hdev->product == 0x357 || hdev->product == 0x358)) { /* Intuos Pro 2 */
   2027 			value = (field->logical_maximum - value);
   2028 
   2029 			if (hdev->product == 0x357 || hdev->product == 0x358)
   2030 				value = wacom_offset_rotation(input, usage, value, 3, 16);
   2031 			else if (hdev->product == 0x34d || hdev->product == 0x34e)
   2032 				value = wacom_offset_rotation(input, usage, value, 1, 2);
   2033 		}
   2034 		else {
   2035 			value = wacom_offset_rotation(input, usage, value, 1, 4);
   2036 		}
   2037 		do_report = true;
   2038 		break;
   2039 	case WACOM_HID_WD_TOUCHRINGSTATUS:
   2040 		if (!value)
   2041 			input_event(input, usage->type, usage->code, 0);
   2042 		break;
   2043 
   2044 	case WACOM_HID_WD_MUTE_DEVICE:
   2045 	case WACOM_HID_WD_TOUCHONOFF:
   2046 		if (wacom_wac->shared->touch_input) {
   2047 			bool *is_touch_on = &wacom_wac->shared->is_touch_on;
   2048 
   2049 			if (equivalent_usage == WACOM_HID_WD_MUTE_DEVICE && value)
   2050 				*is_touch_on = !(*is_touch_on);
   2051 			else if (equivalent_usage == WACOM_HID_WD_TOUCHONOFF)
   2052 				*is_touch_on = value;
   2053 
   2054 			input_report_switch(wacom_wac->shared->touch_input,
   2055 					    SW_MUTE_DEVICE, !(*is_touch_on));
   2056 			input_sync(wacom_wac->shared->touch_input);
   2057 		}
   2058 		break;
   2059 
   2060 	case WACOM_HID_WD_MODE_CHANGE:
   2061 		if (wacom_wac->is_direct_mode != value) {
   2062 			wacom_wac->is_direct_mode = value;
   2063 			wacom_schedule_work(&wacom->wacom_wac, WACOM_WORKER_MODE_CHANGE);
   2064 		}
   2065 		break;
   2066 
   2067 	case WACOM_HID_WD_BUTTONCENTER:
   2068 		for (i = 0; i < wacom->led.count; i++)
   2069 			wacom_update_led(wacom, features->numbered_buttons,
   2070 					 value, i);
   2071 		 /* fall through*/
   2072 	default:
   2073 		do_report = true;
   2074 		break;
   2075 	}
   2076 
   2077 	if (do_report) {
   2078 		input_event(input, usage->type, usage->code, value);
   2079 		if (value)
   2080 			wacom_wac->hid_data.pad_input_event_flag = true;
   2081 	}
   2082 }
   2083 
   2084 static void wacom_wac_pad_pre_report(struct hid_device *hdev,
   2085 		struct hid_report *report)
   2086 {
   2087 	struct wacom *wacom = hid_get_drvdata(hdev);
   2088 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2089 
   2090 	wacom_wac->hid_data.inrange_state = 0;
   2091 }
   2092 
   2093 static void wacom_wac_pad_report(struct hid_device *hdev,
   2094 		struct hid_report *report, struct hid_field *field)
   2095 {
   2096 	struct wacom *wacom = hid_get_drvdata(hdev);
   2097 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2098 	struct input_dev *input = wacom_wac->pad_input;
   2099 	bool active = wacom_wac->hid_data.inrange_state != 0;
   2100 
   2101 	/* report prox for expresskey events */
   2102 	if ((wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) &&
   2103 	    wacom_wac->hid_data.pad_input_event_flag) {
   2104 		input_event(input, EV_ABS, ABS_MISC, active ? PAD_DEVICE_ID : 0);
   2105 		input_sync(input);
   2106 		if (!active)
   2107 			wacom_wac->hid_data.pad_input_event_flag = false;
   2108 	}
   2109 
   2110 }
   2111 
   2112 static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
   2113 		struct hid_field *field, struct hid_usage *usage)
   2114 {
   2115 	struct wacom *wacom = hid_get_drvdata(hdev);
   2116 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2117 	struct wacom_features *features = &wacom_wac->features;
   2118 	struct input_dev *input = wacom_wac->pen_input;
   2119 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   2120 
   2121 	switch (equivalent_usage) {
   2122 	case HID_GD_X:
   2123 		wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
   2124 		break;
   2125 	case HID_GD_Y:
   2126 		wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
   2127 		break;
   2128 	case WACOM_HID_WD_DISTANCE:
   2129 	case HID_GD_Z:
   2130 		wacom_map_usage(input, usage, field, EV_ABS, ABS_DISTANCE, 0);
   2131 		break;
   2132 	case HID_DG_TIPPRESSURE:
   2133 		wacom_map_usage(input, usage, field, EV_ABS, ABS_PRESSURE, 0);
   2134 		break;
   2135 	case HID_DG_INRANGE:
   2136 		wacom_map_usage(input, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
   2137 		break;
   2138 	case HID_DG_INVERT:
   2139 		wacom_map_usage(input, usage, field, EV_KEY,
   2140 				BTN_TOOL_RUBBER, 0);
   2141 		break;
   2142 	case HID_DG_TILT_X:
   2143 		wacom_map_usage(input, usage, field, EV_ABS, ABS_TILT_X, 0);
   2144 		break;
   2145 	case HID_DG_TILT_Y:
   2146 		wacom_map_usage(input, usage, field, EV_ABS, ABS_TILT_Y, 0);
   2147 		break;
   2148 	case HID_DG_TWIST:
   2149 		wacom_map_usage(input, usage, field, EV_ABS, ABS_Z, 0);
   2150 		break;
   2151 	case HID_DG_ERASER:
   2152 	case HID_DG_TIPSWITCH:
   2153 		wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
   2154 		break;
   2155 	case HID_DG_BARRELSWITCH:
   2156 		wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS, 0);
   2157 		break;
   2158 	case HID_DG_BARRELSWITCH2:
   2159 		wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS2, 0);
   2160 		break;
   2161 	case HID_DG_TOOLSERIALNUMBER:
   2162 		features->quirks |= WACOM_QUIRK_TOOLSERIAL;
   2163 		wacom_map_usage(input, usage, field, EV_MSC, MSC_SERIAL, 0);
   2164 		break;
   2165 	case WACOM_HID_WD_SENSE:
   2166 		features->quirks |= WACOM_QUIRK_SENSE;
   2167 		wacom_map_usage(input, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
   2168 		break;
   2169 	case WACOM_HID_WD_SERIALHI:
   2170 		wacom_map_usage(input, usage, field, EV_ABS, ABS_MISC, 0);
   2171 
   2172 		if (!(features->quirks & WACOM_QUIRK_AESPEN)) {
   2173 			set_bit(EV_KEY, input->evbit);
   2174 			input_set_capability(input, EV_KEY, BTN_TOOL_PEN);
   2175 			input_set_capability(input, EV_KEY, BTN_TOOL_RUBBER);
   2176 			input_set_capability(input, EV_KEY, BTN_TOOL_BRUSH);
   2177 			input_set_capability(input, EV_KEY, BTN_TOOL_PENCIL);
   2178 			input_set_capability(input, EV_KEY, BTN_TOOL_AIRBRUSH);
   2179 			if (!(features->device_type & WACOM_DEVICETYPE_DIRECT)) {
   2180 				input_set_capability(input, EV_KEY, BTN_TOOL_MOUSE);
   2181 				input_set_capability(input, EV_KEY, BTN_TOOL_LENS);
   2182 			}
   2183 		}
   2184 		break;
   2185 	case WACOM_HID_WD_FINGERWHEEL:
   2186 		wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0);
   2187 		break;
   2188 	}
   2189 }
   2190 
   2191 static void wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
   2192 		struct hid_usage *usage, __s32 value)
   2193 {
   2194 	struct wacom *wacom = hid_get_drvdata(hdev);
   2195 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2196 	struct wacom_features *features = &wacom_wac->features;
   2197 	struct input_dev *input = wacom_wac->pen_input;
   2198 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   2199 
   2200 	if (wacom_wac->is_invalid_bt_frame)
   2201 		return;
   2202 
   2203 	switch (equivalent_usage) {
   2204 	case HID_GD_Z:
   2205 		/*
   2206 		 * HID_GD_Z "should increase as the control's position is
   2207 		 * moved from high to low", while ABS_DISTANCE instead
   2208 		 * increases in value as the tool moves from low to high.
   2209 		 */
   2210 		value = field->logical_maximum - value;
   2211 		break;
   2212 	case HID_DG_INRANGE:
   2213 		wacom_wac->hid_data.inrange_state = value;
   2214 		if (!(features->quirks & WACOM_QUIRK_SENSE))
   2215 			wacom_wac->hid_data.sense_state = value;
   2216 		return;
   2217 	case HID_DG_INVERT:
   2218 		wacom_wac->hid_data.invert_state = value;
   2219 		return;
   2220 	case HID_DG_ERASER:
   2221 	case HID_DG_TIPSWITCH:
   2222 		wacom_wac->hid_data.tipswitch |= value;
   2223 		return;
   2224 	case HID_DG_BARRELSWITCH:
   2225 		wacom_wac->hid_data.barrelswitch = value;
   2226 		return;
   2227 	case HID_DG_BARRELSWITCH2:
   2228 		wacom_wac->hid_data.barrelswitch2 = value;
   2229 		return;
   2230 	case HID_DG_TOOLSERIALNUMBER:
   2231 		if (value) {
   2232 			wacom_wac->serial[0] = (wacom_wac->serial[0] & ~0xFFFFFFFFULL);
   2233 			wacom_wac->serial[0] |= (__u32)value;
   2234 		}
   2235 		return;
   2236 	case HID_DG_TWIST:
   2237 		/*
   2238 		 * Userspace expects pen twist to have its zero point when
   2239 		 * the buttons/finger is on the tablet's left. HID values
   2240 		 * are zero when buttons are toward the top.
   2241 		 */
   2242 		value = wacom_offset_rotation(input, usage, value, 1, 4);
   2243 		break;
   2244 	case WACOM_HID_WD_SENSE:
   2245 		wacom_wac->hid_data.sense_state = value;
   2246 		return;
   2247 	case WACOM_HID_WD_SERIALHI:
   2248 		if (value) {
   2249 			wacom_wac->serial[0] = (wacom_wac->serial[0] & 0xFFFFFFFF);
   2250 			wacom_wac->serial[0] |= ((__u64)value) << 32;
   2251 			/*
   2252 			 * Non-USI EMR devices may contain additional tool type
   2253 			 * information here. See WACOM_HID_WD_TOOLTYPE case for
   2254 			 * more details.
   2255 			 */
   2256 			if (value >> 20 == 1) {
   2257 				wacom_wac->id[0] |= value & 0xFFFFF;
   2258 			}
   2259 		}
   2260 		return;
   2261 	case WACOM_HID_WD_TOOLTYPE:
   2262 		/*
   2263 		 * Some devices (MobileStudio Pro, and possibly later
   2264 		 * devices as well) do not return the complete tool
   2265 		 * type in their WACOM_HID_WD_TOOLTYPE usage. Use a
   2266 		 * bitwise OR so the complete value can be built
   2267 		 * up over time :(
   2268 		 */
   2269 		wacom_wac->id[0] |= value;
   2270 		return;
   2271 	case WACOM_HID_WD_OFFSETLEFT:
   2272 		if (features->offset_left && value != features->offset_left)
   2273 			hid_warn(hdev, "%s: overriding existing left offset "
   2274 				 "%d -> %d\n", __func__, value,
   2275 				 features->offset_left);
   2276 		features->offset_left = value;
   2277 		return;
   2278 	case WACOM_HID_WD_OFFSETRIGHT:
   2279 		if (features->offset_right && value != features->offset_right)
   2280 			hid_warn(hdev, "%s: overriding existing right offset "
   2281 				 "%d -> %d\n", __func__, value,
   2282 				 features->offset_right);
   2283 		features->offset_right = value;
   2284 		return;
   2285 	case WACOM_HID_WD_OFFSETTOP:
   2286 		if (features->offset_top && value != features->offset_top)
   2287 			hid_warn(hdev, "%s: overriding existing top offset "
   2288 				 "%d -> %d\n", __func__, value,
   2289 				 features->offset_top);
   2290 		features->offset_top = value;
   2291 		return;
   2292 	case WACOM_HID_WD_OFFSETBOTTOM:
   2293 		if (features->offset_bottom && value != features->offset_bottom)
   2294 			hid_warn(hdev, "%s: overriding existing bottom offset "
   2295 				 "%d -> %d\n", __func__, value,
   2296 				 features->offset_bottom);
   2297 		features->offset_bottom = value;
   2298 		return;
   2299 	case WACOM_HID_WD_REPORT_VALID:
   2300 		wacom_wac->is_invalid_bt_frame = !value;
   2301 		return;
   2302 	}
   2303 
   2304 	/* send pen events only when touch is up or forced out
   2305 	 * or touch arbitration is off
   2306 	 */
   2307 	if (!usage->type || delay_pen_events(wacom_wac))
   2308 		return;
   2309 
   2310 	/* send pen events only when the pen is in range */
   2311 	if (wacom_wac->hid_data.inrange_state)
   2312 		input_event(input, usage->type, usage->code, value);
   2313 	else if (wacom_wac->shared->stylus_in_proximity && !wacom_wac->hid_data.sense_state)
   2314 		input_event(input, usage->type, usage->code, 0);
   2315 }
   2316 
   2317 static void wacom_wac_pen_pre_report(struct hid_device *hdev,
   2318 		struct hid_report *report)
   2319 {
   2320 	struct wacom *wacom = hid_get_drvdata(hdev);
   2321 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2322 
   2323 	wacom_wac->is_invalid_bt_frame = false;
   2324 	return;
   2325 }
   2326 
   2327 static void wacom_wac_pen_report(struct hid_device *hdev,
   2328 		struct hid_report *report)
   2329 {
   2330 	struct wacom *wacom = hid_get_drvdata(hdev);
   2331 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2332 	struct input_dev *input = wacom_wac->pen_input;
   2333 	bool range = wacom_wac->hid_data.inrange_state;
   2334 	bool sense = wacom_wac->hid_data.sense_state;
   2335 
   2336 	if (wacom_wac->is_invalid_bt_frame)
   2337 		return;
   2338 
   2339 	if (!wacom_wac->tool[0] && range) { /* first in range */
   2340 		/* Going into range select tool */
   2341 		if (wacom_wac->hid_data.invert_state)
   2342 			wacom_wac->tool[0] = BTN_TOOL_RUBBER;
   2343 		else if (wacom_wac->id[0])
   2344 			wacom_wac->tool[0] = wacom_intuos_get_tool_type(wacom_wac->id[0]);
   2345 		else
   2346 			wacom_wac->tool[0] = BTN_TOOL_PEN;
   2347 	}
   2348 
   2349 	/* keep pen state for touch events */
   2350 	wacom_wac->shared->stylus_in_proximity = sense;
   2351 
   2352 	if (!delay_pen_events(wacom_wac) && wacom_wac->tool[0]) {
   2353 		int id = wacom_wac->id[0];
   2354 		int sw_state = wacom_wac->hid_data.barrelswitch |
   2355 			       (wacom_wac->hid_data.barrelswitch2 << 1);
   2356 
   2357 		input_report_key(input, BTN_STYLUS, sw_state == 1);
   2358 		input_report_key(input, BTN_STYLUS2, sw_state == 2);
   2359 		input_report_key(input, BTN_STYLUS3, sw_state == 3);
   2360 
   2361 		/*
   2362 		 * Non-USI EMR tools should have their IDs mangled to
   2363 		 * match the legacy behavior of wacom_intuos_general
   2364 		 */
   2365 		if (wacom_wac->serial[0] >> 52 == 1)
   2366 			id = wacom_intuos_id_mangle(id);
   2367 
   2368 		/*
   2369 		 * To ensure compatibility with xf86-input-wacom, we should
   2370 		 * report the BTN_TOOL_* event prior to the ABS_MISC or
   2371 		 * MSC_SERIAL events.
   2372 		 */
   2373 		input_report_key(input, BTN_TOUCH,
   2374 				wacom_wac->hid_data.tipswitch);
   2375 		input_report_key(input, wacom_wac->tool[0], sense);
   2376 		if (wacom_wac->serial[0]) {
   2377 			input_event(input, EV_MSC, MSC_SERIAL, wacom_wac->serial[0]);
   2378 			input_report_abs(input, ABS_MISC, sense ? id : 0);
   2379 		}
   2380 
   2381 		wacom_wac->hid_data.tipswitch = false;
   2382 
   2383 		input_sync(input);
   2384 	}
   2385 
   2386 	if (!sense) {
   2387 		wacom_wac->tool[0] = 0;
   2388 		wacom_wac->id[0] = 0;
   2389 		wacom_wac->serial[0] = 0;
   2390 	}
   2391 }
   2392 
   2393 static void wacom_wac_finger_usage_mapping(struct hid_device *hdev,
   2394 		struct hid_field *field, struct hid_usage *usage)
   2395 {
   2396 	struct wacom *wacom = hid_get_drvdata(hdev);
   2397 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2398 	struct input_dev *input = wacom_wac->touch_input;
   2399 	unsigned touch_max = wacom_wac->features.touch_max;
   2400 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   2401 
   2402 	switch (equivalent_usage) {
   2403 	case HID_GD_X:
   2404 		if (touch_max == 1)
   2405 			wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
   2406 		else
   2407 			wacom_map_usage(input, usage, field, EV_ABS,
   2408 					ABS_MT_POSITION_X, 4);
   2409 		break;
   2410 	case HID_GD_Y:
   2411 		if (touch_max == 1)
   2412 			wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
   2413 		else
   2414 			wacom_map_usage(input, usage, field, EV_ABS,
   2415 					ABS_MT_POSITION_Y, 4);
   2416 		break;
   2417 	case HID_DG_WIDTH:
   2418 	case HID_DG_HEIGHT:
   2419 		wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MAJOR, 0);
   2420 		wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MINOR, 0);
   2421 		input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0);
   2422 		break;
   2423 	case HID_DG_TIPSWITCH:
   2424 		wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
   2425 		break;
   2426 	case HID_DG_CONTACTCOUNT:
   2427 		wacom_wac->hid_data.cc_report = field->report->id;
   2428 		wacom_wac->hid_data.cc_index = field->index;
   2429 		wacom_wac->hid_data.cc_value_index = usage->usage_index;
   2430 		break;
   2431 	case HID_DG_CONTACTID:
   2432 		if ((field->logical_maximum - field->logical_minimum) < touch_max) {
   2433 			/*
   2434 			 * The HID descriptor for G11 sensors leaves logical
   2435 			 * maximum set to '1' despite it being a multitouch
   2436 			 * device. Override to a sensible number.
   2437 			 */
   2438 			field->logical_maximum = 255;
   2439 		}
   2440 		break;
   2441 	}
   2442 }
   2443 
   2444 static void wacom_wac_finger_slot(struct wacom_wac *wacom_wac,
   2445 		struct input_dev *input)
   2446 {
   2447 	struct hid_data *hid_data = &wacom_wac->hid_data;
   2448 	bool mt = wacom_wac->features.touch_max > 1;
   2449 	bool prox = hid_data->tipswitch &&
   2450 		    report_touch_events(wacom_wac);
   2451 
   2452 	if (wacom_wac->shared->has_mute_touch_switch &&
   2453 	    !wacom_wac->shared->is_touch_on) {
   2454 		if (!wacom_wac->shared->touch_down)
   2455 			return;
   2456 		prox = 0;
   2457 	}
   2458 
   2459 	wacom_wac->hid_data.num_received++;
   2460 	if (wacom_wac->hid_data.num_received > wacom_wac->hid_data.num_expected)
   2461 		return;
   2462 
   2463 	if (mt) {
   2464 		int slot;
   2465 
   2466 		slot = input_mt_get_slot_by_key(input, hid_data->id);
   2467 		input_mt_slot(input, slot);
   2468 		input_mt_report_slot_state(input, MT_TOOL_FINGER, prox);
   2469 	}
   2470 	else {
   2471 		input_report_key(input, BTN_TOUCH, prox);
   2472 	}
   2473 
   2474 	if (prox) {
   2475 		input_report_abs(input, mt ? ABS_MT_POSITION_X : ABS_X,
   2476 				 hid_data->x);
   2477 		input_report_abs(input, mt ? ABS_MT_POSITION_Y : ABS_Y,
   2478 				 hid_data->y);
   2479 
   2480 		if (test_bit(ABS_MT_TOUCH_MAJOR, input->absbit)) {
   2481 			input_report_abs(input, ABS_MT_TOUCH_MAJOR, max(hid_data->width, hid_data->height));
   2482 			input_report_abs(input, ABS_MT_TOUCH_MINOR, min(hid_data->width, hid_data->height));
   2483 			if (hid_data->width != hid_data->height)
   2484 				input_report_abs(input, ABS_MT_ORIENTATION, hid_data->width <= hid_data->height ? 0 : 1);
   2485 		}
   2486 	}
   2487 }
   2488 
   2489 static void wacom_wac_finger_event(struct hid_device *hdev,
   2490 		struct hid_field *field, struct hid_usage *usage, __s32 value)
   2491 {
   2492 	struct wacom *wacom = hid_get_drvdata(hdev);
   2493 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2494 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
   2495 
   2496 	switch (equivalent_usage) {
   2497 	case HID_GD_X:
   2498 		wacom_wac->hid_data.x = value;
   2499 		break;
   2500 	case HID_GD_Y:
   2501 		wacom_wac->hid_data.y = value;
   2502 		break;
   2503 	case HID_DG_WIDTH:
   2504 		wacom_wac->hid_data.width = value;
   2505 		break;
   2506 	case HID_DG_HEIGHT:
   2507 		wacom_wac->hid_data.height = value;
   2508 		break;
   2509 	case HID_DG_CONTACTID:
   2510 		wacom_wac->hid_data.id = value;
   2511 		break;
   2512 	case HID_DG_TIPSWITCH:
   2513 		wacom_wac->hid_data.tipswitch = value;
   2514 		break;
   2515 	}
   2516 
   2517 
   2518 	if (usage->usage_index + 1 == field->report_count) {
   2519 		if (equivalent_usage == wacom_wac->hid_data.last_slot_field)
   2520 			wacom_wac_finger_slot(wacom_wac, wacom_wac->touch_input);
   2521 	}
   2522 }
   2523 
   2524 static void wacom_wac_finger_pre_report(struct hid_device *hdev,
   2525 		struct hid_report *report)
   2526 {
   2527 	struct wacom *wacom = hid_get_drvdata(hdev);
   2528 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2529 	struct hid_data* hid_data = &wacom_wac->hid_data;
   2530 	int i;
   2531 
   2532 	for (i = 0; i < report->maxfield; i++) {
   2533 		struct hid_field *field = report->field[i];
   2534 		int j;
   2535 
   2536 		for (j = 0; j < field->maxusage; j++) {
   2537 			struct hid_usage *usage = &field->usage[j];
   2538 			unsigned int equivalent_usage =
   2539 				wacom_equivalent_usage(usage->hid);
   2540 
   2541 			switch (equivalent_usage) {
   2542 			case HID_GD_X:
   2543 			case HID_GD_Y:
   2544 			case HID_DG_WIDTH:
   2545 			case HID_DG_HEIGHT:
   2546 			case HID_DG_CONTACTID:
   2547 			case HID_DG_INRANGE:
   2548 			case HID_DG_INVERT:
   2549 			case HID_DG_TIPSWITCH:
   2550 				hid_data->last_slot_field = equivalent_usage;
   2551 				break;
   2552 			case HID_DG_CONTACTCOUNT:
   2553 				hid_data->cc_report = report->id;
   2554 				hid_data->cc_index = i;
   2555 				hid_data->cc_value_index = j;
   2556 				break;
   2557 			}
   2558 		}
   2559 	}
   2560 
   2561 	if (hid_data->cc_report != 0 &&
   2562 	    hid_data->cc_index >= 0) {
   2563 		struct hid_field *field = report->field[hid_data->cc_index];
   2564 		int value = field->value[hid_data->cc_value_index];
   2565 		if (value)
   2566 			hid_data->num_expected = value;
   2567 	}
   2568 	else {
   2569 		hid_data->num_expected = wacom_wac->features.touch_max;
   2570 	}
   2571 }
   2572 
   2573 static void wacom_wac_finger_report(struct hid_device *hdev,
   2574 		struct hid_report *report)
   2575 {
   2576 	struct wacom *wacom = hid_get_drvdata(hdev);
   2577 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2578 	struct input_dev *input = wacom_wac->touch_input;
   2579 	unsigned touch_max = wacom_wac->features.touch_max;
   2580 
   2581 	/* If more packets of data are expected, give us a chance to
   2582 	 * process them rather than immediately syncing a partial
   2583 	 * update.
   2584 	 */
   2585 	if (wacom_wac->hid_data.num_received < wacom_wac->hid_data.num_expected)
   2586 		return;
   2587 
   2588 	if (touch_max > 1)
   2589 		input_mt_sync_frame(input);
   2590 
   2591 	input_sync(input);
   2592 	wacom_wac->hid_data.num_received = 0;
   2593 
   2594 	/* keep touch state for pen event */
   2595 	wacom_wac->shared->touch_down = wacom_wac_finger_count_touches(wacom_wac);
   2596 }
   2597 
   2598 void wacom_wac_usage_mapping(struct hid_device *hdev,
   2599 		struct hid_field *field, struct hid_usage *usage)
   2600 {
   2601 	struct wacom *wacom = hid_get_drvdata(hdev);
   2602 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2603 	struct wacom_features *features = &wacom_wac->features;
   2604 
   2605 	if (WACOM_DIRECT_DEVICE(field))
   2606 		features->device_type |= WACOM_DEVICETYPE_DIRECT;
   2607 
   2608 	/* usage tests must precede field tests */
   2609 	if (WACOM_BATTERY_USAGE(usage))
   2610 		wacom_wac_battery_usage_mapping(hdev, field, usage);
   2611 	else if (WACOM_PAD_FIELD(field))
   2612 		wacom_wac_pad_usage_mapping(hdev, field, usage);
   2613 	else if (WACOM_PEN_FIELD(field))
   2614 		wacom_wac_pen_usage_mapping(hdev, field, usage);
   2615 	else if (WACOM_FINGER_FIELD(field))
   2616 		wacom_wac_finger_usage_mapping(hdev, field, usage);
   2617 }
   2618 
   2619 void wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
   2620 		struct hid_usage *usage, __s32 value)
   2621 {
   2622 	struct wacom *wacom = hid_get_drvdata(hdev);
   2623 
   2624 	if (wacom->wacom_wac.features.type != HID_GENERIC)
   2625 		return;
   2626 
   2627 	if (value > field->logical_maximum || value < field->logical_minimum)
   2628 		return;
   2629 
   2630 	/* usage tests must precede field tests */
   2631 	if (WACOM_BATTERY_USAGE(usage))
   2632 		wacom_wac_battery_event(hdev, field, usage, value);
   2633 	else if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
   2634 		wacom_wac_pad_event(hdev, field, usage, value);
   2635 	else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
   2636 		wacom_wac_pen_event(hdev, field, usage, value);
   2637 	else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
   2638 		wacom_wac_finger_event(hdev, field, usage, value);
   2639 }
   2640 
   2641 static void wacom_report_events(struct hid_device *hdev,
   2642 				struct hid_report *report, int collection_index,
   2643 				int field_index)
   2644 {
   2645 	int r;
   2646 
   2647 	for (r = field_index; r < report->maxfield; r++) {
   2648 		struct hid_field *field;
   2649 		unsigned count, n;
   2650 
   2651 		field = report->field[r];
   2652 		count = field->report_count;
   2653 
   2654 		if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
   2655 			continue;
   2656 
   2657 		for (n = 0 ; n < count; n++) {
   2658 			if (field->usage[n].collection_index == collection_index)
   2659 				wacom_wac_event(hdev, field, &field->usage[n],
   2660 						field->value[n]);
   2661 			else
   2662 				return;
   2663 		}
   2664 	}
   2665 }
   2666 
   2667 static int wacom_wac_collection(struct hid_device *hdev, struct hid_report *report,
   2668 			 int collection_index, struct hid_field *field,
   2669 			 int field_index)
   2670 {
   2671 	struct wacom *wacom = hid_get_drvdata(hdev);
   2672 
   2673 	wacom_report_events(hdev, report, collection_index, field_index);
   2674 
   2675 	/*
   2676 	 * Non-input reports may be sent prior to the device being
   2677 	 * completely initialized. Since only their events need
   2678 	 * to be processed, exit after 'wacom_report_events' has
   2679 	 * been called to prevent potential crashes in the report-
   2680 	 * processing functions.
   2681 	 */
   2682 	if (report->type != HID_INPUT_REPORT)
   2683 		return -1;
   2684 
   2685 	if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
   2686 		wacom_wac_pad_report(hdev, report, field);
   2687 	else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
   2688 		wacom_wac_pen_report(hdev, report);
   2689 	else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
   2690 		wacom_wac_finger_report(hdev, report);
   2691 
   2692 	return 0;
   2693 }
   2694 
   2695 void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
   2696 {
   2697 	struct wacom *wacom = hid_get_drvdata(hdev);
   2698 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   2699 	struct hid_field *field;
   2700 	bool pad_in_hid_field = false, pen_in_hid_field = false,
   2701 		finger_in_hid_field = false;
   2702 	int r;
   2703 	int prev_collection = -1;
   2704 
   2705 	if (wacom_wac->features.type != HID_GENERIC)
   2706 		return;
   2707 
   2708 	for (r = 0; r < report->maxfield; r++) {
   2709 		field = report->field[r];
   2710 
   2711 		if (WACOM_PAD_FIELD(field))
   2712 			pad_in_hid_field = true;
   2713 		if (WACOM_PEN_FIELD(field))
   2714 			pen_in_hid_field = true;
   2715 		if (WACOM_FINGER_FIELD(field))
   2716 			finger_in_hid_field = true;
   2717 	}
   2718 
   2719 	wacom_wac_battery_pre_report(hdev, report);
   2720 
   2721 	if (pad_in_hid_field && wacom->wacom_wac.pad_input)
   2722 		wacom_wac_pad_pre_report(hdev, report);
   2723 	if (pen_in_hid_field && wacom->wacom_wac.pen_input)
   2724 		wacom_wac_pen_pre_report(hdev, report);
   2725 	if (finger_in_hid_field && wacom->wacom_wac.touch_input)
   2726 		wacom_wac_finger_pre_report(hdev, report);
   2727 
   2728 	for (r = 0; r < report->maxfield; r++) {
   2729 		field = report->field[r];
   2730 
   2731 		if (field->usage[0].collection_index != prev_collection) {
   2732 			if (wacom_wac_collection(hdev, report,
   2733 				field->usage[0].collection_index, field, r) < 0)
   2734 				return;
   2735 			prev_collection = field->usage[0].collection_index;
   2736 		}
   2737 	}
   2738 
   2739 	wacom_wac_battery_report(hdev, report);
   2740 }
   2741 
   2742 static int wacom_bpt_touch(struct wacom_wac *wacom)
   2743 {
   2744 	struct wacom_features *features = &wacom->features;
   2745 	struct input_dev *input = wacom->touch_input;
   2746 	struct input_dev *pad_input = wacom->pad_input;
   2747 	unsigned char *data = wacom->data;
   2748 	int i;
   2749 
   2750 	if (data[0] != 0x02)
   2751 	    return 0;
   2752 
   2753 	for (i = 0; i < 2; i++) {
   2754 		int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
   2755 		bool touch = report_touch_events(wacom)
   2756 			   && (data[offset + 3] & 0x80);
   2757 
   2758 		input_mt_slot(input, i);
   2759 		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
   2760 		if (touch) {
   2761 			int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
   2762 			int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
   2763 			if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
   2764 				x <<= 5;
   2765 				y <<= 5;
   2766 			}
   2767 			input_report_abs(input, ABS_MT_POSITION_X, x);
   2768 			input_report_abs(input, ABS_MT_POSITION_Y, y);
   2769 		}
   2770 	}
   2771 
   2772 	input_mt_sync_frame(input);
   2773 
   2774 	input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
   2775 	input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
   2776 	input_report_key(pad_input, BTN_BACK, (data[1] & 0x02) != 0);
   2777 	input_report_key(pad_input, BTN_RIGHT, (data[1] & 0x01) != 0);
   2778 	wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
   2779 
   2780 	return 1;
   2781 }
   2782 
   2783 static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
   2784 {
   2785 	struct wacom_features *features = &wacom->features;
   2786 	struct input_dev *input = wacom->touch_input;
   2787 	bool touch = data[1] & 0x80;
   2788 	int slot = input_mt_get_slot_by_key(input, data[0]);
   2789 
   2790 	if (slot < 0)
   2791 		return;
   2792 
   2793 	touch = touch && report_touch_events(wacom);
   2794 
   2795 	input_mt_slot(input, slot);
   2796 	input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
   2797 
   2798 	if (touch) {
   2799 		int x = (data[2] << 4) | (data[4] >> 4);
   2800 		int y = (data[3] << 4) | (data[4] & 0x0f);
   2801 		int width, height;
   2802 
   2803 		if (features->type >= INTUOSPS && features->type <= INTUOSHT2) {
   2804 			width  = data[5] * 100;
   2805 			height = data[6] * 100;
   2806 		} else {
   2807 			/*
   2808 			 * "a" is a scaled-down area which we assume is
   2809 			 * roughly circular and which can be described as:
   2810 			 * a=(pi*r^2)/C.
   2811 			 */
   2812 			int a = data[5];
   2813 			int x_res = input_abs_get_res(input, ABS_MT_POSITION_X);
   2814 			int y_res = input_abs_get_res(input, ABS_MT_POSITION_Y);
   2815 			width = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
   2816 			height = width * y_res / x_res;
   2817 		}
   2818 
   2819 		input_report_abs(input, ABS_MT_POSITION_X, x);
   2820 		input_report_abs(input, ABS_MT_POSITION_Y, y);
   2821 		input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
   2822 		input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
   2823 	}
   2824 }
   2825 
   2826 static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
   2827 {
   2828 	struct input_dev *input = wacom->pad_input;
   2829 	struct wacom_features *features = &wacom->features;
   2830 
   2831 	if (features->type == INTUOSHT || features->type == INTUOSHT2) {
   2832 		input_report_key(input, BTN_LEFT, (data[1] & 0x02) != 0);
   2833 		input_report_key(input, BTN_BACK, (data[1] & 0x08) != 0);
   2834 	} else {
   2835 		input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
   2836 		input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
   2837 	}
   2838 	input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
   2839 	input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
   2840 }
   2841 
   2842 static int wacom_bpt3_touch(struct wacom_wac *wacom)
   2843 {
   2844 	unsigned char *data = wacom->data;
   2845 	int count = data[1] & 0x07;
   2846 	int  touch_changed = 0, i;
   2847 
   2848 	if (data[0] != 0x02)
   2849 	    return 0;
   2850 
   2851 	/* data has up to 7 fixed sized 8-byte messages starting at data[2] */
   2852 	for (i = 0; i < count; i++) {
   2853 		int offset = (8 * i) + 2;
   2854 		int msg_id = data[offset];
   2855 
   2856 		if (msg_id >= 2 && msg_id <= 17) {
   2857 			wacom_bpt3_touch_msg(wacom, data + offset);
   2858 			touch_changed++;
   2859 		} else if (msg_id == 128)
   2860 			wacom_bpt3_button_msg(wacom, data + offset);
   2861 
   2862 	}
   2863 
   2864 	/* only update touch if we actually have a touchpad and touch data changed */
   2865 	if (wacom->touch_input && touch_changed) {
   2866 		input_mt_sync_frame(wacom->touch_input);
   2867 		wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
   2868 	}
   2869 
   2870 	return 1;
   2871 }
   2872 
   2873 static int wacom_bpt_pen(struct wacom_wac *wacom)
   2874 {
   2875 	struct wacom_features *features = &wacom->features;
   2876 	struct input_dev *input = wacom->pen_input;
   2877 	unsigned char *data = wacom->data;
   2878 	int x = 0, y = 0, p = 0, d = 0;
   2879 	bool pen = false, btn1 = false, btn2 = false;
   2880 	bool range, prox, rdy;
   2881 
   2882 	if (data[0] != WACOM_REPORT_PENABLED)
   2883 	    return 0;
   2884 
   2885 	range = (data[1] & 0x80) == 0x80;
   2886 	prox = (data[1] & 0x40) == 0x40;
   2887 	rdy = (data[1] & 0x20) == 0x20;
   2888 
   2889 	wacom->shared->stylus_in_proximity = range;
   2890 	if (delay_pen_events(wacom))
   2891 		return 0;
   2892 
   2893 	if (rdy) {
   2894 		p = le16_to_cpup((__le16 *)&data[6]);
   2895 		pen = data[1] & 0x01;
   2896 		btn1 = data[1] & 0x02;
   2897 		btn2 = data[1] & 0x04;
   2898 	}
   2899 	if (prox) {
   2900 		x = le16_to_cpup((__le16 *)&data[2]);
   2901 		y = le16_to_cpup((__le16 *)&data[4]);
   2902 
   2903 		if (data[1] & 0x08) {
   2904 			wacom->tool[0] = BTN_TOOL_RUBBER;
   2905 			wacom->id[0] = ERASER_DEVICE_ID;
   2906 		} else {
   2907 			wacom->tool[0] = BTN_TOOL_PEN;
   2908 			wacom->id[0] = STYLUS_DEVICE_ID;
   2909 		}
   2910 		wacom->reporting_data = true;
   2911 	}
   2912 	if (range) {
   2913 		/*
   2914 		 * Convert distance from out prox to distance from tablet.
   2915 		 * distance will be greater than distance_max once
   2916 		 * touching and applying pressure; do not report negative
   2917 		 * distance.
   2918 		 */
   2919 		if (data[8] <= features->distance_max)
   2920 			d = features->distance_max - data[8];
   2921 	} else {
   2922 		wacom->id[0] = 0;
   2923 	}
   2924 
   2925 	if (wacom->reporting_data) {
   2926 		input_report_key(input, BTN_TOUCH, pen);
   2927 		input_report_key(input, BTN_STYLUS, btn1);
   2928 		input_report_key(input, BTN_STYLUS2, btn2);
   2929 
   2930 		if (prox || !range) {
   2931 			input_report_abs(input, ABS_X, x);
   2932 			input_report_abs(input, ABS_Y, y);
   2933 		}
   2934 		input_report_abs(input, ABS_PRESSURE, p);
   2935 		input_report_abs(input, ABS_DISTANCE, d);
   2936 
   2937 		input_report_key(input, wacom->tool[0], range); /* PEN or RUBBER */
   2938 		input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
   2939 	}
   2940 
   2941 	if (!range) {
   2942 		wacom->reporting_data = false;
   2943 	}
   2944 
   2945 	return 1;
   2946 }
   2947 
   2948 static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
   2949 {
   2950 	struct wacom_features *features = &wacom->features;
   2951 
   2952 	if ((features->type == INTUOSHT2) &&
   2953 	    (features->device_type & WACOM_DEVICETYPE_PEN))
   2954 		return wacom_intuos_irq(wacom);
   2955 	else if (len == WACOM_PKGLEN_BBTOUCH)
   2956 		return wacom_bpt_touch(wacom);
   2957 	else if (len == WACOM_PKGLEN_BBTOUCH3)
   2958 		return wacom_bpt3_touch(wacom);
   2959 	else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
   2960 		return wacom_bpt_pen(wacom);
   2961 
   2962 	return 0;
   2963 }
   2964 
   2965 static void wacom_bamboo_pad_pen_event(struct wacom_wac *wacom,
   2966 		unsigned char *data)
   2967 {
   2968 	unsigned char prefix;
   2969 
   2970 	/*
   2971 	 * We need to reroute the event from the debug interface to the
   2972 	 * pen interface.
   2973 	 * We need to add the report ID to the actual pen report, so we
   2974 	 * temporary overwrite the first byte to prevent having to kzalloc/kfree
   2975 	 * and memcpy the report.
   2976 	 */
   2977 	prefix = data[0];
   2978 	data[0] = WACOM_REPORT_BPAD_PEN;
   2979 
   2980 	/*
   2981 	 * actually reroute the event.
   2982 	 * No need to check if wacom->shared->pen is valid, hid_input_report()
   2983 	 * will check for us.
   2984 	 */
   2985 	hid_input_report(wacom->shared->pen, HID_INPUT_REPORT, data,
   2986 			 WACOM_PKGLEN_PENABLED, 1);
   2987 
   2988 	data[0] = prefix;
   2989 }
   2990 
   2991 static int wacom_bamboo_pad_touch_event(struct wacom_wac *wacom,
   2992 		unsigned char *data)
   2993 {
   2994 	struct input_dev *input = wacom->touch_input;
   2995 	unsigned char *finger_data, prefix;
   2996 	unsigned id;
   2997 	int x, y;
   2998 	bool valid;
   2999 
   3000 	prefix = data[0];
   3001 
   3002 	for (id = 0; id < wacom->features.touch_max; id++) {
   3003 		valid = !!(prefix & BIT(id)) &&
   3004 			report_touch_events(wacom);
   3005 
   3006 		input_mt_slot(input, id);
   3007 		input_mt_report_slot_state(input, MT_TOOL_FINGER, valid);
   3008 
   3009 		if (!valid)
   3010 			continue;
   3011 
   3012 		finger_data = data + 1 + id * 3;
   3013 		x = finger_data[0] | ((finger_data[1] & 0x0f) << 8);
   3014 		y = (finger_data[2] << 4) | (finger_data[1] >> 4);
   3015 
   3016 		input_report_abs(input, ABS_MT_POSITION_X, x);
   3017 		input_report_abs(input, ABS_MT_POSITION_Y, y);
   3018 	}
   3019 
   3020 	input_mt_sync_frame(input);
   3021 
   3022 	input_report_key(input, BTN_LEFT, prefix & 0x40);
   3023 	input_report_key(input, BTN_RIGHT, prefix & 0x80);
   3024 
   3025 	/* keep touch state for pen event */
   3026 	wacom->shared->touch_down = !!prefix && report_touch_events(wacom);
   3027 
   3028 	return 1;
   3029 }
   3030 
   3031 static int wacom_bamboo_pad_irq(struct wacom_wac *wacom, size_t len)
   3032 {
   3033 	unsigned char *data = wacom->data;
   3034 
   3035 	if (!((len == WACOM_PKGLEN_BPAD_TOUCH) ||
   3036 	      (len == WACOM_PKGLEN_BPAD_TOUCH_USB)) ||
   3037 	    (data[0] != WACOM_REPORT_BPAD_TOUCH))
   3038 		return 0;
   3039 
   3040 	if (data[1] & 0x01)
   3041 		wacom_bamboo_pad_pen_event(wacom, &data[1]);
   3042 
   3043 	if (data[1] & 0x02)
   3044 		return wacom_bamboo_pad_touch_event(wacom, &data[9]);
   3045 
   3046 	return 0;
   3047 }
   3048 
   3049 static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
   3050 {
   3051 	unsigned char *data = wacom->data;
   3052 	int connected;
   3053 
   3054 	if (len != WACOM_PKGLEN_WIRELESS || data[0] != WACOM_REPORT_WL)
   3055 		return 0;
   3056 
   3057 	connected = data[1] & 0x01;
   3058 	if (connected) {
   3059 		int pid, battery, charging;
   3060 
   3061 		if ((wacom->shared->type == INTUOSHT ||
   3062 		    wacom->shared->type == INTUOSHT2) &&
   3063 		    wacom->shared->touch_input &&
   3064 		    wacom->shared->touch_max) {
   3065 			input_report_switch(wacom->shared->touch_input,
   3066 					SW_MUTE_DEVICE, data[5] & 0x40);
   3067 			input_sync(wacom->shared->touch_input);
   3068 		}
   3069 
   3070 		pid = get_unaligned_be16(&data[6]);
   3071 		battery = (data[5] & 0x3f) * 100 / 31;
   3072 		charging = !!(data[5] & 0x80);
   3073 		if (wacom->pid != pid) {
   3074 			wacom->pid = pid;
   3075 			wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
   3076 		}
   3077 
   3078 		wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
   3079 				     battery, charging, 1, 0);
   3080 
   3081 	} else if (wacom->pid != 0) {
   3082 		/* disconnected while previously connected */
   3083 		wacom->pid = 0;
   3084 		wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
   3085 		wacom_notify_battery(wacom, POWER_SUPPLY_STATUS_UNKNOWN, 0, 0, 0, 0);
   3086 	}
   3087 
   3088 	return 0;
   3089 }
   3090 
   3091 static int wacom_status_irq(struct wacom_wac *wacom_wac, size_t len)
   3092 {
   3093 	struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
   3094 	struct wacom_features *features = &wacom_wac->features;
   3095 	unsigned char *data = wacom_wac->data;
   3096 
   3097 	if (data[0] != WACOM_REPORT_USB)
   3098 		return 0;
   3099 
   3100 	if ((features->type == INTUOSHT ||
   3101 	    features->type == INTUOSHT2) &&
   3102 	    wacom_wac->shared->touch_input &&
   3103 	    features->touch_max) {
   3104 		input_report_switch(wacom_wac->shared->touch_input,
   3105 				    SW_MUTE_DEVICE, data[8] & 0x40);
   3106 		input_sync(wacom_wac->shared->touch_input);
   3107 	}
   3108 
   3109 	if (data[9] & 0x02) { /* wireless module is attached */
   3110 		int battery = (data[8] & 0x3f) * 100 / 31;
   3111 		bool charging = !!(data[8] & 0x80);
   3112 
   3113 		wacom_notify_battery(wacom_wac, WACOM_POWER_SUPPLY_STATUS_AUTO,
   3114 				     battery, charging, battery || charging, 1);
   3115 
   3116 		if (!wacom->battery.battery &&
   3117 		    !(features->quirks & WACOM_QUIRK_BATTERY)) {
   3118 			features->quirks |= WACOM_QUIRK_BATTERY;
   3119 			wacom_schedule_work(wacom_wac, WACOM_WORKER_BATTERY);
   3120 		}
   3121 	}
   3122 	else if ((features->quirks & WACOM_QUIRK_BATTERY) &&
   3123 		 wacom->battery.battery) {
   3124 		features->quirks &= ~WACOM_QUIRK_BATTERY;
   3125 		wacom_schedule_work(wacom_wac, WACOM_WORKER_BATTERY);
   3126 		wacom_notify_battery(wacom_wac, POWER_SUPPLY_STATUS_UNKNOWN, 0, 0, 0, 0);
   3127 	}
   3128 	return 0;
   3129 }
   3130 
   3131 void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
   3132 {
   3133 	bool sync;
   3134 
   3135 	switch (wacom_wac->features.type) {
   3136 	case PENPARTNER:
   3137 		sync = wacom_penpartner_irq(wacom_wac);
   3138 		break;
   3139 
   3140 	case PL:
   3141 		sync = wacom_pl_irq(wacom_wac);
   3142 		break;
   3143 
   3144 	case WACOM_G4:
   3145 	case GRAPHIRE:
   3146 	case GRAPHIRE_BT:
   3147 	case WACOM_MO:
   3148 		sync = wacom_graphire_irq(wacom_wac);
   3149 		break;
   3150 
   3151 	case PTU:
   3152 		sync = wacom_ptu_irq(wacom_wac);
   3153 		break;
   3154 
   3155 	case DTU:
   3156 		sync = wacom_dtu_irq(wacom_wac);
   3157 		break;
   3158 
   3159 	case DTUS:
   3160 	case DTUSX:
   3161 		sync = wacom_dtus_irq(wacom_wac);
   3162 		break;
   3163 
   3164 	case INTUOS:
   3165 	case INTUOS3S:
   3166 	case INTUOS3:
   3167 	case INTUOS3L:
   3168 	case INTUOS4S:
   3169 	case INTUOS4:
   3170 	case INTUOS4L:
   3171 	case CINTIQ:
   3172 	case WACOM_BEE:
   3173 	case WACOM_13HD:
   3174 	case WACOM_21UX2:
   3175 	case WACOM_22HD:
   3176 	case WACOM_24HD:
   3177 	case WACOM_27QHD:
   3178 	case DTK:
   3179 	case CINTIQ_HYBRID:
   3180 	case CINTIQ_COMPANION_2:
   3181 		sync = wacom_intuos_irq(wacom_wac);
   3182 		break;
   3183 
   3184 	case INTUOS4WL:
   3185 		sync = wacom_intuos_bt_irq(wacom_wac, len);
   3186 		break;
   3187 
   3188 	case WACOM_24HDT:
   3189 	case WACOM_27QHDT:
   3190 		sync = wacom_24hdt_irq(wacom_wac);
   3191 		break;
   3192 
   3193 	case INTUOS5S:
   3194 	case INTUOS5:
   3195 	case INTUOS5L:
   3196 	case INTUOSPS:
   3197 	case INTUOSPM:
   3198 	case INTUOSPL:
   3199 		if (len == WACOM_PKGLEN_BBTOUCH3)
   3200 			sync = wacom_bpt3_touch(wacom_wac);
   3201 		else if (wacom_wac->data[0] == WACOM_REPORT_USB)
   3202 			sync = wacom_status_irq(wacom_wac, len);
   3203 		else
   3204 			sync = wacom_intuos_irq(wacom_wac);
   3205 		break;
   3206 
   3207 	case INTUOSP2_BT:
   3208 	case INTUOSHT3_BT:
   3209 		sync = wacom_intuos_pro2_bt_irq(wacom_wac, len);
   3210 		break;
   3211 
   3212 	case TABLETPC:
   3213 	case TABLETPCE:
   3214 	case TABLETPC2FG:
   3215 	case MTSCREEN:
   3216 	case MTTPC:
   3217 	case MTTPC_B:
   3218 		sync = wacom_tpc_irq(wacom_wac, len);
   3219 		break;
   3220 
   3221 	case BAMBOO_PT:
   3222 	case BAMBOO_PEN:
   3223 	case BAMBOO_TOUCH:
   3224 	case INTUOSHT:
   3225 	case INTUOSHT2:
   3226 		if (wacom_wac->data[0] == WACOM_REPORT_USB)
   3227 			sync = wacom_status_irq(wacom_wac, len);
   3228 		else
   3229 			sync = wacom_bpt_irq(wacom_wac, len);
   3230 		break;
   3231 
   3232 	case BAMBOO_PAD:
   3233 		sync = wacom_bamboo_pad_irq(wacom_wac, len);
   3234 		break;
   3235 
   3236 	case WIRELESS:
   3237 		sync = wacom_wireless_irq(wacom_wac, len);
   3238 		break;
   3239 
   3240 	case REMOTE:
   3241 		sync = false;
   3242 		if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
   3243 			wacom_remote_status_irq(wacom_wac, len);
   3244 		else
   3245 			sync = wacom_remote_irq(wacom_wac, len);
   3246 		break;
   3247 
   3248 	default:
   3249 		sync = false;
   3250 		break;
   3251 	}
   3252 
   3253 	if (sync) {
   3254 		if (wacom_wac->pen_input)
   3255 			input_sync(wacom_wac->pen_input);
   3256 		if (wacom_wac->touch_input)
   3257 			input_sync(wacom_wac->touch_input);
   3258 		if (wacom_wac->pad_input)
   3259 			input_sync(wacom_wac->pad_input);
   3260 	}
   3261 }
   3262 
   3263 static void wacom_setup_basic_pro_pen(struct wacom_wac *wacom_wac)
   3264 {
   3265 	struct input_dev *input_dev = wacom_wac->pen_input;
   3266 
   3267 	input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
   3268 
   3269 	__set_bit(BTN_TOOL_PEN, input_dev->keybit);
   3270 	__set_bit(BTN_STYLUS, input_dev->keybit);
   3271 	__set_bit(BTN_STYLUS2, input_dev->keybit);
   3272 
   3273 	input_set_abs_params(input_dev, ABS_DISTANCE,
   3274 			     0, wacom_wac->features.distance_max, wacom_wac->features.distance_fuzz, 0);
   3275 }
   3276 
   3277 static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
   3278 {
   3279 	struct input_dev *input_dev = wacom_wac->pen_input;
   3280 	struct wacom_features *features = &wacom_wac->features;
   3281 
   3282 	wacom_setup_basic_pro_pen(wacom_wac);
   3283 
   3284 	__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
   3285 	__set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
   3286 	__set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
   3287 	__set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
   3288 
   3289 	input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
   3290 	input_set_abs_params(input_dev, ABS_TILT_X, -64, 63, features->tilt_fuzz, 0);
   3291 	input_abs_set_res(input_dev, ABS_TILT_X, 57);
   3292 	input_set_abs_params(input_dev, ABS_TILT_Y, -64, 63, features->tilt_fuzz, 0);
   3293 	input_abs_set_res(input_dev, ABS_TILT_Y, 57);
   3294 }
   3295 
   3296 static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
   3297 {
   3298 	struct input_dev *input_dev = wacom_wac->pen_input;
   3299 
   3300 	input_set_capability(input_dev, EV_REL, REL_WHEEL);
   3301 
   3302 	wacom_setup_cintiq(wacom_wac);
   3303 
   3304 	__set_bit(BTN_LEFT, input_dev->keybit);
   3305 	__set_bit(BTN_RIGHT, input_dev->keybit);
   3306 	__set_bit(BTN_MIDDLE, input_dev->keybit);
   3307 	__set_bit(BTN_SIDE, input_dev->keybit);
   3308 	__set_bit(BTN_EXTRA, input_dev->keybit);
   3309 	__set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
   3310 	__set_bit(BTN_TOOL_LENS, input_dev->keybit);
   3311 
   3312 	input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
   3313 	input_abs_set_res(input_dev, ABS_RZ, 287);
   3314 	input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
   3315 }
   3316 
   3317 void wacom_setup_device_quirks(struct wacom *wacom)
   3318 {
   3319 	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
   3320 	struct wacom_features *features = &wacom->wacom_wac.features;
   3321 
   3322 	/* The pen and pad share the same interface on most devices */
   3323 	if (features->type == GRAPHIRE_BT || features->type == WACOM_G4 ||
   3324 	    features->type == DTUS ||
   3325 	    (features->type >= INTUOS3S && features->type <= WACOM_MO)) {
   3326 		if (features->device_type & WACOM_DEVICETYPE_PEN)
   3327 			features->device_type |= WACOM_DEVICETYPE_PAD;
   3328 	}
   3329 
   3330 	/* touch device found but size is not defined. use default */
   3331 	if (features->device_type & WACOM_DEVICETYPE_TOUCH && !features->x_max) {
   3332 		features->x_max = 1023;
   3333 		features->y_max = 1023;
   3334 	}
   3335 
   3336 	/*
   3337 	 * Intuos5/Pro and Bamboo 3rd gen have no useful data about its
   3338 	 * touch interface in its HID descriptor. If this is the touch
   3339 	 * interface (PacketSize of WACOM_PKGLEN_BBTOUCH3), override the
   3340 	 * tablet values.
   3341 	 */
   3342 	if ((features->type >= INTUOS5S && features->type <= INTUOSPL) ||
   3343 		(features->type >= INTUOSHT && features->type <= BAMBOO_PT)) {
   3344 		if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
   3345 			if (features->touch_max)
   3346 				features->device_type |= WACOM_DEVICETYPE_TOUCH;
   3347 			if (features->type >= INTUOSHT && features->type <= BAMBOO_PT)
   3348 				features->device_type |= WACOM_DEVICETYPE_PAD;
   3349 
   3350 			if (features->type == INTUOSHT2) {
   3351 				features->x_max = features->x_max / 10;
   3352 				features->y_max = features->y_max / 10;
   3353 			}
   3354 			else {
   3355 				features->x_max = 4096;
   3356 				features->y_max = 4096;
   3357 			}
   3358 		}
   3359 		else if (features->pktlen == WACOM_PKGLEN_BBTOUCH) {
   3360 			features->device_type |= WACOM_DEVICETYPE_PAD;
   3361 		}
   3362 	}
   3363 
   3364 	/*
   3365 	 * Hack for the Bamboo One:
   3366 	 * the device presents a PAD/Touch interface as most Bamboos and even
   3367 	 * sends ghosts PAD data on it. However, later, we must disable this
   3368 	 * ghost interface, and we can not detect it unless we set it here
   3369 	 * to WACOM_DEVICETYPE_PAD or WACOM_DEVICETYPE_TOUCH.
   3370 	 */
   3371 	if (features->type == BAMBOO_PEN &&
   3372 	    features->pktlen == WACOM_PKGLEN_BBTOUCH3)
   3373 		features->device_type |= WACOM_DEVICETYPE_PAD;
   3374 
   3375 	/*
   3376 	 * Raw Wacom-mode pen and touch events both come from interface
   3377 	 * 0, whose HID descriptor has an application usage of 0xFF0D
   3378 	 * (i.e., WACOM_HID_WD_DIGITIZER). We route pen packets back
   3379 	 * out through the HID_GENERIC device created for interface 1,
   3380 	 * so rewrite this one to be of type WACOM_DEVICETYPE_TOUCH.
   3381 	 */
   3382 	if (features->type == BAMBOO_PAD)
   3383 		features->device_type = WACOM_DEVICETYPE_TOUCH;
   3384 
   3385 	if (features->type == REMOTE)
   3386 		features->device_type = WACOM_DEVICETYPE_PAD;
   3387 
   3388 	if (features->type == INTUOSP2_BT) {
   3389 		features->device_type |= WACOM_DEVICETYPE_PEN |
   3390 					 WACOM_DEVICETYPE_PAD |
   3391 					 WACOM_DEVICETYPE_TOUCH;
   3392 		features->quirks |= WACOM_QUIRK_BATTERY;
   3393 	}
   3394 
   3395 	if (features->type == INTUOSHT3_BT) {
   3396 		features->device_type |= WACOM_DEVICETYPE_PEN |
   3397 					 WACOM_DEVICETYPE_PAD;
   3398 		features->quirks |= WACOM_QUIRK_BATTERY;
   3399 	}
   3400 
   3401 	switch (features->type) {
   3402 	case PL:
   3403 	case DTU:
   3404 	case DTUS:
   3405 	case DTUSX:
   3406 	case WACOM_21UX2:
   3407 	case WACOM_22HD:
   3408 	case DTK:
   3409 	case WACOM_24HD:
   3410 	case WACOM_27QHD:
   3411 	case CINTIQ_HYBRID:
   3412 	case CINTIQ_COMPANION_2:
   3413 	case CINTIQ:
   3414 	case WACOM_BEE:
   3415 	case WACOM_13HD:
   3416 	case WACOM_24HDT:
   3417 	case WACOM_27QHDT:
   3418 	case TABLETPC:
   3419 	case TABLETPCE:
   3420 	case TABLETPC2FG:
   3421 	case MTSCREEN:
   3422 	case MTTPC:
   3423 	case MTTPC_B:
   3424 		features->device_type |= WACOM_DEVICETYPE_DIRECT;
   3425 		break;
   3426 	}
   3427 
   3428 	if (wacom->hdev->bus == BUS_BLUETOOTH)
   3429 		features->quirks |= WACOM_QUIRK_BATTERY;
   3430 
   3431 	/* quirk for bamboo touch with 2 low res touches */
   3432 	if ((features->type == BAMBOO_PT || features->type == BAMBOO_TOUCH) &&
   3433 	    features->pktlen == WACOM_PKGLEN_BBTOUCH) {
   3434 		features->x_max <<= 5;
   3435 		features->y_max <<= 5;
   3436 		features->x_fuzz <<= 5;
   3437 		features->y_fuzz <<= 5;
   3438 		features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
   3439 	}
   3440 
   3441 	if (features->type == WIRELESS) {
   3442 		if (features->device_type == WACOM_DEVICETYPE_WL_MONITOR) {
   3443 			features->quirks |= WACOM_QUIRK_BATTERY;
   3444 		}
   3445 	}
   3446 
   3447 	if (features->type == REMOTE)
   3448 		features->device_type |= WACOM_DEVICETYPE_WL_MONITOR;
   3449 
   3450 	/* HID descriptor for DTK-2451 / DTH-2452 claims to report lots
   3451 	 * of things it shouldn't. Lets fix up the damage...
   3452 	 */
   3453 	if (wacom->hdev->product == 0x382 || wacom->hdev->product == 0x37d) {
   3454 		features->quirks &= ~WACOM_QUIRK_TOOLSERIAL;
   3455 		__clear_bit(BTN_TOOL_BRUSH, wacom_wac->pen_input->keybit);
   3456 		__clear_bit(BTN_TOOL_PENCIL, wacom_wac->pen_input->keybit);
   3457 		__clear_bit(BTN_TOOL_AIRBRUSH, wacom_wac->pen_input->keybit);
   3458 		__clear_bit(ABS_Z, wacom_wac->pen_input->absbit);
   3459 		__clear_bit(ABS_DISTANCE, wacom_wac->pen_input->absbit);
   3460 		__clear_bit(ABS_TILT_X, wacom_wac->pen_input->absbit);
   3461 		__clear_bit(ABS_TILT_Y, wacom_wac->pen_input->absbit);
   3462 		__clear_bit(ABS_WHEEL, wacom_wac->pen_input->absbit);
   3463 		__clear_bit(ABS_MISC, wacom_wac->pen_input->absbit);
   3464 		__clear_bit(MSC_SERIAL, wacom_wac->pen_input->mscbit);
   3465 		__clear_bit(EV_MSC, wacom_wac->pen_input->evbit);
   3466 	}
   3467 }
   3468 
   3469 int wacom_setup_pen_input_capabilities(struct input_dev *input_dev,
   3470 				   struct wacom_wac *wacom_wac)
   3471 {
   3472 	struct wacom_features *features = &wacom_wac->features;
   3473 
   3474 	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
   3475 
   3476 	if (!(features->device_type & WACOM_DEVICETYPE_PEN))
   3477 		return -ENODEV;
   3478 
   3479 	if (features->device_type & WACOM_DEVICETYPE_DIRECT)
   3480 		__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
   3481 	else
   3482 		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
   3483 
   3484 	if (features->type == HID_GENERIC) {
   3485 		/* setup has already been done; apply otherwise-undetectible quirks */
   3486 		input_set_capability(input_dev, EV_KEY, BTN_STYLUS3);
   3487 		return 0;
   3488 	}
   3489 
   3490 	__set_bit(BTN_TOUCH, input_dev->keybit);
   3491 	__set_bit(ABS_MISC, input_dev->absbit);
   3492 
   3493 	input_set_abs_params(input_dev, ABS_X, 0 + features->offset_left,
   3494 			     features->x_max - features->offset_right,
   3495 			     features->x_fuzz, 0);
   3496 	input_set_abs_params(input_dev, ABS_Y, 0 + features->offset_top,
   3497 			     features->y_max - features->offset_bottom,
   3498 			     features->y_fuzz, 0);
   3499 	input_set_abs_params(input_dev, ABS_PRESSURE, 0,
   3500 		features->pressure_max, features->pressure_fuzz, 0);
   3501 
   3502 	/* penabled devices have fixed resolution for each model */
   3503 	input_abs_set_res(input_dev, ABS_X, features->x_resolution);
   3504 	input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
   3505 
   3506 	switch (features->type) {
   3507 	case GRAPHIRE_BT:
   3508 		__clear_bit(ABS_MISC, input_dev->absbit);
   3509 		/* fall through */
   3510 
   3511 	case WACOM_MO:
   3512 	case WACOM_G4:
   3513 		input_set_abs_params(input_dev, ABS_DISTANCE, 0,
   3514 					      features->distance_max,
   3515 					      features->distance_fuzz, 0);
   3516 		/* fall through */
   3517 
   3518 	case GRAPHIRE:
   3519 		input_set_capability(input_dev, EV_REL, REL_WHEEL);
   3520 
   3521 		__set_bit(BTN_LEFT, input_dev->keybit);
   3522 		__set_bit(BTN_RIGHT, input_dev->keybit);
   3523 		__set_bit(BTN_MIDDLE, input_dev->keybit);
   3524 
   3525 		__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
   3526 		__set_bit(BTN_TOOL_PEN, input_dev->keybit);
   3527 		__set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
   3528 		__set_bit(BTN_STYLUS, input_dev->keybit);
   3529 		__set_bit(BTN_STYLUS2, input_dev->keybit);
   3530 		break;
   3531 
   3532 	case WACOM_27QHD:
   3533 	case WACOM_24HD:
   3534 	case DTK:
   3535 	case WACOM_22HD:
   3536 	case WACOM_21UX2:
   3537 	case WACOM_BEE:
   3538 	case CINTIQ:
   3539 	case WACOM_13HD:
   3540 	case CINTIQ_HYBRID:
   3541 	case CINTIQ_COMPANION_2:
   3542 		input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
   3543 		input_abs_set_res(input_dev, ABS_Z, 287);
   3544 		wacom_setup_cintiq(wacom_wac);
   3545 		break;
   3546 
   3547 	case INTUOS3:
   3548 	case INTUOS3L:
   3549 	case INTUOS3S:
   3550 	case INTUOS4:
   3551 	case INTUOS4WL:
   3552 	case INTUOS4L:
   3553 	case INTUOS4S:
   3554 		input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
   3555 		input_abs_set_res(input_dev, ABS_Z, 287);
   3556 		/* fall through */
   3557 
   3558 	case INTUOS:
   3559 		wacom_setup_intuos(wacom_wac);
   3560 		break;
   3561 
   3562 	case INTUOS5:
   3563 	case INTUOS5L:
   3564 	case INTUOSPM:
   3565 	case INTUOSPL:
   3566 	case INTUOS5S:
   3567 	case INTUOSPS:
   3568 	case INTUOSP2_BT:
   3569 		input_set_abs_params(input_dev, ABS_DISTANCE, 0,
   3570 				      features->distance_max,
   3571 				      features->distance_fuzz, 0);
   3572 
   3573 		input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
   3574 		input_abs_set_res(input_dev, ABS_Z, 287);
   3575 
   3576 		wacom_setup_intuos(wacom_wac);
   3577 		break;
   3578 
   3579 	case WACOM_24HDT:
   3580 	case WACOM_27QHDT:
   3581 	case MTSCREEN:
   3582 	case MTTPC:
   3583 	case MTTPC_B:
   3584 	case TABLETPC2FG:
   3585 	case TABLETPC:
   3586 	case TABLETPCE:
   3587 		__clear_bit(ABS_MISC, input_dev->absbit);
   3588 		/* fall through */
   3589 
   3590 	case DTUS:
   3591 	case DTUSX:
   3592 	case PL:
   3593 	case DTU:
   3594 		__set_bit(BTN_TOOL_PEN, input_dev->keybit);
   3595 		__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
   3596 		__set_bit(BTN_STYLUS, input_dev->keybit);
   3597 		__set_bit(BTN_STYLUS2, input_dev->keybit);
   3598 		break;
   3599 
   3600 	case PTU:
   3601 		__set_bit(BTN_STYLUS2, input_dev->keybit);
   3602 		/* fall through */
   3603 
   3604 	case PENPARTNER:
   3605 		__set_bit(BTN_TOOL_PEN, input_dev->keybit);
   3606 		__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
   3607 		__set_bit(BTN_STYLUS, input_dev->keybit);
   3608 		break;
   3609 
   3610 	case INTUOSHT:
   3611 	case BAMBOO_PT:
   3612 	case BAMBOO_PEN:
   3613 	case INTUOSHT2:
   3614 	case INTUOSHT3_BT:
   3615 		if (features->type == INTUOSHT2 ||
   3616 		    features->type == INTUOSHT3_BT) {
   3617 			wacom_setup_basic_pro_pen(wacom_wac);
   3618 		} else {
   3619 			__clear_bit(ABS_MISC, input_dev->absbit);
   3620 			__set_bit(BTN_TOOL_PEN, input_dev->keybit);
   3621 			__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
   3622 			__set_bit(BTN_STYLUS, input_dev->keybit);
   3623 			__set_bit(BTN_STYLUS2, input_dev->keybit);
   3624 			input_set_abs_params(input_dev, ABS_DISTANCE, 0,
   3625 				      features->distance_max,
   3626 				      features->distance_fuzz, 0);
   3627 		}
   3628 		break;
   3629 	case BAMBOO_PAD:
   3630 		__clear_bit(ABS_MISC, input_dev->absbit);
   3631 		break;
   3632 	}
   3633 	return 0;
   3634 }
   3635 
   3636 int wacom_setup_touch_input_capabilities(struct input_dev *input_dev,
   3637 					 struct wacom_wac *wacom_wac)
   3638 {
   3639 	struct wacom_features *features = &wacom_wac->features;
   3640 
   3641 	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
   3642 
   3643 	if (!(features->device_type & WACOM_DEVICETYPE_TOUCH))
   3644 		return -ENODEV;
   3645 
   3646 	if (features->device_type & WACOM_DEVICETYPE_DIRECT)
   3647 		__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
   3648 	else
   3649 		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
   3650 
   3651 	if (features->type == HID_GENERIC)
   3652 		/* setup has already been done */
   3653 		return 0;
   3654 
   3655 	__set_bit(BTN_TOUCH, input_dev->keybit);
   3656 
   3657 	if (features->touch_max == 1) {
   3658 		input_set_abs_params(input_dev, ABS_X, 0,
   3659 			features->x_max, features->x_fuzz, 0);
   3660 		input_set_abs_params(input_dev, ABS_Y, 0,
   3661 			features->y_max, features->y_fuzz, 0);
   3662 		input_abs_set_res(input_dev, ABS_X,
   3663 				  features->x_resolution);
   3664 		input_abs_set_res(input_dev, ABS_Y,
   3665 				  features->y_resolution);
   3666 	}
   3667 	else if (features->touch_max > 1) {
   3668 		input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
   3669 			features->x_max, features->x_fuzz, 0);
   3670 		input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
   3671 			features->y_max, features->y_fuzz, 0);
   3672 		input_abs_set_res(input_dev, ABS_MT_POSITION_X,
   3673 				  features->x_resolution);
   3674 		input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
   3675 				  features->y_resolution);
   3676 	}
   3677 
   3678 	switch (features->type) {
   3679 	case INTUOSP2_BT:
   3680 		input_dev->evbit[0] |= BIT_MASK(EV_SW);
   3681 		__set_bit(SW_MUTE_DEVICE, input_dev->swbit);
   3682 
   3683 		if (wacom_wac->shared->touch->product == 0x361) {
   3684 			input_set_abs_params(input_dev, ABS_MT_POSITION_X,
   3685 					     0, 12440, 4, 0);
   3686 			input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
   3687 					     0, 8640, 4, 0);
   3688 		}
   3689 		else if (wacom_wac->shared->touch->product == 0x360) {
   3690 			input_set_abs_params(input_dev, ABS_MT_POSITION_X,
   3691 					     0, 8960, 4, 0);
   3692 			input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
   3693 					     0, 5920, 4, 0);
   3694 		}
   3695 		input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40);
   3696 		input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40);
   3697 
   3698 		/* fall through */
   3699 
   3700 	case INTUOS5:
   3701 	case INTUOS5L:
   3702 	case INTUOSPM:
   3703 	case INTUOSPL:
   3704 	case INTUOS5S:
   3705 	case INTUOSPS:
   3706 		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
   3707 		input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, features->y_max, 0, 0);
   3708 		input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
   3709 		break;
   3710 
   3711 	case WACOM_24HDT:
   3712 		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
   3713 		input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
   3714 		input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
   3715 		input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
   3716 		/* fall through */
   3717 
   3718 	case WACOM_27QHDT:
   3719 	case MTSCREEN:
   3720 	case MTTPC:
   3721 	case MTTPC_B:
   3722 	case TABLETPC2FG:
   3723 		input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_DIRECT);
   3724 		/*fall through */
   3725 
   3726 	case TABLETPC:
   3727 	case TABLETPCE:
   3728 		break;
   3729 
   3730 	case INTUOSHT:
   3731 	case INTUOSHT2:
   3732 		input_dev->evbit[0] |= BIT_MASK(EV_SW);
   3733 		__set_bit(SW_MUTE_DEVICE, input_dev->swbit);
   3734 		/* fall through */
   3735 
   3736 	case BAMBOO_PT:
   3737 	case BAMBOO_TOUCH:
   3738 		if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
   3739 			input_set_abs_params(input_dev,
   3740 				     ABS_MT_TOUCH_MAJOR,
   3741 				     0, features->x_max, 0, 0);
   3742 			input_set_abs_params(input_dev,
   3743 				     ABS_MT_TOUCH_MINOR,
   3744 				     0, features->y_max, 0, 0);
   3745 		}
   3746 		input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
   3747 		break;
   3748 
   3749 	case BAMBOO_PAD:
   3750 		input_mt_init_slots(input_dev, features->touch_max,
   3751 				    INPUT_MT_POINTER);
   3752 		__set_bit(BTN_LEFT, input_dev->keybit);
   3753 		__set_bit(BTN_RIGHT, input_dev->keybit);
   3754 		break;
   3755 	}
   3756 	return 0;
   3757 }
   3758 
   3759 static int wacom_numbered_button_to_key(int n)
   3760 {
   3761 	if (n < 10)
   3762 		return BTN_0 + n;
   3763 	else if (n < 16)
   3764 		return BTN_A + (n-10);
   3765 	else if (n < 18)
   3766 		return BTN_BASE + (n-16);
   3767 	else
   3768 		return 0;
   3769 }
   3770 
   3771 static void wacom_setup_numbered_buttons(struct input_dev *input_dev,
   3772 				int button_count)
   3773 {
   3774 	int i;
   3775 
   3776 	for (i = 0; i < button_count; i++) {
   3777 		int key = wacom_numbered_button_to_key(i);
   3778 
   3779 		if (key)
   3780 			__set_bit(key, input_dev->keybit);
   3781 	}
   3782 }
   3783 
   3784 static void wacom_24hd_update_leds(struct wacom *wacom, int mask, int group)
   3785 {
   3786 	struct wacom_led *led;
   3787 	int i;
   3788 	bool updated = false;
   3789 
   3790 	/*
   3791 	 * 24HD has LED group 1 to the left and LED group 0 to the right.
   3792 	 * So group 0 matches the second half of the buttons and thus the mask
   3793 	 * needs to be shifted.
   3794 	 */
   3795 	if (group == 0)
   3796 		mask >>= 8;
   3797 
   3798 	for (i = 0; i < 3; i++) {
   3799 		led = wacom_led_find(wacom, group, i);
   3800 		if (!led) {
   3801 			hid_err(wacom->hdev, "can't find LED %d in group %d\n",
   3802 				i, group);
   3803 			continue;
   3804 		}
   3805 		if (!updated && mask & BIT(i)) {
   3806 			led->held = true;
   3807 			led_trigger_event(&led->trigger, LED_FULL);
   3808 		} else {
   3809 			led->held = false;
   3810 		}
   3811 	}
   3812 }
   3813 
   3814 static bool wacom_is_led_toggled(struct wacom *wacom, int button_count,
   3815 				 int mask, int group)
   3816 {
   3817 	int button_per_group;
   3818 
   3819 	/*
   3820 	 * 21UX2 has LED group 1 to the left and LED group 0
   3821 	 * to the right. We need to reverse the group to match this
   3822 	 * historical behavior.
   3823 	 */
   3824 	if (wacom->wacom_wac.features.type == WACOM_21UX2)
   3825 		group = 1 - group;
   3826 
   3827 	button_per_group = button_count/wacom->led.count;
   3828 
   3829 	return mask & (1 << (group * button_per_group));
   3830 }
   3831 
   3832 static void wacom_update_led(struct wacom *wacom, int button_count, int mask,
   3833 			     int group)
   3834 {
   3835 	struct wacom_led *led, *next_led;
   3836 	int cur;
   3837 	bool pressed;
   3838 
   3839 	if (wacom->wacom_wac.features.type == WACOM_24HD)
   3840 		return wacom_24hd_update_leds(wacom, mask, group);
   3841 
   3842 	pressed = wacom_is_led_toggled(wacom, button_count, mask, group);
   3843 	cur = wacom->led.groups[group].select;
   3844 
   3845 	led = wacom_led_find(wacom, group, cur);
   3846 	if (!led) {
   3847 		hid_err(wacom->hdev, "can't find current LED %d in group %d\n",
   3848 			cur, group);
   3849 		return;
   3850 	}
   3851 
   3852 	if (!pressed) {
   3853 		led->held = false;
   3854 		return;
   3855 	}
   3856 
   3857 	if (led->held && pressed)
   3858 		return;
   3859 
   3860 	next_led = wacom_led_next(wacom, led);
   3861 	if (!next_led) {
   3862 		hid_err(wacom->hdev, "can't find next LED in group %d\n",
   3863 			group);
   3864 		return;
   3865 	}
   3866 	if (next_led == led)
   3867 		return;
   3868 
   3869 	next_led->held = true;
   3870 	led_trigger_event(&next_led->trigger,
   3871 			  wacom_leds_brightness_get(next_led));
   3872 }
   3873 
   3874 static void wacom_report_numbered_buttons(struct input_dev *input_dev,
   3875 				int button_count, int mask)
   3876 {
   3877 	struct wacom *wacom = input_get_drvdata(input_dev);
   3878 	int i;
   3879 
   3880 	for (i = 0; i < wacom->led.count; i++)
   3881 		wacom_update_led(wacom,  button_count, mask, i);
   3882 
   3883 	for (i = 0; i < button_count; i++) {
   3884 		int key = wacom_numbered_button_to_key(i);
   3885 
   3886 		if (key)
   3887 			input_report_key(input_dev, key, mask & (1 << i));
   3888 	}
   3889 }
   3890 
   3891 int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
   3892 				   struct wacom_wac *wacom_wac)
   3893 {
   3894 	struct wacom_features *features = &wacom_wac->features;
   3895 
   3896 	if ((features->type == HID_GENERIC) && features->numbered_buttons > 0)
   3897 		features->device_type |= WACOM_DEVICETYPE_PAD;
   3898 
   3899 	if (!(features->device_type & WACOM_DEVICETYPE_PAD))
   3900 		return -ENODEV;
   3901 
   3902 	if (features->type == REMOTE && input_dev == wacom_wac->pad_input)
   3903 		return -ENODEV;
   3904 
   3905 	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
   3906 
   3907 	/* kept for making legacy xf86-input-wacom working with the wheels */
   3908 	__set_bit(ABS_MISC, input_dev->absbit);
   3909 
   3910 	/* kept for making legacy xf86-input-wacom accepting the pad */
   3911 	if (!(input_dev->absinfo && (input_dev->absinfo[ABS_X].minimum ||
   3912 	      input_dev->absinfo[ABS_X].maximum)))
   3913 		input_set_abs_params(input_dev, ABS_X, 0, 1, 0, 0);
   3914 	if (!(input_dev->absinfo && (input_dev->absinfo[ABS_Y].minimum ||
   3915 	      input_dev->absinfo[ABS_Y].maximum)))
   3916 		input_set_abs_params(input_dev, ABS_Y, 0, 1, 0, 0);
   3917 
   3918 	/* kept for making udev and libwacom accepting the pad */
   3919 	__set_bit(BTN_STYLUS, input_dev->keybit);
   3920 
   3921 	wacom_setup_numbered_buttons(input_dev, features->numbered_buttons);
   3922 
   3923 	switch (features->type) {
   3924 
   3925 	case CINTIQ_HYBRID:
   3926 	case CINTIQ_COMPANION_2:
   3927 	case DTK:
   3928 	case DTUS:
   3929 	case GRAPHIRE_BT:
   3930 		break;
   3931 
   3932 	case WACOM_MO:
   3933 		__set_bit(BTN_BACK, input_dev->keybit);
   3934 		__set_bit(BTN_LEFT, input_dev->keybit);
   3935 		__set_bit(BTN_FORWARD, input_dev->keybit);
   3936 		__set_bit(BTN_RIGHT, input_dev->keybit);
   3937 		input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
   3938 		break;
   3939 
   3940 	case WACOM_G4:
   3941 		__set_bit(BTN_BACK, input_dev->keybit);
   3942 		__set_bit(BTN_FORWARD, input_dev->keybit);
   3943 		input_set_capability(input_dev, EV_REL, REL_WHEEL);
   3944 		break;
   3945 
   3946 	case WACOM_24HD:
   3947 		__set_bit(KEY_PROG1, input_dev->keybit);
   3948 		__set_bit(KEY_PROG2, input_dev->keybit);
   3949 		__set_bit(KEY_PROG3, input_dev->keybit);
   3950 
   3951 		input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
   3952 		input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
   3953 		break;
   3954 
   3955 	case WACOM_27QHD:
   3956 		__set_bit(KEY_PROG1, input_dev->keybit);
   3957 		__set_bit(KEY_PROG2, input_dev->keybit);
   3958 		__set_bit(KEY_PROG3, input_dev->keybit);
   3959 		input_set_abs_params(input_dev, ABS_X, -2048, 2048, 0, 0);
   3960 		input_abs_set_res(input_dev, ABS_X, 1024); /* points/g */
   3961 		input_set_abs_params(input_dev, ABS_Y, -2048, 2048, 0, 0);
   3962 		input_abs_set_res(input_dev, ABS_Y, 1024);
   3963 		input_set_abs_params(input_dev, ABS_Z, -2048, 2048, 0, 0);
   3964 		input_abs_set_res(input_dev, ABS_Z, 1024);
   3965 		__set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit);
   3966 		break;
   3967 
   3968 	case WACOM_22HD:
   3969 		__set_bit(KEY_PROG1, input_dev->keybit);
   3970 		__set_bit(KEY_PROG2, input_dev->keybit);
   3971 		__set_bit(KEY_PROG3, input_dev->keybit);
   3972 		/* fall through */
   3973 
   3974 	case WACOM_21UX2:
   3975 	case WACOM_BEE:
   3976 	case CINTIQ:
   3977 		input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
   3978 		input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
   3979 		break;
   3980 
   3981 	case WACOM_13HD:
   3982 		input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
   3983 		break;
   3984 
   3985 	case INTUOS3:
   3986 	case INTUOS3L:
   3987 		input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
   3988 		/* fall through */
   3989 
   3990 	case INTUOS3S:
   3991 		input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
   3992 		break;
   3993 
   3994 	case INTUOS5:
   3995 	case INTUOS5L:
   3996 	case INTUOSPM:
   3997 	case INTUOSPL:
   3998 	case INTUOS5S:
   3999 	case INTUOSPS:
   4000 	case INTUOSP2_BT:
   4001 		input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
   4002 		break;
   4003 
   4004 	case INTUOS4WL:
   4005 		/*
   4006 		 * For Bluetooth devices, the udev rule does not work correctly
   4007 		 * for pads unless we add a stylus capability, which forces
   4008 		 * ID_INPUT_TABLET to be set.
   4009 		 */
   4010 		__set_bit(BTN_STYLUS, input_dev->keybit);
   4011 		/* fall through */
   4012 
   4013 	case INTUOS4:
   4014 	case INTUOS4L:
   4015 	case INTUOS4S:
   4016 		input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
   4017 		break;
   4018 
   4019 	case INTUOSHT:
   4020 	case BAMBOO_PT:
   4021 	case BAMBOO_TOUCH:
   4022 	case INTUOSHT2:
   4023 		__clear_bit(ABS_MISC, input_dev->absbit);
   4024 
   4025 		__set_bit(BTN_LEFT, input_dev->keybit);
   4026 		__set_bit(BTN_FORWARD, input_dev->keybit);
   4027 		__set_bit(BTN_BACK, input_dev->keybit);
   4028 		__set_bit(BTN_RIGHT, input_dev->keybit);
   4029 
   4030 		break;
   4031 
   4032 	case REMOTE:
   4033 		input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
   4034 		input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
   4035 		break;
   4036 
   4037 	case INTUOSHT3_BT:
   4038 	case HID_GENERIC:
   4039 		break;
   4040 
   4041 	default:
   4042 		/* no pad supported */
   4043 		return -ENODEV;
   4044 	}
   4045 	return 0;
   4046 }
   4047 
   4048 static const struct wacom_features wacom_features_0x00 =
   4049 	{ "Wacom Penpartner", 5040, 3780, 255, 0,
   4050 	  PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
   4051 static const struct wacom_features wacom_features_0x10 =
   4052 	{ "Wacom Graphire", 10206, 7422, 511, 63,
   4053 	  GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4054 static const struct wacom_features wacom_features_0x81 =
   4055 	{ "Wacom Graphire BT", 16704, 12064, 511, 32,
   4056 	  GRAPHIRE_BT, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES, 2 };
   4057 static const struct wacom_features wacom_features_0x11 =
   4058 	{ "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
   4059 	  GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4060 static const struct wacom_features wacom_features_0x12 =
   4061 	{ "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
   4062 	  GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4063 static const struct wacom_features wacom_features_0x13 =
   4064 	{ "Wacom Graphire3", 10208, 7424, 511, 63,
   4065 	  GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4066 static const struct wacom_features wacom_features_0x14 =
   4067 	{ "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
   4068 	  GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4069 static const struct wacom_features wacom_features_0x15 =
   4070 	{ "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
   4071 	  WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4072 static const struct wacom_features wacom_features_0x16 =
   4073 	{ "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
   4074 	  WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4075 static const struct wacom_features wacom_features_0x17 =
   4076 	{ "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
   4077 	  WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4078 static const struct wacom_features wacom_features_0x18 =
   4079 	{ "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
   4080 	  WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4081 static const struct wacom_features wacom_features_0x19 =
   4082 	{ "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
   4083 	  GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
   4084 static const struct wacom_features wacom_features_0x60 =
   4085 	{ "Wacom Volito", 5104, 3712, 511, 63,
   4086 	  GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
   4087 static const struct wacom_features wacom_features_0x61 =
   4088 	{ "Wacom PenStation2", 3250, 2320, 255, 63,
   4089 	  GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
   4090 static const struct wacom_features wacom_features_0x62 =
   4091 	{ "Wacom Volito2 4x5", 5104, 3712, 511, 63,
   4092 	  GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
   4093 static const struct wacom_features wacom_features_0x63 =
   4094 	{ "Wacom Volito2 2x3", 3248, 2320, 511, 63,
   4095 	  GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
   4096 static const struct wacom_features wacom_features_0x64 =
   4097 	{ "Wacom PenPartner2", 3250, 2320, 511, 63,
   4098 	  GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
   4099 static const struct wacom_features wacom_features_0x65 =
   4100 	{ "Wacom Bamboo", 14760, 9225, 511, 63,
   4101 	  WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4102 static const struct wacom_features wacom_features_0x69 =
   4103 	{ "Wacom Bamboo1", 5104, 3712, 511, 63,
   4104 	  GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
   4105 static const struct wacom_features wacom_features_0x6A =
   4106 	{ "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
   4107 	  GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4108 static const struct wacom_features wacom_features_0x6B =
   4109 	{ "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
   4110 	  GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4111 static const struct wacom_features wacom_features_0x20 =
   4112 	{ "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
   4113 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4114 static const struct wacom_features wacom_features_0x21 =
   4115 	{ "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
   4116 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4117 static const struct wacom_features wacom_features_0x22 =
   4118 	{ "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
   4119 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4120 static const struct wacom_features wacom_features_0x23 =
   4121 	{ "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
   4122 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4123 static const struct wacom_features wacom_features_0x24 =
   4124 	{ "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
   4125 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4126 static const struct wacom_features wacom_features_0x30 =
   4127 	{ "Wacom PL400", 5408, 4056, 255, 0,
   4128 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4129 static const struct wacom_features wacom_features_0x31 =
   4130 	{ "Wacom PL500", 6144, 4608, 255, 0,
   4131 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4132 static const struct wacom_features wacom_features_0x32 =
   4133 	{ "Wacom PL600", 6126, 4604, 255, 0,
   4134 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4135 static const struct wacom_features wacom_features_0x33 =
   4136 	{ "Wacom PL600SX", 6260, 5016, 255, 0,
   4137 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4138 static const struct wacom_features wacom_features_0x34 =
   4139 	{ "Wacom PL550", 6144, 4608, 511, 0,
   4140 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4141 static const struct wacom_features wacom_features_0x35 =
   4142 	{ "Wacom PL800", 7220, 5780, 511, 0,
   4143 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4144 static const struct wacom_features wacom_features_0x37 =
   4145 	{ "Wacom PL700", 6758, 5406, 511, 0,
   4146 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4147 static const struct wacom_features wacom_features_0x38 =
   4148 	{ "Wacom PL510", 6282, 4762, 511, 0,
   4149 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4150 static const struct wacom_features wacom_features_0x39 =
   4151 	{ "Wacom DTU710", 34080, 27660, 511, 0,
   4152 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4153 static const struct wacom_features wacom_features_0xC4 =
   4154 	{ "Wacom DTF521", 6282, 4762, 511, 0,
   4155 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4156 static const struct wacom_features wacom_features_0xC0 =
   4157 	{ "Wacom DTF720", 6858, 5506, 511, 0,
   4158 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4159 static const struct wacom_features wacom_features_0xC2 =
   4160 	{ "Wacom DTF720a", 6858, 5506, 511, 0,
   4161 	  PL, WACOM_PL_RES, WACOM_PL_RES };
   4162 static const struct wacom_features wacom_features_0x03 =
   4163 	{ "Wacom Cintiq Partner", 20480, 15360, 511, 0,
   4164 	  PTU, WACOM_PL_RES, WACOM_PL_RES };
   4165 static const struct wacom_features wacom_features_0x41 =
   4166 	{ "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
   4167 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4168 static const struct wacom_features wacom_features_0x42 =
   4169 	{ "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
   4170 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4171 static const struct wacom_features wacom_features_0x43 =
   4172 	{ "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
   4173 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4174 static const struct wacom_features wacom_features_0x44 =
   4175 	{ "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
   4176 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4177 static const struct wacom_features wacom_features_0x45 =
   4178 	{ "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
   4179 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4180 static const struct wacom_features wacom_features_0xB0 =
   4181 	{ "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
   4182 	  INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
   4183 static const struct wacom_features wacom_features_0xB1 =
   4184 	{ "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
   4185 	  INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
   4186 static const struct wacom_features wacom_features_0xB2 =
   4187 	{ "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
   4188 	  INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
   4189 static const struct wacom_features wacom_features_0xB3 =
   4190 	{ "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
   4191 	  INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
   4192 static const struct wacom_features wacom_features_0xB4 =
   4193 	{ "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
   4194 	  INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
   4195 static const struct wacom_features wacom_features_0xB5 =
   4196 	{ "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
   4197 	  INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
   4198 static const struct wacom_features wacom_features_0xB7 =
   4199 	{ "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
   4200 	  INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
   4201 static const struct wacom_features wacom_features_0xB8 =
   4202 	{ "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
   4203 	  INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
   4204 static const struct wacom_features wacom_features_0xB9 =
   4205 	{ "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
   4206 	  INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
   4207 static const struct wacom_features wacom_features_0xBA =
   4208 	{ "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
   4209 	  INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
   4210 static const struct wacom_features wacom_features_0xBB =
   4211 	{ "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
   4212 	  INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
   4213 static const struct wacom_features wacom_features_0xBC =
   4214 	{ "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
   4215 	  INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
   4216 static const struct wacom_features wacom_features_0xBD =
   4217 	{ "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
   4218 	  INTUOS4WL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
   4219 static const struct wacom_features wacom_features_0x26 =
   4220 	{ "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
   4221 	  INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16 };
   4222 static const struct wacom_features wacom_features_0x27 =
   4223 	{ "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
   4224 	  INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
   4225 static const struct wacom_features wacom_features_0x28 =
   4226 	{ "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
   4227 	  INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
   4228 static const struct wacom_features wacom_features_0x29 =
   4229 	{ "Wacom Intuos5 S", 31496, 19685, 2047, 63,
   4230 	  INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
   4231 static const struct wacom_features wacom_features_0x2A =
   4232 	{ "Wacom Intuos5 M", 44704, 27940, 2047, 63,
   4233 	  INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
   4234 static const struct wacom_features wacom_features_0x314 =
   4235 	{ "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
   4236 	  INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16,
   4237 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4238 static const struct wacom_features wacom_features_0x315 =
   4239 	{ "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
   4240 	  INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
   4241 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4242 static const struct wacom_features wacom_features_0x317 =
   4243 	{ "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
   4244 	  INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
   4245 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4246 static const struct wacom_features wacom_features_0xF4 =
   4247 	{ "Wacom Cintiq 24HD", 104480, 65600, 2047, 63,
   4248 	  WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
   4249 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4250 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
   4251 static const struct wacom_features wacom_features_0xF8 =
   4252 	{ "Wacom Cintiq 24HD touch", 104480, 65600, 2047, 63, /* Pen */
   4253 	  WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
   4254 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4255 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4256 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
   4257 static const struct wacom_features wacom_features_0xF6 =
   4258 	{ "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
   4259 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
   4260 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4261 static const struct wacom_features wacom_features_0x32A =
   4262 	{ "Wacom Cintiq 27QHD", 120140, 67920, 2047, 63,
   4263 	  WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
   4264 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4265 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
   4266 static const struct wacom_features wacom_features_0x32B =
   4267 	{ "Wacom Cintiq 27QHD touch", 120140, 67920, 2047, 63,
   4268 	  WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
   4269 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4270 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4271 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32C };
   4272 static const struct wacom_features wacom_features_0x32C =
   4273 	{ "Wacom Cintiq 27QHD touch", .type = WACOM_27QHDT,
   4274 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32B, .touch_max = 10 };
   4275 static const struct wacom_features wacom_features_0x3F =
   4276 	{ "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
   4277 	  CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
   4278 static const struct wacom_features wacom_features_0xC5 =
   4279 	{ "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
   4280 	  WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
   4281 static const struct wacom_features wacom_features_0xC6 =
   4282 	{ "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
   4283 	  WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
   4284 static const struct wacom_features wacom_features_0x304 =
   4285 	{ "Wacom Cintiq 13HD", 59552, 33848, 1023, 63,
   4286 	  WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
   4287 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4288 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
   4289 static const struct wacom_features wacom_features_0x333 =
   4290 	{ "Wacom Cintiq 13HD touch", 59552, 33848, 2047, 63,
   4291 	  WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
   4292 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4293 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4294 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x335 };
   4295 static const struct wacom_features wacom_features_0x335 =
   4296 	{ "Wacom Cintiq 13HD touch", .type = WACOM_24HDT, /* Touch */
   4297 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x333, .touch_max = 10,
   4298 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4299 static const struct wacom_features wacom_features_0xC7 =
   4300 	{ "Wacom DTU1931", 37832, 30305, 511, 0,
   4301 	  PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4302 static const struct wacom_features wacom_features_0xCE =
   4303 	{ "Wacom DTU2231", 47864, 27011, 511, 0,
   4304 	  DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
   4305 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
   4306 static const struct wacom_features wacom_features_0xF0 =
   4307 	{ "Wacom DTU1631", 34623, 19553, 511, 0,
   4308 	  DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4309 static const struct wacom_features wacom_features_0xFB =
   4310 	{ "Wacom DTU1031", 22096, 13960, 511, 0,
   4311 	  DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
   4312 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
   4313 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
   4314 static const struct wacom_features wacom_features_0x32F =
   4315 	{ "Wacom DTU1031X", 22672, 12928, 511, 0,
   4316 	  DTUSX, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 0,
   4317 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
   4318 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
   4319 static const struct wacom_features wacom_features_0x336 =
   4320 	{ "Wacom DTU1141", 23672, 13403, 1023, 0,
   4321 	  DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
   4322 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
   4323 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
   4324 static const struct wacom_features wacom_features_0x57 =
   4325 	{ "Wacom DTK2241", 95840, 54260, 2047, 63,
   4326 	  DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
   4327 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4328 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
   4329 static const struct wacom_features wacom_features_0x59 = /* Pen */
   4330 	{ "Wacom DTH2242", 95840, 54260, 2047, 63,
   4331 	  DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
   4332 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4333 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4334 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
   4335 static const struct wacom_features wacom_features_0x5D = /* Touch */
   4336 	{ "Wacom DTH2242",       .type = WACOM_24HDT,
   4337 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
   4338 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4339 static const struct wacom_features wacom_features_0xCC =
   4340 	{ "Wacom Cintiq 21UX2", 87200, 65600, 2047, 63,
   4341 	  WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
   4342 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4343 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
   4344 static const struct wacom_features wacom_features_0xFA =
   4345 	{ "Wacom Cintiq 22HD", 95840, 54260, 2047, 63,
   4346 	  WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
   4347 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4348 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
   4349 static const struct wacom_features wacom_features_0x5B =
   4350 	{ "Wacom Cintiq 22HDT", 95840, 54260, 2047, 63,
   4351 	  WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
   4352 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4353 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4354 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
   4355 static const struct wacom_features wacom_features_0x5E =
   4356 	{ "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
   4357 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
   4358 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4359 static const struct wacom_features wacom_features_0x90 =
   4360 	{ "Wacom ISDv4 90", 26202, 16325, 255, 0,
   4361 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
   4362 static const struct wacom_features wacom_features_0x93 =
   4363 	{ "Wacom ISDv4 93", 26202, 16325, 255, 0,
   4364 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
   4365 static const struct wacom_features wacom_features_0x97 =
   4366 	{ "Wacom ISDv4 97", 26202, 16325, 511, 0,
   4367 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
   4368 static const struct wacom_features wacom_features_0x9A =
   4369 	{ "Wacom ISDv4 9A", 26202, 16325, 255, 0,
   4370 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
   4371 static const struct wacom_features wacom_features_0x9F =
   4372 	{ "Wacom ISDv4 9F", 26202, 16325, 255, 0,
   4373 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
   4374 static const struct wacom_features wacom_features_0xE2 =
   4375 	{ "Wacom ISDv4 E2", 26202, 16325, 255, 0,
   4376 	  TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4377 static const struct wacom_features wacom_features_0xE3 =
   4378 	{ "Wacom ISDv4 E3", 26202, 16325, 255, 0,
   4379 	  TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4380 static const struct wacom_features wacom_features_0xE5 =
   4381 	{ "Wacom ISDv4 E5", 26202, 16325, 255, 0,
   4382 	  MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4383 static const struct wacom_features wacom_features_0xE6 =
   4384 	{ "Wacom ISDv4 E6", 27760, 15694, 255, 0,
   4385 	  TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4386 static const struct wacom_features wacom_features_0xEC =
   4387 	{ "Wacom ISDv4 EC", 25710, 14500, 255, 0,
   4388 	  TABLETPC,    WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
   4389 static const struct wacom_features wacom_features_0xED =
   4390 	{ "Wacom ISDv4 ED", 26202, 16325, 255, 0,
   4391 	  TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
   4392 static const struct wacom_features wacom_features_0xEF =
   4393 	{ "Wacom ISDv4 EF", 26202, 16325, 255, 0,
   4394 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
   4395 static const struct wacom_features wacom_features_0x100 =
   4396 	{ "Wacom ISDv4 100", 26202, 16325, 255, 0,
   4397 	  MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4398 static const struct wacom_features wacom_features_0x101 =
   4399 	{ "Wacom ISDv4 101", 26202, 16325, 255, 0,
   4400 	  MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4401 static const struct wacom_features wacom_features_0x10D =
   4402 	{ "Wacom ISDv4 10D", 26202, 16325, 255, 0,
   4403 	  MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4404 static const struct wacom_features wacom_features_0x10E =
   4405 	{ "Wacom ISDv4 10E", 27760, 15694, 255, 0,
   4406 	  MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4407 static const struct wacom_features wacom_features_0x10F =
   4408 	{ "Wacom ISDv4 10F", 27760, 15694, 255, 0,
   4409 	  MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4410 static const struct wacom_features wacom_features_0x116 =
   4411 	{ "Wacom ISDv4 116", 26202, 16325, 255, 0,
   4412 	  TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
   4413 static const struct wacom_features wacom_features_0x12C =
   4414 	{ "Wacom ISDv4 12C", 27848, 15752, 2047, 0,
   4415 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
   4416 static const struct wacom_features wacom_features_0x4001 =
   4417 	{ "Wacom ISDv4 4001", 26202, 16325, 255, 0,
   4418 	  MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4419 static const struct wacom_features wacom_features_0x4004 =
   4420 	{ "Wacom ISDv4 4004", 11060, 6220, 255, 0,
   4421 	  MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4422 static const struct wacom_features wacom_features_0x5000 =
   4423 	{ "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
   4424 	  MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4425 static const struct wacom_features wacom_features_0x5002 =
   4426 	{ "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
   4427 	  MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4428 static const struct wacom_features wacom_features_0x47 =
   4429 	{ "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
   4430 	  INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4431 static const struct wacom_features wacom_features_0x84 =
   4432 	{ "Wacom Wireless Receiver", .type = WIRELESS, .touch_max = 16 };
   4433 static const struct wacom_features wacom_features_0xD0 =
   4434 	{ "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
   4435 	  BAMBOO_TOUCH, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4436 static const struct wacom_features wacom_features_0xD1 =
   4437 	{ "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
   4438 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4439 static const struct wacom_features wacom_features_0xD2 =
   4440 	{ "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
   4441 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4442 static const struct wacom_features wacom_features_0xD3 =
   4443 	{ "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
   4444 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4445 static const struct wacom_features wacom_features_0xD4 =
   4446 	{ "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
   4447 	  BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4448 static const struct wacom_features wacom_features_0xD5 =
   4449 	{ "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
   4450 	  BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4451 static const struct wacom_features wacom_features_0xD6 =
   4452 	{ "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
   4453 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4454 static const struct wacom_features wacom_features_0xD7 =
   4455 	{ "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
   4456 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4457 static const struct wacom_features wacom_features_0xD8 =
   4458 	{ "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
   4459 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4460 static const struct wacom_features wacom_features_0xDA =
   4461 	{ "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
   4462 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4463 static const struct wacom_features wacom_features_0xDB =
   4464 	{ "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
   4465 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
   4466 static const struct wacom_features wacom_features_0xDD =
   4467         { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
   4468           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4469 static const struct wacom_features wacom_features_0xDE =
   4470         { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
   4471 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
   4472 static const struct wacom_features wacom_features_0xDF =
   4473         { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
   4474 	  BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
   4475 static const struct wacom_features wacom_features_0x300 =
   4476 	{ "Wacom Bamboo One S", 14720, 9225, 1023, 31,
   4477 	  BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4478 static const struct wacom_features wacom_features_0x301 =
   4479 	{ "Wacom Bamboo One M", 21648, 13530, 1023, 31,
   4480 	  BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4481 static const struct wacom_features wacom_features_0x302 =
   4482 	{ "Wacom Intuos PT S", 15200, 9500, 1023, 31,
   4483 	  INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
   4484 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4485 static const struct wacom_features wacom_features_0x303 =
   4486 	{ "Wacom Intuos PT M", 21600, 13500, 1023, 31,
   4487 	  INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
   4488 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4489 static const struct wacom_features wacom_features_0x30E =
   4490 	{ "Wacom Intuos S", 15200, 9500, 1023, 31,
   4491 	  INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
   4492 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4493 static const struct wacom_features wacom_features_0x6004 =
   4494 	{ "ISD-V4", 12800, 8000, 255, 0,
   4495 	  TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4496 static const struct wacom_features wacom_features_0x307 =
   4497 	{ "Wacom ISDv5 307", 59552, 33848, 2047, 63,
   4498 	  CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
   4499 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4500 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4501 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
   4502 static const struct wacom_features wacom_features_0x309 =
   4503 	{ "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
   4504 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
   4505 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4506 static const struct wacom_features wacom_features_0x30A =
   4507 	{ "Wacom ISDv5 30A", 59552, 33848, 2047, 63,
   4508 	  CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
   4509 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4510 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4511 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30C };
   4512 static const struct wacom_features wacom_features_0x30C =
   4513 	{ "Wacom ISDv5 30C", .type = WACOM_24HDT, /* Touch */
   4514 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30A, .touch_max = 10,
   4515 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4516 static const struct wacom_features wacom_features_0x318 =
   4517 	{ "Wacom USB Bamboo PAD", 4095, 4095, /* Touch */
   4518 	  .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
   4519 static const struct wacom_features wacom_features_0x319 =
   4520 	{ "Wacom Wireless Bamboo PAD", 4095, 4095, /* Touch */
   4521 	  .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
   4522 static const struct wacom_features wacom_features_0x325 =
   4523 	{ "Wacom ISDv5 325", 59552, 33848, 2047, 63,
   4524 	  CINTIQ_COMPANION_2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 11,
   4525 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4526 	  WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
   4527 	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x326 };
   4528 static const struct wacom_features wacom_features_0x326 = /* Touch */
   4529 	{ "Wacom ISDv5 326", .type = HID_GENERIC, .oVid = USB_VENDOR_ID_WACOM,
   4530 	  .oPid = 0x325 };
   4531 static const struct wacom_features wacom_features_0x323 =
   4532 	{ "Wacom Intuos P M", 21600, 13500, 1023, 31,
   4533 	  INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
   4534 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4535 static const struct wacom_features wacom_features_0x331 =
   4536 	{ "Wacom Express Key Remote", .type = REMOTE,
   4537 	  .numbered_buttons = 18, .check_for_hid_type = true,
   4538 	  .hid_type = HID_TYPE_USBNONE };
   4539 static const struct wacom_features wacom_features_0x33B =
   4540 	{ "Wacom Intuos S 2", 15200, 9500, 2047, 63,
   4541 	  INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
   4542 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4543 static const struct wacom_features wacom_features_0x33C =
   4544 	{ "Wacom Intuos PT S 2", 15200, 9500, 2047, 63,
   4545 	  INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
   4546 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4547 static const struct wacom_features wacom_features_0x33D =
   4548 	{ "Wacom Intuos P M 2", 21600, 13500, 2047, 63,
   4549 	  INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
   4550 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4551 static const struct wacom_features wacom_features_0x33E =
   4552 	{ "Wacom Intuos PT M 2", 21600, 13500, 2047, 63,
   4553 	  INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
   4554 	  .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
   4555 static const struct wacom_features wacom_features_0x343 =
   4556 	{ "Wacom DTK1651", 34816, 19759, 1023, 0,
   4557 	  DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
   4558 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
   4559 	  WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
   4560 static const struct wacom_features wacom_features_0x360 =
   4561 	{ "Wacom Intuos Pro M", 44800, 29600, 8191, 63,
   4562 	  INTUOSP2_BT, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 10 };
   4563 static const struct wacom_features wacom_features_0x361 =
   4564 	{ "Wacom Intuos Pro L", 62200, 43200, 8191, 63,
   4565 	  INTUOSP2_BT, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 10 };
   4566 static const struct wacom_features wacom_features_0x377 =
   4567 	{ "Wacom Intuos BT S", 15200, 9500, 4095, 63,
   4568 	  INTUOSHT3_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4 };
   4569 static const struct wacom_features wacom_features_0x379 =
   4570 	{ "Wacom Intuos BT M", 21600, 13500, 4095, 63,
   4571 	  INTUOSHT3_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4 };
   4572 static const struct wacom_features wacom_features_0x37A =
   4573 	{ "Wacom One by Wacom S", 15200, 9500, 2047, 63,
   4574 	  BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4575 static const struct wacom_features wacom_features_0x37B =
   4576 	{ "Wacom One by Wacom M", 21600, 13500, 2047, 63,
   4577 	  BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
   4578 
   4579 static const struct wacom_features wacom_features_HID_ANY_ID =
   4580 	{ "Wacom HID", .type = HID_GENERIC, .oVid = HID_ANY_ID, .oPid = HID_ANY_ID };
   4581 
   4582 #define USB_DEVICE_WACOM(prod)						\
   4583 	HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
   4584 	.driver_data = (kernel_ulong_t)&wacom_features_##prod
   4585 
   4586 #define BT_DEVICE_WACOM(prod)						\
   4587 	HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
   4588 	.driver_data = (kernel_ulong_t)&wacom_features_##prod
   4589 
   4590 #define I2C_DEVICE_WACOM(prod)						\
   4591 	HID_DEVICE(BUS_I2C, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
   4592 	.driver_data = (kernel_ulong_t)&wacom_features_##prod
   4593 
   4594 #define USB_DEVICE_LENOVO(prod)					\
   4595 	HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),			\
   4596 	.driver_data = (kernel_ulong_t)&wacom_features_##prod
   4597 
   4598 const struct hid_device_id wacom_ids[] = {
   4599 	{ USB_DEVICE_WACOM(0x00) },
   4600 	{ USB_DEVICE_WACOM(0x03) },
   4601 	{ USB_DEVICE_WACOM(0x10) },
   4602 	{ USB_DEVICE_WACOM(0x11) },
   4603 	{ USB_DEVICE_WACOM(0x12) },
   4604 	{ USB_DEVICE_WACOM(0x13) },
   4605 	{ USB_DEVICE_WACOM(0x14) },
   4606 	{ USB_DEVICE_WACOM(0x15) },
   4607 	{ USB_DEVICE_WACOM(0x16) },
   4608 	{ USB_DEVICE_WACOM(0x17) },
   4609 	{ USB_DEVICE_WACOM(0x18) },
   4610 	{ USB_DEVICE_WACOM(0x19) },
   4611 	{ USB_DEVICE_WACOM(0x20) },
   4612 	{ USB_DEVICE_WACOM(0x21) },
   4613 	{ USB_DEVICE_WACOM(0x22) },
   4614 	{ USB_DEVICE_WACOM(0x23) },
   4615 	{ USB_DEVICE_WACOM(0x24) },
   4616 	{ USB_DEVICE_WACOM(0x26) },
   4617 	{ USB_DEVICE_WACOM(0x27) },
   4618 	{ USB_DEVICE_WACOM(0x28) },
   4619 	{ USB_DEVICE_WACOM(0x29) },
   4620 	{ USB_DEVICE_WACOM(0x2A) },
   4621 	{ USB_DEVICE_WACOM(0x30) },
   4622 	{ USB_DEVICE_WACOM(0x31) },
   4623 	{ USB_DEVICE_WACOM(0x32) },
   4624 	{ USB_DEVICE_WACOM(0x33) },
   4625 	{ USB_DEVICE_WACOM(0x34) },
   4626 	{ USB_DEVICE_WACOM(0x35) },
   4627 	{ USB_DEVICE_WACOM(0x37) },
   4628 	{ USB_DEVICE_WACOM(0x38) },
   4629 	{ USB_DEVICE_WACOM(0x39) },
   4630 	{ USB_DEVICE_WACOM(0x3F) },
   4631 	{ USB_DEVICE_WACOM(0x41) },
   4632 	{ USB_DEVICE_WACOM(0x42) },
   4633 	{ USB_DEVICE_WACOM(0x43) },
   4634 	{ USB_DEVICE_WACOM(0x44) },
   4635 	{ USB_DEVICE_WACOM(0x45) },
   4636 	{ USB_DEVICE_WACOM(0x47) },
   4637 	{ USB_DEVICE_WACOM(0x57) },
   4638 	{ USB_DEVICE_WACOM(0x59) },
   4639 	{ USB_DEVICE_WACOM(0x5B) },
   4640 	{ USB_DEVICE_WACOM(0x5D) },
   4641 	{ USB_DEVICE_WACOM(0x5E) },
   4642 	{ USB_DEVICE_WACOM(0x60) },
   4643 	{ USB_DEVICE_WACOM(0x61) },
   4644 	{ USB_DEVICE_WACOM(0x62) },
   4645 	{ USB_DEVICE_WACOM(0x63) },
   4646 	{ USB_DEVICE_WACOM(0x64) },
   4647 	{ USB_DEVICE_WACOM(0x65) },
   4648 	{ USB_DEVICE_WACOM(0x69) },
   4649 	{ USB_DEVICE_WACOM(0x6A) },
   4650 	{ USB_DEVICE_WACOM(0x6B) },
   4651 	{ BT_DEVICE_WACOM(0x81) },
   4652 	{ USB_DEVICE_WACOM(0x84) },
   4653 	{ USB_DEVICE_WACOM(0x90) },
   4654 	{ USB_DEVICE_WACOM(0x93) },
   4655 	{ USB_DEVICE_WACOM(0x97) },
   4656 	{ USB_DEVICE_WACOM(0x9A) },
   4657 	{ USB_DEVICE_WACOM(0x9F) },
   4658 	{ USB_DEVICE_WACOM(0xB0) },
   4659 	{ USB_DEVICE_WACOM(0xB1) },
   4660 	{ USB_DEVICE_WACOM(0xB2) },
   4661 	{ USB_DEVICE_WACOM(0xB3) },
   4662 	{ USB_DEVICE_WACOM(0xB4) },
   4663 	{ USB_DEVICE_WACOM(0xB5) },
   4664 	{ USB_DEVICE_WACOM(0xB7) },
   4665 	{ USB_DEVICE_WACOM(0xB8) },
   4666 	{ USB_DEVICE_WACOM(0xB9) },
   4667 	{ USB_DEVICE_WACOM(0xBA) },
   4668 	{ USB_DEVICE_WACOM(0xBB) },
   4669 	{ USB_DEVICE_WACOM(0xBC) },
   4670 	{ BT_DEVICE_WACOM(0xBD) },
   4671 	{ USB_DEVICE_WACOM(0xC0) },
   4672 	{ USB_DEVICE_WACOM(0xC2) },
   4673 	{ USB_DEVICE_WACOM(0xC4) },
   4674 	{ USB_DEVICE_WACOM(0xC5) },
   4675 	{ USB_DEVICE_WACOM(0xC6) },
   4676 	{ USB_DEVICE_WACOM(0xC7) },
   4677 	{ USB_DEVICE_WACOM(0xCC) },
   4678 	{ USB_DEVICE_WACOM(0xCE) },
   4679 	{ USB_DEVICE_WACOM(0xD0) },
   4680 	{ USB_DEVICE_WACOM(0xD1) },
   4681 	{ USB_DEVICE_WACOM(0xD2) },
   4682 	{ USB_DEVICE_WACOM(0xD3) },
   4683 	{ USB_DEVICE_WACOM(0xD4) },
   4684 	{ USB_DEVICE_WACOM(0xD5) },
   4685 	{ USB_DEVICE_WACOM(0xD6) },
   4686 	{ USB_DEVICE_WACOM(0xD7) },
   4687 	{ USB_DEVICE_WACOM(0xD8) },
   4688 	{ USB_DEVICE_WACOM(0xDA) },
   4689 	{ USB_DEVICE_WACOM(0xDB) },
   4690 	{ USB_DEVICE_WACOM(0xDD) },
   4691 	{ USB_DEVICE_WACOM(0xDE) },
   4692 	{ USB_DEVICE_WACOM(0xDF) },
   4693 	{ USB_DEVICE_WACOM(0xE2) },
   4694 	{ USB_DEVICE_WACOM(0xE3) },
   4695 	{ USB_DEVICE_WACOM(0xE5) },
   4696 	{ USB_DEVICE_WACOM(0xE6) },
   4697 	{ USB_DEVICE_WACOM(0xEC) },
   4698 	{ USB_DEVICE_WACOM(0xED) },
   4699 	{ USB_DEVICE_WACOM(0xEF) },
   4700 	{ USB_DEVICE_WACOM(0xF0) },
   4701 	{ USB_DEVICE_WACOM(0xF4) },
   4702 	{ USB_DEVICE_WACOM(0xF6) },
   4703 	{ USB_DEVICE_WACOM(0xF8) },
   4704 	{ USB_DEVICE_WACOM(0xFA) },
   4705 	{ USB_DEVICE_WACOM(0xFB) },
   4706 	{ USB_DEVICE_WACOM(0x100) },
   4707 	{ USB_DEVICE_WACOM(0x101) },
   4708 	{ USB_DEVICE_WACOM(0x10D) },
   4709 	{ USB_DEVICE_WACOM(0x10E) },
   4710 	{ USB_DEVICE_WACOM(0x10F) },
   4711 	{ USB_DEVICE_WACOM(0x116) },
   4712 	{ USB_DEVICE_WACOM(0x12C) },
   4713 	{ USB_DEVICE_WACOM(0x300) },
   4714 	{ USB_DEVICE_WACOM(0x301) },
   4715 	{ USB_DEVICE_WACOM(0x302) },
   4716 	{ USB_DEVICE_WACOM(0x303) },
   4717 	{ USB_DEVICE_WACOM(0x304) },
   4718 	{ USB_DEVICE_WACOM(0x307) },
   4719 	{ USB_DEVICE_WACOM(0x309) },
   4720 	{ USB_DEVICE_WACOM(0x30A) },
   4721 	{ USB_DEVICE_WACOM(0x30C) },
   4722 	{ USB_DEVICE_WACOM(0x30E) },
   4723 	{ USB_DEVICE_WACOM(0x314) },
   4724 	{ USB_DEVICE_WACOM(0x315) },
   4725 	{ USB_DEVICE_WACOM(0x317) },
   4726 	{ USB_DEVICE_WACOM(0x318) },
   4727 	{ USB_DEVICE_WACOM(0x319) },
   4728 	{ USB_DEVICE_WACOM(0x323) },
   4729 	{ USB_DEVICE_WACOM(0x325) },
   4730 	{ USB_DEVICE_WACOM(0x326) },
   4731 	{ USB_DEVICE_WACOM(0x32A) },
   4732 	{ USB_DEVICE_WACOM(0x32B) },
   4733 	{ USB_DEVICE_WACOM(0x32C) },
   4734 	{ USB_DEVICE_WACOM(0x32F) },
   4735 	{ USB_DEVICE_WACOM(0x331) },
   4736 	{ USB_DEVICE_WACOM(0x333) },
   4737 	{ USB_DEVICE_WACOM(0x335) },
   4738 	{ USB_DEVICE_WACOM(0x336) },
   4739 	{ USB_DEVICE_WACOM(0x33B) },
   4740 	{ USB_DEVICE_WACOM(0x33C) },
   4741 	{ USB_DEVICE_WACOM(0x33D) },
   4742 	{ USB_DEVICE_WACOM(0x33E) },
   4743 	{ USB_DEVICE_WACOM(0x343) },
   4744 	{ BT_DEVICE_WACOM(0x360) },
   4745 	{ BT_DEVICE_WACOM(0x361) },
   4746 	{ BT_DEVICE_WACOM(0x377) },
   4747 	{ BT_DEVICE_WACOM(0x379) },
   4748 	{ USB_DEVICE_WACOM(0x37A) },
   4749 	{ USB_DEVICE_WACOM(0x37B) },
   4750 	{ USB_DEVICE_WACOM(0x4001) },
   4751 	{ USB_DEVICE_WACOM(0x4004) },
   4752 	{ USB_DEVICE_WACOM(0x5000) },
   4753 	{ USB_DEVICE_WACOM(0x5002) },
   4754 	{ USB_DEVICE_LENOVO(0x6004) },
   4755 
   4756 	{ USB_DEVICE_WACOM(HID_ANY_ID) },
   4757 	{ I2C_DEVICE_WACOM(HID_ANY_ID) },
   4758 	{ BT_DEVICE_WACOM(HID_ANY_ID) },
   4759 	{ }
   4760 };
   4761 MODULE_DEVICE_TABLE(hid, wacom_ids);