wacom_sys.c 40.2 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

17
#define WAC_MSG_RETRIES		5
18

19
#define WAC_CMD_WL_LED_CONTROL	0x03
20 21 22
#define WAC_CMD_LED_CONTROL	0x20
#define WAC_CMD_ICON_START	0x21
#define WAC_CMD_ICON_XFER	0x23
23
#define WAC_CMD_ICON_BT_XFER	0x26
24 25
#define WAC_CMD_RETRIES		10

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

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

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

	return retval;
40 41
}

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

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

	return retval;
53 54
}

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

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

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

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

	return 0;
68 69 70 71
}

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

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

79
	return retval;
80 81 82 83
}

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

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

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

107 108
static void wacom_feature_mapping(struct hid_device *hdev,
		struct hid_field *field, struct hid_usage *usage)
109
{
110 111
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_features *features = &wacom->wacom_wac.features;
112
	struct hid_data *hid_data = &wacom->wacom_wac.hid_data;
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
	case HID_DG_INPUTMODE:
		/* Ignore if value index is out of bounds. */
		if (usage->usage_index >= field->report_count) {
			dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n");
			break;
		}

		hid_data->inputmode = field->report->id;
		hid_data->inputmode_index = usage->usage_index;
		break;
142 143 144
	}
}

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

187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
	/*
	* 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;
208
			}
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
		} 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;
	}
228 229 230

	if (features->type == HID_GENERIC)
		wacom_wac_usage_mapping(hdev, field, usage);
231
}
232

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
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);
251
			}
252 253 254
		}
	}

255 256 257 258 259 260 261 262 263 264 265 266
	/* 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);
	}
267 268
}

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
static int wacom_hid_set_device_mode(struct hid_device *hdev)
{
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct hid_data *hid_data = &wacom->wacom_wac.hid_data;
	struct hid_report *r;
	struct hid_report_enum *re;

	if (hid_data->inputmode < 0)
		return 0;

	re = &(hdev->report_enum[HID_FEATURE_REPORT]);
	r = re->report_id_hash[hid_data->inputmode];
	if (r) {
		r->field[0]->value[hid_data->inputmode_index] = 2;
		hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
	}
	return 0;
}

288 289
static int wacom_set_device_mode(struct hid_device *hdev, int report_id,
		int length, int mode)
290 291
{
	unsigned char *rep_data;
292
	int error = -ENOMEM, limit = 0;
293

294
	rep_data = kzalloc(length, GFP_KERNEL);
295
	if (!rep_data)
296 297
		return error;

298
	do {
299 300 301
		rep_data[0] = report_id;
		rep_data[1] = mode;

302 303
		error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
					 length, 1);
304
		if (error >= 0)
305
			error = wacom_get_report(hdev, HID_FEATURE_REPORT,
306
			                         rep_data, length, 1);
307 308 309 310 311 312 313
	} while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);

	kfree(rep_data);

	return error < 0 ? error : 0;
}

314 315 316
static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
		struct wacom_features *features)
{
317 318 319 320 321 322 323 324
	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;
325 326
		ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
					3);
327 328 329 330 331 332

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

			ret = wacom_set_report(hdev, HID_FEATURE_REPORT,
333
						rep_data, 2, 3);
334 335 336 337 338 339 340 341 342 343 344 345 346 347

			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;
348 349 350 351 352 353 354 355 356
	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;

357 358
		ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
					1);
359 360 361
		if (ret >= 0)
			wacom->wacom_wac.bt_high_speed = speed;
		break;
362 363
	}

364 365 366
	return 0;
}

367 368 369 370 371 372 373
/*
 * 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.
 */
374 375
static int wacom_query_tablet_data(struct hid_device *hdev,
		struct wacom_features *features)
