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

/*
 * 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.
 */

#include "wacom_wac.h"
15
#include "wacom.h"
16
#include <linux/hid.h>
17

18
#define WAC_MSG_RETRIES		5
19

20 21 22 23 24
#define WAC_CMD_LED_CONTROL	0x20
#define WAC_CMD_ICON_START	0x21
#define WAC_CMD_ICON_XFER	0x23
#define WAC_CMD_RETRIES		10

25
static int wacom_get_report(struct hid_device *hdev, u8 type, u8 id,
26
			    void *buf, size_t size, unsigned int retries)
27
{
28 29 30
	int retval;

	do {
31 32
		retval = hid_hw_raw_request(hdev, id, buf, size, type,
				HID_REQ_GET_REPORT);
33 34 35
	} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);

	return retval;
36 37
}

38
static int wacom_set_report(struct hid_device *hdev, u8 type, u8 id,
39
			    void *buf, size_t size, unsigned int retries)
40
{
41 42 43
	int retval;

	do {
44 45
		retval = hid_hw_raw_request(hdev, id, buf, size, type,
				HID_REQ_SET_REPORT);
46 47 48
	} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);

	return retval;
49 50
}

51 52
static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
		u8 *raw_data, int size)
53
{
54
	struct wacom *wacom = hid_get_drvdata(hdev);
55

56 57
	if (size > WACOM_PKGLEN_MAX)
		return 1;
58

59
	memcpy(wacom->wacom_wac.data, raw_data, size);
60

61 62 63
	wacom_wac_irq(&wacom->wacom_wac, size);

	return 0;
64 65 66 67
}

static int wacom_open(struct input_dev *dev)
{
68
	struct wacom *wacom = input_get_drvdata(dev);
69
	int retval;
70 71

	mutex_lock(&wacom->lock);
72
	retval = hid_hw_open(wacom->hdev);
73
	mutex_unlock(&wacom->lock);
74

75
	return retval;
76 77 78 79
}

static void wacom_close(struct input_dev *dev)
{
80
	struct wacom *wacom = input_get_drvdata(dev);
81

82
	mutex_lock(&wacom->lock);
83
	hid_hw_close(wacom->hdev);
84
	mutex_unlock(&wacom->lock);
85 86
}

87
/*
88
 * Calculate the resolution of the X or Y axis using hidinput_calc_abs_res.
89 90
 */
static int wacom_calc_hid_res(int logical_extents, int physical_extents,
91
			       unsigned unit, int exponent)
92
{
93 94 95 96 97 98 99 100
	struct hid_field field = {
		.logical_maximum = logical_extents,
		.physical_maximum = physical_extents,
		.unit = unit,
		.unit_exponent = exponent,
	};

	return hidinput_calc_abs_res(&field, ABS_X);
101 102
}

103 104
static void wacom_feature_mapping(struct hid_device *hdev,
		struct hid_field *field, struct hid_usage *usage)
105
{
106 107
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_features *features = &wacom->wacom_wac.features;
108

109 110 111 112 113 114
	switch (usage->hid) {
	case HID_DG_CONTACTMAX:
		/* leave touch_max as is if predefined */
		if (!features->touch_max)
			features->touch_max = field->value[0];
		break;
115 116 117
	}
}

118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
/*
 * Interface Descriptor of wacom devices can be incomplete and
 * inconsistent so wacom_features table is used to store stylus
 * device's packet lengths, various maximum values, and tablet
 * resolution based on product ID's.
 *
 * For devices that contain 2 interfaces, wacom_features table is
 * inaccurate for the touch interface.  Since the Interface Descriptor
 * for touch interfaces has pretty complete data, this function exists
 * to query tablet for this missing information instead of hard coding in
 * an additional table.
 *
 * A typical Interface Descriptor for a stylus will contain a
 * boot mouse application collection that is not of interest and this
 * function will ignore it.
 *
 * It also contains a digitizer application collection that also is not
 * of interest since any information it contains would be duplicate
 * of what is in wacom_features. Usually it defines a report of an array
 * of bytes that could be used as max length of the stylus packet returned.
 * If it happens to define a Digitizer-Stylus Physical Collection then
 * the X and Y logical values contain valid data but it is ignored.
 *
 * A typical Interface Descriptor for a touch interface will contain a
 * Digitizer-Finger Physical Collection which will define both logical
 * X/Y maximum as well as the physical size of tablet. Since touch
 * interfaces haven't supported pressure or distance, this is enough
 * information to override invalid values in the wacom_features table.
146
 *
147 148
 * Intuos5 touch interface and 3rd gen Bamboo Touch do not contain useful
 * data. We deal with them after returning from this function.
149
 */
150 151
static void wacom_usage_mapping(struct hid_device *hdev,
		struct hid_field *field, struct hid_usage *usage)
