wacom_wac.c 75.3 KB
Newer Older
1
/*
2
 * drivers/input/tablet/wacom_wac.c
3
 *
4
 *  USB Wacom tablet support - Wacom specific code
5 6 7 8 9 10 11 12 13
 *
 */

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
14

15
#include "wacom_wac.h"
16
#include "wacom.h"
17
#include <linux/input/mt.h>
18
#include <linux/hid.h>
19

20 21 22 23 24 25 26 27
/* resolution for penabled devices */
#define WACOM_PL_RES		20
#define WACOM_PENPRTN_RES	40
#define WACOM_VOLITO_RES	50
#define WACOM_GRAPHIRE_RES	80
#define WACOM_INTUOS_RES	100
#define WACOM_INTUOS3_RES	200

28 29 30 31 32
/* Scale factor relating reported contact size to logical contact area.
 * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
 */
#define WACOM_CONTACT_AREA_SCALE 2607

33
static int wacom_penpartner_irq(struct wacom_wac *wacom)
34 35
{
	unsigned char *data = wacom->data;
36
	struct input_dev *input = wacom->input;
37 38

	switch (data[0]) {
39 40 41 42
	case 1:
		if (data[5] & 0x80) {
			wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
			wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
43 44
			input_report_key(input, wacom->tool[0], 1);
			input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
45 46
			input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
			input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
47 48 49
			input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
			input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
			input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
50
		} else {
51 52 53 54
			input_report_key(input, wacom->tool[0], 0);
			input_report_abs(input, ABS_MISC, 0); /* report tool id */
			input_report_abs(input, ABS_PRESSURE, -1);
			input_report_key(input, BTN_TOUCH, 0);
55 56
		}
		break;
57

58
	case 2:
59 60
		input_report_key(input, BTN_TOOL_PEN, 1);
		input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
61 62
		input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
		input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
63 64 65
		input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
		input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
		input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
66
		break;
67

68
	default:
69 70
		dev_dbg(input->dev.parent,
			"%s: received unknown report #%d\n", __func__, data[0]);
71
		return 0;
72
        }
73

74 75 76
	return 1;
}