376
{
377 378 379
	if (hdev->bus == BUS_BLUETOOTH)
		return wacom_bt_query_tablet_data(hdev, 1, features);

380 381 382
	if (features->type == HID_GENERIC)
		return wacom_hid_set_device_mode(hdev);

383
	if (features->device_type == BTN_TOOL_FINGER) {
P
Ping Cheng 已提交
384
		if (features->type > TABLETPC) {
385
			/* MT Tablet PC touch */
386
			return wacom_set_device_mode(hdev, 3, 4, 4);
387
		}
388
		else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
389
			return wacom_set_device_mode(hdev, 18, 3, 2);
390
		}
391 392
	} else if (features->device_type == BTN_TOOL_PEN) {
		if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
393
			return wacom_set_device_mode(hdev, 2, 2, 2);
394
		}
395
	}
396

397
	return 0;
398 399
}

400
static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
401
					 struct wacom_features *features)
402
{
403 404
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct usb_interface *intf = wacom->intf;
405

406
	/* default features */
407
	features->device_type = BTN_TOOL_PEN;
408 409 410 411
	features->x_fuzz = 4;
	features->y_fuzz = 4;
	features->pressure_fuzz = 0;
	features->distance_fuzz = 0;
412

413 414 415 416 417 418 419 420 421 422
	/*
	 * 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) {
423
			features->device_type = BTN_TOOL_FINGER;
424 425 426 427
			features->pktlen = WACOM_PKGLEN_BBTOUCH3;
		}
	}

428
	/* only devices that support touch need to retrieve the info */
429 430
	if (features->type < BAMBOO_PT)
		return;
431

432
	wacom_parse_hid(hdev, features);
433 434
}

435
struct wacom_hdev_data {
436 437
	struct list_head list;
	struct kref kref;
438
	struct hid_device *dev;
439 440 441 442 443 444
	struct wacom_shared shared;
};

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

445 446
static bool wacom_are_sibling(struct hid_device *hdev,
		struct hid_device *sibling)
447
{
448 449 450 451 452 453 454 455 456 457
	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;
	}
458

459 460
	if (vid != sibling->vendor || pid != sibling->product)
		return false;
461

462 463 464 465 466
	/* 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;
467

468
	return !strncmp(hdev->phys, sibling->phys, n1);
469 470
}

471
static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
472
{
473
	struct wacom_hdev_data *data;
474 475

	list_for_each_entry(data, &wacom_udev_list, list) {
476
		if (wacom_are_sibling(hdev, data->dev)) {
477 478 479 480 481 482 483 484
			kref_get(&data->kref);
			return data;
		}
	}

	return NULL;
}

485
static int wacom_add_shared_data(struct hid_device *hdev)
486
{
487 488 489
	struct wacom *wacom = hid_get_drvdata(hdev);
	struct wacom_wac *wacom_wac = &wacom->wacom_wac;
	struct wacom_hdev_data *data;
490 491 492 493
	int retval = 0;

	mutex_lock(&wacom_udev_list_lock);

494
	data = wacom_get_hdev_data(hdev);
495
	if (!data) {
496
		data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
497 498 499 500 501 502
		if (!data) {
			retval = -ENOMEM;
			goto out;
		}

		kref_init(&data->kref);
503
		data->dev = hdev;
504 505 506
		list_add_tail(&data->list, &wacom_udev_list);
	}

507
	wacom_wac->shared = &data->shared;
508 509 510 511 512 513 514 515

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

static void wacom_release_shared_data(struct kref *kref)
{
516 517
	struct wacom_hdev_data *data =
		container_of(kref, struct wacom_hdev_data, kref);
518 519 520 521 522 523 524 525 526 527

	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)
{
528
	struct wacom_hdev_data *data;
529 530

	if (wacom->shared) {
531
		data = container_of(wacom->shared, struct wacom_hdev_data, shared);
532 533 534 535 536
		kref_put(&data->kref, wacom_release_shared_data);
		wacom->shared = NULL;
	}
}

537 538 539
static int wacom_led_control(struct wacom *wacom)
{
	unsigned char *buf;
540
	int retval;
541 542
	unsigned char report_id = WAC_CMD_LED_CONTROL;
	int buf_size = 9;
543

544 545 546 547 548
	if (wacom->wacom_wac.pid) { /* wireless connected */
		report_id = WAC_CMD_WL_LED_CONTROL;
		buf_size = 13;
	}
	buf = kzalloc(buf_size, GFP_KERNEL);