152
{
153 154 155 156 157 158
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_features *features = &wacom->wacom_wac.features;
	bool finger = (field->logical == HID_DG_FINGER) ||
		      (field->physical == HID_DG_FINGER);
	bool pen = (field->logical == HID_DG_STYLUS) ||
		   (field->physical == HID_DG_STYLUS);
159

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
	/*
	* Requiring Stylus Usage will ignore boot mouse
	* X/Y values and some cases of invalid Digitizer X/Y
	* values commonly reported.
	*/
	if (!pen && !finger)
		return;

	if (finger && !features->touch_max)
		/* touch device at least supports one touch point */
		features->touch_max = 1;

	switch (usage->hid) {
	case HID_GD_X:
		features->x_max = field->logical_maximum;
		if (finger) {
			features->device_type = BTN_TOOL_FINGER;
			features->x_phy = field->physical_maximum;
			if (features->type != BAMBOO_PT) {
				features->unit = field->unit;
				features->unitExpo = field->unit_exponent;
181
			}
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
		} else {
			features->device_type = BTN_TOOL_PEN;
		}
		break;
	case HID_GD_Y:
		features->y_max = field->logical_maximum;
		if (finger) {
			features->y_phy = field->physical_maximum;
			if (features->type != BAMBOO_PT) {
				features->unit = field->unit;
				features->unitExpo = field->unit_exponent;
			}
		}
		break;
	case HID_DG_TIPPRESSURE:
		if (pen)
			features->pressure_max = field->logical_maximum;
		break;
	}
}
202

203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
static void wacom_parse_hid(struct hid_device *hdev,
			   struct wacom_features *features)
{
	struct hid_report_enum *rep_enum;
	struct hid_report *hreport;
	int i, j;

	/* check features first */
	rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
	list_for_each_entry(hreport, &rep_enum->report_list, list) {
		for (i = 0; i < hreport->maxfield; i++) {
			/* Ignore if report count is out of bounds. */
			if (hreport->field[i]->report_count < 1)
				continue;

			for (j = 0; j < hreport->field[i]->maxusage; j++) {
				wacom_feature_mapping(hdev, hreport->field[i],
						hreport->field[i]->usage + j);
221
			}
222 223 224
		}
	}

225 226 227 228 229 230 231 232 233 234 235 236
	/* now check the input usages */
	rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
	list_for_each_entry(hreport, &rep_enum->report_list, list) {

		if (!hreport->maxfield)
			continue;

		for (i = 0; i < hreport->maxfield; i++)
			for (j = 0; j < hreport->field[i]->maxusage; j++)
				wacom_usage_mapping(hdev, hreport->field[i],
						hreport->field[i]->usage + j);
	}
237 238
}

239 240
static int wacom_set_device_mode(struct hid_device *hdev, int report_id,
		int length, int mode)
241 242
{
	unsigned char *rep_data;
243
	int error = -ENOMEM, limit = 0;
244

245
	rep_data = kzalloc(length, GFP_KERNEL);
246
	if (!rep_data)
247 248
		return error;

249
	do {
250 251 252
		rep_data[0] = report_id;
		rep_data[1] = mode;

253
		error = wacom_set_report(hdev, HID_FEATURE_REPORT,
254
		                         report_id, rep_data, length, 1);
255
		if (error >= 0)
256
			error = wacom_get_report(hdev, HID_FEATURE_REPORT,
257
			                         report_id, rep_data, length, 1);
258 259 260 261 262 263 264 265 266 267 268 269 270 271
	} while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);

	kfree(rep_data);

	return error < 0 ? error : 0;
}

/*
 * Switch the tablet into its most-capable mode. Wacom tablets are
 * typically configured to power-up in a mode which sends mouse-like
 * reports to the OS. To get absolute position, pressure data, etc.
 * from the tablet, it is necessary to switch the tablet out of this
 * mode and into one which sends the full range of tablet data.
 */
272 273
static int wacom_query_tablet_data(struct hid_device *hdev,
		struct wacom_features *features)
274
{
275
	if (features->device_type == BTN_TOOL_FINGER) {
P
Ping Cheng 已提交
276
		if (features->type > TABLETPC) {
277
			/* MT Tablet PC touch */
278
			return wacom_set_device_mode(hdev, 3, 4, 4);
279
		}
280
		else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
281
			return wacom_set_device_mode(hdev, 18, 3, 2);
282
		}
283 284
	} else if (features->device_type == BTN_TOOL_PEN) {
		if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
285
			return wacom_set_device_mode(hdev, 2, 2, 2);
286
		}
287
	}
288

289
	return 0;
290 291
}

292
static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
293
					 struct wacom_features *features)
294
{
295 296
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct usb_interface *intf = wacom->intf;
297

298
	/* default features */
299
	features->device_type = BTN_TOOL_PEN;
300 301 302 303
	features->x_fuzz = 4;
	features->y_fuzz = 4;
	features->pressure_fuzz = 0;
	features->distance_fuzz = 0;
304

305 306 307 308 309 310 311 312 313 314
	/*
	 * The wireless device HID is basic and layout conflicts with
	 * other tablets (monitor and touch interface can look like pen).
	 * Skip the query for this type and modify defaults based on
	 * interface number.
	 */
	if (features->type == WIRELESS) {
		if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
			features->device_type = 0;
		} else if (intf->cur_altsetting->desc.bInterfaceNumber == 2) {
315
			features->device_type = BTN_TOOL_FINGER;
316 317 318 319
			features->pktlen = WACOM_PKGLEN_BBTOUCH3;
		}
	}

320
	/* only devices that support touch need to retrieve the info */
321 322
	if (features->type < BAMBOO_PT)
		return;
323

324
	wacom_parse_hid(hdev, features);
325 326
}

327
struct wacom_hdev_data {
328 329
	struct list_head list;
	struct kref kref;
330
	struct hid_device *dev;
331 332 333 334 335 336
	struct wacom_shared shared;
};

static LIST_HEAD(wacom_udev_list);
static DEFINE_MUTEX(wacom_udev_list_lock);