77
static int wacom_pl_irq(struct wacom_wac *wacom)
78
{
79
	struct wacom_features *features = &wacom->features;
80
	unsigned char *data = wacom->data;
81
	struct input_dev *input = wacom->input;
82
	int prox, pressure;
83

84
	if (data[0] != WACOM_REPORT_PENABLED) {
85 86
		dev_dbg(input->dev.parent,
			"%s: received unknown report #%d\n", __func__, data[0]);
87 88 89 90 91 92
		return 0;
	}

	prox = data[1] & 0x40;

	if (prox) {
93
		wacom->id[0] = ERASER_DEVICE_ID;
94
		pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
95
		if (features->pressure_max > 255)
96
			pressure = (pressure << 1) | ((data[4] >> 6) & 1);
97
		pressure += (features->pressure_max + 1) / 2;
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

		/*
		 * if going from out of proximity into proximity select between the eraser
		 * and the pen based on the state of the stylus2 button, choose eraser if
		 * pressed else choose pen. if not a proximity change from out to in, send
		 * an out of proximity for previous tool then a in for new tool.
		 */
		if (!wacom->tool[0]) {
			/* Eraser bit set for DTF */
			if (data[1] & 0x10)
				wacom->tool[1] = BTN_TOOL_RUBBER;
			else
				/* Going into proximity select tool */
				wacom->tool[1] = (data[4] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
		} else {
			/* was entered with stylus2 pressed */
			if (wacom->tool[1] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
				/* report out proximity for previous tool */
116 117
				input_report_key(input, wacom->tool[1], 0);
				input_sync(input);
118 119 120 121 122 123 124
				wacom->tool[1] = BTN_TOOL_PEN;
				return 0;
			}
		}
		if (wacom->tool[1] != BTN_TOOL_RUBBER) {
			/* Unknown tool selected default to pen tool */
			wacom->tool[1] = BTN_TOOL_PEN;
125
			wacom->id[0] = STYLUS_DEVICE_ID;
126
		}
127 128 129 130 131 132 133 134
		input_report_key(input, wacom->tool[1], prox); /* report in proximity for tool */
		input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
		input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
		input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
		input_report_abs(input, ABS_PRESSURE, pressure);

		input_report_key(input, BTN_TOUCH, data[4] & 0x08);
		input_report_key(input, BTN_STYLUS, data[4] & 0x10);
135
		/* Only allow the stylus2 button to be reported for the pen tool. */
136
		input_report_key(input, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
137 138 139 140 141 142
	} else {
		/* report proximity-out of a (valid) tool */
		if (wacom->tool[1] != BTN_TOOL_RUBBER) {
			/* Unknown tool selected default to pen tool */
			wacom->tool[1] = BTN_TOOL_PEN;
		}
143
		input_report_key(input, wacom->tool[1], prox);
144 145 146 147 148 149
	}

	wacom->tool[0] = prox; /* Save proximity state */
	return 1;
}

150
static int wacom_ptu_irq(struct wacom_wac *wacom)
151 152
{
	unsigned char *data = wacom->data;
153
	struct input_dev *input = wacom->input;
154

155
	if (data[0] != WACOM_REPORT_PENABLED) {
156 157
		dev_dbg(input->dev.parent,
			"%s: received unknown report #%d\n", __func__, data[0]);
158 159 160 161
		return 0;
	}

	if (data[1] & 0x04) {
162 163
		input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
		input_report_key(input, BTN_TOUCH, data[1] & 0x08);
164
		wacom->id[0] = ERASER_DEVICE_ID;
165
	} else {
166 167
		input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
		input_report_key(input, BTN_TOUCH, data[1] & 0x01);
168
		wacom->id[0] = STYLUS_DEVICE_ID;
169
	}
170
	input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
171 172 173
	input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
	input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
	input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
174 175
	input_report_key(input, BTN_STYLUS, data[1] & 0x02);
	input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
176 177 178
	return 1;
}

179 180 181 182 183 184 185
static int wacom_dtu_irq(struct wacom_wac *wacom)
{
	struct wacom_features *features = &wacom->features;
	char *data = wacom->data;
	struct input_dev *input = wacom->input;
	int prox = data[1] & 0x20, pressure;

186 187
	dev_dbg(input->dev.parent,
		"%s: received report #%d", __func__, data[0]);
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212

	if (prox) {
		/* Going into proximity select tool */
		wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
		if (wacom->tool[0] == BTN_TOOL_PEN)
			wacom->id[0] = STYLUS_DEVICE_ID;
		else
			wacom->id[0] = ERASER_DEVICE_ID;
	}
	input_report_key(input, BTN_STYLUS, data[1] & 0x02);
	input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
	input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
	input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
	pressure = ((data[7] & 0x01) << 8) | data[6];
	if (pressure < 0)
		pressure = features->pressure_max + pressure + 1;
	input_report_abs(input, ABS_PRESSURE, pressure);
	input_report_key(input, BTN_TOUCH, data[1] & 0x05);
	if (!prox) /* out-prox */
		wacom->id[0] = 0;
	input_report_key(input, wacom->tool[0], prox);
	input_report_abs(input, ABS_MISC, wacom->id[0]);
	return 1;
}

213
static int wacom_graphire_irq(struct wacom_wac *wacom)
214
{
215
	struct wacom_features *features = &wacom->features;
216
	unsigned char *data = wacom->data;
217
	struct input_dev *input = wacom->input;
218
	int prox;
219 220
	int rw = 0;
	int retval = 0;
221

222
	if (data[0] != WACOM_REPORT_PENABLED) {
223 224
		dev_dbg(input->dev.parent,
			"%s: received unknown report #%d\n", __func__, data[0]);
225
		goto exit;
226 227
	}

228 229 230 231
	prox = data[1] & 0x80;
	if (prox || wacom->id[0]) {
		if (prox) {
			switch ((data[1] >> 5) & 3) {
232 233 234

			case 0:	/* Pen */
				wacom->tool[0] = BTN_TOOL_PEN;
235
				wacom->id[0] = STYLUS_DEVICE_ID;
236 237 238 239
				break;

			case 1: /* Rubber */
				wacom->tool[0] = BTN_TOOL_RUBBER;
240
				wacom->id[0] = ERASER_DEVICE_ID;
241 242 243
				break;

			case 2: /* Mouse with wheel */
244
				input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
245 246 247 248
				/* fall through */

			case 3: /* Mouse without wheel */
				wacom->tool[0] = BTN_TOOL_MOUSE;
249
				wacom->id[0] = CURSOR_DEVICE_ID;
250
				break;
251
			}
252
		}
253 254
		input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
		input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
255
		if (wacom->tool[0] != BTN_TOOL_MOUSE) {
256
			input_report_abs(input, ABS_PRESSURE, data[6] | ((data[7] & 0x03) << 8));
257 258 259
			input_report_key(input, BTN_TOUCH, data[1] & 0x01);
			input_report_key(input, BTN_STYLUS, data[1] & 0x02);
			input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
260
		} else {
261 262
			input_report_key(input, BTN_LEFT, data[1] & 0x01);
			input_report_key(input, BTN_RIGHT, data[1] & 0x02);
263 264
			if (features->type == WACOM_G4 ||
					features->type == WACOM_MO) {
265
				input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
266
				rw = (data[7] & 0x04) - (data[7] & 0x03);
267
			} else {
268
				input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
269
				rw = -(signed char)data[6];
270
			}
271
			input_report_rel(input, REL_WHEEL, rw);
272
		}
273 274 275

		if (!prox)
			wacom->id[0] = 0;
276 277
		input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
		input_report_key(input, wacom->tool[0], prox);
278
		input_event(input, EV_MSC, MSC_SERIAL, 1);
279
		input_sync(input); /* sync last event */
P
Ping Cheng 已提交
280
	}
281 282

	/* send pad data */
283
	switch (features->type) {
284
	case WACOM_G4:
285 286
		prox = data[7] & 0xf8;
		if (prox || wacom->id[1]) {
287
			wacom->id[1] = PAD_DEVICE_ID;
288 289
			input_report_key(input, BTN_BACK, (data[7] & 0x40));
			input_report_key(input, BTN_FORWARD, (data[7] & 0x80));
290
			rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
291
			input_report_rel(input, REL_WHEEL, rw);
292 293
			if (!prox)
				wacom->id[1] = 0;
294 295
			input_report_abs(input, ABS_MISC, wacom->id[1]);
			input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
296
			retval = 1;
297
		}
298
		break;
299 300

	case WACOM_MO:
301 302
		prox = (data[7] & 0xf8) || data[8];
		if (prox || wacom->id[1]) {
303
			wacom->id[1] = PAD_DEVICE_ID;
304 305 306 307
			input_report_key(input, BTN_BACK, (data[7] & 0x08));
			input_report_key(input, BTN_LEFT, (data[7] & 0x20));
			input_report_key(input, BTN_FORWARD, (data[7] & 0x10));
			input_report_key(input, BTN_RIGHT, (data[7] & 0x40));
308
			input_report_abs(input, ABS_WHEEL, (data[8] & 0x7f));
309 310
			if (!prox)
				wacom->id[1] = 0;
311 312
			input_report_abs(input, ABS_MISC, wacom->id[1]);
			input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
313
			retval = 1;
314 315
		}
		break;
316
	}
317 318
exit:
	return retval;
319 320
}

321
static int wacom_intuos_inout(struct wacom_wac *wacom)
322
{
323
	struct wacom_features *features = &wacom->features;
324
	unsigned char *data = wacom->data;
325
	struct input_dev *input = wacom->input;
326
	int idx = 0;
327 328

	/* tool number */
329
	if (features->type == INTUOS)
330
		idx = data[1] & 0x01;
331 332 333

	/* Enter report */
	if ((data[1] & 0xfc) == 0xc0) {
334
		if (features->quirks == WACOM_QUIRK_MULTI_INPUT)
335 336
			wacom->shared->stylus_in_proximity = true;

337 338 339 340 341
		/* serial number of the tool */
		wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
			(data[4] << 20) + (data[5] << 12) +
			(data[6] << 4) + (data[7] >> 4);

342 343
		wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
			((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
344

345
		switch (wacom->id[idx] & 0xfffff) {
346 347
		case 0x812: /* Inking pen */
		case 0x801: /* Intuos3 Inking pen */
348
		case 0x20802: /* Intuos4 Inking Pen */
349 350 351 352 353 354 355 356 357 358
		case 0x012:
			wacom->tool[idx] = BTN_TOOL_PENCIL;
			break;

		case 0x822: /* Pen */
		case 0x842:
		case 0x852:
		case 0x823: /* Intuos3 Grip Pen */
		case 0x813: /* Intuos3 Classic Pen */
		case 0x885: /* Intuos3 Marker Pen */
359
		case 0x802: /* Intuos4 General Pen */
360 361
		case 0x804: /* Intuos4 Marker Pen */
		case 0x40802: /* Intuos4 Classic Pen */
362
		case 0x18803: /* DTH2242 Grip Pen */
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
		case 0x022:
			wacom->tool[idx] = BTN_TOOL_PEN;
			break;

		case 0x832: /* Stroke pen */
		case 0x032:
			wacom->tool[idx] = BTN_TOOL_BRUSH;
			break;

		case 0x007: /* Mouse 4D and 2D */
		case 0x09c:
		case 0x094:
		case 0x017: /* Intuos3 2D Mouse */
		case 0x806: /* Intuos4 Mouse */
			wacom->tool[idx] = BTN_TOOL_MOUSE;
			break;

		case 0x096: /* Lens cursor */
		case 0x097: /* Intuos3 Lens cursor */
		case 0x006: /* Intuos4 Lens cursor */
			wacom->tool[idx] = BTN_TOOL_LENS;
			break;

		case 0x82a: /* Eraser */
		case 0x85a:
		case 0x91a:
		case 0xd1a:
		case 0x0fa:
		case 0x82b: /* Intuos3 Grip Pen Eraser */
		case 0x81b: /* Intuos3 Classic Pen Eraser */
		case 0x91b: /* Intuos3 Airbrush Eraser */
		case 0x80c: /* Intuos4 Marker Pen Eraser */
395
		case 0x80a: /* Intuos4 General Pen Eraser */
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
		case 0x4080a: /* Intuos4 Classic Pen Eraser */
		case 0x90a: /* Intuos4 Airbrush Eraser */
			wacom->tool[idx] = BTN_TOOL_RUBBER;
			break;

		case 0xd12:
		case 0x912:
		case 0x112:
		case 0x913: /* Intuos3 Airbrush */
		case 0x902: /* Intuos4 Airbrush */
			wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
			break;

		default: /* Unknown tool */
			wacom->tool[idx] = BTN_TOOL_PEN;
			break;
412 413 414 415
		}
		return 1;
	}

416 417 418 419 420
	/* older I4 styli don't work with new Cintiqs */
	if (!((wacom->id[idx] >> 20) & 0x01) &&
			(features->type == WACOM_21UX2))
		return 1;

421 422
	/* Exit report */
	if ((data[1] & 0xfe) == 0x80) {
423
		if (features->quirks == WACOM_QUIRK_MULTI_INPUT)
424 425
			wacom->shared->stylus_in_proximity = false;

426 427 428 429
		/*
		 * Reset all states otherwise we lose the initial states
		 * when in-prox next time
		 */
430 431 432 433 434
		input_report_abs(input, ABS_X, 0);
		input_report_abs(input, ABS_Y, 0);
		input_report_abs(input, ABS_DISTANCE, 0);
		input_report_abs(input, ABS_TILT_X, 0);
		input_report_abs(input, ABS_TILT_Y, 0);
P
Ping Cheng 已提交
435
		if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
436 437 438 439 440 441 442
			input_report_key(input, BTN_LEFT, 0);
			input_report_key(input, BTN_MIDDLE, 0);
			input_report_key(input, BTN_RIGHT, 0);
			input_report_key(input, BTN_SIDE, 0);
			input_report_key(input, BTN_EXTRA, 0);
			input_report_abs(input, ABS_THROTTLE, 0);
			input_report_abs(input, ABS_RZ, 0);
443
		} else {
444 445 446 447 448
			input_report_abs(input, ABS_PRESSURE, 0);
			input_report_key(input, BTN_STYLUS, 0);
			input_report_key(input, BTN_STYLUS2, 0);
			input_report_key(input, BTN_TOUCH, 0);
			input_report_abs(input, ABS_WHEEL, 0);
449
			if (features->type >= INTUOS3S)
450
				input_report_abs(input, ABS_Z, 0);
P
Ping Cheng 已提交
451
		}
452 453 454
		input_report_key(input, wacom->tool[idx], 0);
		input_report_abs(input, ABS_MISC, 0); /* reset tool id */
		input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
455
		wacom->id[idx] = 0;
P
Ping Cheng 已提交
456
		return 2;
457 458 459 460
	}
	return 0;
}

461
static void wacom_intuos_general(struct wacom_wac *wacom)
462
{
463
	struct wacom_features *features = &wacom->features;
464
	unsigned char *data = wacom->data;
465
	struct input_dev *input = wacom->input;
466 467 468 469 470
	unsigned int t;

	/* general pen packet */
	if ((data[1] & 0xb8) == 0xa0) {
		t = (data[6] << 2) | ((data[7] >> 6) & 3);
471
		if (features->type >= INTUOS4S && features->type <= WACOM_24HD) {
472
			t = (t << 1) | (data[1] & 1);
473
		}
474 475
		input_report_abs(input, ABS_PRESSURE, t);
		input_report_abs(input, ABS_TILT_X,
476
				((data[7] << 1) & 0x7e) | (data[8] >> 7));
477 478 479 480
		input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
		input_report_key(input, BTN_STYLUS, data[1] & 2);
		input_report_key(input, BTN_STYLUS2, data[1] & 4);
		input_report_key(input, BTN_TOUCH, t > 10);
481 482 483 484
	}

	/* airbrush second packet */
	if ((data[1] & 0xbc) == 0xb4) {
485
		input_report_abs(input, ABS_WHEEL,
486
				(data[6] << 2) | ((data[7] >> 6) & 3));
487
		input_report_abs(input, ABS_TILT_X,
488
				((data[7] << 1) & 0x7e) | (data[8] >> 7));
489
		input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
490 491 492
	}
}

493
static int wacom_intuos_irq(struct wacom_wac *wacom)
494
{
495
	struct wacom_features *features = &wacom->features;
496
	unsigned char *data = wacom->data;
497
	struct input_dev *input = wacom->input;
498
	unsigned int t;
499
	int idx = 0, result;
500

501 502 503 504 505 506 507
	if (data[0] != WACOM_REPORT_PENABLED &&
	    data[0] != WACOM_REPORT_INTUOSREAD &&
	    data[0] != WACOM_REPORT_INTUOSWRITE &&
	    data[0] != WACOM_REPORT_INTUOSPAD &&
	    data[0] != WACOM_REPORT_INTUOS5PAD) {
		dev_dbg(input->dev.parent,
			"%s: received unknown report #%d\n", __func__, data[0]);
508 509 510 511
                return 0;
	}

	/* tool number */
512
	if (features->type == INTUOS)
513
		idx = data[1] & 0x01;
514 515

	/* pad packets. Works as a second tool and is always in prox */
516
	if (data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD) {
517
		if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
518 519 520 521 522 523 524
			input_report_key(input, BTN_0, (data[2] & 0x01));
			input_report_key(input, BTN_1, (data[3] & 0x01));
			input_report_key(input, BTN_2, (data[3] & 0x02));
			input_report_key(input, BTN_3, (data[3] & 0x04));
			input_report_key(input, BTN_4, (data[3] & 0x08));
			input_report_key(input, BTN_5, (data[3] & 0x10));
			input_report_key(input, BTN_6, (data[3] & 0x20));
525
			if (data[1] & 0x80) {
526
				input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
527 528
			} else {
				/* Out of proximity, clear wheel value. */
529
				input_report_abs(input, ABS_WHEEL, 0);
530
			}
531
			if (features->type != INTUOS4S) {
532 533
				input_report_key(input, BTN_7, (data[3] & 0x40));
				input_report_key(input, BTN_8, (data[3] & 0x80));
534 535
			}
			if (data[1] | (data[2] & 0x01) | data[3]) {
536 537
				input_report_key(input, wacom->tool[1], 1);
				input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
538
			} else {
539 540
				input_report_key(input, wacom->tool[1], 0);
				input_report_abs(input, ABS_MISC, 0);
541
			}
542 543 544 545 546 547 548
		} else if (features->type == DTK) {
			input_report_key(input, BTN_0, (data[6] & 0x01));
			input_report_key(input, BTN_1, (data[6] & 0x02));
			input_report_key(input, BTN_2, (data[6] & 0x04));
			input_report_key(input, BTN_3, (data[6] & 0x08));
			input_report_key(input, BTN_4, (data[6] & 0x10));
			input_report_key(input, BTN_5, (data[6] & 0x20));
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
		} else if (features->type == WACOM_24HD) {
			input_report_key(input, BTN_0, (data[6] & 0x01));
			input_report_key(input, BTN_1, (data[6] & 0x02));
			input_report_key(input, BTN_2, (data[6] & 0x04));
			input_report_key(input, BTN_3, (data[6] & 0x08));
			input_report_key(input, BTN_4, (data[6] & 0x10));
			input_report_key(input, BTN_5, (data[6] & 0x20));
			input_report_key(input, BTN_6, (data[6] & 0x40));
			input_report_key(input, BTN_7, (data[6] & 0x80));
			input_report_key(input, BTN_8, (data[8] & 0x01));
			input_report_key(input, BTN_9, (data[8] & 0x02));
			input_report_key(input, BTN_A, (data[8] & 0x04));
			input_report_key(input, BTN_B, (data[8] & 0x08));
			input_report_key(input, BTN_C, (data[8] & 0x10));
			input_report_key(input, BTN_X, (data[8] & 0x20));
			input_report_key(input, BTN_Y, (data[8] & 0x40));
			input_report_key(input, BTN_Z, (data[8] & 0x80));

			/*
			 * Three "buttons" are available on the 24HD which are
			 * physically implemented as a touchstrip. Each button
			 * is approximately 3 bits wide with a 2 bit spacing.
			 * The raw touchstrip bits are stored at:
			 *    ((data[3] & 0x1f) << 8) | data[4])
			 */
			input_report_key(input, KEY_PROG1, data[4] & 0x07);
			input_report_key(input, KEY_PROG2, data[4] & 0xE0);
			input_report_key(input, KEY_PROG3, data[3] & 0x1C);

			if (data[1] & 0x80) {
				input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
			} else {
				/* Out of proximity, clear wheel value. */
				input_report_abs(input, ABS_WHEEL, 0);
			}

			if (data[2] & 0x80) {
				input_report_abs(input, ABS_THROTTLE, (data[2] & 0x7f));
			} else {
				/* Out of proximity, clear second wheel value. */
				input_report_abs(input, ABS_THROTTLE, 0);
			}

			if (data[1] | data[2] | (data[3] & 0x1f) | data[4] | data[6] | data[8]) {
				input_report_key(input, wacom->tool[1], 1);
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
				input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
			} else {
				input_report_key(input, wacom->tool[1], 0);
				input_report_abs(input, ABS_MISC, 0);
			}
		} else if (features->type >= INTUOS5S && features->type <= INTUOS5L) {
			int i;

			/* Touch ring mode switch has no capacitive sensor */
			input_report_key(input, BTN_0, (data[3] & 0x01));

			/*
			 * ExpressKeys on Intuos5 have a capacitive sensor in
			 * addition to the mechanical switch. Switch data is
			 * stored in data[4], capacitive data in data[5].
			 */
			for (i = 0; i < 8; i++)
				input_report_key(input, BTN_1 + i, data[4] & (1 << i));

			if (data[2] & 0x80) {
				input_report_abs(input, ABS_WHEEL, (data[2] & 0x7f));
			} else {
				/* Out of proximity, clear wheel value. */
				input_report_abs(input, ABS_WHEEL, 0);
			}

620
			if (data[2] | (data[3] & 0x01) | data[4] | data[5]) {
621
				input_report_key(input, wacom->tool[1], 1);
622 623 624 625 626
				input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
			} else {
				input_report_key(input, wacom->tool[1], 0);
				input_report_abs(input, ABS_MISC, 0);
			}
627
		} else {
628
			if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
				input_report_key(input, BTN_0, (data[5] & 0x01));
				input_report_key(input, BTN_1, (data[6] & 0x01));
				input_report_key(input, BTN_2, (data[6] & 0x02));
				input_report_key(input, BTN_3, (data[6] & 0x04));
				input_report_key(input, BTN_4, (data[6] & 0x08));
				input_report_key(input, BTN_5, (data[6] & 0x10));
				input_report_key(input, BTN_6, (data[6] & 0x20));
				input_report_key(input, BTN_7, (data[6] & 0x40));
				input_report_key(input, BTN_8, (data[6] & 0x80));
				input_report_key(input, BTN_9, (data[7] & 0x01));
				input_report_key(input, BTN_A, (data[8] & 0x01));
				input_report_key(input, BTN_B, (data[8] & 0x02));
				input_report_key(input, BTN_C, (data[8] & 0x04));
				input_report_key(input, BTN_X, (data[8] & 0x08));
				input_report_key(input, BTN_Y, (data[8] & 0x10));
				input_report_key(input, BTN_Z, (data[8] & 0x20));
				input_report_key(input, BTN_BASE, (data[8] & 0x40));
				input_report_key(input, BTN_BASE2, (data[8] & 0x80));
647 648 649 650 651 652

				if (features->type == WACOM_22HD) {
					input_report_key(input, KEY_PROG1, data[9] & 0x01);
					input_report_key(input, KEY_PROG2, data[9] & 0x02);
					input_report_key(input, KEY_PROG3, data[9] & 0x04);
				}
653 654 655 656 657 658 659 660 661 662 663 664
			} else {
				input_report_key(input, BTN_0, (data[5] & 0x01));
				input_report_key(input, BTN_1, (data[5] & 0x02));
				input_report_key(input, BTN_2, (data[5] & 0x04));
				input_report_key(input, BTN_3, (data[5] & 0x08));
				input_report_key(input, BTN_4, (data[6] & 0x01));
				input_report_key(input, BTN_5, (data[6] & 0x02));
				input_report_key(input, BTN_6, (data[6] & 0x04));
				input_report_key(input, BTN_7, (data[6] & 0x08));
				input_report_key(input, BTN_8, (data[5] & 0x10));
				input_report_key(input, BTN_9, (data[6] & 0x10));
			}
665 666
			input_report_abs(input, ABS_RX, ((data[1] & 0x1f) << 8) | data[2]);
			input_report_abs(input, ABS_RY, ((data[3] & 0x1f) << 8) | data[4]);
667

668
			if ((data[5] & 0x1f) | data[6] | (data[1] & 0x1f) |
669 670
				data[2] | (data[3] & 0x1f) | data[4] | data[8] |
				(data[7] & 0x01)) {
671 672
				input_report_key(input, wacom->tool[1], 1);
				input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
673
			} else {
674 675
				input_report_key(input, wacom->tool[1], 0);
				input_report_abs(input, ABS_MISC, 0);
676 677
			}
		}
678
		input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
679 680 681 682
                return 1;
	}

	/* process in/out prox events */
683
	result = wacom_intuos_inout(wacom);
684
	if (result)
685
                return result - 1;
686

687 688 689 690 691
	/* don't proceed if we don't know the ID */
	if (!wacom->id[idx])
		return 0;

	/* Only large Intuos support Lense Cursor */
692 693 694 695
	if (wacom->tool[idx] == BTN_TOOL_LENS &&
	    (features->type == INTUOS3 ||
	     features->type == INTUOS3S ||
	     features->type == INTUOS4 ||
696 697 698
	     features->type == INTUOS4S ||
	     features->type == INTUOS5 ||
	     features->type == INTUOS5S)) {
699

P
Ping Cheng 已提交
700
		return 0;
701
	}
P
Ping Cheng 已提交
702

703
	/* Cintiq doesn't send data when RDY bit isn't set */
704
	if (features->type == CINTIQ && !(data[1] & 0x40))
705 706
                 return 0;

707
	if (features->type >= INTUOS3S) {
708 709 710
		input_report_abs(input, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
		input_report_abs(input, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
		input_report_abs(input, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
711
	} else {
712 713
		input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[2]));
		input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[4]));
714
		input_report_abs(input, ABS_DISTANCE, ((data[9] >> 3) & 0x1f));
715 716 717
	}

	/* process general packets */
718
	wacom_intuos_general(wacom);
719

720 721
	/* 4D mouse, 2D mouse, marker pen rotation, tilt mouse, or Lens cursor packets */
	if ((data[1] & 0xbc) == 0xa8 || (data[1] & 0xbe) == 0xb0 || (data[1] & 0xbc) == 0xac) {
722 723 724

		if (data[1] & 0x02) {
			/* Rotation packet */
725
			if (features->type >= INTUOS3S) {
726
				/* I3 marker pen rotation */
727 728 729
				t = (data[6] << 3) | ((data[7] >> 5) & 7);
				t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
					((t-1) / 2 + 450)) : (450 - t / 2) ;
730
				input_report_abs(input, ABS_Z, t);
731 732 733
			} else {
				/* 4D mouse rotation packet */
				t = (data[6] << 3) | ((data[7] >> 5) & 7);
734
				input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
735 736 737
					((t - 1) / 2) : -t / 2);
			}

738
		} else if (!(data[1] & 0x10) && features->type < INTUOS3S) {
739
			/* 4D mouse packet */
740 741 742
			input_report_key(input, BTN_LEFT,   data[8] & 0x01);
			input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
			input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
743

744 745
			input_report_key(input, BTN_SIDE,   data[8] & 0x20);
			input_report_key(input, BTN_EXTRA,  data[8] & 0x10);
746
			t = (data[6] << 2) | ((data[7] >> 6) & 3);
747
			input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
748 749

		} else if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