549 550 551
	if (!buf)
		return -ENOMEM;

552
	if (wacom->wacom_wac.features.type >= INTUOS5S &&
553
	    wacom->wacom_wac.features.type <= INTUOSPL) {
554 555 556 557 558 559 560 561
		/*
		 * 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;
562 563 564 565 566 567 568 569 570 571
		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;
572 573 574 575 576 577 578 579
	}
	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;

580
		buf[0] = report_id;
581 582 583 584 585
		buf[1] = led;
		buf[2] = wacom->led.llv;
		buf[3] = wacom->led.hlv;
		buf[4] = wacom->led.img_lum;
	}
586

587
	retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, buf_size,
588
				  WAC_CMD_RETRIES);
589 590 591 592 593
	kfree(buf);

	return retval;
}

594 595
static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id,
		const unsigned len, const void *img)
596 597 598
{
	unsigned char *buf;
	int i, retval;
599
	const unsigned chunk_len = len / 4; /* 4 chunks are needed to be sent */
600

601
	buf = kzalloc(chunk_len + 3 , GFP_KERNEL);
602 603 604 605 606 607
	if (!buf)
		return -ENOMEM;

	/* Send 'start' command */
	buf[0] = WAC_CMD_ICON_START;
	buf[1] = 1;
608 609
	retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
				  WAC_CMD_RETRIES);
610 611 612
	if (retval < 0)
		goto out;

613
	buf[0] = xfer_id;
614 615 616
	buf[1] = button_id & 0x07;
	for (i = 0; i < 4; i++) {
		buf[2] = i;
617
		memcpy(buf + 3, img + i * chunk_len, chunk_len);
618

619
		retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
620
					  buf, chunk_len + 3, WAC_CMD_RETRIES);
621 622 623 624 625 626 627
		if (retval < 0)
			break;
	}

	/* Send 'stop' */
	buf[0] = WAC_CMD_ICON_START;
	buf[1] = 0;
628 629
	wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
			 WAC_CMD_RETRIES);
630 631 632 633 634 635

out:
	kfree(buf);
	return retval;
}

636
static ssize_t wacom_led_select_store(struct device *dev, int set_id,
637 638
				      const char *buf, size_t count)
{
639
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
640
	struct wacom *wacom = hid_get_drvdata(hdev);
641 642 643 644 645 646 647 648 649
	unsigned int id;
	int err;

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

	mutex_lock(&wacom->lock);

650
	wacom->led.select[set_id] = id & 0x3;
651 652 653 654 655 656 657
	err = wacom_led_control(wacom);

	mutex_unlock(&wacom->lock);

	return err < 0 ? err : count;
}

658 659 660 661 662 663
#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);		\
}									\
664 665 666
static ssize_t wacom_led##SET_ID##_select_show(struct device *dev,	\
	struct device_attribute *attr, char *buf)			\
{									\
667
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
668
	struct wacom *wacom = hid_get_drvdata(hdev);			\
P
Ping Cheng 已提交
669 670
	return scnprintf(buf, PAGE_SIZE, "%d\n",			\
			 wacom->led.select[SET_ID]);			\
671
}									\
672
static DEVICE_ATTR(status_led##SET_ID##_select, DEV_ATTR_RW_PERM,	\
673
		    wacom_led##SET_ID##_select_show,			\
674 675 676 677
		    wacom_led##SET_ID##_select_store)

DEVICE_LED_SELECT_ATTR(0);
DEVICE_LED_SELECT_ATTR(1);
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702

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)	\
{									\
703
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
704
	struct wacom *wacom = hid_get_drvdata(hdev);			\
705 706 707 708
									\
	return wacom_luminance_store(wacom, &wacom->led.field,		\
				     buf, count);			\
}									\
P
Ping Cheng 已提交
709 710 711 712 713 714
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);	\
}									\
715
static DEVICE_ATTR(name##_luminance, DEV_ATTR_RW_PERM,			\
P
Ping Cheng 已提交
716 717
		   wacom_##name##_luminance_show,			\
		   wacom_##name##_luminance_store)
718 719 720 721 722 723 724 725

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)
{
726
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
727
	struct wacom *wacom = hid_get_drvdata(hdev);
728
	int err;
729 730 731 732 733 734 735 736 737 738
	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;
	}