337 338
static bool wacom_are_sibling(struct hid_device *hdev,
		struct hid_device *sibling)
339
{
340 341 342 343 344 345 346 347 348 349
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_features *features = &wacom->wacom_wac.features;
	int vid = features->oVid;
	int pid = features->oPid;
	int n1,n2;

	if (vid == 0 && pid == 0) {
		vid = hdev->vendor;
		pid = hdev->product;
	}
350

351 352
	if (vid != sibling->vendor || pid != sibling->product)
		return false;
353

354 355 356 357 358
	/* Compare the physical path. */
	n1 = strrchr(hdev->phys, '.') - hdev->phys;
	n2 = strrchr(sibling->phys, '.') - sibling->phys;
	if (n1 != n2 || n1 <= 0 || n2 <= 0)
		return false;
359

360
	return !strncmp(hdev->phys, sibling->phys, n1);
361 362
}

363
static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
364
{
365
	struct wacom_hdev_data *data;
366 367

	list_for_each_entry(data, &wacom_udev_list, list) {
368
		if (wacom_are_sibling(hdev, data->dev)) {
369 370 371 372 373 374 375 376
			kref_get(&data->kref);
			return data;
		}
	}

	return NULL;
}

377
static int wacom_add_shared_data(struct hid_device *hdev)
378
{
379 380 381
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
	struct wacom_hdev_data *data;
382 383 384 385
	int retval = 0;

	mutex_lock(&wacom_udev_list_lock);

386
	data = wacom_get_hdev_data(hdev);
387
	if (!data) {
388
		data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
389 390 391 392 393 394
		if (!data) {
			retval = -ENOMEM;
			goto out;
		}

		kref_init(&data->kref);
395
		data->dev = hdev;
396 397 398
		list_add_tail(&data->list, &wacom_udev_list);
	}

399
	wacom_wac->shared = &data->shared;
400 401 402 403 404 405 406 407

out:
	mutex_unlock(&wacom_udev_list_lock);
	return retval;
}

static void wacom_release_shared_data(struct kref *kref)
{
408 409
	struct wacom_hdev_data *data =
		container_of(kref, struct wacom_hdev_data, kref);
410 411 412 413 414 415 416 417 418 419

	mutex_lock(&wacom_udev_list_lock);
	list_del(&data->list);
	mutex_unlock(&wacom_udev_list_lock);

	kfree(data);
}

static void wacom_remove_shared_data(struct wacom_wac *wacom)
{
420
	struct wacom_hdev_data *data;
421 422

	if (wacom->shared) {
423
		data = container_of(wacom->shared, struct wacom_hdev_data, shared);
424 425 426 427 428
		kref_put(&data->kref, wacom_release_shared_data);
		wacom->shared = NULL;
	}
}

429 430 431
static int wacom_led_control(struct wacom *wacom)
{
	unsigned char *buf;
432
	int retval;
433 434 435 436 437

	buf = kzalloc(9, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

438
	if (wacom->wacom_wac.features.type >= INTUOS5S &&
439
	    wacom->wacom_wac.features.type <= INTUOSPL) {
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
		/*
		 * Touch Ring and crop mark LED luminance may take on
		 * one of four values:
		 *    0 = Low; 1 = Medium; 2 = High; 3 = Off
		 */
		int ring_led = wacom->led.select[0] & 0x03;
		int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03;
		int crop_lum = 0;

		buf[0] = WAC_CMD_LED_CONTROL;
		buf[1] = (crop_lum << 4) | (ring_lum << 2) | (ring_led);
	}
	else {
		int led = wacom->led.select[0] | 0x4;

		if (wacom->wacom_wac.features.type == WACOM_21UX2 ||
		    wacom->wacom_wac.features.type == WACOM_24HD)
			led |= (wacom->led.select[1] << 4) | 0x40;

		buf[0] = WAC_CMD_LED_CONTROL;
		buf[1] = led;
		buf[2] = wacom->led.llv;
		buf[3] = wacom->led.hlv;
		buf[4] = wacom->led.img_lum;
	}
465

466 467
	retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
				  WAC_CMD_LED_CONTROL, buf, 9, WAC_CMD_RETRIES);
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
	kfree(buf);

	return retval;
}

static int wacom_led_putimage(struct wacom *wacom, int button_id, const void *img)
{
	unsigned char *buf;
	int i, retval;

	buf = kzalloc(259, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	/* Send 'start' command */
	buf[0] = WAC_CMD_ICON_START;
	buf[1] = 1;
485 486
	retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
				  WAC_CMD_ICON_START, buf, 2, WAC_CMD_RETRIES);
487 488 489 490 491 492 493 494 495
	if (retval < 0)
		goto out;

	buf[0] = WAC_CMD_ICON_XFER;
	buf[1] = button_id & 0x07;
	for (i = 0; i < 4; i++) {
		buf[2] = i;
		memcpy(buf + 3, img + i * 256, 256);

496 497
		retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
					  WAC_CMD_ICON_XFER,
498 499 500 501 502 503 504 505
					  buf, 259, WAC_CMD_RETRIES);
		if (retval < 0)
			break;
	}

	/* Send 'stop' */
	buf[0] = WAC_CMD_ICON_START;
	buf[1] = 0;
506
	wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, WAC_CMD_ICON_START,
507 508 509 510 511 512 513
			 buf, 2, WAC_CMD_RETRIES);

out:
	kfree(buf);
	return retval;
}

