hid-lenovo.c 18.9 KB
Newer Older
1
/*
2 3
 *  HID driver for Lenovo:
 *  - ThinkPad USB Keyboard with TrackPoint (tpkbd)
4 5
 *  - ThinkPad Compact Bluetooth Keyboard with TrackPoint (cptkbd)
 *  - ThinkPad Compact USB Keyboard with TrackPoint (cptkbd)
6 7
 *
 *  Copyright (c) 2012 Bernhard Seibold
8
 *  Copyright (c) 2014 Jamie Lentin <jm@lentin.co.uk>
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 */

/*
 * 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 <linux/module.h>
#include <linux/sysfs.h>
#include <linux/device.h>
#include <linux/hid.h>
#include <linux/input.h>
#include <linux/leds.h>

#include "hid-ids.h"

27
struct lenovo_drvdata_tpkbd {
28 29 30 31 32 33 34 35 36 37 38
	int led_state;
	struct led_classdev led_mute;
	struct led_classdev led_micmute;
	int press_to_select;
	int dragging;
	int release_to_select;
	int select_right;
	int sensitivity;
	int press_speed;
};

39 40 41 42
struct lenovo_drvdata_cptkbd {
	bool fn_lock;
};

43 44
#define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))

45
static int lenovo_input_mapping_tpkbd(struct hid_device *hdev,
46 47 48
		struct hid_input *hi, struct hid_field *field,
		struct hid_usage *usage, unsigned long **bit, int *max)
{
49
	if (usage->hid == (HID_UP_BUTTON | 0x0010)) {
50
		/* This sub-device contains trackpoint, mark it */
51
		hid_set_drvdata(hdev, (void *)1);
52 53 54 55 56 57
		map_key_clear(KEY_MICMUTE);
		return 1;
	}
	return 0;
}

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
static int lenovo_input_mapping_cptkbd(struct hid_device *hdev,
		struct hid_input *hi, struct hid_field *field,
		struct hid_usage *usage, unsigned long **bit, int *max)
{
	/* HID_UP_LNVENDOR = USB, HID_UP_MSVENDOR = BT */
	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR ||
	    (usage->hid & HID_USAGE_PAGE) == HID_UP_LNVENDOR) {
		switch (usage->hid & HID_USAGE) {
		case 0x00f1: /* Fn-F4: Mic mute */
			map_key_clear(KEY_MICMUTE);
			return 1;
		case 0x00f2: /* Fn-F5: Brightness down */
			map_key_clear(KEY_BRIGHTNESSDOWN);
			return 1;
		case 0x00f3: /* Fn-F6: Brightness up */
			map_key_clear(KEY_BRIGHTNESSUP);
			return 1;
		case 0x00f4: /* Fn-F7: External display (projector) */
			map_key_clear(KEY_SWITCHVIDEOMODE);
			return 1;
		case 0x00f5: /* Fn-F8: Wireless */
			map_key_clear(KEY_WLAN);
			return 1;
		case 0x00f6: /* Fn-F9: Control panel */
			map_key_clear(KEY_CONFIG);
			return 1;
		case 0x00f8: /* Fn-F11: View open applications (3 boxes) */
			map_key_clear(KEY_SCALE);
			return 1;
87
		case 0x00f9: /* Fn-F12: Open My computer (6 boxes) USB-only */
88 89 90
			/* NB: This mapping is invented in raw_event below */
			map_key_clear(KEY_FILE);
			return 1;
91 92 93
		case 0x00fa: /* Fn-Esc: Fn-lock toggle */
			map_key_clear(KEY_FN_ESC);
			return 1;
94 95 96 97 98 99
		}
	}

	return 0;
}

100 101 102 103 104 105 106 107
static int lenovo_input_mapping(struct hid_device *hdev,
		struct hid_input *hi, struct hid_field *field,
		struct hid_usage *usage, unsigned long **bit, int *max)
{
	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_TPKBD:
		return lenovo_input_mapping_tpkbd(hdev, hi, field,
							usage, bit, max);
108 109 110 111
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		return lenovo_input_mapping_cptkbd(hdev, hi, field,
							usage, bit, max);
112 113 114 115 116
	default:
		return 0;
	}
}

117 118
#undef map_key_clear