750
			/* I4 mouse */
751 752
			if ((features->type >= INTUOS4S && features->type <= INTUOS4L) ||
			    (features->type >= INTUOS5S && features->type <= INTUOS5L)) {
753 754 755 756
				input_report_key(input, BTN_LEFT,   data[6] & 0x01);
				input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
				input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
				input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
757
						 - ((data[7] & 0x40) >> 6));
758 759
				input_report_key(input, BTN_SIDE,   data[6] & 0x08);
				input_report_key(input, BTN_EXTRA,  data[6] & 0x10);
760

761
				input_report_abs(input, ABS_TILT_X,
762
					((data[7] << 1) & 0x7e) | (data[8] >> 7));
763
				input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
764 765
			} else {
				/* 2D mouse packet */
766 767 768 769
				input_report_key(input, BTN_LEFT,   data[8] & 0x04);
				input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
				input_report_key(input, BTN_RIGHT,  data[8] & 0x10);
				input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
770 771
						 - ((data[8] & 0x02) >> 1));

772
				/* I3 2D mouse side buttons */
773
				if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
774 775
					input_report_key(input, BTN_SIDE,   data[8] & 0x40);
					input_report_key(input, BTN_EXTRA,  data[8] & 0x20);
776
				}
777
			}
778
		} else if ((features->type < INTUOS3S || features->type == INTUOS3L ||
779
				features->type == INTUOS4L || features->type == INTUOS5L) &&
780
			   wacom->tool[idx] == BTN_TOOL_LENS) {
781
			/* Lens cursor packets */
782 783 784 785 786
			input_report_key(input, BTN_LEFT,   data[8] & 0x01);
			input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
			input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
			input_report_key(input, BTN_SIDE,   data[8] & 0x10);
			input_report_key(input, BTN_EXTRA,  data[8] & 0x08);
787 788 789
		}
	}

790 791 792
	input_report_abs(input, ABS_MISC, wacom->id[idx]); /* report tool id */
	input_report_key(input, wacom->tool[idx], 1);
	input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
793 794 795
	return 1;
}

796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
static int int_dist(int x1, int y1, int x2, int y2)
{
	int x = x2 - x1;
	int y = y2 - y1;

	return int_sqrt(x*x + y*y);
}

static int wacom_24hdt_irq(struct wacom_wac *wacom)
{
	struct input_dev *input = wacom->input;
	char *data = wacom->data;
	int i;
	int current_num_contacts = data[61];
	int contacts_to_send = 0;

	/*
	 * First packet resets the counter since only the first
	 * packet in series will have non-zero current_num_contacts.
	 */
	if (current_num_contacts)
		wacom->num_contacts_left = current_num_contacts;

	/* There are at most 4 contacts per packet */
	contacts_to_send = min(4, wacom->num_contacts_left);

	for (i = 0; i < contacts_to_send; i++) {
		int offset = (WACOM_BYTES_PER_24HDT_PACKET * i) + 1;
		bool touch = data[offset] & 0x1 && !wacom->shared->stylus_in_proximity;
825
		int slot = input_mt_get_slot_by_key(input, data[offset + 1]);
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856

		if (slot < 0)
			continue;
		input_mt_slot(input, slot);
		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);

		if (touch) {
			int t_x = le16_to_cpup((__le16 *)&data[offset + 2]);
			int c_x = le16_to_cpup((__le16 *)&data[offset + 4]);
			int t_y = le16_to_cpup((__le16 *)&data[offset + 6]);
			int c_y = le16_to_cpup((__le16 *)&data[offset + 8]);
			int w = le16_to_cpup((__le16 *)&data[offset + 10]);
			int h = le16_to_cpup((__le16 *)&data[offset + 12]);

			input_report_abs(input, ABS_MT_POSITION_X, t_x);
			input_report_abs(input, ABS_MT_POSITION_Y, t_y);
			input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
			input_report_abs(input, ABS_MT_WIDTH_MAJOR, min(w, h) + int_dist(t_x, t_y, c_x, c_y));
			input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
			input_report_abs(input, ABS_MT_ORIENTATION, w > h);
		}
	}
	input_mt_report_pointer_emulation(input, true);

	wacom->num_contacts_left -= contacts_to_send;
	if (wacom->num_contacts_left <= 0)
		wacom->num_contacts_left = 0;

	return 1;
}