514
static ssize_t wacom_led_select_store(struct device *dev, int set_id,
515 516
				      const char *buf, size_t count)
{
517
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
518
	struct wacom *wacom = hid_get_drvdata(hdev);
519 520 521 522 523 524 525 526 527
	unsigned int id;
	int err;

	err = kstrtouint(buf, 10, &id);
	if (err)
		return err;

	mutex_lock(&wacom->lock);

528
	wacom->led.select[set_id] = id & 0x3;
529 530 531 532 533 534 535
	err = wacom_led_control(wacom);

	mutex_unlock(&wacom->lock);

	return err < 0 ? err : count;
}

536 537 538 539 540 541
#define DEVICE_LED_SELECT_ATTR(SET_ID)					\
static ssize_t wacom_led##SET_ID##_select_store(struct device *dev,	\
	struct device_attribute *attr, const char *buf, size_t count)	\
{									\
	return wacom_led_select_store(dev, SET_ID, buf, count);		\
}									\
542 543 544
static ssize_t wacom_led##SET_ID##_select_show(struct device *dev,	\
	struct device_attribute *attr, char *buf)			\
{									\
545
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
546
	struct wacom *wacom = hid_get_drvdata(hdev);			\
547 548 549 550
	return snprintf(buf, 2, "%d\n", wacom->led.select[SET_ID]);	\
}									\
static DEVICE_ATTR(status_led##SET_ID##_select, S_IWUSR | S_IRUSR,	\
		    wacom_led##SET_ID##_select_show,			\
551 552 553 554
		    wacom_led##SET_ID##_select_store)

DEVICE_LED_SELECT_ATTR(0);
DEVICE_LED_SELECT_ATTR(1);
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

static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest,
				     const char *buf, size_t count)
{
	unsigned int value;
	int err;

	err = kstrtouint(buf, 10, &value);
	if (err)
		return err;

	mutex_lock(&wacom->lock);

	*dest = value & 0x7f;
	err = wacom_led_control(wacom);

	mutex_unlock(&wacom->lock);

	return err < 0 ? err : count;
}

#define DEVICE_LUMINANCE_ATTR(name, field)				\
static ssize_t wacom_##name##_luminance_store(struct device *dev,	\
	struct device_attribute *attr, const char *buf, size_t count)	\
{									\
580
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
581
	struct wacom *wacom = hid_get_drvdata(hdev);			\
582 583 584 585 586 587 588 589 590 591 592 593 594 595
									\
	return wacom_luminance_store(wacom, &wacom->led.field,		\
				     buf, count);			\
}									\
static DEVICE_ATTR(name##_luminance, S_IWUSR,				\
		   NULL, wacom_##name##_luminance_store)

DEVICE_LUMINANCE_ATTR(status0, llv);
DEVICE_LUMINANCE_ATTR(status1, hlv);
DEVICE_LUMINANCE_ATTR(buttons, img_lum);

static ssize_t wacom_button_image_store(struct device *dev, int button_id,
					const char *buf, size_t count)
{
596
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
597
	struct wacom *wacom = hid_get_drvdata(hdev);
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
	int err;

	if (count != 1024)
		return -EINVAL;

	mutex_lock(&wacom->lock);

	err = wacom_led_putimage(wacom, button_id, buf);

	mutex_unlock(&wacom->lock);

	return err < 0 ? err : count;
}

#define DEVICE_BTNIMG_ATTR(BUTTON_ID)					\
static ssize_t wacom_btnimg##BUTTON_ID##_store(struct device *dev,	\
	struct device_attribute *attr, const char *buf, size_t count)	\
{									\
	return wacom_button_image_store(dev, BUTTON_ID, buf, count);	\
}									\
static DEVICE_ATTR(button##BUTTON_ID##_rawimg, S_IWUSR,			\
		   NULL, wacom_btnimg##BUTTON_ID##_store)

DEVICE_BTNIMG_ATTR(0);
DEVICE_BTNIMG_ATTR(1);
DEVICE_BTNIMG_ATTR(2);
DEVICE_BTNIMG_ATTR(3);
DEVICE_BTNIMG_ATTR(4);
DEVICE_BTNIMG_ATTR(5);
DEVICE_BTNIMG_ATTR(6);
DEVICE_BTNIMG_ATTR(7);

630 631 632 633 634 635 636 637 638 639 640 641
static struct attribute *cintiq_led_attrs[] = {
	&dev_attr_status_led0_select.attr,
	&dev_attr_status_led1_select.attr,
	NULL
};

static struct attribute_group cintiq_led_attr_group = {
	.name = "wacom_led",
	.attrs = cintiq_led_attrs,
};

static struct attribute *intuos4_led_attrs[] = {
642 643
	&dev_attr_status0_luminance.attr,
	&dev_attr_status1_luminance.attr,
644
	&dev_attr_status_led0_select.attr,
645 646 647 648 649 650 651 652 653 654 655 656
	&dev_attr_buttons_luminance.attr,
	&dev_attr_button0_rawimg.attr,
	&dev_attr_button1_rawimg.attr,
	&dev_attr_button2_rawimg.attr,
	&dev_attr_button3_rawimg.attr,
	&dev_attr_button4_rawimg.attr,
	&dev_attr_button5_rawimg.attr,
	&dev_attr_button6_rawimg.attr,
	&dev_attr_button7_rawimg.attr,
	NULL
};

657
static struct attribute_group intuos4_led_attr_group = {
658
	.name = "wacom_led",
659
	.attrs = intuos4_led_attrs,
660 661
};

662 663 664 665 666 667 668 669 670 671 672
static struct attribute *intuos5_led_attrs[] = {
	&dev_attr_status0_luminance.attr,
	&dev_attr_status_led0_select.attr,
	NULL
};

static struct attribute_group intuos5_led_attr_group = {
	.name = "wacom_led",
	.attrs = intuos5_led_attrs,
};

673 674 675 676
static int wacom_initialize_leds(struct wacom *wacom)
{
	int error;

677 678
	/* Initialize default values */
	switch (wacom->wacom_wac.features.type) {
679
	case INTUOS4S:
680 681 682 683
	case INTUOS4:
	case INTUOS4L:
		wacom->led.select[0] = 0;
		wacom->led.select[1] = 0;
684
		wacom->led.llv = 10;
685 686
		wacom->led.hlv = 20;
		wacom->led.img_lum = 10;
687
		error = sysfs_create_group(&wacom->hdev->dev.kobj,
688 689 690
					   &intuos4_led_attr_group);
		break;

691
	case WACOM_24HD:
692 693 694 695 696 697
	case WACOM_21UX2:
		wacom->led.select[0] = 0;
		wacom->led.select[1] = 0;
		wacom->led.llv = 0;
		wacom->led.hlv = 0;
		wacom->led.img_lum = 0;
698

699
		error = sysfs_create_group(&wacom->hdev->dev.kobj,
700 701 702
					   &cintiq_led_attr_group);
		break;

703 704 705
	case INTUOS5S:
	case INTUOS5:
	case INTUOS5L:
706 707 708
	case INTUOSPS:
	case INTUOSPM:
	case INTUOSPL:
709 710 711 712 713 714 715
		if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN) {
			wacom->led.select[0] = 0;
			wacom->led.select[1] = 0;
			wacom->led.llv = 32;
			wacom->led.hlv = 0;
			wacom->led.img_lum = 0;

716
			error = sysfs_create_group(&wacom->hdev->dev.kobj,
717 718 719
						  &intuos5_led_attr_group);
		} else
			return 0;
720 721
		break;

722 723
	default:
		return 0;
724 725
	}

726
	if (error) {
727
		hid_err(wacom->hdev,
728 729 730 731
			"cannot create sysfs group err: %d\n", error);
		return error;
	}
	wacom_led_control(wacom);
732
	wacom->led_initialized = true;
733

734 735 736 737 738
	return 0;
}