119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 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 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
/* Send a config command to the keyboard */
static int lenovo_send_cmd_cptkbd(struct hid_device *hdev,
			unsigned char byte2, unsigned char byte3)
{
	int ret;
	unsigned char buf[] = {0x18, byte2, byte3};

	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
		ret = hid_hw_raw_request(hdev, 0x13, buf, sizeof(buf),
					HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
		break;
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		ret = hid_hw_output_report(hdev, buf, sizeof(buf));
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */
}

static void lenovo_features_set_cptkbd(struct hid_device *hdev)
{
	int ret;
	struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);

	ret = lenovo_send_cmd_cptkbd(hdev, 0x05, cptkbd_data->fn_lock);
	if (ret)
		hid_err(hdev, "Fn-lock setting failed: %d\n", ret);
}

static ssize_t attr_fn_lock_show_cptkbd(struct device *dev,
		struct device_attribute *attr,
		char *buf)
{
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
	struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);

	return snprintf(buf, PAGE_SIZE, "%u\n", cptkbd_data->fn_lock);
}

static ssize_t attr_fn_lock_store_cptkbd(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 lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
	int value;

	if (kstrtoint(buf, 10, &value))
		return -EINVAL;
	if (value < 0 || value > 1)
		return -EINVAL;

	cptkbd_data->fn_lock = !!value;
	lenovo_features_set_cptkbd(hdev);

	return count;
}

static struct device_attribute dev_attr_fn_lock_cptkbd =
	__ATTR(fn_lock, S_IWUSR | S_IRUGO,
			attr_fn_lock_show_cptkbd,
			attr_fn_lock_store_cptkbd);

static struct attribute *lenovo_attributes_cptkbd[] = {
	&dev_attr_fn_lock_cptkbd.attr,
	NULL
};

static const struct attribute_group lenovo_attr_group_cptkbd = {
	.attrs = lenovo_attributes_cptkbd,
};

static int lenovo_raw_event(struct hid_device *hdev,
			struct hid_report *report, u8 *data, int size)
{
	/*
	 * Compact USB keyboard's Fn-F12 report holds down many other keys, and
	 * its own key is outside the usage page range. Remove extra
	 * keypresses and remap to inside usage page.
	 */
	if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
			&& size == 3
			&& data[0] == 0x15
			&& data[1] == 0x94
			&& data[2] == 0x01)) {
209 210
		data[1] = 0x00;
		data[2] = 0x01;
211 212 213 214 215
	}

	return 0;
}

216
static int lenovo_features_set_tpkbd(struct hid_device *hdev)
217 218
{
	struct hid_report *report;
219
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
220 221 222 223 224 225 226 227 228 229 230

	report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4];

	report->field[0]->value[0]  = data_pointer->press_to_select   ? 0x01 : 0x02;
	report->field[0]->value[0] |= data_pointer->dragging          ? 0x04 : 0x08;
	report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20;
	report->field[0]->value[0] |= data_pointer->select_right      ? 0x80 : 0x40;
	report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver
	report->field[2]->value[0] = data_pointer->sensitivity;
	report->field[3]->value[0] = data_pointer->press_speed;

231
	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
232 233 234
	return 0;
}

235
static ssize_t attr_press_to_select_show_tpkbd(struct device *dev,
236 237 238
		struct device_attribute *attr,
		char *buf)
{
239
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
240
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
241 242 243 244

	return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select);
}

245
static ssize_t attr_press_to_select_store_tpkbd(struct device *dev,
246 247 248 249
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
250
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
251
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
252 253 254 255 256 257 258 259
	int value;

	if (kstrtoint(buf, 10, &value))
		return -EINVAL;
	if (value < 0 || value > 1)
		return -EINVAL;

	data_pointer->press_to_select = value;
260
	lenovo_features_set_tpkbd(hdev);
261 262 263 264

	return count;
}

265
static ssize_t attr_dragging_show_tpkbd(struct device *dev,
266 267 268
		struct device_attribute *attr,
		char *buf)
{
269
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
270
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
271 272 273 274

	return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging);
}