857 858 859 860 861 862 863
static int wacom_mt_touch(struct wacom_wac *wacom)
{
	struct input_dev *input = wacom->input;
	char *data = wacom->data;
	int i;
	int current_num_contacts = data[2];
	int contacts_to_send = 0;
864 865 866 867 868
	int x_offset = 0;

	/* MTTPC does not support Height and Width */
	if (wacom->features.type == MTTPC)
		x_offset = -4;
869 870 871 872 873 874 875 876 877 878 879 880

	/*
	 * First packet resets the counter since only the first
	 * packet in series will have non-zero current_num_contacts.
	 */
	if (current_num_contacts)
		wacom->num_contacts_left = current_num_contacts;

	/* There are at most 5 contacts per packet */
	contacts_to_send = min(5, wacom->num_contacts_left);

	for (i = 0; i < contacts_to_send; i++) {
881
		int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
882 883
		bool touch = data[offset] & 0x1;
		int id = le16_to_cpup((__le16 *)&data[offset + 1]);
884
		int slot = input_mt_get_slot_by_key(input, id);
885 886 887 888 889 890 891

		if (slot < 0)
			continue;

		input_mt_slot(input, slot);
		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
		if (touch) {
892 893
			int x = le16_to_cpup((__le16 *)&data[offset + x_offset + 7]);
			int y = le16_to_cpup((__le16 *)&data[offset + x_offset + 9]);
894 895 896 897 898 899 900 901 902 903 904 905 906
			input_report_abs(input, ABS_MT_POSITION_X, x);
			input_report_abs(input, ABS_MT_POSITION_Y, y);
		}
	}
	input_mt_report_pointer_emulation(input, true);

	wacom->num_contacts_left -= contacts_to_send;
	if (wacom->num_contacts_left < 0)
		wacom->num_contacts_left = 0;

	return 1;
}

907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
{
	struct input_dev *input = wacom->input;
	unsigned char *data = wacom->data;
	int contact_with_no_pen_down_count = 0;
	int i;

	for (i = 0; i < 2; i++) {
		int p = data[1] & (1 << i);
		bool touch = p && !wacom->shared->stylus_in_proximity;

		input_mt_slot(input, i);
		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
		if (touch) {
			int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
			int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;

			input_report_abs(input, ABS_MT_POSITION_X, x);
			input_report_abs(input, ABS_MT_POSITION_Y, y);
			contact_with_no_pen_down_count++;
		}
	}
929
	input_mt_report_pointer_emulation(input, true);
930 931 932 933 934 935 936

	/* keep touch state for pen event */
	wacom->shared->touch_down = (contact_with_no_pen_down_count > 0);

	return 1;
}

937
static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
938 939
{
	char *data = wacom->data;
940
	struct input_dev *input = wacom->input;
941 942
	bool prox;
	int x = 0, y = 0;
943

944 945 946
	if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
		return 0;

947 948 949 950 951
	if (!wacom->shared->stylus_in_proximity) {
		if (len == WACOM_PKGLEN_TPC1FG) {
			prox = data[0] & 0x01;
			x = get_unaligned_le16(&data[1]);
			y = get_unaligned_le16(&data[3]);
952
		} else {
953 954 955 956 957 958 959
			prox = data[1] & 0x01;
			x = le16_to_cpup((__le16 *)&data[2]);
			y = le16_to_cpup((__le16 *)&data[4]);
		}
	} else
		/* force touch out when pen is in prox */
		prox = 0;
960

961 962 963 964 965
	if (prox) {
		input_report_abs(input, ABS_X, x);
		input_report_abs(input, ABS_Y, y);
	}
	input_report_key(input, BTN_TOUCH, prox);
966

967 968
	/* keep touch state for pen events */
	wacom->shared->touch_down = prox;
969

970
	return 1;
971 972
}

973
static int wacom_tpc_pen(struct wacom_wac *wacom)
974
{
975
	struct wacom_features *features = &wacom->features;
976
	char *data = wacom->data;
977
	struct input_dev *input = wacom->input;
978 979
	int pressure;
	bool prox = data[1] & 0x20;
980

981
	if (!wacom->shared->stylus_in_proximity) /* first in prox */
982 983 984
		/* Going into proximity select tool */
		wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;

985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000
	/* keep pen state for touch events */
	wacom->shared->stylus_in_proximity = prox;

	/* send pen events only when touch is up or forced out */
	if (!wacom->shared->touch_down) {
		input_report_key(input, BTN_STYLUS, data[1] & 0x02);
		input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
		input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
		input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
		pressure = ((data[7] & 0x01) << 8) | data[6];
		if (pressure < 0)
			pressure = features->pressure_max + pressure + 1;
		input_report_abs(input, ABS_PRESSURE, pressure);
		input_report_key(input, BTN_TOUCH, data[1] & 0x05);
		input_report_key(input, wacom->tool[0], prox);
		return 1;
1001 1002
	}

1003
	return 0;
1004 1005 1006 1007 1008
}

static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
{
	char *data = wacom->data;
1009

1010 1011
	dev_dbg(wacom->input->dev.parent,
		"%s: received report #%d\n", __func__, data[0]);
1012

1013 1014
	switch (len) {
	case WACOM_PKGLEN_TPC1FG:
1015
		return wacom_tpc_single_touch(wacom, len);
1016 1017

	case WACOM_PKGLEN_TPC2FG:
1018
		return wacom_tpc_mt_touch(wacom);
1019 1020 1021 1022 1023 1024

	default:
		switch (data[0]) {
		case WACOM_REPORT_TPC1FG:
		case WACOM_REPORT_TPCHID:
		case WACOM_REPORT_TPCST:
1025
		case WACOM_REPORT_TPC1FGE:
1026 1027
			return wacom_tpc_single_touch(wacom, len);

1028 1029 1030
		case WACOM_REPORT_TPCMT:
			return wacom_mt_touch(wacom);

1031 1032 1033 1034
		case WACOM_REPORT_PENABLED:
			return wacom_tpc_pen(wacom);
		}
	}
1035

1036
	return 0;
1037 1038
}

1039
static int wacom_bpt_touch(struct wacom_wac *wacom)
1040
{
1041
	struct wacom_features *features = &wacom->features;
1042 1043 1044 1045
	struct input_dev *input = wacom->input;
	unsigned char *data = wacom->data;
	int i;

1046 1047 1048
	if (data[0] != 0x02)
	    return 0;

1049
	for (i = 0; i < 2; i++) {
1050 1051
		int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
		bool touch = data[offset + 3] & 0x80;
1052

1053 1054 1055 1056 1057 1058
		/*
		 * Touch events need to be disabled while stylus is
		 * in proximity because user's hand is resting on touchpad
		 * and sending unwanted events.  User expects tablet buttons
		 * to continue working though.
		 */
1059 1060 1061 1062
		touch = touch && !wacom->shared->stylus_in_proximity;

		input_mt_slot(input, i);
		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1063
		if (touch) {
1064 1065
			int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
			int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
1066 1067 1068 1069
			if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
				x <<= 5;
				y <<= 5;
			}
1070 1071 1072 1073 1074
			input_report_abs(input, ABS_MT_POSITION_X, x);
			input_report_abs(input, ABS_MT_POSITION_Y, y);
		}
	}

1075
	input_mt_report_pointer_emulation(input, true);
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086

	input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
	input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
	input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
	input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);

	input_sync(input);

	return 0;
}

1087 1088 1089 1090
static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
{
	struct input_dev *input = wacom->input;
	bool touch = data[1] & 0x80;
1091 1092 1093 1094
	int slot = input_mt_get_slot_by_key(input, data[0]);

	if (slot < 0)
		return;
1095 1096 1097

	touch = touch && !wacom->shared->stylus_in_proximity;

1098
	input_mt_slot(input, slot);
1099 1100 1101 1102 1103
	input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);

	if (touch) {
		int x = (data[2] << 4) | (data[4] >> 4);
		int y = (data[3] << 4) | (data[4] & 0x0f);
1104 1105 1106 1107 1108 1109 1110 1111
		int a = data[5];

		// "a" is a scaled-down area which we assume is roughly
		// circular and which can be described as: a=(pi*r^2)/C.
		int x_res  = input_abs_get_res(input, ABS_X);
		int y_res  = input_abs_get_res(input, ABS_Y);
		int width  = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
		int height = width * y_res / x_res;
1112 1113 1114

		input_report_abs(input, ABS_MT_POSITION_X, x);
		input_report_abs(input, ABS_MT_POSITION_Y, y);
1115 1116
		input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
		input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	}
}

static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
{
	struct input_dev *input = wacom->input;

	input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
	input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
	input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
	input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
}

static int wacom_bpt3_touch(struct wacom_wac *wacom)
{
	struct input_dev *input = wacom->input;
	unsigned char *data = wacom->data;
1134
	int count = data[1] & 0x07;
1135 1136
	int i;

1137 1138 1139
	if (data[0] != 0x02)
	    return 0;

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	/* data has up to 7 fixed sized 8-byte messages starting at data[2] */
	for (i = 0; i < count; i++) {
		int offset = (8 * i) + 2;
		int msg_id = data[offset];

		if (msg_id >= 2 && msg_id <= 17)
			wacom_bpt3_touch_msg(wacom, data + offset);
		else if (msg_id == 128)
			wacom_bpt3_button_msg(wacom, data + offset);

	}
	input_mt_report_pointer_emulation(input, true);

	input_sync(input);

	return 0;
}

1158 1159 1160 1161 1162 1163
static int wacom_bpt_pen(struct wacom_wac *wacom)
{
	struct input_dev *input = wacom->input;
	unsigned char *data = wacom->data;
	int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;

1164 1165 1166
	if (data[0] != 0x02)
	    return 0;

1167
	prox = (data[1] & 0x20) == 0x20;
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192

	/*
	 * All reports shared between PEN and RUBBER tool must be
	 * forced to a known starting value (zero) when transitioning to
	 * out-of-prox.
	 *
	 * If not reset then, to userspace, it will look like lost events
	 * if new tool comes in-prox with same values as previous tool sent.
	 *
	 * Hardware does report zero in most out-of-prox cases but not all.
	 */
	if (prox) {
		if (!wacom->shared->stylus_in_proximity) {
			if (data[1] & 0x08) {
				wacom->tool[0] = BTN_TOOL_RUBBER;
				wacom->id[0] = ERASER_DEVICE_ID;
			} else {
				wacom->tool[0] = BTN_TOOL_PEN;
				wacom->id[0] = STYLUS_DEVICE_ID;
			}
			wacom->shared->stylus_in_proximity = true;
		}
		x = le16_to_cpup((__le16 *)&data[2]);
		y = le16_to_cpup((__le16 *)&data[4]);
		p = le16_to_cpup((__le16 *)&data[6]);
1193 1194 1195 1196 1197 1198 1199 1200 1201
		/*
		 * Convert distance from out prox to distance from tablet.
		 * distance will be greater than distance_max once
		 * touching and applying pressure; do not report negative
		 * distance.
		 */
		if (data[8] <= wacom->features.distance_max)
			d = wacom->features.distance_max - data[8];

1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
		pen = data[1] & 0x01;
		btn1 = data[1] & 0x02;
		btn2 = data[1] & 0x04;
	}

	input_report_key(input, BTN_TOUCH, pen);
	input_report_key(input, BTN_STYLUS, btn1);
	input_report_key(input, BTN_STYLUS2, btn2);

	input_report_abs(input, ABS_X, x);
	input_report_abs(input, ABS_Y, y);
	input_report_abs(input, ABS_PRESSURE, p);
	input_report_abs(input, ABS_DISTANCE, d);

	if (!prox) {
		wacom->id[0] = 0;
		wacom->shared->stylus_in_proximity = false;
	}

	input_report_key(input, wacom->tool[0], prox); /* PEN or RUBBER */
	input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */

	return 1;
}

