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