wacom_sys.c 39.0 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
#define WAC_CMD_WL_LED_CONTROL	0x03
21 22 23
#define WAC_CMD_LED_CONTROL	0x20
#define WAC_CMD_ICON_START	0x21
#define WAC_CMD_ICON_XFER	0x23
24
#define WAC_CMD_ICON_BT_XFER	0x26
25 26
#define WAC_CMD_RETRIES		10

27 28 29
#define DEV_ATTR_RW_PERM (S_IRUGO | S_IWUSR | S_IWGRP)
#define DEV_ATTR_WO_PERM (S_IWUSR | S_IWGRP)

30 31
static int wacom_get_report(struct hid_device *hdev, u8 type, u8 *buf,
			    size_t size, unsigned int retries)
32
{
33 34 35
	int retval;

	do {
36
		retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
37
				HID_REQ_GET_REPORT);
38 39 40
	} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);

	return retval;
41 42
}

43 44
static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf,
			    size_t size, unsigned int retries)
45
{
46 47 48
	int retval;

	do {
49
		retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
50
				HID_REQ_SET_REPORT);
51 52 53
	} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);

	return retval;
54 55
}

56 57
static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
		u8 *raw_data, int size)
58
{
59
	struct wacom *wacom = hid_get_drvdata(hdev);
60

61 62
	if (size > WACOM_PKGLEN_MAX)
		return 1;
63

64
	memcpy(wacom->wacom_wac.data, raw_data, size);
65

66 67 68
	wacom_wac_irq(&wacom->wacom_wac, size);

	return 0;
69 70 71 72
}

static int wacom_open(struct input_dev *dev)
{
73
	struct wacom *wacom = input_get_drvdata(dev);
74
	int retval;
75 76

	mutex_lock(&wacom->lock);
77
	retval = hid_hw_open(wacom->hdev);
78
	mutex_unlock(&wacom->lock);
79

80
	return retval;
81 82 83 84
}

static void wacom_close(struct input_dev *dev)
{
85
	struct wacom *wacom = input_get_drvdata(dev);
86

87
	mutex_lock(&wacom->lock);
88
	hid_hw_close(wacom->hdev);
89
	mutex_unlock(&wacom->lock);
90 91
}

92
/*
93
 * Calculate the resolution of the X or Y axis using hidinput_calc_abs_res.
94 95
 */
static int wacom_calc_hid_res(int logical_extents, int physical_extents,
96
			       unsigned unit, int exponent)
97
{
98 99 100 101 102 103 104 105
	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);
106 107
}

108 109
static void wacom_feature_mapping(struct hid_device *hdev,
		struct hid_field *field, struct hid_usage *usage)
110
{
111 112
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_features *features = &wacom->wacom_wac.features;
113 114
	u8 *data;
	int ret;
115

116 117 118
	switch (usage->hid) {
	case HID_DG_CONTACTMAX:
		/* leave touch_max as is if predefined */
119 120 121 122 123 124 125 126 127 128 129 130
		if (!features->touch_max) {
			/* read manually */
			data = kzalloc(2, GFP_KERNEL);
			if (!data)
				break;
			data[0] = field->report->id;
			ret = wacom_get_report(hdev, HID_FEATURE_REPORT,
						data, 2, 0);
			if (ret == 2)
				features->touch_max = data[1];
			kfree(data);
		}
131
		break;
132 133 134
	}
}

135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
/*
 * 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.
163
 *
164 165
 * Intuos5 touch interface and 3rd gen Bamboo Touch do not contain useful
 * data. We deal with them after returning from this function.
166
 */
167 168
static void wacom_usage_mapping(struct hid_device *hdev,
		struct hid_field *field, struct hid_usage *usage)
169
{
170 171 172 173 174 175
	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);
176

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
	/*
	* 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;
198
			}
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
		} 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;
	}
}
219

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
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);
238
			}
239 240 241
		}
	}

242 243 244 245 246 247 248 249 250 251 252 253
	/* 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);
	}
254 255
}

256 257
static int wacom_set_device_mode(struct hid_device *hdev, int report_id,
		int length, int mode)
258 259
{
	unsigned char *rep_data;
260
	int error = -ENOMEM, limit = 0;
261

262
	rep_data = kzalloc(length, GFP_KERNEL);
263
	if (!rep_data)
264 265
		return error;

266
	do {
267 268 269
		rep_data[0] = report_id;
		rep_data[1] = mode;

270 271
		error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
					 length, 1);
272
		if (error >= 0)
273
			error = wacom_get_report(hdev, HID_FEATURE_REPORT,
274
			                         rep_data, length, 1);
275 276 277 278 279 280 281
	} while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);

	kfree(rep_data);

	return error < 0 ? error : 0;
}

282 283 284
static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
		struct wacom_features *features)
{
285 286 287 288 289 290 291 292
	struct wacom *wacom = hid_get_drvdata(hdev);
	int ret;
	u8 rep_data[2];

	switch (features->type) {
	case GRAPHIRE_BT:
		rep_data[0] = 0x03;
		rep_data[1] = 0x00;
293 294
		ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
					3);
295 296 297 298 299 300

		if (ret >= 0) {
			rep_data[0] = speed == 0 ? 0x05 : 0x06;
			rep_data[1] = 0x00;

			ret = wacom_set_report(hdev, HID_FEATURE_REPORT,
301
						rep_data, 2, 3);
302 303 304 305 306 307 308 309 310 311 312 313 314 315

			if (ret >= 0) {
				wacom->wacom_wac.bt_high_speed = speed;
				return 0;
			}
		}

		/*
		 * Note that if the raw queries fail, it's not a hard failure
		 * and it is safe to continue
		 */
		hid_warn(hdev, "failed to poke device, command %d, err %d\n",
			 rep_data[0], ret);
		break;