1227 1228 1229 1230
static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
{
	if (len == WACOM_PKGLEN_BBTOUCH)
		return wacom_bpt_touch(wacom);
1231 1232 1233
	else if (len == WACOM_PKGLEN_BBTOUCH3)
		return wacom_bpt3_touch(wacom);
	else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
1234
		return wacom_bpt_pen(wacom);
1235 1236 1237 1238

	return 0;
}

1239 1240
static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
{
1241 1242 1243 1244
	unsigned char *data = wacom->data;
	int connected;

	if (len != WACOM_PKGLEN_WIRELESS || data[0] != 0x80)
1245 1246
		return 0;

1247 1248
	connected = data[1] & 0x01;
	if (connected) {
1249
		int pid, battery;
1250 1251

		pid = get_unaligned_be16(&data[6]);
1252
		battery = data[5] & 0x3f;
1253 1254 1255 1256
		if (wacom->pid != pid) {
			wacom->pid = pid;
			wacom_schedule_work(wacom);
		}
1257
		wacom->battery_capacity = battery;
1258 1259 1260 1261
	} else if (wacom->pid != 0) {
		/* disconnected while previously connected */
		wacom->pid = 0;
		wacom_schedule_work(wacom);
1262
		wacom->battery_capacity = 0;
1263 1264
	}

1265 1266 1267
	return 0;
}

1268
void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
1269
{
1270 1271
	bool sync;

1272
	switch (wacom_wac->features.type) {
1273
	case PENPARTNER:
1274 1275
		sync = wacom_penpartner_irq(wacom_wac);
		break;
1276 1277

	case PL:
1278 1279
		sync = wacom_pl_irq(wacom_wac);
		break;
1280 1281 1282 1283

	case WACOM_G4:
	case GRAPHIRE:
	case WACOM_MO:
1284 1285
		sync = wacom_graphire_irq(wacom_wac);
		break;
1286 1287

	case PTU:
1288 1289
		sync = wacom_ptu_irq(wacom_wac);
		break;
1290

1291 1292 1293 1294
	case DTU:
		sync = wacom_dtu_irq(wacom_wac);
		break;

1295 1296 1297 1298 1299 1300 1301 1302 1303
	case INTUOS:
	case INTUOS3S:
	case INTUOS3:
	case INTUOS3L:
	case INTUOS4S:
	case INTUOS4:
	case INTUOS4L:
	case CINTIQ:
	case WACOM_BEE:
1304
	case WACOM_21UX2:
1305
	case WACOM_22HD:
1306
	case WACOM_24HD:
1307
	case DTK:
1308 1309
		sync = wacom_intuos_irq(wacom_wac);
		break;
1310

1311 1312 1313 1314
	case WACOM_24HDT:
		sync = wacom_24hdt_irq(wacom_wac);
		break;

1315 1316 1317 1318 1319 1320 1321 1322 1323
	case INTUOS5S:
	case INTUOS5:
	case INTUOS5L:
		if (len == WACOM_PKGLEN_BBTOUCH3)
			sync = wacom_bpt3_touch(wacom_wac);
		else
			sync = wacom_intuos_irq(wacom_wac);
		break;

1324
	case TABLETPC:
1325
	case TABLETPCE:
1326
	case TABLETPC2FG:
1327
	case MTSCREEN:
1328
	case MTTPC:
1329 1330
		sync = wacom_tpc_irq(wacom_wac, len);
		break;
1331

1332 1333 1334 1335
	case BAMBOO_PT:
		sync = wacom_bpt_irq(wacom_wac, len);
		break;

1336 1337 1338 1339
	case WIRELESS:
		sync = wacom_wireless_irq(wacom_wac, len);
		break;

1340
	default:
1341 1342
		sync = false;
		break;
1343
	}
1344 1345 1346

	if (sync)
		input_sync(wacom_wac->input);
1347 1348
}

1349
static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
{
	struct input_dev *input_dev = wacom_wac->input;

	input_set_capability(input_dev, EV_MSC, MSC_SERIAL);

	__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
	__set_bit(BTN_TOOL_PEN, input_dev->keybit);
	__set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
	__set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
	__set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
	__set_bit(BTN_STYLUS, input_dev->keybit);
	__set_bit(BTN_STYLUS2, input_dev->keybit);

	input_set_abs_params(input_dev, ABS_DISTANCE,
			     0, wacom_wac->features.distance_max, 0, 0);
	input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
	input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
	input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
}

static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
{
	struct input_dev *input_dev = wacom_wac->input;

	input_set_capability(input_dev, EV_REL, REL_WHEEL);

	wacom_setup_cintiq(wacom_wac);

	__set_bit(BTN_LEFT, input_dev->keybit);
	__set_bit(BTN_RIGHT, input_dev->keybit);
	__set_bit(BTN_MIDDLE, input_dev->keybit);
	__set_bit(BTN_SIDE, input_dev->keybit);
	__set_bit(BTN_EXTRA, input_dev->keybit);
	__set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
	__set_bit(BTN_TOOL_LENS, input_dev->keybit);

1386 1387 1388 1389
	input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
	input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
}

1390 1391 1392 1393
void wacom_setup_device_quirks(struct wacom_features *features)
{

	/* touch device found but size is not defined. use default */
1394
	if (features->device_type == BTN_TOOL_FINGER && !features->x_max) {
1395 1396 1397 1398 1399
		features->x_max = 1023;
		features->y_max = 1023;
	}

	/* these device have multiple inputs */
P
Ping Cheng 已提交
1400
	if (features->type >= WIRELESS ||
1401 1402
	    (features->type >= INTUOS5S && features->type <= INTUOS5L) ||
	    (features->oVid && features->oPid))
1403
		features->quirks |= WACOM_QUIRK_MULTI_INPUT;
1404

1405
	/* quirk for bamboo touch with 2 low res touches */
1406
	if (features->type == BAMBOO_PT &&
1407
	    features->pktlen == WACOM_PKGLEN_BBTOUCH) {
1408 1409 1410 1411 1412
		features->x_max <<= 5;
		features->y_max <<= 5;
		features->x_fuzz <<= 5;
		features->y_fuzz <<= 5;
		features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
1413
	}
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423

	if (features->type == WIRELESS) {

		/* monitor never has input and pen/touch have delayed create */
		features->quirks |= WACOM_QUIRK_NO_INPUT;

		/* must be monitor interface if no device_type set */
		if (!features->device_type)
			features->quirks |= WACOM_QUIRK_MONITOR;
	}
1424 1425
}

1426 1427 1428 1429 1430 1431 1432
static unsigned int wacom_calculate_touch_res(unsigned int logical_max,
					      unsigned int physical_max)
{
       /* Touch physical dimensions are in 100th of mm */
       return (logical_max * 100) / physical_max;
}

1433 1434
static void wacom_abs_set_axis(struct input_dev *input_dev,
			       struct wacom_wac *wacom_wac)
1435
{
1436 1437
	struct wacom_features *features = &wacom_wac->features;

1438
	if (features->device_type == BTN_TOOL_PEN) {
1439 1440 1441 1442 1443 1444
		input_set_abs_params(input_dev, ABS_X, 0, features->x_max,
				     features->x_fuzz, 0);
		input_set_abs_params(input_dev, ABS_Y, 0, features->y_max,
				     features->y_fuzz, 0);
		input_set_abs_params(input_dev, ABS_PRESSURE, 0,
			features->pressure_max, features->pressure_fuzz, 0);
1445

1446 1447 1448 1449
		/* penabled devices have fixed resolution for each model */
		input_abs_set_res(input_dev, ABS_X, features->x_resolution);
		input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
	} else {
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
		if (features->touch_max <= 2) {
			input_set_abs_params(input_dev, ABS_X, 0,
				features->x_max, features->x_fuzz, 0);
			input_set_abs_params(input_dev, ABS_Y, 0,
				features->y_max, features->y_fuzz, 0);
			input_abs_set_res(input_dev, ABS_X,
				wacom_calculate_touch_res(features->x_max,
							features->x_phy));
			input_abs_set_res(input_dev, ABS_Y,
				wacom_calculate_touch_res(features->y_max,
							features->y_phy));
		}

		if (features->touch_max > 1) {
			input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
				features->x_max, features->x_fuzz, 0);
			input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
				features->y_max, features->y_fuzz, 0);
			input_abs_set_res(input_dev, ABS_MT_POSITION_X,
				wacom_calculate_touch_res(features->x_max,
							features->x_phy));
			input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
				wacom_calculate_touch_res(features->y_max,
							features->y_phy));
		}
1475
	}
1476
}
1477

1478 1479 1480 1481 1482 1483 1484 1485 1486
int wacom_setup_input_capabilities(struct input_dev *input_dev,
				   struct wacom_wac *wacom_wac)
{
	struct wacom_features *features = &wacom_wac->features;
	int i;

	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);

	__set_bit(BTN_TOUCH, input_dev->keybit);
1487 1488
	__set_bit(ABS_MISC, input_dev->absbit);

1489 1490
	wacom_abs_set_axis(input_dev, wacom_wac);

1491
	switch (wacom_wac->features.type) {
1492
	case WACOM_MO:
1493 1494
		input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
		/* fall through */
1495 1496

	case WACOM_G4:
1497 1498
		input_set_capability(input_dev, EV_MSC, MSC_SERIAL);

1499 1500
		__set_bit(BTN_BACK, input_dev->keybit);
		__set_bit(BTN_FORWARD, input_dev->keybit);
1501 1502 1503
		/* fall through */

	case GRAPHIRE:
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
		input_set_capability(input_dev, EV_REL, REL_WHEEL);

		__set_bit(BTN_LEFT, input_dev->keybit);
		__set_bit(BTN_RIGHT, input_dev->keybit);
		__set_bit(BTN_MIDDLE, input_dev->keybit);

		__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
		__set_bit(BTN_TOOL_PEN, input_dev->keybit);
		__set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
		__set_bit(BTN_STYLUS, input_dev->keybit);
		__set_bit(BTN_STYLUS2, input_dev->keybit);
1515 1516

		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1517 1518
		break;

1519 1520 1521 1522 1523 1524 1525 1526
	case WACOM_24HD:
		__set_bit(BTN_A, input_dev->keybit);
		__set_bit(BTN_B, input_dev->keybit);
		__set_bit(BTN_C, input_dev->keybit);
		__set_bit(BTN_X, input_dev->keybit);
		__set_bit(BTN_Y, input_dev->keybit);
		__set_bit(BTN_Z, input_dev->keybit);

1527
		for (i = 6; i < 10; i++)
1528 1529 1530 1531 1532
			__set_bit(BTN_0 + i, input_dev->keybit);

		__set_bit(KEY_PROG1, input_dev->keybit);
		__set_bit(KEY_PROG2, input_dev->keybit);
		__set_bit(KEY_PROG3, input_dev->keybit);
1533 1534 1535 1536 1537
		/* fall through */

	case DTK:
		for (i = 0; i < 6; i++)
			__set_bit(BTN_0 + i, input_dev->keybit);
1538 1539 1540

		input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
		input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
1541 1542 1543

		__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);