275
static ssize_t attr_dragging_store_tpkbd(struct device *dev,
276 277 278 279
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
280
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
281
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
282 283 284 285 286 287 288 289
	int value;

	if (kstrtoint(buf, 10, &value))
		return -EINVAL;
	if (value < 0 || value > 1)
		return -EINVAL;

	data_pointer->dragging = value;
290
	lenovo_features_set_tpkbd(hdev);
291 292 293 294

	return count;
}

295
static ssize_t attr_release_to_select_show_tpkbd(struct device *dev,
296 297 298
		struct device_attribute *attr,
		char *buf)
{
299
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
300
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
301 302 303 304

	return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select);
}

305
static ssize_t attr_release_to_select_store_tpkbd(struct device *dev,
306 307 308 309
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
310
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
311
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
312 313 314 315 316 317 318 319
	int value;

	if (kstrtoint(buf, 10, &value))
		return -EINVAL;
	if (value < 0 || value > 1)
		return -EINVAL;

	data_pointer->release_to_select = value;
320
	lenovo_features_set_tpkbd(hdev);
321 322 323 324

	return count;
}

325
static ssize_t attr_select_right_show_tpkbd(struct device *dev,
326 327 328
		struct device_attribute *attr,
		char *buf)
{
329
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
330
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
331 332 333 334

	return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right);
}

335
static ssize_t attr_select_right_store_tpkbd(struct device *dev,
336 337 338 339
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
340
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
341
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
342 343 344 345 346 347 348 349
	int value;

	if (kstrtoint(buf, 10, &value))
		return -EINVAL;
	if (value < 0 || value > 1)
		return -EINVAL;

	data_pointer->select_right = value;
350
	lenovo_features_set_tpkbd(hdev);
351 352 353 354

	return count;
}

355
static ssize_t attr_sensitivity_show_tpkbd(struct device *dev,
356 357 358
		struct device_attribute *attr,
		char *buf)
{
359
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
360
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
361 362 363 364 365

	return snprintf(buf, PAGE_SIZE, "%u\n",
		data_pointer->sensitivity);
}

366
static ssize_t attr_sensitivity_store_tpkbd(struct device *dev,
367 368 369 370
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
371
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
372
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
373 374 375 376 377 378
	int value;

	if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
		return -EINVAL;

	data_pointer->sensitivity = value;
379
	lenovo_features_set_tpkbd(hdev);
380 381 382 383

	return count;
}

384
static ssize_t attr_press_speed_show_tpkbd(struct device *dev,
385 386 387
		struct device_attribute *attr,
		char *buf)
{
388
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
389
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
390 391 392 393 394

	return snprintf(buf, PAGE_SIZE, "%u\n",
		data_pointer->press_speed);
}

395
static ssize_t attr_press_speed_store_tpkbd(struct device *dev,
396 397 398 399
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
400
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
401
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
402 403 404 405 406 407
	int value;

	if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
		return -EINVAL;

	data_pointer->press_speed = value;
408
	lenovo_features_set_tpkbd(hdev);
409 410 411 412

	return count;
}

413
static struct device_attribute dev_attr_press_to_select_tpkbd =
414
	__ATTR(press_to_select, S_IWUSR | S_IRUGO,
415 416
			attr_press_to_select_show_tpkbd,
			attr_press_to_select_store_tpkbd);
417

418
static struct device_attribute dev_attr_dragging_tpkbd =
419
	__ATTR(dragging, S_IWUSR | S_IRUGO,
420 421
			attr_dragging_show_tpkbd,
			attr_dragging_store_tpkbd);
422

423
static struct device_attribute dev_attr_release_to_select_tpkbd =
424
	__ATTR(release_to_select, S_IWUSR | S_IRUGO,
425 426
			attr_release_to_select_show_tpkbd,
			attr_release_to_select_store_tpkbd);
427

428
static struct device_attribute dev_attr_select_right_tpkbd =
429
	__ATTR(select_right, S_IWUSR | S_IRUGO,
430 431
			attr_select_right_show_tpkbd,
			attr_select_right_store_tpkbd);
432

433
static struct device_attribute dev_attr_sensitivity_tpkbd =
434
	__ATTR(sensitivity, S_IWUSR | S_IRUGO,
435 436
			attr_sensitivity_show_tpkbd,
			attr_sensitivity_store_tpkbd);
437