316 317 318 319 320 321 322 323 324
	case INTUOS4WL:
		if (speed == 1)
			wacom->wacom_wac.bt_features &= ~0x20;
		else
			wacom->wacom_wac.bt_features |= 0x20;

		rep_data[0] = 0x03;
		rep_data[1] = wacom->wacom_wac.bt_features;

325 326
		ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
					1);
327 328 329
		if (ret >= 0)
			wacom->wacom_wac.bt_high_speed = speed;
		break;
330 331
	}

332 333 334
	return 0;
}

335 336 337 338 339 340 341
/*
 * 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.
 */
342 343
static int wacom_query_tablet_data(struct hid_device *hdev,
		struct wacom_features *features)
344
{
345 346 347
	if (hdev->bus == BUS_BLUETOOTH)
		return wacom_bt_query_tablet_data(hdev, 1, features);

348
	if (features->device_type == BTN_TOOL_FINGER) {
P
Ping Cheng 已提交
349
		if (features->type > TABLETPC) {
350
			/* MT Tablet PC touch */
351
			return wacom_set_device_mode(hdev, 3, 4, 4);
352
		}
353
		else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
354
			return wacom_set_device_mode(hdev, 18, 3, 2);
355
		}
356 357
	} else if (features->device_type == BTN_TOOL_PEN) {
		if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
358
			return wacom_set_device_mode(hdev, 2, 2, 2);
359
		}
360
	}
361

362
	return 0;
363 364
}

365
static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
366
					 struct wacom_features *features)
367
{
368 369
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct usb_interface *intf = wacom->intf;
370

371
	/* default features */
372
	features->device_type = BTN_TOOL_PEN;
373 374 375 376
	features->x_fuzz = 4;
	features->y_fuzz = 4;
	features->pressure_fuzz = 0;
	features->distance_fuzz = 0;
377

378 379 380 381 382 383 384 385 386 387
	/*
	 * 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) {
388
			features->device_type = BTN_TOOL_FINGER;
389 390 391 392
			features->pktlen = WACOM_PKGLEN_BBTOUCH3;
		}
	}

393
	/* only devices that support touch need to retrieve the info */
394 395
	if (features->type < BAMBOO_PT)
		return;
396

397
	wacom_parse_hid(hdev, features);
398 399
}

400
struct wacom_hdev_data {
401 402
	struct list_head list;
	struct kref kref;
403
	struct hid_device *dev;
404 405 406 407 408 409
	struct wacom_shared shared;
};

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

410 411
static bool wacom_are_sibling(struct hid_device *hdev,
		struct hid_device *sibling)
412
{
413 414 415 416 417 418 419 420 421 422
	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;
	}
423

424 425
	if (vid != sibling->vendor || pid != sibling->product)
		return false;
426

427 428 429 430 431
	/* 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;
432

433
	return !strncmp(hdev->phys, sibling->phys, n1);
434 435
}

436
static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
437
{
438
	struct wacom_hdev_data *data;
439 440

	list_for_each_entry(data, &wacom_udev_list, list) {
441
		if (wacom_are_sibling(hdev, data->dev)) {
442 443 444 445 446 447 448 449
			kref_get(&data->kref);
			return data;
		}
	}

	return NULL;
}

450
static int wacom_add_shared_data(struct hid_device *hdev)
451
{
452 453 454
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
	struct wacom_hdev_data *data;
455 456 457 458
	int retval = 0;

	mutex_lock(&wacom_udev_list_lock);

459
	data = wacom_get_hdev_data(hdev);
460
	if (!data) {
461
		data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
462 463 464 465 466 467
		if (!data) {
			retval = -ENOMEM;
			goto out;
		}

		kref_init(&data->kref);
468
		data->dev = hdev;
469 470 471
		list_add_tail(&data->list, &wacom_udev_list);
	}

472
	wacom_wac->shared = &data->shared;
473 474 475 476 477 478 479 480

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

static void wacom_release_shared_data(struct kref *kref)
{
481 482
	struct wacom_hdev_data *data =
		container_of(kref, struct wacom_hdev_data, kref);
483 484 485 486 487 488 489 490 491 492

	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)
{
493
	struct wacom_hdev_data *data;
494 495

	if (wacom->shared) {
496
		data = container_of(wacom->shared, struct wacom_hdev_data, shared);
497 498 499 500 501
		kref_put(&data->kref, wacom_release_shared_data);
		wacom->shared = NULL;
	}
}

502 503 504
static int wacom_led_control(struct wacom *wacom)
{
	unsigned char *buf;
505
	int retval;
506 507
	unsigned char report_id = WAC_CMD_LED_CONTROL;
	int buf_size = 9;
508

509 510 511 512 513
	if (wacom->wacom_wac.pid) { /* wireless connected */
		report_id = WAC_CMD_WL_LED_CONTROL;
		buf_size = 13;
	}
	buf = kzalloc(buf_size, GFP_KERNEL);