static void wacom_destroy_leds(struct wacom *wacom)
{
739 740 741 742 743
	if (!wacom->led_initialized)
		return;

	wacom->led_initialized = false;

744
	switch (wacom->wacom_wac.features.type) {
745
	case INTUOS4S:
746 747
	case INTUOS4:
	case INTUOS4L:
748
		sysfs_remove_group(&wacom->hdev->dev.kobj,
749 750 751
				   &intuos4_led_attr_group);
		break;

752
	case WACOM_24HD:
753
	case WACOM_21UX2:
754
		sysfs_remove_group(&wacom->hdev->dev.kobj,
755 756
				   &cintiq_led_attr_group);
		break;
757 758 759 760

	case INTUOS5S:
	case INTUOS5:
	case INTUOS5L:
761 762 763
	case INTUOSPS:
	case INTUOSPM:
	case INTUOSPL:
764
		if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN)
765
			sysfs_remove_group(&wacom->hdev->dev.kobj,
766
					   &intuos5_led_attr_group);
767
		break;
768 769 770
	}
}

771
static enum power_supply_property wacom_battery_props[] = {
772
	POWER_SUPPLY_PROP_STATUS,
773
	POWER_SUPPLY_PROP_SCOPE,
774 775 776 777 778 779 780 781 782 783 784
	POWER_SUPPLY_PROP_CAPACITY
};

static int wacom_battery_get_property(struct power_supply *psy,
				      enum power_supply_property psp,
				      union power_supply_propval *val)
{
	struct wacom *wacom = container_of(psy, struct wacom, battery);
	int ret = 0;

	switch (psp) {
785 786 787
		case POWER_SUPPLY_PROP_SCOPE:
			val->intval = POWER_SUPPLY_SCOPE_DEVICE;
			break;
788 789
		case POWER_SUPPLY_PROP_CAPACITY:
			val->intval =
790 791 792 793 794 795 796 797 798 799
				wacom->wacom_wac.battery_capacity;
			break;
		case POWER_SUPPLY_PROP_STATUS:
			if (wacom->wacom_wac.bat_charging)
				val->intval = POWER_SUPPLY_STATUS_CHARGING;
			else if (wacom->wacom_wac.battery_capacity == 100 &&
				    wacom->wacom_wac.ps_connected)
				val->intval = POWER_SUPPLY_STATUS_FULL;
			else
				val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
800 801 802 803 804 805 806 807 808 809 810 811
			break;
		default:
			ret = -EINVAL;
			break;
	}

	return ret;
}