739

740
	if (count != len)
741 742 743 744
		return -EINVAL;

	mutex_lock(&wacom->lock);

745
	err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf);
746 747 748 749 750 751 752 753 754 755 756 757

	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);	\
}									\
758
static DEVICE_ATTR(button##BUTTON_ID##_rawimg, DEV_ATTR_WO_PERM,	\
759 760 761 762 763 764 765 766 767 768 769
		   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);

770 771 772 773 774 775 776 777 778 779 780 781
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[] = {
782 783
	&dev_attr_status0_luminance.attr,
	&dev_attr_status1_luminance.attr,
784
	&dev_attr_status_led0_select.attr,
785 786 787 788 789 790 791 792 793 794 795 796
	&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
};

797
static struct attribute_group intuos4_led_attr_group = {
798
	.name = "wacom_led",
799
	.attrs = intuos4_led_attrs,
800 801
};

802 803 804 805 806 807 808 809 810 811 812
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,
};

813 814 815 816
static int wacom_initialize_leds(struct wacom *wacom)
{
	int error;

817 818
	/* Initialize default values */
	switch (wacom->wacom_wac.features.type) {
819
	case INTUOS4S:
820
	case INTUOS4:
821
	case INTUOS4WL:
822 823 824
	case INTUOS4L:
		wacom->led.select[0] = 0;
		wacom->led.select[1] = 0;
825
		wacom->led.llv = 10;
826 827
		wacom->led.hlv = 20;
		wacom->led.img_lum = 10;
828
		error = sysfs_create_group(&wacom->hdev->dev.kobj,
829 830 831
					   &intuos4_led_attr_group);
		break;

832
	case WACOM_24HD:
833 834 835 836 837 838
	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;
839

840
		error = sysfs_create_group(&wacom->hdev->dev.kobj,
841 842 843
					   &cintiq_led_attr_group);
		break;

844 845 846
	case INTUOS5S:
	case INTUOS5:
	case INTUOS5L:
847 848 849
	case INTUOSPS:
	case INTUOSPM:
	case INTUOSPL:
850 851 852 853 854 855 856
		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;

857
			error = sysfs_create_group(&wacom->hdev->dev.kobj,
858 859 860
						  &intuos5_led_attr_group);
		} else
			return 0;
861 862
		break;

863 864
	default:
		return 0;
865 866
	}

867
	if (error) {
868
		hid_err(wacom->hdev,
869 870 871 872
			"cannot create sysfs group err: %d\n", error);
		return error;
	}
	wacom_led_control(wacom);
873
	wacom->led_initialized = true;
874

875 876 877 878 879
	return 0;
}

static void wacom_destroy_leds(struct wacom *wacom)
{
880 881 882 883 884
	if (!wacom->led_initialized)
		return;

	wacom->led_initialized = false;

885
	switch (wacom->wacom_wac.features.type) {
886
	case INTUOS4S:
887
	case INTUOS4:
888
	case INTUOS4WL:
889
	case INTUOS4L:
890
		sysfs_remove_group(&wacom->hdev->dev.kobj,
891 892 893
				   &intuos4_led_attr_group);
		break;

894
	case WACOM_24HD:
895
	case WACOM_21UX2:
896
		sysfs_remove_group(&wacom->hdev->dev.kobj,
897 898
				   &cintiq_led_attr_group);
		break;
899 900 901 902

	case INTUOS5S:
	case INTUOS5:
	case INTUOS5L:
903 904 905
	case INTUOSPS:
	case INTUOSPM:
	case INTUOSPL:
906
		if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN)
907
			sysfs_remove_group(&wacom->hdev->dev.kobj,
908
					   &intuos5_led_attr_group);
909
		break;
910 911 912
	}
}

