hid-lenovo.c 23.7 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
struct lenovo_drvdata_cptkbd {
40
	u8 middlebutton_state; /* 0:Up, 1:Down (undecided), 2:Scrolling */
41
	bool fn_lock;
42
	int sensitivity;
43 44
};

45 46
#define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))

47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
static const __u8 lenovo_pro_dock_need_fixup_collection[] = {
	0x05, 0x88,		/* Usage Page (Vendor Usage Page 0x88)	*/
	0x09, 0x01,		/* Usage (Vendor Usage 0x01)		*/
	0xa1, 0x01,		/* Collection (Application)		*/
	0x85, 0x04,		/*  Report ID (4)			*/
	0x19, 0x00,		/*  Usage Minimum (0)			*/
	0x2a, 0xff, 0xff,	/*  Usage Maximum (65535)		*/
};

static __u8 *lenovo_report_fixup(struct hid_device *hdev, __u8 *rdesc,
		unsigned int *rsize)
{
	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_TPPRODOCK:
		/* the fixups that need to be done:
		 *   - get a reasonable usage max for the vendor collection
		 *     0x8801 from the report ID 4
		 */
		if (*rsize >= 153 &&
		    memcmp(&rdesc[140], lenovo_pro_dock_need_fixup_collection,
			  sizeof(lenovo_pro_dock_need_fixup_collection)) == 0) {
			rdesc[151] = 0x01;
			rdesc[152] = 0x00;
		}
		break;
	}
	return rdesc;
}

76
static int lenovo_input_mapping_tpkbd(struct hid_device *hdev,
77 78 79
		struct hid_input *hi, struct hid_field *field,
		struct hid_usage *usage, unsigned long **bit, int *max)
{
80
	if (usage->hid == (HID_UP_BUTTON | 0x0010)) {
81
		/* This sub-device contains trackpoint, mark it */
82
		hid_set_drvdata(hdev, (void *)1);
83 84 85 86 87 88
		map_key_clear(KEY_MICMUTE);
		return 1;
	}
	return 0;
}

89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
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;
118
		case 0x00f9: /* Fn-F12: Open My computer (6 boxes) USB-only */
119 120 121
			/* NB: This mapping is invented in raw_event below */
			map_key_clear(KEY_FILE);
			return 1;
122 123 124
		case 0x00fa: /* Fn-Esc: Fn-lock toggle */
			map_key_clear(KEY_FN_ESC);
			return 1;
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
		case 0x00fb: /* Middle mouse button (in native mode) */
			map_key_clear(BTN_MIDDLE);
			return 1;
		}
	}

	/* Compatibility middle/wheel mappings should be ignored */
	if (usage->hid == HID_GD_WHEEL)
		return -1;
	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON &&
			(usage->hid & HID_USAGE) == 0x003)
		return -1;
	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER &&
			(usage->hid & HID_USAGE) == 0x238)
		return -1;

	/* Map wheel emulation reports: 0xffa1 = USB, 0xff10 = BT */
	if ((usage->hid & HID_USAGE_PAGE) == 0xff100000 ||
	    (usage->hid & HID_USAGE_PAGE) == 0xffa10000) {
		field->flags |= HID_MAIN_ITEM_RELATIVE | HID_MAIN_ITEM_VARIABLE;
		field->logical_minimum = -127;
		field->logical_maximum = 127;

		switch (usage->hid & HID_USAGE) {
		case 0x0000:
150
			hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
151 152
			return 1;
		case 0x0001:
153
			hid_map_usage(hi, usage, bit, max, EV_REL, REL_WHEEL);
154 155 156
			return 1;
		default:
			return -1;
157 158 159 160 161 162
		}
	}

	return 0;
}

163 164 165 166 167 168 169 170
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);
171 172 173 174
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		return lenovo_input_mapping_cptkbd(hdev, hi, field,
							usage, bit, max);
175 176 177 178 179
	default:
		return 0;
	}
}