static int wacom_initialize_battery(struct wacom *wacom)
{
	int error = 0;
812 813
	static atomic_t battery_no = ATOMIC_INIT(0);
	unsigned long n;
814

815
	if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) {
816
		n = atomic_inc_return(&battery_no) - 1;
817 818 819
		wacom->battery.properties = wacom_battery_props;
		wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
		wacom->battery.get_property = wacom_battery_get_property;
820 821
		sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
		wacom->battery.name = wacom->wacom_wac.bat_name;
822 823 824
		wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
		wacom->battery.use_for_apm = 0;

825
		error = power_supply_register(&wacom->hdev->dev,
826
					      &wacom->battery);
827 828 829

		if (!error)
			power_supply_powers(&wacom->battery,
830
					    &wacom->hdev->dev);
831 832 833 834 835 836 837
	}

	return error;
}

static void wacom_destroy_battery(struct wacom *wacom)
{
838 839
	if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
	     wacom->battery.dev) {
840
		power_supply_unregister(&wacom->battery);
841 842
		wacom->battery.dev = NULL;
	}
843 844
}

845
static struct input_dev *wacom_allocate_input(struct wacom *wacom)
846 847
{
	struct input_dev *input_dev;
848
	struct hid_device *hdev = wacom->hdev;
849 850 851
	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);

	input_dev = input_allocate_device();
852 853
	if (!input_dev)
		return NULL;
854 855

	input_dev->name = wacom_wac->name;
856 857
	input_dev->phys = hdev->phys;
	input_dev->dev.parent = &hdev->dev;
858 859
	input_dev->open = wacom_open;
	input_dev->close = wacom_close;
860 861 862 863 864
	input_dev->uniq = hdev->uniq;
	input_dev->id.bustype = hdev->bus;
	input_dev->id.vendor  = hdev->vendor;
	input_dev->id.product = hdev->product;
	input_dev->id.version = hdev->version;
865 866
	input_set_drvdata(input_dev, wacom);

867 868 869
	return input_dev;
}

870 871 872 873 874 875 876 877 878 879 880
static void wacom_unregister_inputs(struct wacom *wacom)
{
	if (wacom->wacom_wac.input)
		input_unregister_device(wacom->wacom_wac.input);
	if (wacom->wacom_wac.pad_input)
		input_unregister_device(wacom->wacom_wac.pad_input);
	wacom->wacom_wac.input = NULL;
	wacom->wacom_wac.pad_input = NULL;
}

static int wacom_register_inputs(struct wacom *wacom)
881 882 883 884 885 886 887 888 889 890 891 892
{
	struct input_dev *input_dev, *pad_input_dev;
	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
	int error;

	input_dev = wacom_allocate_input(wacom);
	pad_input_dev = wacom_allocate_input(wacom);
	if (!input_dev || !pad_input_dev) {
		error = -ENOMEM;
		goto fail1;
	}

893
	wacom_wac->input = input_dev;
894 895 896
	wacom_wac->pad_input = pad_input_dev;
	wacom_wac->pad_input->name = wacom_wac->pad_name;

897 898
	error = wacom_setup_input_capabilities(input_dev, wacom_wac);
	if (error)
899
		goto fail2;
900 901

	error = input_register_device(input_dev);
902 903 904
	if (error)
		goto fail2;

905 906 907 908 909 910 911 912 913 914 915 916
	error = wacom_setup_pad_input_capabilities(pad_input_dev, wacom_wac);
	if (error) {
		/* no pad in use on this interface */
		input_free_device(pad_input_dev);
		wacom_wac->pad_input = NULL;
		pad_input_dev = NULL;
	} else {
		error = input_register_device(pad_input_dev);
		if (error)
			goto fail3;
	}

917
	return 0;
918

919 920 921
fail3:
	input_unregister_device(input_dev);
	input_dev = NULL;
922 923
fail2:
	wacom_wac->input = NULL;
924
	wacom_wac->pad_input = NULL;
925
fail1:
926 927 928 929
	if (input_dev)
		input_free_device(input_dev);
	if (pad_input_dev)
		input_free_device(pad_input_dev);
930 931 932
	return error;
}

933 934 935 936 937
static void wacom_wireless_work(struct work_struct *work)
{
	struct wacom *wacom = container_of(work, struct wacom, work);
	struct usb_device *usbdev = wacom->usbdev;
	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
938
	struct hid_device *hdev1, *hdev2;
939 940 941
	struct wacom *wacom1, *wacom2;
	struct wacom_wac *wacom_wac1, *wacom_wac2;
	int error;
942 943 944

	/*
	 * Regardless if this is a disconnect or a new tablet,
945
	 * remove any existing input and battery devices.
946 947
	 */

948 949
	wacom_destroy_battery(wacom);

950
	/* Stylus interface */
951 952
	hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
	wacom1 = hid_get_drvdata(hdev1);
953
	wacom_wac1 = &(wacom1->wacom_wac);
954
	wacom_unregister_inputs(wacom1);
955 956

	/* Touch interface */
957 958
	hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
	wacom2 = hid_get_drvdata(hdev2);
959
	wacom_wac2 = &(wacom2->wacom_wac);
960
	wacom_unregister_inputs(wacom2);
961 962

	if (wacom_wac->pid == 0) {
963
		hid_info(wacom->hdev, "wireless tablet disconnected\n");
964
		wacom_wac1->shared->type = 0;
965
	} else {
966
		const struct hid_device_id *id = wacom_ids;
967

968
		hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
969
			 wacom_wac->pid);
970

971 972 973
		while (id->bus) {
			if (id->vendor == USB_VENDOR_ID_WACOM &&
			    id->product == wacom_wac->pid)
974 975 976 977
				break;
			id++;
		}

978
		if (!id->bus) {
979
			hid_info(wacom->hdev, "ignoring unknown PID.\n");
980 981 982 983
			return;
		}

		/* Stylus interface */
984
		wacom_wac1->features =
985
			*((struct wacom_features *)id->driver_data);
986
		wacom_wac1->features.device_type = BTN_TOOL_PEN;
987 988
		snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen",
			 wacom_wac1->features.name);