913
static enum power_supply_property wacom_battery_props[] = {
914
	POWER_SUPPLY_PROP_STATUS,
915
	POWER_SUPPLY_PROP_SCOPE,
916 917 918
	POWER_SUPPLY_PROP_CAPACITY
};

919 920 921 922 923 924
static enum power_supply_property wacom_ac_props[] = {
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_SCOPE,
};

925 926 927 928 929 930 931 932
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) {
933 934 935
		case POWER_SUPPLY_PROP_SCOPE:
			val->intval = POWER_SUPPLY_SCOPE_DEVICE;
			break;
936 937
		case POWER_SUPPLY_PROP_CAPACITY:
			val->intval =
938 939 940 941 942 943 944 945 946 947
				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;
948 949 950 951 952 953 954 955 956
			break;
		default:
			ret = -EINVAL;
			break;
	}

	return ret;
}

957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
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;
}

980 981
static int wacom_initialize_battery(struct wacom *wacom)
{
982
	static atomic_t battery_no = ATOMIC_INIT(0);
983
	int error;
984
	unsigned long n;
985

986
	if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) {
987
		n = atomic_inc_return(&battery_no) - 1;
988

989 990 991
		wacom->battery.properties = wacom_battery_props;
		wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
		wacom->battery.get_property = wacom_battery_get_property;
992 993
		sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
		wacom->battery.name = wacom->wacom_wac.bat_name;
994 995 996
		wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
		wacom->battery.use_for_apm = 0;

997 998 999 1000 1001 1002 1003 1004
		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;

1005
		error = power_supply_register(&wacom->hdev->dev,
1006
					      &wacom->battery);
1007 1008 1009 1010
		if (error)
			return error;

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

1012 1013 1014 1015 1016 1017 1018
		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);
1019 1020
	}

1021
	return 0;
1022 1023 1024 1025
}

static void wacom_destroy_battery(struct wacom *wacom)
{
1026 1027
	if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
	     wacom->battery.dev) {
1028
		power_supply_unregister(&wacom->battery);
1029
		wacom->battery.dev = NULL;
1030 1031
		power_supply_unregister(&wacom->ac);
		wacom->ac.dev = NULL;
1032
	}
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 1062 1063
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;
}

1064
static DEVICE_ATTR(speed, DEV_ATTR_RW_PERM,
1065 1066
		wacom_show_speed, wacom_store_speed);

1067
static struct input_dev *wacom_allocate_input(struct wacom *wacom)
1068 1069
{
	struct input_dev *input_dev;
1070
	struct hid_device *hdev = wacom->hdev;
1071 1072 1073
	struct wacom_wac *wacom_wac = &(wacom->wacom_wac);

	input_dev = input_allocate_device();
1074 1075
	if (!input_dev)
		return NULL;
1076 1077

	input_dev->name = wacom_wac->name;
1078 1079
	input_dev->phys = hdev->phys;
	input_dev->dev.parent = &hdev->dev;
1080 1081
	input_dev->open = wacom_open;
	input_dev->close = wacom_close;
1082 1083 1084
	input_dev->uniq = hdev->uniq;
	input_dev->id.bustype = hdev->bus;
	input_dev->id.vendor  = hdev->vendor;
1085
	input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product;
1086
	input_dev->id.version = hdev->version;
1087 1088
	input_set_drvdata(input_dev, wacom);

1089 1090 1091
	return input_dev;
}

1092
static void wacom_free_inputs(struct wacom *wacom)
1093
{
1094 1095 1096 1097 1098 1099 1100 1101
	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;
1102 1103
}

1104
static int wacom_allocate_inputs(struct wacom *wacom)
1105 1106 1107 1108 1109 1110 1111
{
	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) {
1112 1113
		wacom_free_inputs(wacom);
		return -ENOMEM;
1114 1115
	}

1116
	wacom_wac->input = input_dev;
1117 1118 1119
	wacom_wac->pad_input = pad_input_dev;
	wacom_wac->pad_input->name = wacom_wac->pad_name;

1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
	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;

1154 1155
	error = wacom_setup_input_capabilities(input_dev, wacom_wac);
	if (error)
1156
		return error;