438
static struct device_attribute dev_attr_press_speed_tpkbd =
439
	__ATTR(press_speed, S_IWUSR | S_IRUGO,
440 441 442 443 444 445 446 447 448 449
			attr_press_speed_show_tpkbd,
			attr_press_speed_store_tpkbd);

static struct attribute *lenovo_attributes_tpkbd[] = {
	&dev_attr_press_to_select_tpkbd.attr,
	&dev_attr_dragging_tpkbd.attr,
	&dev_attr_release_to_select_tpkbd.attr,
	&dev_attr_select_right_tpkbd.attr,
	&dev_attr_sensitivity_tpkbd.attr,
	&dev_attr_press_speed_tpkbd.attr,
450 451 452
	NULL
};

453 454
static const struct attribute_group lenovo_attr_group_tpkbd = {
	.attrs = lenovo_attributes_tpkbd,
455 456
};

457
static enum led_brightness lenovo_led_brightness_get_tpkbd(
458 459
			struct led_classdev *led_cdev)
{
460 461
	struct device *dev = led_cdev->dev->parent;
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
462
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
463 464 465 466 467 468 469 470 471 472
	int led_nr = 0;

	if (led_cdev == &data_pointer->led_micmute)
		led_nr = 1;

	return data_pointer->led_state & (1 << led_nr)
				? LED_FULL
				: LED_OFF;
}

473
static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev,
474 475
			enum led_brightness value)
{
476 477
	struct device *dev = led_cdev->dev->parent;
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
478
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
479 480 481 482 483 484 485 486 487 488 489 490 491 492
	struct hid_report *report;
	int led_nr = 0;

	if (led_cdev == &data_pointer->led_micmute)
		led_nr = 1;

	if (value == LED_OFF)
		data_pointer->led_state &= ~(1 << led_nr);
	else
		data_pointer->led_state |= 1 << led_nr;

	report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3];
	report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1;
	report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1;
493
	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
494 495
}

496
static int lenovo_probe_tpkbd(struct hid_device *hdev)
497 498
{
	struct device *dev = &hdev->dev;
499
	struct lenovo_drvdata_tpkbd *data_pointer;
500 501
	size_t name_sz = strlen(dev_name(dev)) + 16;
	char *name_mute, *name_micmute;
502
	int i;
503
	int ret;
504

505 506 507 508 509 510 511 512 513
	/*
	 * Only register extra settings against subdevice where input_mapping
	 * set drvdata to 1, i.e. the trackpoint.
	 */
	if (!hid_get_drvdata(hdev))
		return 0;

	hid_set_drvdata(hdev, NULL);

514 515 516 517 518 519 520
	/* Validate required reports. */
	for (i = 0; i < 4; i++) {
		if (!hid_validate_values(hdev, HID_FEATURE_REPORT, 4, i, 1))
			return -ENODEV;
	}
	if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 3, 0, 2))
		return -ENODEV;
521

522 523 524
	ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
	if (ret)
		hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
525

526
	data_pointer = devm_kzalloc(&hdev->dev,
527
				    sizeof(struct lenovo_drvdata_tpkbd),
528
				    GFP_KERNEL);
529 530 531 532 533 534 535 536 537
	if (data_pointer == NULL) {
		hid_err(hdev, "Could not allocate memory for driver data\n");
		return -ENOMEM;
	}

	// set same default values as windows driver
	data_pointer->sensitivity = 0xa0;
	data_pointer->press_speed = 0x38;

538 539 540
	name_mute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL);
	name_micmute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL);
	if (name_mute == NULL || name_micmute == NULL) {
541
		hid_err(hdev, "Could not allocate memory for led data\n");
542
		return -ENOMEM;
543 544 545 546 547 548 549
	}
	snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev));
	snprintf(name_micmute, name_sz, "%s:amber:micmute", dev_name(dev));

	hid_set_drvdata(hdev, data_pointer);

	data_pointer->led_mute.name = name_mute;
550 551
	data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd;
	data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd;
552 553 554 555
	data_pointer->led_mute.dev = dev;
	led_classdev_register(dev, &data_pointer->led_mute);

	data_pointer->led_micmute.name = name_micmute;
556 557 558 559
	data_pointer->led_micmute.brightness_get =
		lenovo_led_brightness_get_tpkbd;
	data_pointer->led_micmute.brightness_set =
		lenovo_led_brightness_set_tpkbd;