989 990
		snprintf(wacom_wac1->pad_name, WACOM_NAME_MAX, "%s (WL) Pad",
			 wacom_wac1->features.name);
991 992
		wacom_wac1->shared->touch_max = wacom_wac1->features.touch_max;
		wacom_wac1->shared->type = wacom_wac1->features.type;
993
		error = wacom_register_inputs(wacom1);
994
		if (error)
995
			goto fail;
996 997

		/* Touch interface */
998 999
		if (wacom_wac1->features.touch_max ||
		    wacom_wac1->features.type == INTUOSHT) {
1000
			wacom_wac2->features =
1001
				*((struct wacom_features *)id->driver_data);
1002 1003 1004 1005 1006 1007 1008 1009 1010
			wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3;
			wacom_wac2->features.device_type = BTN_TOOL_FINGER;
			wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096;
			if (wacom_wac2->features.touch_max)
				snprintf(wacom_wac2->name, WACOM_NAME_MAX,
					 "%s (WL) Finger",wacom_wac2->features.name);
			else
				snprintf(wacom_wac2->name, WACOM_NAME_MAX,
					 "%s (WL) Pad",wacom_wac2->features.name);
1011 1012 1013
			snprintf(wacom_wac2->pad_name, WACOM_NAME_MAX,
				 "%s (WL) Pad", wacom_wac2->features.name);
			error = wacom_register_inputs(wacom2);
1014 1015
			if (error)
				goto fail;
1016 1017 1018 1019

			if (wacom_wac1->features.type == INTUOSHT &&
			    wacom_wac1->features.touch_max)
				wacom_wac->shared->touch_input = wacom_wac2->input;
1020
		}
1021 1022 1023

		error = wacom_initialize_battery(wacom);
		if (error)
1024
			goto fail;
1025
	}
1026 1027 1028

	return;

1029
fail:
1030 1031
	wacom_unregister_inputs(wacom1);
	wacom_unregister_inputs(wacom2);
1032
	return;
1033 1034
}

1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
/*
 * Not all devices report physical dimensions from HID.
 * Compute the default from hardcoded logical dimension
 * and resolution before driver overwrites them.
 */
static void wacom_set_default_phy(struct wacom_features *features)
{
	if (features->x_resolution) {
		features->x_phy = (features->x_max * 100) /
					features->x_resolution;
		features->y_phy = (features->y_max * 100) /
					features->y_resolution;
	}
}

static void wacom_calculate_res(struct wacom_features *features)
{
	features->x_resolution = wacom_calc_hid_res(features->x_max,
						    features->x_phy,
						    features->unit,
						    features->unitExpo);
	features->y_resolution = wacom_calc_hid_res(features->y_max,
						    features->y_phy,
						    features->unit,
						    features->unitExpo);
}

1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
static int wacom_hid_report_len(struct hid_report *report)
{
	/* equivalent to DIV_ROUND_UP(report->size, 8) + !!(report->id > 0) */
	return ((report->size - 1) >> 3) + 1 + (report->id > 0);
}

static size_t wacom_compute_pktlen(struct hid_device *hdev)
{
	struct hid_report_enum *report_enum;
	struct hid_report *report;
	size_t size = 0;

	report_enum = hdev->report_enum + HID_INPUT_REPORT;

	list_for_each_entry(report, &report_enum->report_list, list) {
		size_t report_size = wacom_hid_report_len(report);
		if (report_size > size)
			size = report_size;
	}

	return size;
}

1085 1086
static int wacom_probe(struct hid_device *hdev,
		const struct hid_device_id *id)
1087
{
1088
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
1089 1090 1091
	struct usb_device *dev = interface_to_usbdev(intf);
	struct wacom *wacom;
	struct wacom_wac *wacom_wac;
1092 1093
	struct wacom_features *features;
	int error;
1094

1095
	if (!id->driver_data)
1096 1097
		return -EINVAL;

1098
	wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
1099 1100
	if (!wacom)
		return -ENOMEM;
1101

1102 1103 1104
	hid_set_drvdata(hdev, wacom);
	wacom->hdev = hdev;

1105 1106 1107 1108 1109 1110 1111
	/* ask for the report descriptor to be loaded by HID */
	error = hid_parse(hdev);
	if (error) {
		hid_err(hdev, "parse failed\n");
		goto fail1;
	}

1112
	wacom_wac = &wacom->wacom_wac;
1113
	wacom_wac->features = *((struct wacom_features *)id->driver_data);
1114
	features = &wacom_wac->features;
1115
	features->pktlen = wacom_compute_pktlen(hdev);
1116 1117
	if (features->pktlen > WACOM_PKGLEN_MAX) {
		error = -EINVAL;
1118
		goto fail1;
1119
	}
1120

1121 1122
	if (features->check_for_hid_type && features->hid_type != hdev->type) {
		error = -ENODEV;
1123
		goto fail1;
1124
	}
1125 1126

	wacom->usbdev = dev;
1127 1128
	wacom->intf = intf;
	mutex_init(&wacom->lock);
1129
	INIT_WORK(&wacom->work, wacom_wireless_work);
1130

1131 1132 1133
	/* set the default size in case we do not get them from hid */
	wacom_set_default_phy(features);

1134
	/* Retrieve the physical and logical size for touch devices */
1135
	wacom_retrieve_hid_descriptor(hdev, features);
1136

1137 1138
	/*
	 * Intuos5 has no useful data about its touch interface in its
1139
	 * HID descriptor. If this is the touch interface (PacketSize
1140 1141
	 * of WACOM_PKGLEN_BBTOUCH3), override the table values.
	 */
1142
	if (features->type >= INTUOS5S && features->type <= INTUOSHT) {
1143
		if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1144 1145 1146 1147 1148 1149 1150 1151 1152
			features->device_type = BTN_TOOL_FINGER;

			features->x_max = 4096;
			features->y_max = 4096;
		} else {
			features->device_type = BTN_TOOL_PEN;
		}
	}