1157 1158

	error = input_register_device(input_dev);
1159
	if (error)
1160
		return error;
1161

1162 1163 1164 1165 1166 1167 1168 1169 1170
	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)
1171
			goto fail_register_pad_input;
1172 1173 1174

		error = wacom_initialize_leds(wacom);
		if (error)
1175
			goto fail_leds;
1176 1177
	}

1178 1179
	wacom_wac->input_registered = true;

1180
	return 0;
1181

1182
fail_leds:
1183 1184
	input_unregister_device(pad_input_dev);
	pad_input_dev = NULL;
1185
fail_register_pad_input:
1186
	input_unregister_device(input_dev);
1187
	wacom_wac->input = NULL;
1188 1189 1190
	return error;
}

1191 1192 1193 1194 1195
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;
1196
	struct hid_device *hdev1, *hdev2;
1197 1198 1199
	struct wacom *wacom1, *wacom2;
	struct wacom_wac *wacom_wac1, *wacom_wac2;
	int error;
1200 1201 1202

	/*
	 * Regardless if this is a disconnect or a new tablet,
1203
	 * remove any existing input and battery devices.
1204 1205
	 */

1206 1207
	wacom_destroy_battery(wacom);

1208
	/* Stylus interface */
1209 1210
	hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
	wacom1 = hid_get_drvdata(hdev1);
1211
	wacom_wac1 = &(wacom1->wacom_wac);
1212
	wacom_clean_inputs(wacom1);
1213 1214

	/* Touch interface */
1215 1216
	hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
	wacom2 = hid_get_drvdata(hdev2);
1217
	wacom_wac2 = &(wacom2->wacom_wac);
1218
	wacom_clean_inputs(wacom2);
1219 1220

	if (wacom_wac->pid == 0) {
1221
		hid_info(wacom->hdev, "wireless tablet disconnected\n");
1222
		wacom_wac1->shared->type = 0;
1223
	} else {
1224
		const struct hid_device_id *id = wacom_ids;
1225

1226
		hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
1227
			 wacom_wac->pid);
1228

1229 1230 1231
		while (id->bus) {
			if (id->vendor == USB_VENDOR_ID_WACOM &&
			    id->product == wacom_wac->pid)
1232 1233 1234 1235
				break;
			id++;
		}

1236
		if (!id->bus) {
1237
			hid_info(wacom->hdev, "ignoring unknown PID.\n");
1238 1239 1240 1241
			return;
		}

		/* Stylus interface */
1242
		wacom_wac1->features =
1243
			*((struct wacom_features *)id->driver_data);
1244
		wacom_wac1->features.device_type = BTN_TOOL_PEN;
1245 1246
		snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen",
			 wacom_wac1->features.name);
1247 1248
		snprintf(wacom_wac1->pad_name, WACOM_NAME_MAX, "%s (WL) Pad",
			 wacom_wac1->features.name);
1249 1250
		wacom_wac1->shared->touch_max = wacom_wac1->features.touch_max;
		wacom_wac1->shared->type = wacom_wac1->features.type;
1251
		wacom_wac1->pid = wacom_wac->pid;
1252 1253
		error = wacom_allocate_inputs(wacom1) ||
			wacom_register_inputs(wacom1);
1254
		if (error)
1255
			goto fail;
1256 1257

		/* Touch interface */
1258 1259
		if (wacom_wac1->features.touch_max ||
		    wacom_wac1->features.type == INTUOSHT) {
1260
			wacom_wac2->features =
1261
				*((struct wacom_features *)id->driver_data);
1262 1263 1264 1265 1266 1267 1268 1269 1270
			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);
1271 1272
			snprintf(wacom_wac2->pad_name, WACOM_NAME_MAX,
				 "%s (WL) Pad", wacom_wac2->features.name);
1273
			wacom_wac2->pid = wacom_wac->pid;
1274 1275
			error = wacom_allocate_inputs(wacom2) ||
				wacom_register_inputs(wacom2);
1276 1277
			if (error)
				goto fail;