514 515 516
	if (!buf)
		return -ENOMEM;

517
	if (wacom->wacom_wac.features.type >= INTUOS5S &&
518
	    wacom->wacom_wac.features.type <= INTUOSPL) {
519 520 521 522 523 524 525 526
		/*
		 * 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;
527 528 529 530 531 532 533 534 535 536
		unsigned char led_bits = (crop_lum << 4) | (ring_lum << 2) | (ring_led);

		buf[0] = report_id;
		if (wacom->wacom_wac.pid) {
			wacom_get_report(wacom->hdev, HID_FEATURE_REPORT,
					 buf, buf_size, WAC_CMD_RETRIES);
			buf[0] = report_id;
			buf[4] = led_bits;
		} else
			buf[1] = led_bits;
537 538 539 540 541 542 543 544
	}
	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;

545
		buf[0] = report_id;
546 547 548 549 550
		buf[1] = led;
		buf[2] = wacom->led.llv;
		buf[3] = wacom->led.hlv;
		buf[4] = wacom->led.img_lum;
	}
551

552
	retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, buf_size,
553
				  WAC_CMD_RETRIES);
554 555 556 557 558
	kfree(buf);

	return retval;
}

559 560
static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id,
		const unsigned len, const void *img)
561 562 563
{
	unsigned char *buf;
	int i, retval;
564
	const unsigned chunk_len = len / 4; /* 4 chunks are needed to be sent */
565

566
	buf = kzalloc(chunk_len + 3 , GFP_KERNEL);
567 568 569 570 571 572
	if (!buf)
		return -ENOMEM;

	/* Send 'start' command */
	buf[0] = WAC_CMD_ICON_START;
	buf[1] = 1;
573 574
	retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
				  WAC_CMD_RETRIES);
575 576 577
	if (retval < 0)
		goto out;

578
	buf[0] = xfer_id;
579 580 581
	buf[1] = button_id & 0x07;
	for (i = 0; i < 4; i++) {
		buf[2] = i;
582
		memcpy(buf + 3, img + i * chunk_len, chunk_len);
583

584
		retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
585
					  buf, chunk_len + 3, WAC_CMD_RETRIES);
586 587 588 589 590 591 592
		if (retval < 0)
			break;
	}

	/* Send 'stop' */
	buf[0] = WAC_CMD_ICON_START;
	buf[1] = 0;
593 594
	wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
			 WAC_CMD_RETRIES);
595 596 597 598 599 600

out:
	kfree(buf);
	return retval;
}

601
static ssize_t wacom_led_select_store(struct device *dev, int set_id,
602 603
				      const char *buf, size_t count)
{
604
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
605
	struct wacom *wacom = hid_get_drvdata(hdev);
606 607 608 609 610 611 612 613 614
	unsigned int id;
	int err;

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

	mutex_lock(&wacom->lock);

615
	wacom->led.select[set_id] = id & 0x3;
616 617 618 619 620 621 622
	err = wacom_led_control(wacom);

	mutex_unlock(&wacom->lock);

	return err < 0 ? err : count;
}