1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
	/*
	 * Same thing for Bamboo 3rd gen.
	 */
	if ((features->type == BAMBOO_PT) &&
	    (features->pktlen == WACOM_PKGLEN_BBTOUCH3) &&
	    (features->device_type == BTN_TOOL_PEN)) {
		features->device_type = BTN_TOOL_FINGER;

		features->x_max = 4096;
		features->y_max = 4096;
	}

1165 1166
	wacom_setup_device_quirks(features);

1167 1168 1169
	/* set unit to "100th of a mm" for devices not reported by HID */
	if (!features->unit) {
		features->unit = 0x11;
1170
		features->unitExpo = -3;
1171 1172 1173
	}
	wacom_calculate_res(features);

1174
	strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
1175 1176
	snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name),
		"%s Pad", features->name);
1177

1178
	if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
1179
		/* Append the device type to the name */
1180 1181 1182 1183 1184 1185
		if (features->device_type != BTN_TOOL_FINGER)
			strlcat(wacom_wac->name, " Pen", WACOM_NAME_MAX);
		else if (features->touch_max)
			strlcat(wacom_wac->name, " Finger", WACOM_NAME_MAX);
		else
			strlcat(wacom_wac->name, " Pad", WACOM_NAME_MAX);
1186

1187
		error = wacom_add_shared_data(hdev);
1188
		if (error)
1189
			goto fail1;
1190 1191
	}

1192
	error = wacom_initialize_leds(wacom);
1193
	if (error)
1194
		goto fail2;
1195

1196
	if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
1197
		error = wacom_register_inputs(wacom);
1198
		if (error)
1199
			goto fail3;
1200
	}
1201

1202
	/* Note that if query fails it is not a hard failure */
1203
	wacom_query_tablet_data(hdev, features);
1204

1205 1206 1207 1208 1209
	/* Regular HID work starts now */
	error = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	if (error) {
		hid_err(hdev, "hw start failed\n");
		goto fail4;
1210
	}
1211

1212 1213 1214
	if (features->quirks & WACOM_QUIRK_MONITOR)
		error = hid_hw_open(hdev);

1215 1216 1217 1218 1219
	if (wacom_wac->features.type == INTUOSHT && wacom_wac->features.touch_max) {
		if (wacom_wac->features.device_type == BTN_TOOL_FINGER)
			wacom_wac->shared->touch_input = wacom_wac->input;
	}

1220 1221
	return 0;

1222 1223 1224
 fail4:	wacom_unregister_inputs(wacom);
 fail3:	wacom_destroy_leds(wacom);
 fail2:	wacom_remove_shared_data(wacom_wac);
1225
 fail1:	kfree(wacom);
1226
	hid_set_drvdata(hdev, NULL);
1227
	return error;
1228 1229
}

1230
static void wacom_remove(struct hid_device *hdev)
1231
{
1232
	struct wacom *wacom = hid_get_drvdata(hdev);
1233

1234
	hid_hw_stop(hdev);
1235

1236
	cancel_work_sync(&wacom->work);
1237
	wacom_unregister_inputs(wacom);
1238
	wacom_destroy_battery(wacom);
1239
	wacom_destroy_leds(wacom);
1240
	wacom_remove_shared_data(&wacom->wacom_wac);
1241

1242 1243
	hid_set_drvdata(hdev, NULL);
	kfree(wacom);
1244 1245
}

1246
static int wacom_resume(struct hid_device *hdev)
1247
{
1248
	struct wacom *wacom = hid_get_drvdata(hdev);
1249
	struct wacom_features *features = &wacom->wacom_wac.features;
1250 1251

	mutex_lock(&wacom->lock);
1252 1253

	/* switch to wacom mode first */
1254
	wacom_query_tablet_data(hdev, features);
1255
	wacom_led_control(wacom);
1256

1257 1258
	mutex_unlock(&wacom->lock);

1259
	return 0;
1260 1261
}

1262
static int wacom_reset_resume(struct hid_device *hdev)
1263
{
1264
	return wacom_resume(hdev);
1265 1266
}

1267
static struct hid_driver wacom_driver = {
1268
	.name =		"wacom",
1269
	.id_table =	wacom_ids,
1270
	.probe =	wacom_probe,
1271 1272
	.remove =	wacom_remove,
#ifdef CONFIG_PM
1273 1274
	.resume =	wacom_resume,
	.reset_resume =	wacom_reset_resume,
1275 1276
#endif
	.raw_event =	wacom_raw_event,
1277
};
1278
module_hid_driver(wacom_driver);