1278 1279 1280 1281

			if (wacom_wac1->features.type == INTUOSHT &&
			    wacom_wac1->features.touch_max)
				wacom_wac->shared->touch_input = wacom_wac2->input;
1282
		}
1283 1284 1285

		error = wacom_initialize_battery(wacom);
		if (error)
1286
			goto fail;
1287
	}
1288 1289 1290

	return;

1291
fail:
1292 1293
	wacom_clean_inputs(wacom1);
	wacom_clean_inputs(wacom2);
1294
	return;
1295 1296
}

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
/*
 * 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);
}

1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
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;
}

1347 1348
static int wacom_probe(struct hid_device *hdev,
		const struct hid_device_id *id)
1349
{
1350
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
1351 1352 1353
	struct usb_device *dev = interface_to_usbdev(intf);
	struct wacom *wacom;
	struct wacom_wac *wacom_wac;
1354 1355
	struct wacom_features *features;
	int error;
1356
	unsigned int connect_mask = HID_CONNECT_HIDRAW;
1357

1358
	if (!id->driver_data)
1359 1360
		return -EINVAL;

1361 1362
	hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;

1363
	wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
1364 1365
	if (!wacom)
		return -ENOMEM;
1366

1367 1368 1369
	hid_set_drvdata(hdev, wacom);
	wacom->hdev = hdev;

1370 1371 1372 1373
	/* ask for the report descriptor to be loaded by HID */
	error = hid_parse(hdev);
	if (error) {
		hid_err(hdev, "parse failed\n");
1374
		goto fail_parse;
1375 1376
	}

1377
	wacom_wac = &wacom->wacom_wac;
1378
	wacom_wac->features = *((struct wacom_features *)id->driver_data);
1379
	features = &wacom_wac->features;
1380
	features->pktlen = wacom_compute_pktlen(hdev);
1381 1382
	if (features->pktlen > WACOM_PKGLEN_MAX) {
		error = -EINVAL;
1383
		goto fail_pktlen;
1384
	}
1385

1386 1387
	if (features->check_for_hid_type && features->hid_type != hdev->type) {
		error = -ENODEV;
1388
		goto fail_type;
1389
	}
1390 1391

	wacom->usbdev = dev;
1392 1393
	wacom->intf = intf;
	mutex_init(&wacom->lock);
1394
	INIT_WORK(&wacom->work, wacom_wireless_work);
1395

1396 1397 1398 1399 1400 1401
	if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
		error = wacom_allocate_inputs(wacom);
		if (error)
			goto fail_allocate_inputs;
	}

1402 1403 1404
	/* set the default size in case we do not get them from hid */
	wacom_set_default_phy(features);

1405
	/* Retrieve the physical and logical size for touch devices */
1406
	wacom_retrieve_hid_descriptor(hdev, features);
1407

1408 1409
	/*
	 * Intuos5 has no useful data about its touch interface in its
1410
	 * HID descriptor. If this is the touch interface (PacketSize
1411 1412
	 * of WACOM_PKGLEN_BBTOUCH3), override the table values.
	 */
1413
	if (features->type >= INTUOS5S && features->type <= INTUOSHT) {
1414
		if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1415 1416 1417 1418 1419 1420 1421 1422 1423
			features->device_type = BTN_TOOL_FINGER;

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

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
	/*
	 * 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;
	}

1436 1437 1438
	if (hdev->bus == BUS_BLUETOOTH)
		features->quirks |= WACOM_QUIRK_BATTERY;

1439 1440
	wacom_setup_device_quirks(features);

1441 1442 1443
	/* set unit to "100th of a mm" for devices not reported by HID */
	if (!features->unit) {
		features->unit = 0x11;
1444
		features->unitExpo = -3;
1445 1446 1447
	}
	wacom_calculate_res(features);

1448
	strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
1449 1450
	snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name),
		"%s Pad", features->name);
1451

1452
	if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
1453
		/* Append the device type to the name */
1454 1455 1456 1457 1458 1459
		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);
1460

1461
		error = wacom_add_shared_data(hdev);
1462
		if (error)
1463
			goto fail_shared_data;