180 181
#undef map_key_clear

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 209 210 211 212
/* 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);
213 214 215 216

	ret = lenovo_send_cmd_cptkbd(hdev, 0x02, cptkbd_data->sensitivity);
	if (ret)
		hid_err(hdev, "Sensitivity setting failed: %d\n", ret);
217 218 219 220 221 222
}

static ssize_t attr_fn_lock_show_cptkbd(struct device *dev,
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
223
	struct hid_device *hdev = to_hid_device(dev);
224 225 226 227 228 229 230 231 232 233
	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)
{
Geliang Tang's avatar
Geliang Tang committed
234
	struct hid_device *hdev = to_hid_device(dev);
235 236 237 238 239 240 241 242 243 244 245 246 247 248
	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;
}

249 250 251 252
static ssize_t attr_sensitivity_show_cptkbd(struct device *dev,
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
253
	struct hid_device *hdev = to_hid_device(dev);
254 255 256 257 258 259 260 261 262 263 264
	struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);

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

static ssize_t attr_sensitivity_store_cptkbd(struct device *dev,
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
265
	struct hid_device *hdev = to_hid_device(dev);
266 267 268 269 270 271 272 273 274 275 276 277 278
	struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
	int value;

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

	cptkbd_data->sensitivity = value;
	lenovo_features_set_cptkbd(hdev);

	return count;
}


279 280 281 282 283
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);

284 285 286 287 288 289
static struct device_attribute dev_attr_sensitivity_cptkbd =
	__ATTR(sensitivity, S_IWUSR | S_IRUGO,
			attr_sensitivity_show_cptkbd,
			attr_sensitivity_store_cptkbd);


290 291
static struct attribute *lenovo_attributes_cptkbd[] = {
	&dev_attr_fn_lock_cptkbd.attr,
292
	&dev_attr_sensitivity_cptkbd.attr,
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
	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)) {
313 314
		data[1] = 0x00;
		data[2] = 0x01;
315 316 317 318 319
	}

	return 0;
}

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
static int lenovo_event_cptkbd(struct hid_device *hdev,
		struct hid_field *field, struct hid_usage *usage, __s32 value)
{
	struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);

	/* "wheel" scroll events */
	if (usage->type == EV_REL && (usage->code == REL_WHEEL ||
			usage->code == REL_HWHEEL)) {
		/* Scroll events disable middle-click event */
		cptkbd_data->middlebutton_state = 2;
		return 0;
	}

	/* Middle click events */
	if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) {
		if (value == 1) {
			cptkbd_data->middlebutton_state = 1;
		} else if (value == 0) {
			if (cptkbd_data->middlebutton_state == 1) {
				/* No scrolling inbetween, send middle-click */
				input_event(field->hidinput->input,
					EV_KEY, BTN_MIDDLE, 1);
				input_sync(field->hidinput->input);
				input_event(field->hidinput->input,
					EV_KEY, BTN_MIDDLE, 0);
				input_sync(field->hidinput->input);
			}
			cptkbd_data->middlebutton_state = 0;
		}
		return 1;
	}

	return 0;
}

static int lenovo_event(struct hid_device *hdev, struct hid_field *field,
		struct hid_usage *usage, __s32 value)
{
	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		return lenovo_event_cptkbd(hdev, field, usage, value);
	default:
		return 0;
	}
}

367
static int lenovo_features_set_tpkbd(struct hid_device *hdev)
368 369
{
	struct hid_report *report;
370
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
371 372 373 374 375 376 377 378 379 380 381

	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;

382
	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
383 384 385
	return 0;
}