1544 1545 1546
		wacom_setup_cintiq(wacom_wac);
		break;

1547 1548 1549 1550 1551 1552
	case WACOM_22HD:
		__set_bit(KEY_PROG1, input_dev->keybit);
		__set_bit(KEY_PROG2, input_dev->keybit);
		__set_bit(KEY_PROG3, input_dev->keybit);
		/* fall through */

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
	case WACOM_21UX2:
		__set_bit(BTN_A, input_dev->keybit);
		__set_bit(BTN_B, input_dev->keybit);
		__set_bit(BTN_C, input_dev->keybit);
		__set_bit(BTN_X, input_dev->keybit);
		__set_bit(BTN_Y, input_dev->keybit);
		__set_bit(BTN_Z, input_dev->keybit);
		__set_bit(BTN_BASE, input_dev->keybit);
		__set_bit(BTN_BASE2, input_dev->keybit);
		/* fall through */

1564
	case WACOM_BEE:
1565 1566 1567
		__set_bit(BTN_8, input_dev->keybit);
		__set_bit(BTN_9, input_dev->keybit);
		/* fall through */
1568

1569 1570 1571 1572
	case CINTIQ:
		for (i = 0; i < 8; i++)
			__set_bit(BTN_0 + i, input_dev->keybit);

1573 1574
		input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
		input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
1575
		input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1576 1577 1578

		__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);

1579 1580 1581
		wacom_setup_cintiq(wacom_wac);
		break;

1582 1583
	case INTUOS3:
	case INTUOS3L:
1584 1585 1586 1587 1588 1589
		__set_bit(BTN_4, input_dev->keybit);
		__set_bit(BTN_5, input_dev->keybit);
		__set_bit(BTN_6, input_dev->keybit);
		__set_bit(BTN_7, input_dev->keybit);

		input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
1590 1591 1592
		/* fall through */

	case INTUOS3S:
1593 1594 1595 1596 1597 1598 1599
		__set_bit(BTN_0, input_dev->keybit);
		__set_bit(BTN_1, input_dev->keybit);
		__set_bit(BTN_2, input_dev->keybit);
		__set_bit(BTN_3, input_dev->keybit);

		input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
		input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1600 1601 1602
		/* fall through */

	case INTUOS:
1603 1604
		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);

1605
		wacom_setup_intuos(wacom_wac);
1606 1607
		break;

1608 1609
	case INTUOS5:
	case INTUOS5L:
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
		if (features->device_type == BTN_TOOL_PEN) {
			__set_bit(BTN_7, input_dev->keybit);
			__set_bit(BTN_8, input_dev->keybit);
		}
		/* fall through */

	case INTUOS5S:
		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);

		if (features->device_type == BTN_TOOL_PEN) {
			for (i = 0; i < 7; i++)
				__set_bit(BTN_0 + i, input_dev->keybit);

			input_set_abs_params(input_dev, ABS_DISTANCE, 0,
					      features->distance_max,
					      0, 0);

			input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);

			wacom_setup_intuos(wacom_wac);
		} else if (features->device_type == BTN_TOOL_FINGER) {
			__clear_bit(ABS_MISC, input_dev->absbit);

			input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1634 1635 1636
			                     0, features->x_max, 0, 0);
			input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
			                     0, features->y_max, 0, 0);
1637
			input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
1638 1639 1640
		}
		break;

1641 1642
	case INTUOS4:
	case INTUOS4L:
1643 1644
		__set_bit(BTN_7, input_dev->keybit);
		__set_bit(BTN_8, input_dev->keybit);
1645 1646 1647
		/* fall through */

	case INTUOS4S:
1648 1649 1650 1651 1652
		for (i = 0; i < 7; i++)
			__set_bit(BTN_0 + i, input_dev->keybit);

		input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
		wacom_setup_intuos(wacom_wac);
1653 1654

		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1655 1656
		break;

1657 1658 1659 1660 1661 1662 1663 1664 1665
	case WACOM_24HDT:
		if (features->device_type == BTN_TOOL_FINGER) {
			input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
			input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
			input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
			input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
		}
		/* fall through */

1666
	case MTSCREEN:
1667
	case MTTPC:
1668 1669
	case TABLETPC2FG:
		if (features->device_type == BTN_TOOL_FINGER) {
1670 1671 1672 1673 1674 1675
			unsigned int flags = INPUT_MT_DIRECT;

			if (wacom_wac->features.type == TABLETPC2FG)
				flags = 0;

			input_mt_init_slots(input_dev, features->touch_max, flags);
1676
		}
1677 1678 1679
		/* fall through */

	case TABLETPC:
1680
	case TABLETPCE:
1681 1682
		__clear_bit(ABS_MISC, input_dev->absbit);

1683 1684
		__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);

1685
		if (features->device_type != BTN_TOOL_PEN)
1686
			break;  /* no need to process stylus stuff */
1687

1688 1689 1690
		/* fall through */

	case PL:
1691
	case DTU:
1692
		__set_bit(BTN_TOOL_PEN, input_dev->keybit);
1693
		__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1694 1695
		__set_bit(BTN_STYLUS, input_dev->keybit);
		__set_bit(BTN_STYLUS2, input_dev->keybit);
1696 1697 1698 1699 1700

		__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
		break;

	case PTU:
1701
		__set_bit(BTN_STYLUS2, input_dev->keybit);
1702 1703 1704
		/* fall through */

	case PENPARTNER:
1705
		__set_bit(BTN_TOOL_PEN, input_dev->keybit);
1706
		__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1707
		__set_bit(BTN_STYLUS, input_dev->keybit);
1708 1709

		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1710
		break;
1711 1712 1713 1714

	case BAMBOO_PT:
		__clear_bit(ABS_MISC, input_dev->absbit);

1715 1716
		__set_bit(INPUT_PROP_POINTER, input_dev->propbit);

1717
		if (features->device_type == BTN_TOOL_FINGER) {
1718 1719
			unsigned int flags = INPUT_MT_POINTER;

1720 1721 1722 1723 1724
			__set_bit(BTN_LEFT, input_dev->keybit);
			__set_bit(BTN_FORWARD, input_dev->keybit);
			__set_bit(BTN_BACK, input_dev->keybit);
			__set_bit(BTN_RIGHT, input_dev->keybit);

1725 1726 1727
			if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
				input_set_abs_params(input_dev,
						     ABS_MT_TOUCH_MAJOR,
1728 1729 1730 1731
						     0, features->x_max, 0, 0);
				input_set_abs_params(input_dev,
						     ABS_MT_TOUCH_MINOR,
						     0, features->y_max, 0, 0);
1732 1733 1734 1735
			} else {
				__set_bit(BTN_TOOL_FINGER, input_dev->keybit);
				__set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
				flags = 0;
1736
			}
1737
			input_mt_init_slots(input_dev, features->touch_max, flags);
1738 1739 1740 1741 1742
		} else if (features->device_type == BTN_TOOL_PEN) {
			__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
			__set_bit(BTN_TOOL_PEN, input_dev->keybit);
			__set_bit(BTN_STYLUS, input_dev->keybit);
			__set_bit(BTN_STYLUS2, input_dev->keybit);
1743 1744 1745
			input_set_abs_params(input_dev, ABS_DISTANCE, 0,
					      features->distance_max,
					      0, 0);
1746 1747
		}
		break;
1748
	}
1749
	return 0;
1750 1751
}