623 624 625 626 627 628
#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);		\
}									\
629 630 631
static ssize_t wacom_led##SET_ID##_select_show(struct device *dev,	\
	struct device_attribute *attr, char *buf)			\
{									\
632
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
633
	struct wacom *wacom = hid_get_drvdata(hdev);			\
P
Ping Cheng 已提交
634 635
	return scnprintf(buf, PAGE_SIZE, "%d\n",			\
			 wacom->led.select[SET_ID]);			\
636
}									\
637
static DEVICE_ATTR(status_led##SET_ID##_select, DEV_ATTR_RW_PERM,	\
638
		    wacom_led##SET_ID##_select_show,			\
639 640 641 642
		    wacom_led##SET_ID##_select_store)

DEVICE_LED_SELECT_ATTR(0);
DEVICE_LED_SELECT_ATTR(1);
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667

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)	\
{									\
668
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
669
	struct wacom *wacom = hid_get_drvdata(hdev);			\
670 671 672 673
									\
	return wacom_luminance_store(wacom, &wacom->led.field,		\
				     buf, count);			\
}									\
P
Ping Cheng 已提交
674 675 676 677 678 679
static ssize_t wacom_##name##_luminance_show(struct device *dev,	\
	struct device_attribute *attr, char *buf)			\
{									\
	struct wacom *wacom = dev_get_drvdata(dev);			\
	return scnprintf(buf, PAGE_SIZE, "%d\n", wacom->led.field);	\
}									\
680
static DEVICE_ATTR(name##_luminance, DEV_ATTR_RW_PERM,			\
P
Ping Cheng 已提交
681 682
		   wacom_##name##_luminance_show,			\
		   wacom_##name##_luminance_store)
683 684 685 686 687 688 689 690

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)
{
691
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
692
	struct wacom *wacom = hid_get_drvdata(hdev);
693
	int err;
694 695 696 697 698 699 700 701 702 703
	unsigned len;
	u8 xfer_id;

	if (hdev->bus == BUS_BLUETOOTH) {
		len = 256;
		xfer_id = WAC_CMD_ICON_BT_XFER;
	} else {
		len = 1024;
		xfer_id = WAC_CMD_ICON_XFER;
	}
704

705
	if (count != len)
706 707 708 709
		return -EINVAL;

	mutex_lock(&wacom->lock);

710
	err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf);
711 712 713 714 715 716 717 718 719 720 721 722

	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);	\
}									\
723
static DEVICE_ATTR(button##BUTTON_ID##_rawimg, DEV_ATTR_WO_PERM,	\
724 725 726 727 728 729 730 731 732 733 734
		   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);

735 736 737 738 739 740 741 742 743 744 745 746
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[] = {
747 748
	&dev_attr_status0_luminance.attr,
	&dev_attr_status1_luminance.attr,
749
	&dev_attr_status_led0_select.attr,
750 751 752 753 754 755 756 757 758 759 760 761
	&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
};

762
static struct attribute_group intuos4_led_attr_group = {
763
	.name = "wacom_led",
764
	.attrs = intuos4_led_attrs,
765 766
};

767 768 769 770 771 772 773 774 775 776 777
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,
};

778 779 780 781
static int wacom_initialize_leds(struct wacom *wacom)
{
	int error;

782 783
	/* Initialize default values */
	switch (wacom->wacom_wac.features.type) {
784
	case INTUOS4S:
785
	case INTUOS4:
786
	case INTUOS4WL:
787 788 789
	case INTUOS4L:
		wacom->led.select[0] = 0;
		wacom->led.select[1] = 0;
790
		wacom->led.llv = 10;
791 792
		wacom->led.hlv = 20;
		wacom->led.img_lum = 10;
793
		error = sysfs_create_group(&wacom->hdev->dev.kobj,
794 795 796
					   &intuos4_led_attr_group);
		break;

797
	case WACOM_24HD:
798 799 800 801 802 803
	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;
804

805
		error = sysfs_create_group(&wacom->hdev->dev.kobj,
806 807 808
					   &cintiq_led_attr_group);
		break;

809 810 811
	case INTUOS5S:
	case INTUOS5:
	case INTUOS5L:
812 813 814
	case INTUOSPS:
	case INTUOSPM:
	case INTUOSPL:
815 816 817 818 819 820 821
		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;

822
			error = sysfs_create_group(&wacom->hdev->dev.kobj,
823 824 825
						  &intuos5_led_attr_group);
		} else
			return 0;
826 827
		break;

828 829
	default:
		return 0;
830 831
	}

832
	if (error) {
833
		hid_err(wacom->hdev,
834 835 836 837
			"cannot create sysfs group err: %d\n", error);
		return error;
	}
	wacom_led_control(wacom);
838
	wacom->led_initialized = true;
839

840 841 842 843 844
	return 0;
}

static void wacom_destroy_leds(struct wacom *wacom)
{
845 846 847 848 849
	if (!wacom->led_initialized)
		return;

	wacom->led_initialized = false;

850
	switch (wacom->wacom_wac.features.type) {
851
	case INTUOS4S:
852
	case INTUOS4:
853
	case INTUOS4WL:
854
	case INTUOS4L:
855
		sysfs_remove_group(&wacom->hdev->dev.kobj,
856 857 858
				   &intuos4_led_attr_group);
		break;

859
	case WACOM_24HD:
860
	case WACOM_21UX2:
861
		sysfs_remove_group(&wacom->hdev->dev.kobj,
862 863
				   &cintiq_led_attr_group);
		break;
864 865 866 867

	case INTUOS5S:
	case INTUOS5:
	case INTUOS5L:
868 869 870
	case INTUOSPS:
	case INTUOSPM:
	case INTUOSPL:
871
		if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN)
872
			sysfs_remove_group(&wacom->hdev->dev.kobj,
873
					   &intuos5_led_attr_group);
874
		break;
875 876 877
	}
}