386
static ssize_t attr_press_to_select_show_tpkbd(struct device *dev,
387 388 389
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
390
	struct hid_device *hdev = to_hid_device(dev);
391
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
392 393 394 395

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

396
static ssize_t attr_press_to_select_store_tpkbd(struct device *dev,
397 398 399 400
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
401
	struct hid_device *hdev = to_hid_device(dev);
402
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
403 404 405 406 407 408 409 410
	int value;

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

	data_pointer->press_to_select = value;
411
	lenovo_features_set_tpkbd(hdev);
412 413 414 415

	return count;
}

416
static ssize_t attr_dragging_show_tpkbd(struct device *dev,
417 418 419
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
420
	struct hid_device *hdev = to_hid_device(dev);
421
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
422 423 424 425

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

426
static ssize_t attr_dragging_store_tpkbd(struct device *dev,
427 428 429 430
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
431
	struct hid_device *hdev = to_hid_device(dev);
432
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
433 434 435 436 437 438 439 440
	int value;

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

	data_pointer->dragging = value;
441
	lenovo_features_set_tpkbd(hdev);
442 443 444 445

	return count;
}

446
static ssize_t attr_release_to_select_show_tpkbd(struct device *dev,
447 448 449
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
450
	struct hid_device *hdev = to_hid_device(dev);
451
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
452 453 454 455

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

456
static ssize_t attr_release_to_select_store_tpkbd(struct device *dev,
457 458 459 460
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
461
	struct hid_device *hdev = to_hid_device(dev);
462
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
463 464 465 466 467 468 469 470
	int value;

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

	data_pointer->release_to_select = value;
471
	lenovo_features_set_tpkbd(hdev);
472 473 474 475

	return count;
}

476
static ssize_t attr_select_right_show_tpkbd(struct device *dev,
477 478 479
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
480
	struct hid_device *hdev = to_hid_device(dev);
481
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
482 483 484 485

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

486
static ssize_t attr_select_right_store_tpkbd(struct device *dev,
487 488 489 490
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
491
	struct hid_device *hdev = to_hid_device(dev);
492
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
493 494 495 496 497 498 499 500
	int value;

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

	data_pointer->select_right = value;
501
	lenovo_features_set_tpkbd(hdev);
502 503 504 505

	return count;
}

506
static ssize_t attr_sensitivity_show_tpkbd(struct device *dev,
507 508 509
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
510
	struct hid_device *hdev = to_hid_device(dev);
511
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
512 513 514 515 516

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

517
static ssize_t attr_sensitivity_store_tpkbd(struct device *dev,
518 519 520 521
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
522
	struct hid_device *hdev = to_hid_device(dev);
523
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
524 525 526 527 528 529
	int value;

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

	data_pointer->sensitivity = value;
530
	lenovo_features_set_tpkbd(hdev);
531 532 533 534

	return count;
}

535
static ssize_t attr_press_speed_show_tpkbd(struct device *dev,
536 537 538
		struct device_attribute *attr,
		char *buf)
{
Geliang Tang's avatar
Geliang Tang committed
539
	struct hid_device *hdev = to_hid_device(dev);
540
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
541 542 543 544 545

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

546
static ssize_t attr_press_speed_store_tpkbd(struct device *dev,
547 548 549 550
		struct device_attribute *attr,
		const char *buf,
		size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
551
	struct hid_device *hdev = to_hid_device(dev);
552
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
553 554 555 556 557 558
	int value;

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

	data_pointer->press_speed = value;
559
	lenovo_features_set_tpkbd(hdev);
560 561 562 563

	return count;
}

564
static struct device_attribute dev_attr_press_to_select_tpkbd =
565
	__ATTR(press_to_select, S_IWUSR | S_IRUGO,
566 567
			attr_press_to_select_show_tpkbd,
			attr_press_to_select_store_tpkbd);
568

569
static struct device_attribute dev_attr_dragging_tpkbd =
570
	__ATTR(dragging, S_IWUSR | S_IRUGO,
571 572
			attr_dragging_show_tpkbd,
			attr_dragging_store_tpkbd);
573

574
static struct device_attribute dev_attr_release_to_select_tpkbd =
575
	__ATTR(release_to_select, S_IWUSR | S_IRUGO,
576 577
			attr_release_to_select_show_tpkbd,
			attr_release_to_select_store_tpkbd);
578

579
static struct device_attribute dev_attr_select_right_tpkbd =
580
	__ATTR(select_right, S_IWUSR | S_IRUGO,
581 582
			attr_select_right_show_tpkbd,
			attr_select_right_store_tpkbd);
583

584
static struct device_attribute dev_attr_sensitivity_tpkbd =
585
	__ATTR(sensitivity, S_IWUSR | S_IRUGO,
586 587
			attr_sensitivity_show_tpkbd,
			attr_sensitivity_store_tpkbd);
588

589
static struct device_attribute dev_attr_press_speed_tpkbd =
590
	__ATTR(press_speed, S_IWUSR | S_IRUGO,
591 592 593 594 595 596 597 598 599 600
			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,
601 602 603
	NULL
};

604 605
static const struct attribute_group lenovo_attr_group_tpkbd = {
	.attrs = lenovo_attributes_tpkbd,
606 607
};

608
static enum led_brightness lenovo_led_brightness_get_tpkbd(
609 610
			struct led_classdev *led_cdev)
{
611
	struct device *dev = led_cdev->dev->parent;
Geliang Tang's avatar
Geliang Tang committed
612
	struct hid_device *hdev = to_hid_device(dev);
613
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
614 615 616 617 618 619 620 621 622 623
	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;
}

624
static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev,
625 626
			enum led_brightness value)
{
627
	struct device *dev = led_cdev->dev->parent;
Geliang Tang's avatar
Geliang Tang committed
628
	struct hid_device *hdev = to_hid_device(dev);
629
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
630 631 632 633 634 635 636 637 638 639 640 641 642 643
	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;
644
	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
645 646
}

647
static int lenovo_probe_tpkbd(struct hid_device *hdev)
648 649
{
	struct device *dev = &hdev->dev;
650
	struct lenovo_drvdata_tpkbd *data_pointer;
651 652
	size_t name_sz = strlen(dev_name(dev)) + 16;
	char *name_mute, *name_micmute;
653
	int i;
654
	int ret;
655

656 657 658 659 660 661 662 663 664
	/*
	 * 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);

665 666 667 668 669 670 671
	/* 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;
672

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

677
	data_pointer = devm_kzalloc(&hdev->dev,
678
				    sizeof(struct lenovo_drvdata_tpkbd),
679
				    GFP_KERNEL);
680 681
	if (data_pointer == NULL) {
		hid_err(hdev, "Could not allocate memory for driver data\n");
682 683
		ret = -ENOMEM;
		goto err;
684 685 686 687 688 689
	}

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

690 691 692
	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) {
693
		hid_err(hdev, "Could not allocate memory for led data\n");
694 695
		ret = -ENOMEM;
		goto err;
696 697 698 699 700 701 702
	}
	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;
703 704
	data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd;
	data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd;
705 706 707 708
	data_pointer->led_mute.dev = dev;
	led_classdev_register(dev, &data_pointer->led_mute);

	data_pointer->led_micmute.name = name_micmute;
709 710 711 712
	data_pointer->led_micmute.brightness_get =
		lenovo_led_brightness_get_tpkbd;
	data_pointer->led_micmute.brightness_set =
		lenovo_led_brightness_set_tpkbd;
713 714 715
	data_pointer->led_micmute.dev = dev;
	led_classdev_register(dev, &data_pointer->led_micmute);

716
	lenovo_features_set_tpkbd(hdev);
717 718

	return 0;
719 720 721
err:
	sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
	return ret;
722 723
}

724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
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);

753 754 755 756 757
	/* Switch middle button to native mode */
	ret = lenovo_send_cmd_cptkbd(hdev, 0x09, 0x01);
	if (ret)
		hid_warn(hdev, "Failed to switch middle button: %d\n", ret);

758
	/* Set keyboard settings to known state */
759
	cptkbd_data->middlebutton_state = 0;
760
	cptkbd_data->fn_lock = true;
761
	cptkbd_data->sensitivity = 0x05;
762 763 764 765 766 767 768 769 770
	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;
}

771
static int lenovo_probe(struct hid_device *hdev,
772 773 774 775 776 777 778
		const struct hid_device_id *id)
{
	int ret;

	ret = hid_parse(hdev);
	if (ret) {
		hid_err(hdev, "hid_parse failed\n");
779
		goto err;
780 781 782 783 784
	}

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (ret) {
		hid_err(hdev, "hid_hw_start failed\n");
785
		goto err;
786 787
	}

788 789
	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_TPKBD:
790
		ret = lenovo_probe_tpkbd(hdev);
791
		break;
792 793 794 795
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		ret = lenovo_probe_cptkbd(hdev);
		break;
796 797 798
	default:
		ret = 0;
		break;
799
	}
800 801
	if (ret)
		goto err_hid;
802 803

	return 0;
804 805 806
err_hid:
	hid_hw_stop(hdev);
err:
807 808 809
	return ret;
}

810
static void lenovo_remove_tpkbd(struct hid_device *hdev)
811
{
812
	struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
813

814 815 816 817 818 819 820
	/*
	 * Only the trackpoint half of the keyboard has drvdata and stuff that
	 * needs unregistering.
	 */
	if (data_pointer == NULL)
		return;

821
	sysfs_remove_group(&hdev->dev.kobj,
822
			&lenovo_attr_group_tpkbd);
823 824 825 826 827 828 829

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

	hid_set_drvdata(hdev, NULL);
}

830 831 832 833 834 835
static void lenovo_remove_cptkbd(struct hid_device *hdev)
{
	sysfs_remove_group(&hdev->dev.kobj,
			&lenovo_attr_group_cptkbd);
}

836
static void lenovo_remove(struct hid_device *hdev)
837
{
838 839
	switch (hdev->product) {
	case USB_DEVICE_ID_LENOVO_TPKBD:
840
		lenovo_remove_tpkbd(hdev);
841
		break;
842 843 844 845
	case USB_DEVICE_ID_LENOVO_CUSBKBD:
	case USB_DEVICE_ID_LENOVO_CBTKBD:
		lenovo_remove_cptkbd(hdev);
		break;
846
	}
847 848 849 850

	hid_hw_stop(hdev);
}

851
static int lenovo_input_configured(struct hid_device *hdev,
852 853 854 855 856 857 858 859 860 861 862 863 864 865
		struct hid_input *hi)
{
	switch (hdev->product) {
		case USB_DEVICE_ID_LENOVO_TPKBD:
		case USB_DEVICE_ID_LENOVO_CUSBKBD:
		case USB_DEVICE_ID_LENOVO_CBTKBD:
			if (test_bit(EV_REL, hi->input->evbit)) {
				/* set only for trackpoint device */
				__set_bit(INPUT_PROP_POINTER, hi->input->propbit);
				__set_bit(INPUT_PROP_POINTING_STICK,
						hi->input->propbit);
			}
			break;
	}
866 867

	return 0;
868 869 870
}


871
static const struct hid_device_id lenovo_devices[] = {
872
	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
873 874
	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
875
	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
876 877 878
	{ }
};

879
MODULE_DEVICE_TABLE(hid, lenovo_devices);
880

881 882 883
static struct hid_driver lenovo_driver = {
	.name = "lenovo",
	.id_table = lenovo_devices,
884
	.input_configured = lenovo_input_configured,
885
	.input_mapping = lenovo_input_mapping,
886 887
	.probe = lenovo_probe,
	.remove = lenovo_remove,
888
	.raw_event = lenovo_raw_event,
889
	.event = lenovo_event,
890
	.report_fixup = lenovo_report_fixup,
891
};
892
module_hid_driver(lenovo_driver);
893 894

MODULE_LICENSE("GPL");