560 561 562
	data_pointer->led_micmute.dev = dev;
	led_classdev_register(dev, &data_pointer->led_micmute);

563
	lenovo_features_set_tpkbd(hdev);
564 565 566 567

	return 0;
}

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
static int lenovo_probe_cptkbd(struct hid_device *hdev)
{
	int ret;
	struct lenovo_drvdata_cptkbd *cptkbd_data;

	/* All the custom action happens on the USBMOUSE device for USB */
	if (hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
			&& hdev->type != HID_TYPE_USBMOUSE) {
		hid_dbg(hdev, "Ignoring keyboard half of device\n");
		return 0;
	}

	cptkbd_data = devm_kzalloc(&hdev->dev,
					sizeof(*cptkbd_data),
					GFP_KERNEL);
	if (cptkbd_data == NULL) {
		hid_err(hdev, "can't alloc keyboard descriptor\n");
		return -ENOMEM;
	}
	hid_set_drvdata(hdev, cptkbd_data);

	/*
	 * Tell the keyboard a driver understands it, and turn F7, F9, F11 into
	 * regular keys
	 */
	ret = lenovo_send_cmd_cptkbd(hdev, 0x01, 0x03);
	if (ret)
		hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n", ret);

	/* Turn Fn-Lock on by default */
	cptkbd_data->fn_lock = true;
	lenovo_features_set_cptkbd(hdev);

	ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd);
	if (ret)
		hid_warn(hdev, "Could not create sysfs group: %d\n", ret);

	return 0;
}

608
static int lenovo_probe(struct hid_device *hdev,
609 610 611 612 613 614 615
		const struct hid_device_id *id)
{
	int ret;

	ret = hid_parse(hdev);
	if (ret) {
		hid_err(hdev, "hid_parse failed\n");
616
		goto err;
617 618 619 620 621
	}

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (ret) {
		hid_err(hdev, "hid_hw_start failed\n");
622
		goto err;
623 624
	}

625 626
	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_TPKBD:
627
		ret = lenovo_probe_tpkbd(hdev);
628
		break;
629 630 631 632
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		ret = lenovo_probe_cptkbd(hdev);
		break;
633 634 635
	default:
		ret = 0;
		break;
636
	}
637 638
	if (ret)
		goto err_hid;
639 640

	return 0;
641 642 643
err_hid:
	hid_hw_stop(hdev);
err:
644 645 646
	return ret;
}

647
static void lenovo_remove_tpkbd(struct hid_device *hdev)
648
{
649
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
650

651 652 653 654 655 656 657
	/*
	 * Only the trackpoint half of the keyboard has drvdata and stuff that
	 * needs unregistering.
	 */
	if (data_pointer == NULL)
		return;

658
	sysfs_remove_group(&hdev->dev.kobj,
659
			&lenovo_attr_group_tpkbd);
660 661 662 663 664 665 666

	led_classdev_unregister(&data_pointer->led_micmute);
	led_classdev_unregister(&data_pointer->led_mute);

	hid_set_drvdata(hdev, NULL);
}

667 668 669 670 671 672
static void lenovo_remove_cptkbd(struct hid_device *hdev)
{
	sysfs_remove_group(&hdev->dev.kobj,
			&lenovo_attr_group_cptkbd);
}

673
static void lenovo_remove(struct hid_device *hdev)
674
{
675 676
	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_TPKBD:
677
		lenovo_remove_tpkbd(hdev);
678
		break;
679 680 681 682
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		lenovo_remove_cptkbd(hdev);
		break;
683
	}
684 685 686 687

	hid_hw_stop(hdev);
}

688
static const struct hid_device_id lenovo_devices[] = {
689
	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
690 691
	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
692 693 694
	{ }
};

695
MODULE_DEVICE_TABLE(hid, lenovo_devices);
696

697 698 699
static struct hid_driver lenovo_driver = {
	.name = "lenovo",
	.id_table = lenovo_devices,
700
	.input_mapping = lenovo_input_mapping,
701 702
	.probe = lenovo_probe,
	.remove = lenovo_remove,
703
	.raw_event = lenovo_raw_event,
704
};
705
module_hid_driver(lenovo_driver);
706 707

MODULE_LICENSE("GPL");