878
static enum power_supply_property wacom_battery_props[] = {
879
	POWER_SUPPLY_PROP_STATUS,
880
	POWER_SUPPLY_PROP_SCOPE,
881 882 883
	POWER_SUPPLY_PROP_CAPACITY
};

884 885 886 887 888 889
static enum power_supply_property wacom_ac_props[] = {
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_SCOPE,
};

890 891 892 893 894 895 896 897
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) {
898 899 900
		case POWER_SUPPLY_PROP_SCOPE:
			val->intval = POWER_SUPPLY_SCOPE_DEVICE;
			break;
901 902
		case POWER_SUPPLY_PROP_CAPACITY:
			val->intval =
903 904 905 906 907 908 909 910 911 912
				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;
913 914 915 916 917 918 919 920 921
			break;
		default:
			ret = -EINVAL;
			break;
	}

	return ret;
}

922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
static int wacom_ac_get_property(struct power_supply *psy,
				enum power_supply_property psp,
				union power_supply_propval *val)
{
	struct wacom *wacom = container_of(psy, struct wacom, ac);
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_PRESENT:
		/* fall through */
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = wacom->wacom_wac.ps_connected;
		break;
	case POWER_SUPPLY_PROP_SCOPE:
		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
		break;
	default:
		ret = -EINVAL;
		break;
	}
	return ret;
}

945 946
static int wacom_initialize_battery(struct wacom *wacom)
{
947
	static atomic_t battery_no = ATOMIC_INIT(0);
948
	int error;
949
	unsigned long n;
950

951
	if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) {
952
		n = atomic_inc_return(&battery_no) - 1;
953

954 955 956
		wacom->battery.properties = wacom_battery_props;
		wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
		wacom->battery.get_property = wacom_battery_get_property;
957 958
		sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
		wacom->battery.name = wacom->wacom_wac.bat_name;
959 960 961
		wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
		wacom->battery.use_for_apm = 0;

962 963 964 965 966 967 968 969
		wacom->ac.properties = wacom_ac_props;
		wacom->ac.num_properties = ARRAY_SIZE(wacom_ac_props);
		wacom->ac.get_property = wacom_ac_get_property;
		sprintf(wacom->wacom_wac.ac_name, "wacom_ac_%ld", n);
		wacom->ac.name = wacom->wacom_wac.ac_name;
		wacom->ac.type = POWER_SUPPLY_TYPE_MAINS;
		wacom->ac.use_for_apm = 0;

970
		error = power_supply_register(&wacom->hdev->dev,
971
					      &wacom->battery);
972 973 974 975
		if (error)
			return error;

		power_supply_powers(&wacom->battery, &wacom->hdev->dev);
976

977 978 979 980 981 982 983
		error = power_supply_register(&wacom->hdev->dev, &wacom->ac);
		if (error) {
			power_supply_unregister(&wacom->battery);
			return error;
		}

		power_supply_powers(&wacom->ac, &wacom->hdev->dev);
984 985
	}

986
	return 0;
987 988 989 990
}

static void wacom_destroy_battery(struct wacom *wacom)
{
991 992
	if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
	     wacom->battery.dev) {
993
		power_supply_unregister(&wacom->battery);
994
		wacom->battery.dev = NULL;
995 996
		power_supply_unregister(&wacom->ac);
		wacom->ac.dev = NULL;
997
	}
998 999
}

1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
static ssize_t wacom_show_speed(struct device *dev,
				struct device_attribute
				*attr, char *buf)
{
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
	struct wacom *wacom = hid_get_drvdata(hdev);

	return snprintf(buf, PAGE_SIZE, "%i\n", wacom->wacom_wac.bt_high_speed);
}

static ssize_t wacom_store_speed(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
	struct wacom *wacom = hid_get_drvdata(hdev);
	u8 new_speed;

	if (kstrtou8(buf, 0, &new_speed))
		return -EINVAL;

	if (new_speed != 0 && new_speed != 1)
		return -EINVAL;

	wacom_bt_query_tablet_data(hdev, new_speed, &wacom->wacom_wac.features);

	return count;
}

1029
static DEVICE_ATTR(speed, DEV_ATTR_RW_PERM,
1030 1031
		wacom_show_speed, wacom_store_speed);

1032
static struct input_dev *wacom_allocate_input(struct wacom *wacom)
1033 1034
{
	struct input_dev *input_dev;
1035
	struct hid_device *hdev = wacom->hdev;
1036 1037 1038
	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);

	input_dev = input_allocate_device();
1039 1040
	if (!input_dev)
		return NULL;
1041 1042

	input_dev->name = wacom_wac->name;
1043 1044
	input_dev->phys = hdev->phys;
	input_dev->dev.parent = &hdev->dev;
1045 1046
	input_dev->open = wacom_open;
	input_dev->close = wacom_close;