1752
static const struct wacom_features wacom_features_0x00 =
1753 1754
	{ "Wacom Penpartner",     WACOM_PKGLEN_PENPRTN,    5040,  3780,  255,
	  0, PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
1755
static const struct wacom_features wacom_features_0x10 =
1756 1757
	{ "Wacom Graphire",       WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511,
	  63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1758
static const struct wacom_features wacom_features_0x11 =
1759 1760
	{ "Wacom Graphire2 4x5",  WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511,
	  63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1761
static const struct wacom_features wacom_features_0x12 =
1762 1763
	{ "Wacom Graphire2 5x7",  WACOM_PKGLEN_GRAPHIRE,  13918, 10206,  511,
	  63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1764
static const struct wacom_features wacom_features_0x13 =
1765 1766
	{ "Wacom Graphire3",      WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511,
	  63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1767
static const struct wacom_features wacom_features_0x14 =
1768 1769
	{ "Wacom Graphire3 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
	  63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1770
static const struct wacom_features wacom_features_0x15 =
1771 1772
	{ "Wacom Graphire4 4x5",  WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511,
	  63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1773
static const struct wacom_features wacom_features_0x16 =
1774 1775
	{ "Wacom Graphire4 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
	  63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1776
static const struct wacom_features wacom_features_0x17 =
1777 1778
	{ "Wacom BambooFun 4x5",  WACOM_PKGLEN_BBFUN,     14760,  9225,  511,
	  63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1779
static const struct wacom_features wacom_features_0x18 =
1780 1781
	{ "Wacom BambooFun 6x8",  WACOM_PKGLEN_BBFUN,     21648, 13530,  511,
	  63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1782
static const struct wacom_features wacom_features_0x19 =
1783 1784
	{ "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
	  63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1785
static const struct wacom_features wacom_features_0x60 =
1786 1787
	{ "Wacom Volito",         WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
	  63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1788
static const struct wacom_features wacom_features_0x61 =
1789 1790
	{ "Wacom PenStation2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  255,
	  63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1791
static const struct wacom_features wacom_features_0x62 =
1792 1793
	{ "Wacom Volito2 4x5",    WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
	  63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1794
static const struct wacom_features wacom_features_0x63 =
1795 1796
	{ "Wacom Volito2 2x3",    WACOM_PKGLEN_GRAPHIRE,   3248,  2320,  511,
	  63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1797
static const struct wacom_features wacom_features_0x64 =
1798 1799
	{ "Wacom PenPartner2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  511,
	  63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1800
static const struct wacom_features wacom_features_0x65 =
1801 1802
	{ "Wacom Bamboo",         WACOM_PKGLEN_BBFUN,     14760,  9225,  511,
	  63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1803
static const struct wacom_features wacom_features_0x69 =
1804 1805
	{ "Wacom Bamboo1",        WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
	  63, GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
1806 1807 1808 1809 1810 1811
static const struct wacom_features wacom_features_0x6A =
	{ "Wacom Bamboo1 4x6",    WACOM_PKGLEN_GRAPHIRE,  14760,  9225, 1023,
	  63, GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
static const struct wacom_features wacom_features_0x6B =
	{ "Wacom Bamboo1 5x8",    WACOM_PKGLEN_GRAPHIRE,  21648, 13530, 1023,
	  63, GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1812
static const struct wacom_features wacom_features_0x20 =
1813 1814
	{ "Wacom Intuos 4x5",     WACOM_PKGLEN_INTUOS,    12700, 10600, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1815
static const struct wacom_features wacom_features_0x21 =
1816 1817
	{ "Wacom Intuos 6x8",     WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1818
static const struct wacom_features wacom_features_0x22 =
1819 1820
	{ "Wacom Intuos 9x12",    WACOM_PKGLEN_INTUOS,    30480, 24060, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1821
static const struct wacom_features wacom_features_0x23 =
1822 1823
	{ "Wacom Intuos 12x12",   WACOM_PKGLEN_INTUOS,    30480, 31680, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1824
static const struct wacom_features wacom_features_0x24 =
1825 1826
	{ "Wacom Intuos 12x18",   WACOM_PKGLEN_INTUOS,    45720, 31680, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1827
static const struct wacom_features wacom_features_0x30 =
1828 1829
	{ "Wacom PL400",          WACOM_PKGLEN_GRAPHIRE,   5408,  4056,  255,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1830
static const struct wacom_features wacom_features_0x31 =
1831 1832
	{ "Wacom PL500",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  255,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1833
static const struct wacom_features wacom_features_0x32 =
1834 1835
	{ "Wacom PL600",          WACOM_PKGLEN_GRAPHIRE,   6126,  4604,  255,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1836
static const struct wacom_features wacom_features_0x33 =
1837 1838
	{ "Wacom PL600SX",        WACOM_PKGLEN_GRAPHIRE,   6260,  5016,  255,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1839
static const struct wacom_features wacom_features_0x34 =
1840 1841
	{ "Wacom PL550",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1842
static const struct wacom_features wacom_features_0x35 =
1843 1844
	{ "Wacom PL800",          WACOM_PKGLEN_GRAPHIRE,   7220,  5780,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1845
static const struct wacom_features wacom_features_0x37 =
1846 1847
	{ "Wacom PL700",          WACOM_PKGLEN_GRAPHIRE,   6758,  5406,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1848
static const struct wacom_features wacom_features_0x38 =
1849 1850
	{ "Wacom PL510",          WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1851
static const struct wacom_features wacom_features_0x39 =
1852 1853
	{ "Wacom DTU710",         WACOM_PKGLEN_GRAPHIRE,  34080, 27660,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1854
static const struct wacom_features wacom_features_0xC4 =
1855 1856
	{ "Wacom DTF521",         WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1857
static const struct wacom_features wacom_features_0xC0 =
1858 1859
	{ "Wacom DTF720",         WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1860
static const struct wacom_features wacom_features_0xC2 =
1861 1862
	{ "Wacom DTF720a",        WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,
	  0, PL, WACOM_PL_RES, WACOM_PL_RES };
1863
static const struct wacom_features wacom_features_0x03 =
1864 1865
	{ "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE,  20480, 15360,  511,
	  0, PTU, WACOM_PL_RES, WACOM_PL_RES };
1866
static const struct wacom_features wacom_features_0x41 =
1867 1868
	{ "Wacom Intuos2 4x5",    WACOM_PKGLEN_INTUOS,    12700, 10600, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1869
static const struct wacom_features wacom_features_0x42 =
1870 1871
	{ "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1872
static const struct wacom_features wacom_features_0x43 =
1873 1874
	{ "Wacom Intuos2 9x12",   WACOM_PKGLEN_INTUOS,    30480, 24060, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1875
static const struct wacom_features wacom_features_0x44 =
1876 1877
	{ "Wacom Intuos2 12x12",  WACOM_PKGLEN_INTUOS,    30480, 31680, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1878
static const struct wacom_features wacom_features_0x45 =
1879 1880
	{ "Wacom Intuos2 12x18",  WACOM_PKGLEN_INTUOS,    45720, 31680, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1881
static const struct wacom_features wacom_features_0xB0 =
1882 1883
	{ "Wacom Intuos3 4x5",    WACOM_PKGLEN_INTUOS,    25400, 20320, 1023,
	  63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1884
static const struct wacom_features wacom_features_0xB1 =
1885 1886
	{ "Wacom Intuos3 6x8",    WACOM_PKGLEN_INTUOS,    40640, 30480, 1023,
	  63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1887
static const struct wacom_features wacom_features_0xB2 =
1888 1889
	{ "Wacom Intuos3 9x12",   WACOM_PKGLEN_INTUOS,    60960, 45720, 1023,
	  63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1890
static const struct wacom_features wacom_features_0xB3 =
1891 1892
	{ "Wacom Intuos3 12x12",  WACOM_PKGLEN_INTUOS,    60960, 60960, 1023,
	  63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1893
static const struct wacom_features wacom_features_0xB4 =
1894 1895
	{ "Wacom Intuos3 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 1023,
	  63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1896
static const struct wacom_features wacom_features_0xB5 =
1897 1898
	{ "Wacom Intuos3 6x11",   WACOM_PKGLEN_INTUOS,    54204, 31750, 1023,
	  63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1899
static const struct wacom_features wacom_features_0xB7 =
1900 1901
	{ "Wacom Intuos3 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 1023,
	  63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1902
static const struct wacom_features wacom_features_0xB8 =
1903 1904
	{ "Wacom Intuos4 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 2047,
	  63, INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1905
static const struct wacom_features wacom_features_0xB9 =
1906 1907
	{ "Wacom Intuos4 6x9",    WACOM_PKGLEN_INTUOS,    44704, 27940, 2047,
	  63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1908
static const struct wacom_features wacom_features_0xBA =
1909 1910
	{ "Wacom Intuos4 8x13",   WACOM_PKGLEN_INTUOS,    65024, 40640, 2047,
	  63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1911
static const struct wacom_features wacom_features_0xBB =
1912 1913
	{ "Wacom Intuos4 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 2047,
	  63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1914
static const struct wacom_features wacom_features_0xBC =
1915
	{ "Wacom Intuos4 WL",     WACOM_PKGLEN_INTUOS,    40640, 25400, 2047,
1916
	  63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1917 1918
static const struct wacom_features wacom_features_0x26 =
	{ "Wacom Intuos5 touch S", WACOM_PKGLEN_INTUOS,  31496, 19685, 2047,
1919 1920
	  63, INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
	  .touch_max = 16 };
1921 1922
static const struct wacom_features wacom_features_0x27 =
	{ "Wacom Intuos5 touch M", WACOM_PKGLEN_INTUOS,  44704, 27940, 2047,
1923 1924
	  63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
	  .touch_max = 16 };
1925 1926
static const struct wacom_features wacom_features_0x28 =
	{ "Wacom Intuos5 touch L", WACOM_PKGLEN_INTUOS, 65024, 40640, 2047,
1927 1928
	  63, INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
	  .touch_max = 16 };
1929 1930 1931 1932 1933 1934
static const struct wacom_features wacom_features_0x29 =
	{ "Wacom Intuos5 S", WACOM_PKGLEN_INTUOS,  31496, 19685, 2047,
	  63, INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
static const struct wacom_features wacom_features_0x2A =
	{ "Wacom Intuos5 M", WACOM_PKGLEN_INTUOS,  44704, 27940, 2047,
	  63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1935
static const struct wacom_features wacom_features_0xF4 =
1936 1937 1938
	{ "Wacom Cintiq 24HD",       WACOM_PKGLEN_INTUOS,   104480, 65600, 2047,
	  63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
static const struct wacom_features wacom_features_0xF8 =
1939 1940 1941 1942 1943
	{ "Wacom Cintiq 24HD touch", WACOM_PKGLEN_INTUOS,   104480, 65600, 2047, /* Pen */
	  63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
static const struct wacom_features wacom_features_0xF6 =
	{ "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10 };
1944
static const struct wacom_features wacom_features_0x3F =
1945 1946
	{ "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023,
	  63, CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1947
static const struct wacom_features wacom_features_0xC5 =
1948 1949
	{ "Wacom Cintiq 20WSX",   WACOM_PKGLEN_INTUOS,    86680, 54180, 1023,
	  63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1950
static const struct wacom_features wacom_features_0xC6 =
1951 1952
	{ "Wacom Cintiq 12WX",    WACOM_PKGLEN_INTUOS,    53020, 33440, 1023,
	  63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1953
static const struct wacom_features wacom_features_0xC7 =
1954 1955
	{ "Wacom DTU1931",        WACOM_PKGLEN_GRAPHIRE,  37832, 30305,  511,
	  0, PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1956
static const struct wacom_features wacom_features_0xCE =
1957 1958
	{ "Wacom DTU2231",        WACOM_PKGLEN_GRAPHIRE,  47864, 27011,  511,
	  0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1959
static const struct wacom_features wacom_features_0xF0 =
1960 1961
	{ "Wacom DTU1631",        WACOM_PKGLEN_GRAPHIRE,  34623, 19553,  511,
	  0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1962 1963 1964 1965 1966 1967 1968
static const struct wacom_features wacom_features_0x59 = /* Pen */
	{ "Wacom DTH2242",        WACOM_PKGLEN_INTUOS,    95840, 54260, 2047,
	  63, DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
static const struct wacom_features wacom_features_0x5D = /* Touch */
	{ "Wacom DTH2242",       .type = WACOM_24HDT,
	  .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10 };
1969
static const struct wacom_features wacom_features_0xCC =
1970 1971
	{ "Wacom Cintiq 21UX2",   WACOM_PKGLEN_INTUOS,    87200, 65600, 2047,
	  63, WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1972 1973 1974
static const struct wacom_features wacom_features_0xFA =
	{ "Wacom Cintiq 22HD",    WACOM_PKGLEN_INTUOS,    95840, 54260, 2047,
	  63, WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1975
static const struct wacom_features wacom_features_0x90 =
1976 1977
	{ "Wacom ISDv4 90",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
	  0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1978
static const struct wacom_features wacom_features_0x93 =
1979 1980
	{ "Wacom ISDv4 93",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
	  0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1981 1982 1983
static const struct wacom_features wacom_features_0x97 =
	{ "Wacom ISDv4 97",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  511,
	  0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1984
static const struct wacom_features wacom_features_0x9A =
1985 1986
	{ "Wacom ISDv4 9A",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
	  0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1987
static const struct wacom_features wacom_features_0x9F =
1988 1989
	{ "Wacom ISDv4 9F",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
	  0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1990
static const struct wacom_features wacom_features_0xE2 =
1991
	{ "Wacom ISDv4 E2",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,
1992 1993
	  0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
1994
static const struct wacom_features wacom_features_0xE3 =
1995
	{ "Wacom ISDv4 E3",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,
1996 1997
	  0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
1998 1999 2000
static const struct wacom_features wacom_features_0xE5 =
	{ "Wacom ISDv4 E5",       WACOM_PKGLEN_MTOUCH,    26202, 16325,  255,
	  0, MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2001 2002
static const struct wacom_features wacom_features_0xE6 =
	{ "Wacom ISDv4 E6",       WACOM_PKGLEN_TPC2FG,    27760, 15694,  255,
2003 2004
	  0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	.touch_max = 2 };
2005 2006 2007
static const struct wacom_features wacom_features_0xEC =
	{ "Wacom ISDv4 EC",       WACOM_PKGLEN_GRAPHIRE,  25710, 14500,  255,
	  0, TABLETPC,    WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2008 2009 2010 2011 2012 2013
static const struct wacom_features wacom_features_0xED =
	{ "Wacom ISDv4 ED",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
	  0, TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
static const struct wacom_features wacom_features_0xEF =
	{ "Wacom ISDv4 EF",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
	  0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2014 2015 2016 2017 2018 2019
static const struct wacom_features wacom_features_0x100 =
	{ "Wacom ISDv4 100",      WACOM_PKGLEN_MTTPC,     26202, 16325,  255,
	  0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
static const struct wacom_features wacom_features_0x101 =
	{ "Wacom ISDv4 101",      WACOM_PKGLEN_MTTPC,     26202, 16325,  255,
	  0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2020 2021 2022
static const struct wacom_features wacom_features_0x10D =
	{ "Wacom ISDv4 10D",      WACOM_PKGLEN_MTTPC,     26202, 16325,  255,
	  0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2023 2024 2025
static const struct wacom_features wacom_features_0x4001 =
	{ "Wacom ISDv4 4001",      WACOM_PKGLEN_MTTPC,     26202, 16325,  255,
	  0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2026
static const struct wacom_features wacom_features_0x47 =
2027 2028
	{ "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
	  31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2029 2030
static const struct wacom_features wacom_features_0x84 =
	{ "Wacom Wireless Receiver", WACOM_PKGLEN_WIRELESS, 0, 0, 0,
2031
	  0, WIRELESS, 0, 0, .touch_max = 16 };
2032
static const struct wacom_features wacom_features_0xD0 =
2033
	{ "Wacom Bamboo 2FG",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2034 2035
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2036
static const struct wacom_features wacom_features_0xD1 =
2037
	{ "Wacom Bamboo 2FG 4x5", WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2038 2039
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2040
static const struct wacom_features wacom_features_0xD2 =
2041
	{ "Wacom Bamboo Craft",   WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2042 2043
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2044
static const struct wacom_features wacom_features_0xD3 =
2045
	{ "Wacom Bamboo 2FG 6x8", WACOM_PKGLEN_BBFUN,     21648, 13700, 1023,
2046 2047
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2048
static const struct wacom_features wacom_features_0xD4 =
2049
	{ "Wacom Bamboo Pen",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2050
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2051
static const struct wacom_features wacom_features_0xD5 =
2052
	{ "Wacom Bamboo Pen 6x8",     WACOM_PKGLEN_BBFUN, 21648, 13700, 1023,
2053
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2054
static const struct wacom_features wacom_features_0xD6 =
2055
	{ "Wacom BambooPT 2FG 4x5", WACOM_PKGLEN_BBFUN,   14720,  9200, 1023,
2056 2057
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2058
static const struct wacom_features wacom_features_0xD7 =
2059
	{ "Wacom BambooPT 2FG Small", WACOM_PKGLEN_BBFUN, 14720,  9200, 1023,
2060 2061
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2062
static const struct wacom_features wacom_features_0xD8 =
2063
	{ "Wacom Bamboo Comic 2FG", WACOM_PKGLEN_BBFUN,   21648, 13700, 1023,
2064 2065
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2066
static const struct wacom_features wacom_features_0xDA =
2067
	{ "Wacom Bamboo 2FG 4x5 SE", WACOM_PKGLEN_BBFUN,  14720,  9200, 1023,
2068 2069
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2070
static struct wacom_features wacom_features_0xDB =
2071
	{ "Wacom Bamboo 2FG 6x8 SE", WACOM_PKGLEN_BBFUN,  21648, 13700, 1023,
2072 2073
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 2 };
2074 2075 2076 2077 2078
static const struct wacom_features wacom_features_0xDD =
        { "Wacom Bamboo Connect", WACOM_PKGLEN_BBPEN,     14720,  9200, 1023,
          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
static const struct wacom_features wacom_features_0xDE =
        { "Wacom Bamboo 16FG 4x5", WACOM_PKGLEN_BBPEN,    14720,  9200, 1023,
2079 2080
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 16 };
2081 2082
static const struct wacom_features wacom_features_0xDF =
        { "Wacom Bamboo 16FG 6x8", WACOM_PKGLEN_BBPEN,    21648, 13700, 1023,
2083 2084
	  31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
	  .touch_max = 16 };
2085
static const struct wacom_features wacom_features_0x6004 =
2086 2087
	{ "ISD-V4",               WACOM_PKGLEN_GRAPHIRE,  12800,  8000,  255,
	  0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2088 2089 2090 2091 2092

#define USB_DEVICE_WACOM(prod)					\
	USB_DEVICE(USB_VENDOR_ID_WACOM, prod),			\
	.driver_info = (kernel_ulong_t)&wacom_features_##prod

2093 2094 2095 2096 2097
#define USB_DEVICE_DETAILED(prod, class, sub, proto)			\
	USB_DEVICE_AND_INTERFACE_INFO(USB_VENDOR_ID_WACOM, prod, class,	\
				      sub, proto),			\
	.driver_info = (kernel_ulong_t)&wacom_features_##prod

2098 2099 2100 2101
#define USB_DEVICE_LENOVO(prod)					\
	USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),			\
	.driver_info = (kernel_ulong_t)&wacom_features_##prod

2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120
const struct usb_device_id wacom_ids[] = {
	{ USB_DEVICE_WACOM(0x00) },
	{ USB_DEVICE_WACOM(0x10) },
	{ USB_DEVICE_WACOM(0x11) },
	{ USB_DEVICE_WACOM(0x12) },
	{ USB_DEVICE_WACOM(0x13) },
	{ USB_DEVICE_WACOM(0x14) },
	{ USB_DEVICE_WACOM(0x15) },
	{ USB_DEVICE_WACOM(0x16) },
	{ USB_DEVICE_WACOM(0x17) },
	{ USB_DEVICE_WACOM(0x18) },
	{ USB_DEVICE_WACOM(0x19) },
	{ USB_DEVICE_WACOM(0x60) },
	{ USB_DEVICE_WACOM(0x61) },
	{ USB_DEVICE_WACOM(0x62) },
	{ USB_DEVICE_WACOM(0x63) },
	{ USB_DEVICE_WACOM(0x64) },
	{ USB_DEVICE_WACOM(0x65) },
	{ USB_DEVICE_WACOM(0x69) },
2121 2122
	{ USB_DEVICE_WACOM(0x6A) },
	{ USB_DEVICE_WACOM(0x6B) },
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
	{ USB_DEVICE_WACOM(0x20) },
	{ USB_DEVICE_WACOM(0x21) },
	{ USB_DEVICE_WACOM(0x22) },
	{ USB_DEVICE_WACOM(0x23) },
	{ USB_DEVICE_WACOM(0x24) },
	{ USB_DEVICE_WACOM(0x30) },
	{ USB_DEVICE_WACOM(0x31) },
	{ USB_DEVICE_WACOM(0x32) },
	{ USB_DEVICE_WACOM(0x33) },
	{ USB_DEVICE_WACOM(0x34) },
	{ USB_DEVICE_WACOM(0x35) },
	{ USB_DEVICE_WACOM(0x37) },
	{ USB_DEVICE_WACOM(0x38) },
	{ USB_DEVICE_WACOM(0x39) },
	{ USB_DEVICE_WACOM(0xC4) },
	{ USB_DEVICE_WACOM(0xC0) },
	{ USB_DEVICE_WACOM(0xC2) },
	{ USB_DEVICE_WACOM(0x03) },
	{ USB_DEVICE_WACOM(0x41) },
	{ USB_DEVICE_WACOM(0x42) },
	{ USB_DEVICE_WACOM(0x43) },
	{ USB_DEVICE_WACOM(0x44) },
	{ USB_DEVICE_WACOM(0x45) },
2146 2147
	{ USB_DEVICE_WACOM(0x59) },
	{ USB_DEVICE_WACOM(0x5D) },
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
	{ USB_DEVICE_WACOM(0xB0) },
	{ USB_DEVICE_WACOM(0xB1) },
	{ USB_DEVICE_WACOM(0xB2) },
	{ USB_DEVICE_WACOM(0xB3) },
	{ USB_DEVICE_WACOM(0xB4) },
	{ USB_DEVICE_WACOM(0xB5) },
	{ USB_DEVICE_WACOM(0xB7) },
	{ USB_DEVICE_WACOM(0xB8) },
	{ USB_DEVICE_WACOM(0xB9) },
	{ USB_DEVICE_WACOM(0xBA) },
	{ USB_DEVICE_WACOM(0xBB) },
2159
	{ USB_DEVICE_WACOM(0xBC) },
2160 2161 2162 2163 2164
	{ USB_DEVICE_WACOM(0x26) },
	{ USB_DEVICE_WACOM(0x27) },
	{ USB_DEVICE_WACOM(0x28) },
	{ USB_DEVICE_WACOM(0x29) },
	{ USB_DEVICE_WACOM(0x2A) },
2165 2166 2167 2168
	{ USB_DEVICE_WACOM(0x3F) },
	{ USB_DEVICE_WACOM(0xC5) },
	{ USB_DEVICE_WACOM(0xC6) },
	{ USB_DEVICE_WACOM(0xC7) },
2169 2170 2171 2172 2173 2174 2175
	/*
	 * DTU-2231 has two interfaces on the same configuration,
	 * only one is used.
	 */
	{ USB_DEVICE_DETAILED(0xCE, USB_CLASS_HID,
			      USB_INTERFACE_SUBCLASS_BOOT,
			      USB_INTERFACE_PROTOCOL_MOUSE) },
2176
	{ USB_DEVICE_WACOM(0x84) },
2177
	{ USB_DEVICE_WACOM(0xD0) },
2178 2179 2180
	{ USB_DEVICE_WACOM(0xD1) },
	{ USB_DEVICE_WACOM(0xD2) },
	{ USB_DEVICE_WACOM(0xD3) },
2181
	{ USB_DEVICE_WACOM(0xD4) },
2182
	{ USB_DEVICE_WACOM(0xD5) },
2183 2184
	{ USB_DEVICE_WACOM(0xD6) },
	{ USB_DEVICE_WACOM(0xD7) },
2185 2186
	{ USB_DEVICE_WACOM(0xD8) },
	{ USB_DEVICE_WACOM(0xDA) },
2187
	{ USB_DEVICE_WACOM(0xDB) },
2188 2189 2190
	{ USB_DEVICE_WACOM(0xDD) },
	{ USB_DEVICE_WACOM(0xDE) },
	{ USB_DEVICE_WACOM(0xDF) },
2191
	{ USB_DEVICE_WACOM(0xF0) },
2192
	{ USB_DEVICE_WACOM(0xCC) },
2193 2194
	{ USB_DEVICE_WACOM(0x90) },
	{ USB_DEVICE_WACOM(0x93) },
2195
	{ USB_DEVICE_WACOM(0x97) },
2196 2197 2198 2199
	{ USB_DEVICE_WACOM(0x9A) },
	{ USB_DEVICE_WACOM(0x9F) },
	{ USB_DEVICE_WACOM(0xE2) },
	{ USB_DEVICE_WACOM(0xE3) },
2200
	{ USB_DEVICE_WACOM(0xE5) },
2201
	{ USB_DEVICE_WACOM(0xE6) },
2202
	{ USB_DEVICE_WACOM(0xEC) },
2203 2204
	{ USB_DEVICE_WACOM(0xED) },
	{ USB_DEVICE_WACOM(0xEF) },
2205 2206
	{ USB_DEVICE_WACOM(0x100) },
	{ USB_DEVICE_WACOM(0x101) },
2207
	{ USB_DEVICE_WACOM(0x10D) },
2208
	{ USB_DEVICE_WACOM(0x4001) },
2209
	{ USB_DEVICE_WACOM(0x47) },
2210
	{ USB_DEVICE_WACOM(0xF4) },
2211
	{ USB_DEVICE_WACOM(0xF8) },
2212
	{ USB_DEVICE_DETAILED(0xF6, USB_CLASS_HID, 0, 0) },
2213
	{ USB_DEVICE_WACOM(0xFA) },
2214
	{ USB_DEVICE_LENOVO(0x6004) },
2215 2216 2217
	{ }
};
MODULE_DEVICE_TABLE(usb, wacom_ids);