1464 1465
	}

1466 1467 1468 1469
	if (!(features->quirks & WACOM_QUIRK_MONITOR) &&
	     (features->quirks & WACOM_QUIRK_BATTERY)) {
		error = wacom_initialize_battery(wacom);
		if (error)
1470
			goto fail_battery;
1471 1472
	}

1473
	if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
1474
		error = wacom_register_inputs(wacom);
1475
		if (error)
1476
			goto fail_register_inputs;
1477 1478 1479 1480 1481 1482 1483 1484
	}

	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);
1485
	}
1486

1487 1488 1489
	if (features->type == HID_GENERIC)
		connect_mask |= HID_CONNECT_DRIVER;

1490
	/* Regular HID work starts now */
1491
	error = hid_hw_start(hdev, connect_mask);
1492 1493
	if (error) {
		hid_err(hdev, "hw start failed\n");
1494
		goto fail_hw_start;
1495
	}
1496

1497 1498 1499
	/* Note that if query fails it is not a hard failure */
	wacom_query_tablet_data(hdev, features);

1500 1501 1502
	if (features->quirks & WACOM_QUIRK_MONITOR)
		error = hid_hw_open(hdev);

1503 1504 1505 1506 1507
	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;
	}

1508 1509
	return 0;

1510 1511
fail_hw_start:
	if (hdev->bus == BUS_BLUETOOTH)
1512
		device_remove_file(&hdev->dev, &dev_attr_speed);
1513
fail_register_inputs:
1514
	wacom_clean_inputs(wacom);
1515 1516 1517 1518
	wacom_destroy_battery(wacom);
fail_battery:
	wacom_remove_shared_data(wacom_wac);
fail_shared_data:
1519 1520
	wacom_clean_inputs(wacom);
fail_allocate_inputs:
1521 1522 1523 1524
fail_type:
fail_pktlen:
fail_parse:
	kfree(wacom);
1525
	hid_set_drvdata(hdev, NULL);
1526
	return error;
1527 1528
}

1529
static void wacom_remove(struct hid_device *hdev)
1530
{
1531
	struct wacom *wacom = hid_get_drvdata(hdev);
1532

1533
	hid_hw_stop(hdev);
1534

1535
	cancel_work_sync(&wacom->work);
1536
	wacom_clean_inputs(wacom);
1537 1538
	if (hdev->bus == BUS_BLUETOOTH)
		device_remove_file(&hdev->dev, &dev_attr_speed);
1539
	wacom_destroy_battery(wacom);
1540
	wacom_remove_shared_data(&wacom->wacom_wac);
1541

1542 1543
	hid_set_drvdata(hdev, NULL);
	kfree(wacom);
1544 1545
}

1546
#ifdef CONFIG_PM
1547
static int wacom_resume(struct hid_device *hdev)
1548
{
1549
	struct wacom *wacom = hid_get_drvdata(hdev);
1550
	struct wacom_features *features = &wacom->wacom_wac.features;
1551 1552

	mutex_lock(&wacom->lock);
1553 1554

	/* switch to wacom mode first */
1555
	wacom_query_tablet_data(hdev, features);
1556
	wacom_led_control(wacom);
1557

1558 1559
	mutex_unlock(&wacom->lock);

1560
	return 0;
1561 1562
}

1563
static int wacom_reset_resume(struct hid_device *hdev)
1564
{
1565
	return wacom_resume(hdev);
1566
}
1567
#endif /* CONFIG_PM */
1568

1569
static struct hid_driver wacom_driver = {
1570
	.name =		"wacom",
1571
	.id_table =	wacom_ids,
1572
	.probe =	wacom_probe,
1573
	.remove =	wacom_remove,
1574 1575
	.event =	wacom_wac_event,
	.report =	wacom_wac_report,
1576
#ifdef CONFIG_PM
1577 1578
	.resume =	wacom_resume,
	.reset_resume =	wacom_reset_resume,
1579 1580
#endif
	.raw_event =	wacom_raw_event,
1581
};
1582
module_hid_driver(wacom_driver);
1583 1584 1585 1586 1587

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