1047 1048 1049
	input_dev->uniq = hdev->uniq;
	input_dev->id.bustype = hdev->bus;
	input_dev->id.vendor  = hdev->vendor;
1050
	input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product;
1051
	input_dev->id.version = hdev->version;
1052 1053
	input_set_drvdata(input_dev, wacom);

1054 1055 1056
	return input_dev;
}

1057
static void wacom_free_inputs(struct wacom *wacom)
1058
{
1059 1060 1061 1062 1063 1064 1065 1066
	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);

	if (wacom_wac->input)
		input_free_device(wacom_wac->input);
	if (wacom_wac->pad_input)
		input_free_device(wacom_wac->pad_input);
	wacom_wac->input = NULL;
	wacom_wac->pad_input = NULL;
1067 1068
}

1069
static int wacom_allocate_inputs(struct wacom *wacom)
1070 1071 1072 1073 1074 1075 1076
{
	struct input_dev *input_dev, *pad_input_dev;
	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);

	input_dev = wacom_allocate_input(wacom);
	pad_input_dev = wacom_allocate_input(wacom);
	if (!input_dev || !pad_input_dev) {
1077 1078
		wacom_free_inputs(wacom);
		return -ENOMEM;
1079 1080
	}

1081
	wacom_wac->input = input_dev;
1082 1083 1084
	wacom_wac->pad_input = pad_input_dev;
	wacom_wac->pad_input->name = wacom_wac->pad_name;

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	return 0;
}

static void wacom_clean_inputs(struct wacom *wacom)
{
	if (wacom->wacom_wac.input) {
		if (wacom->wacom_wac.input_registered)
			input_unregister_device(wacom->wacom_wac.input);
		else
			input_free_device(wacom->wacom_wac.input);
	}
	if (wacom->wacom_wac.pad_input) {
		if (wacom->wacom_wac.input_registered)
			input_unregister_device(wacom->wacom_wac.pad_input);
		else
			input_free_device(wacom->wacom_wac.pad_input);
	}
	wacom->wacom_wac.input = NULL;
	wacom->wacom_wac.pad_input = NULL;
	wacom_destroy_leds(wacom);
}

static int wacom_register_inputs(struct wacom *wacom)
{
	struct input_dev *input_dev, *pad_input_dev;
	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
	int error;

	input_dev = wacom_wac->input;
	pad_input_dev = wacom_wac->pad_input;

	if (!input_dev || !pad_input_dev)
		return -EINVAL;

1119 1120
	error = wacom_setup_input_capabilities(input_dev, wacom_wac);
	if (error)
1121
		return error;
1122 1123

	error = input_register_device(input_dev);
1124
	if (error)
1125
		return error;
1126

1127 1128 1129 1130 1131 1132 1133 1134 1135
	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)
1136
			goto fail_register_pad_input;
1137 1138 1139

		error = wacom_initialize_leds(wacom);
		if (error)
1140
			goto fail_leds;
1141 1142
	}

1143 1144
	wacom_wac->input_registered = true;

1145
	return 0;
1146

1147
fail_leds:
1148 1149
	input_unregister_device(pad_input_dev);
	pad_input_dev = NULL;
1150
fail_register_pad_input:
1151
	input_unregister_device(input_dev);
1152
	wacom_wac->input = NULL;
1153 1154 1155
	return error;
}

1156 1157 1158 1159 1160
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;
1161
	struct hid_device *hdev1, *hdev2;
1162 1163 1164
	struct wacom *wacom1, *wacom2;
	struct wacom_wac *wacom_wac1, *wacom_wac2;
	int error;
1165 1166 1167

	/*
	 * Regardless if this is a disconnect or a new tablet,
1168
	 * remove any existing input and battery devices.
1169 1170
	 */

1171 1172
	wacom_destroy_battery(wacom);

1173
	/* Stylus interface */
1174 1175
	hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
	wacom1 = hid_get_drvdata(hdev1);
1176
	wacom_wac1 = &(wacom1->wacom_wac);
1177
	wacom_clean_inputs(wacom1);
1178 1179

	/* Touch interface */
1180 1181
	hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
	wacom2 = hid_get_drvdata(hdev2);
1182
	wacom_wac2 = &(wacom2->wacom_wac);
1183
	wacom_clean_inputs(wacom2);
1184 1185

	if (wacom_wac->pid == 0) {
1186
		hid_info(wacom->hdev, "wireless tablet disconnected\n");
1187
		wacom_wac1->shared->type = 0;
1188
	} else {
1189
		const struct hid_device_id *id = wacom_ids;
1190

1191
		hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
1192
			 wacom_wac->pid);
1193

1194 1195 1196
		while (id->bus) {
			if (id->vendor == USB_VENDOR_ID_WACOM &&
			    id->product == wacom_wac->pid)
1197 1198 1199 1200
				break;
			id++;
		}

1201
		if (!id->bus) {
1202
			hid_info(wacom->hdev, "ignoring unknown PID.\n");
1203 1204 1205 1206
			return;
		}

		/* Stylus interface */
1207
		wacom_wac1->features =
1208
			*((struct wacom_features *)id->driver_data);
1209
		wacom_wac1->features.device_type = BTN_TOOL_PEN;
1210 1211
		snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen",
			 wacom_wac1->features.name);
1212 1213
		snprintf(wacom_wac1->pad_name, WACOM_NAME_MAX, "%s (WL) Pad",
			 wacom_wac1->features.name);
1214 1215
		wacom_wac1->shared->touch_max = wacom_wac1->features.touch_max;
		wacom_wac1->shared->type = wacom_wac1->features.type;
1216
		wacom_wac1->pid = wacom_wac->pid;
1217 1218
		error = wacom_allocate_inputs(wacom1) ||
			wacom_register_inputs(wacom1);
1219
		if (error)
1220
			goto fail;
1221 1222

		/* Touch interface */
1223 1224
		if (wacom_wac1->features.touch_max ||
		    wacom_wac1->features.type == INTUOSHT) {
1225
			wacom_wac2->features =
1226
				*((struct wacom_features *)id->driver_data);
1227 1228 1229 1230 1231 1232 1233 1234 1235
			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);
1236 1237
			snprintf(wacom_wac2->pad_name, WACOM_NAME_MAX,
				 "%s (WL) Pad", wacom_wac2->features.name);
1238
			wacom_wac2->pid = wacom_wac->pid;
1239 1240
			error = wacom_allocate_inputs(wacom2) ||
				wacom_register_inputs(wacom2);
1241 1242
			if (error)
				goto fail;
1243 1244 1245 1246

			if (wacom_wac1->features.type == INTUOSHT &&
			    wacom_wac1->features.touch_max)
				wacom_wac->shared->touch_input = wacom_wac2->input;
1247
		}
1248 1249 1250

		error = wacom_initialize_battery(wacom);
		if (error)
1251
			goto fail;
1252
	}
1253 1254 1255

	return;

1256
fail:
1257 1258
	wacom_clean_inputs(wacom1);
	wacom_clean_inputs(wacom2);
1259
	return;
1260 1261
}

1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
/*
 * 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);
}

1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
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;
}

1312 1313
static int wacom_probe(struct hid_device *hdev,
		const struct hid_device_id *id)
1314
{
1315
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
1316 1317 1318
	struct usb_device *dev = interface_to_usbdev(intf);
	struct wacom *wacom;
	struct wacom_wac *wacom_wac;
1319 1320
	struct wacom_features *features;
	int error;
1321

1322
	if (!id->driver_data)
1323 1324
		return -EINVAL;

1325 1326
	hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;

1327
	wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
1328 1329
	if (!wacom)
		return -ENOMEM;
1330

1331 1332 1333
	hid_set_drvdata(hdev, wacom);
	wacom->hdev = hdev;

1334 1335 1336 1337
	/* ask for the report descriptor to be loaded by HID */
	error = hid_parse(hdev);
	if (error) {
		hid_err(hdev, "parse failed\n");
1338
		goto fail_parse;
1339 1340
	}

1341
	wacom_wac = &wacom->wacom_wac;
1342
	wacom_wac->features = *((struct wacom_features *)id->driver_data);
1343
	features = &wacom_wac->features;
1344
	features->pktlen = wacom_compute_pktlen(hdev);
1345 1346
	if (features->pktlen > WACOM_PKGLEN_MAX) {
		error = -EINVAL;
1347
		goto fail_pktlen;
1348
	}
1349

1350 1351
	if (features->check_for_hid_type && features->hid_type != hdev->type) {
		error = -ENODEV;
1352
		goto fail_type;
1353
	}
1354 1355

	wacom->usbdev = dev;
1356 1357
	wacom->intf = intf;
	mutex_init(&wacom->lock);
1358
	INIT_WORK(&wacom->work, wacom_wireless_work);
1359

1360 1361 1362 1363 1364 1365
	if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
		error = wacom_allocate_inputs(wacom);
		if (error)
			goto fail_allocate_inputs;
	}

1366 1367 1368
	/* set the default size in case we do not get them from hid */
	wacom_set_default_phy(features);

1369
	/* Retrieve the physical and logical size for touch devices */
1370
	wacom_retrieve_hid_descriptor(hdev, features);
1371

1372 1373
	/*
	 * Intuos5 has no useful data about its touch interface in its
1374
	 * HID descriptor. If this is the touch interface (PacketSize
1375 1376
	 * of WACOM_PKGLEN_BBTOUCH3), override the table values.
	 */
1377
	if (features->type >= INTUOS5S && features->type <= INTUOSHT) {
1378
		if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1379 1380 1381 1382 1383 1384 1385 1386 1387
			features->device_type = BTN_TOOL_FINGER;

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

1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
	/*
	 * 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;
	}

1400 1401 1402
	if (hdev->bus == BUS_BLUETOOTH)
		features->quirks |= WACOM_QUIRK_BATTERY;

1403 1404
	wacom_setup_device_quirks(features);

1405 1406 1407
	/* set unit to "100th of a mm" for devices not reported by HID */
	if (!features->unit) {
		features->unit = 0x11;
1408
		features->unitExpo = -3;
1409 1410 1411
	}
	wacom_calculate_res(features);

1412
	strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
1413 1414
	snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name),
		"%s Pad", features->name);
1415

1416
	if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
1417
		/* Append the device type to the name */
1418 1419 1420 1421 1422 1423
		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);
1424

1425
		error = wacom_add_shared_data(hdev);
1426
		if (error)
1427
			goto fail_shared_data;
1428 1429
	}

1430 1431 1432 1433
	if (!(features->quirks & WACOM_QUIRK_MONITOR) &&
	     (features->quirks & WACOM_QUIRK_BATTERY)) {
		error = wacom_initialize_battery(wacom);
		if (error)
1434
			goto fail_battery;
1435 1436
	}

1437
	if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
1438
		error = wacom_register_inputs(wacom);
1439
		if (error)
1440
			goto fail_register_inputs;
1441 1442 1443 1444 1445 1446 1447 1448
	}

	if (hdev->bus == BUS_BLUETOOTH) {
		error = device_create_file(&hdev->dev, &dev_attr_speed);
		if (error)
			hid_warn(hdev,
				 "can't create sysfs speed attribute err: %d\n",
				 error);
1449
	}
1450

1451
	/* Note that if query fails it is not a hard failure */
1452
	wacom_query_tablet_data(hdev, features);
1453

1454 1455 1456 1457
	/* Regular HID work starts now */
	error = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	if (error) {
		hid_err(hdev, "hw start failed\n");
1458
		goto fail_hw_start;
1459
	}
1460

1461 1462 1463
	if (features->quirks & WACOM_QUIRK_MONITOR)
		error = hid_hw_open(hdev);

1464 1465 1466 1467 1468
	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;
	}

1469 1470
	return 0;

1471 1472
fail_hw_start:
	if (hdev->bus == BUS_BLUETOOTH)
1473
		device_remove_file(&hdev->dev, &dev_attr_speed);
1474
fail_register_inputs:
1475
	wacom_clean_inputs(wacom);
1476 1477 1478 1479
	wacom_destroy_battery(wacom);
fail_battery:
	wacom_remove_shared_data(wacom_wac);
fail_shared_data:
1480 1481
	wacom_clean_inputs(wacom);
fail_allocate_inputs:
1482 1483 1484 1485
fail_type:
fail_pktlen:
fail_parse:
	kfree(wacom);
1486
	hid_set_drvdata(hdev, NULL);
1487
	return error;
1488 1489
}

1490
static void wacom_remove(struct hid_device *hdev)
1491
{
1492
	struct wacom *wacom = hid_get_drvdata(hdev);
1493

1494
	hid_hw_stop(hdev);
1495

1496
	cancel_work_sync(&wacom->work);
1497
	wacom_clean_inputs(wacom);
1498 1499
	if (hdev->bus == BUS_BLUETOOTH)
		device_remove_file(&hdev->dev, &dev_attr_speed);
1500
	wacom_destroy_battery(wacom);
1501
	wacom_remove_shared_data(&wacom->wacom_wac);
1502

1503 1504
	hid_set_drvdata(hdev, NULL);
	kfree(wacom);
1505 1506
}

1507
#ifdef CONFIG_PM
1508
static int wacom_resume(struct hid_device *hdev)
1509
{
1510
	struct wacom *wacom = hid_get_drvdata(hdev);
1511
	struct wacom_features *features = &wacom->wacom_wac.features;
1512 1513

	mutex_lock(&wacom->lock);
1514 1515

	/* switch to wacom mode first */
1516
	wacom_query_tablet_data(hdev, features);
1517
	wacom_led_control(wacom);
1518

1519 1520
	mutex_unlock(&wacom->lock);

1521
	return 0;
1522 1523
}

1524
static int wacom_reset_resume(struct hid_device *hdev)
1525
{
1526
	return wacom_resume(hdev);
1527
}
1528
#endif /* CONFIG_PM */
1529

1530
static struct hid_driver wacom_driver = {
1531
	.name =		"wacom",
1532
	.id_table =	wacom_ids,
1533
	.probe =	wacom_probe,
1534 1535
	.remove =	wacom_remove,
#ifdef CONFIG_PM
1536 1537
	.resume =	wacom_resume,
	.reset_resume =	wacom_reset_resume,
1538 1539
#endif
	.raw_event =	wacom_raw_event,
1540
};
1541
module_hid_driver(wacom_driver);
1542 1543 1544 1545 1546

MODULE_VERSION(DRIVER_VERSION);
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);