hid-roccat-koneplus.c 15.4 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
2 3 4 5 6 7 8 9 10 11 12 13
/*
 * Roccat Kone[+] driver for Linux
 *
 * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
 */

/*
 */

/*
 * Roccat Kone[+] is an updated/improved version of the Kone with more memory
 * and functionality and without the non-standard behaviours the Kone had.
14
 * KoneXTD has same capabilities but updated sensor.
15 16 17 18 19 20 21
 */

#include <linux/device.h>
#include <linux/input.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/slab.h>
22
#include <linux/hid-roccat.h>
23
#include "hid-ids.h"
24
#include "hid-roccat-common.h"
25 26 27 28 29 30 31 32 33 34 35 36 37
#include "hid-roccat-koneplus.h"

static uint profile_numbers[5] = {0, 1, 2, 3, 4};

static void koneplus_profile_activated(struct koneplus_device *koneplus,
		uint new_profile)
{
	koneplus->actual_profile = new_profile;
}

static int koneplus_send_control(struct usb_device *usb_dev, uint value,
		enum koneplus_control_requests request)
{
38
	struct roccat_common2_control control;
39 40 41 42 43 44

	if ((request == KONEPLUS_CONTROL_REQUEST_PROFILE_SETTINGS ||
			request == KONEPLUS_CONTROL_REQUEST_PROFILE_BUTTONS) &&
			value > 4)
		return -EINVAL;

45
	control.command = ROCCAT_COMMON_COMMAND_CONTROL;
46 47
	control.value = value;
	control.request = request;
48

49
	return roccat_common2_send_with_status(usb_dev,
50
			ROCCAT_COMMON_COMMAND_CONTROL,
51
			&control, sizeof(struct roccat_common2_control));
52 53 54 55
}


/* retval is 0-4 on success, < 0 on error */
56
static int koneplus_get_actual_profile(struct usb_device *usb_dev)
57
{
58
	struct koneplus_actual_profile buf;
59 60
	int retval;

61
	retval = roccat_common2_receive(usb_dev, KONEPLUS_COMMAND_ACTUAL_PROFILE,
62
			&buf, KONEPLUS_SIZE_ACTUAL_PROFILE);
63

64
	return retval ? retval : buf.actual_profile;
65 66
}

67 68
static int koneplus_set_actual_profile(struct usb_device *usb_dev,
		int new_profile)
69
{
70
	struct koneplus_actual_profile buf;
71

72
	buf.command = KONEPLUS_COMMAND_ACTUAL_PROFILE;
73
	buf.size = KONEPLUS_SIZE_ACTUAL_PROFILE;
74
	buf.actual_profile = new_profile;
75

76
	return roccat_common2_send_with_status(usb_dev,
77
			KONEPLUS_COMMAND_ACTUAL_PROFILE,
78
			&buf, KONEPLUS_SIZE_ACTUAL_PROFILE);
79 80 81 82 83 84
}

static ssize_t koneplus_sysfs_read(struct file *fp, struct kobject *kobj,
		char *buf, loff_t off, size_t count,
		size_t real_size, uint command)
{
Geliang Tang's avatar
Geliang Tang committed
85
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
86 87 88 89
	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	int retval;

90 91 92
	if (off >= real_size)
		return 0;

93 94 95 96
	if (off != 0 || count != real_size)
		return -EINVAL;

	mutex_lock(&koneplus->koneplus_lock);
97
	retval = roccat_common2_receive(usb_dev, command, buf, real_size);
98 99 100 101 102 103 104 105 106 107 108 109
	mutex_unlock(&koneplus->koneplus_lock);

	if (retval)
		return retval;

	return real_size;
}

static ssize_t koneplus_sysfs_write(struct file *fp, struct kobject *kobj,
		void const *buf, loff_t off, size_t count,
		size_t real_size, uint command)
{
Geliang Tang's avatar
Geliang Tang committed
110
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
111 112 113 114 115 116 117 118
	struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev));
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	int retval;

	if (off != 0 || count != real_size)
		return -EINVAL;

	mutex_lock(&koneplus->koneplus_lock);
119
	retval = roccat_common2_send_with_status(usb_dev, command,
120
			buf, real_size);
121 122 123 124 125 126 127 128
	mutex_unlock(&koneplus->koneplus_lock);

	if (retval)
		return retval;

	return real_size;
}

129 130 131 132 133 134 135
#define KONEPLUS_SYSFS_W(thingy, THINGY) \
static ssize_t koneplus_sysfs_write_ ## thingy(struct file *fp, \
		struct kobject *kobj, struct bin_attribute *attr, char *buf, \
		loff_t off, size_t count) \
{ \
	return koneplus_sysfs_write(fp, kobj, buf, off, count, \
			KONEPLUS_SIZE_ ## THINGY, KONEPLUS_COMMAND_ ## THINGY); \
136 137
}

138 139 140 141 142 143 144
#define KONEPLUS_SYSFS_R(thingy, THINGY) \
static ssize_t koneplus_sysfs_read_ ## thingy(struct file *fp, \
		struct kobject *kobj, struct bin_attribute *attr, char *buf, \
		loff_t off, size_t count) \
{ \
	return koneplus_sysfs_read(fp, kobj, buf, off, count, \
			KONEPLUS_SIZE_ ## THINGY, KONEPLUS_COMMAND_ ## THINGY); \
145 146
}

147 148 149
#define KONEPLUS_SYSFS_RW(thingy, THINGY) \
KONEPLUS_SYSFS_W(thingy, THINGY) \
KONEPLUS_SYSFS_R(thingy, THINGY)
150

151
#define KONEPLUS_BIN_ATTRIBUTE_RW(thingy, THINGY) \
152 153
KONEPLUS_SYSFS_RW(thingy, THINGY); \
static struct bin_attribute bin_attr_##thingy = { \
154 155 156 157
	.attr = { .name = #thingy, .mode = 0660 }, \
	.size = KONEPLUS_SIZE_ ## THINGY, \
	.read = koneplus_sysfs_read_ ## thingy, \
	.write = koneplus_sysfs_write_ ## thingy \
158 159
}

160
#define KONEPLUS_BIN_ATTRIBUTE_R(thingy, THINGY) \
161 162
KONEPLUS_SYSFS_R(thingy, THINGY); \
static struct bin_attribute bin_attr_##thingy = { \
163 164 165
	.attr = { .name = #thingy, .mode = 0440 }, \
	.size = KONEPLUS_SIZE_ ## THINGY, \
	.read = koneplus_sysfs_read_ ## thingy, \
166 167
}

168
#define KONEPLUS_BIN_ATTRIBUTE_W(thingy, THINGY) \
169 170
KONEPLUS_SYSFS_W(thingy, THINGY); \
static struct bin_attribute bin_attr_##thingy = { \
171 172 173
	.attr = { .name = #thingy, .mode = 0220 }, \
	.size = KONEPLUS_SIZE_ ## THINGY, \
	.write = koneplus_sysfs_write_ ## thingy \
174
}
175 176 177 178 179 180 181 182 183
KONEPLUS_BIN_ATTRIBUTE_W(control, CONTROL);
KONEPLUS_BIN_ATTRIBUTE_W(talk, TALK);
KONEPLUS_BIN_ATTRIBUTE_W(macro, MACRO);
KONEPLUS_BIN_ATTRIBUTE_R(tcu_image, TCU_IMAGE);
KONEPLUS_BIN_ATTRIBUTE_RW(info, INFO);
KONEPLUS_BIN_ATTRIBUTE_RW(sensor, SENSOR);
KONEPLUS_BIN_ATTRIBUTE_RW(tcu, TCU);
KONEPLUS_BIN_ATTRIBUTE_RW(profile_settings, PROFILE_SETTINGS);
KONEPLUS_BIN_ATTRIBUTE_RW(profile_buttons, PROFILE_BUTTONS);
184 185 186 187 188

static ssize_t koneplus_sysfs_read_profilex_settings(struct file *fp,
		struct kobject *kobj, struct bin_attribute *attr, char *buf,
		loff_t off, size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
189
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
190
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
191
	ssize_t retval;
192

193 194
	retval = koneplus_send_control(usb_dev, *(uint *)(attr->private),
			KONEPLUS_CONTROL_REQUEST_PROFILE_SETTINGS);
195 196 197
	if (retval)
		return retval;

198 199 200
	return koneplus_sysfs_read(fp, kobj, buf, off, count,
			KONEPLUS_SIZE_PROFILE_SETTINGS,
			KONEPLUS_COMMAND_PROFILE_SETTINGS);
201 202 203 204 205 206
}

static ssize_t koneplus_sysfs_read_profilex_buttons(struct file *fp,
		struct kobject *kobj, struct bin_attribute *attr, char *buf,
		loff_t off, size_t count)
{
Geliang Tang's avatar
Geliang Tang committed
207
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
208
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
209
	ssize_t retval;
210

211 212
	retval = koneplus_send_control(usb_dev, *(uint *)(attr->private),
			KONEPLUS_CONTROL_REQUEST_PROFILE_BUTTONS);
213 214 215
	if (retval)
		return retval;

216 217 218
	return koneplus_sysfs_read(fp, kobj, buf, off, count,
			KONEPLUS_SIZE_PROFILE_BUTTONS,
			KONEPLUS_COMMAND_PROFILE_BUTTONS);
219 220
}

221 222
#define PROFILE_ATTR(number)						\
static struct bin_attribute bin_attr_profile##number##_settings = {	\
223
	.attr = { .name = "profile" #number "_settings", .mode = 0440 },	\
224 225 226 227 228
	.size = KONEPLUS_SIZE_PROFILE_SETTINGS,				\
	.read = koneplus_sysfs_read_profilex_settings,			\
	.private = &profile_numbers[number-1],				\
};									\
static struct bin_attribute bin_attr_profile##number##_buttons = {	\
229
	.attr = { .name = "profile" #number "_buttons", .mode = 0440 },	\
230 231 232 233 234 235 236 237 238 239
	.size = KONEPLUS_SIZE_PROFILE_BUTTONS,				\
	.read = koneplus_sysfs_read_profilex_buttons,			\
	.private = &profile_numbers[number-1],				\
};
PROFILE_ATTR(1);
PROFILE_ATTR(2);
PROFILE_ATTR(3);
PROFILE_ATTR(4);
PROFILE_ATTR(5);

240
static ssize_t koneplus_sysfs_show_actual_profile(struct device *dev,
241 242 243 244
		struct device_attribute *attr, char *buf)
{
	struct koneplus_device *koneplus =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
245
	return sysfs_emit(buf, "%d\n", koneplus->actual_profile);
246 247
}

248
static ssize_t koneplus_sysfs_set_actual_profile(struct device *dev,
249 250 251 252 253 254
		struct device_attribute *attr, char const *buf, size_t size)
{
	struct koneplus_device *koneplus;
	struct usb_device *usb_dev;
	unsigned long profile;
	int retval;
255
	struct koneplus_roccat_report roccat_report;
256 257 258 259 260

	dev = dev->parent->parent;
	koneplus = hid_get_drvdata(dev_get_drvdata(dev));
	usb_dev = interface_to_usbdev(to_usb_interface(dev));

261
	retval = kstrtoul(buf, 10, &profile);
262 263 264
	if (retval)
		return retval;

265 266 267
	if (profile > 4)
		return -EINVAL;

268
	mutex_lock(&koneplus->koneplus_lock);
269 270 271 272

	retval = koneplus_set_actual_profile(usb_dev, profile);
	if (retval) {
		mutex_unlock(&koneplus->koneplus_lock);
273
		return retval;
274
	}
275

276
	koneplus_profile_activated(koneplus, profile);
277

278 279 280 281 282 283 284 285 286 287
	roccat_report.type = KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE;
	roccat_report.data1 = profile + 1;
	roccat_report.data2 = 0;
	roccat_report.profile = profile + 1;
	roccat_report_event(koneplus->chrdev_minor,
			(uint8_t const *)&roccat_report);

	mutex_unlock(&koneplus->koneplus_lock);

	return size;
288
}
289 290 291 292 293 294
static DEVICE_ATTR(actual_profile, 0660,
		   koneplus_sysfs_show_actual_profile,
		   koneplus_sysfs_set_actual_profile);
static DEVICE_ATTR(startup_profile, 0660,
		   koneplus_sysfs_show_actual_profile,
		   koneplus_sysfs_set_actual_profile);
295 296 297 298

static ssize_t koneplus_sysfs_show_firmware_version(struct device *dev,
		struct device_attribute *attr, char *buf)
{
299 300 301 302 303 304 305 306 307 308 309 310 311
	struct koneplus_device *koneplus;
	struct usb_device *usb_dev;
	struct koneplus_info info;

	dev = dev->parent->parent;
	koneplus = hid_get_drvdata(dev_get_drvdata(dev));
	usb_dev = interface_to_usbdev(to_usb_interface(dev));

	mutex_lock(&koneplus->koneplus_lock);
	roccat_common2_receive(usb_dev, KONEPLUS_COMMAND_INFO,
			&info, KONEPLUS_SIZE_INFO);
	mutex_unlock(&koneplus->koneplus_lock);

312
	return sysfs_emit(buf, "%d\n", info.firmware_version);
313
}
314 315 316 317 318 319 320 321
static DEVICE_ATTR(firmware_version, 0440,
		   koneplus_sysfs_show_firmware_version, NULL);

static struct attribute *koneplus_attrs[] = {
	&dev_attr_actual_profile.attr,
	&dev_attr_startup_profile.attr,
	&dev_attr_firmware_version.attr,
	NULL,
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

static struct bin_attribute *koneplus_bin_attributes[] = {
	&bin_attr_control,
	&bin_attr_talk,
	&bin_attr_macro,
	&bin_attr_tcu_image,
	&bin_attr_info,
	&bin_attr_sensor,
	&bin_attr_tcu,
	&bin_attr_profile_settings,
	&bin_attr_profile_buttons,
	&bin_attr_profile1_settings,
	&bin_attr_profile2_settings,
	&bin_attr_profile3_settings,
	&bin_attr_profile4_settings,
	&bin_attr_profile5_settings,
	&bin_attr_profile1_buttons,
	&bin_attr_profile2_buttons,
	&bin_attr_profile3_buttons,
	&bin_attr_profile4_buttons,
	&bin_attr_profile5_buttons,
	NULL,
};

static const struct attribute_group koneplus_group = {
	.attrs = koneplus_attrs,
	.bin_attrs = koneplus_bin_attributes,
};

static const struct attribute_group *koneplus_groups[] = {
	&koneplus_group,
	NULL,
355 356
};

357 358 359 360 361
static const struct class koneplus_class = {
	.name = "koneplus",
	.dev_groups = koneplus_groups,
};

362 363 364
static int koneplus_init_koneplus_device_struct(struct usb_device *usb_dev,
		struct koneplus_device *koneplus)
{
365
	int retval;
366 367 368

	mutex_init(&koneplus->koneplus_lock);

369 370 371 372
	retval = koneplus_get_actual_profile(usb_dev);
	if (retval < 0)
		return retval;
	koneplus_profile_activated(koneplus, retval);
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

	return 0;
}

static int koneplus_init_specials(struct hid_device *hdev)
{
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	struct usb_device *usb_dev = interface_to_usbdev(intf);
	struct koneplus_device *koneplus;
	int retval;

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			== USB_INTERFACE_PROTOCOL_MOUSE) {

		koneplus = kzalloc(sizeof(*koneplus), GFP_KERNEL);
		if (!koneplus) {
389
			hid_err(hdev, "can't alloc device descriptor\n");
390 391 392 393 394 395
			return -ENOMEM;
		}
		hid_set_drvdata(hdev, koneplus);

		retval = koneplus_init_koneplus_device_struct(usb_dev, koneplus);
		if (retval) {
396
			hid_err(hdev, "couldn't init struct koneplus_device\n");
397 398 399
			goto exit_free;
		}

400 401
		retval = roccat_connect(&koneplus_class, hdev,
					sizeof(struct koneplus_roccat_report));
402
		if (retval < 0) {
403
			hid_err(hdev, "couldn't init char dev\n");
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
		} else {
			koneplus->chrdev_minor = retval;
			koneplus->roccat_claimed = 1;
		}
	} else {
		hid_set_drvdata(hdev, NULL);
	}

	return 0;
exit_free:
	kfree(koneplus);
	return retval;
}

static void koneplus_remove_specials(struct hid_device *hdev)
{
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	struct koneplus_device *koneplus;

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			== USB_INTERFACE_PROTOCOL_MOUSE) {
		koneplus = hid_get_drvdata(hdev);
		if (koneplus->roccat_claimed)
			roccat_disconnect(koneplus->chrdev_minor);
		kfree(koneplus);
	}
}

static int koneplus_probe(struct hid_device *hdev,
		const struct hid_device_id *id)
{
	int retval;

437 438 439
	if (!hid_is_usb(hdev))
		return -EINVAL;

440 441
	retval = hid_parse(hdev);
	if (retval) {
442
		hid_err(hdev, "parse failed\n");
443 444 445 446 447
		goto exit;
	}

	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (retval) {
448
		hid_err(hdev, "hw start failed\n");
449 450 451 452 453
		goto exit;
	}

	retval = koneplus_init_specials(hdev);
	if (retval) {
454
		hid_err(hdev, "couldn't install mouse\n");
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
		goto exit_stop;
	}

	return 0;

exit_stop:
	hid_hw_stop(hdev);
exit:
	return retval;
}

static void koneplus_remove(struct hid_device *hdev)
{
	koneplus_remove_specials(hdev);
	hid_hw_stop(hdev);
}

static void koneplus_keep_values_up_to_date(struct koneplus_device *koneplus,
		u8 const *data)
{
	struct koneplus_mouse_report_button const *button_report;

	switch (data[0]) {
	case KONEPLUS_MOUSE_REPORT_NUMBER_BUTTON:
		button_report = (struct koneplus_mouse_report_button const *)data;
		switch (button_report->type) {
		case KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE:
			koneplus_profile_activated(koneplus, button_report->data1 - 1);
			break;
		}
		break;
	}
}

static void koneplus_report_to_chrdev(struct koneplus_device const *koneplus,
		u8 const *data)
{
	struct koneplus_roccat_report roccat_report;
	struct koneplus_mouse_report_button const *button_report;

	if (data[0] != KONEPLUS_MOUSE_REPORT_NUMBER_BUTTON)
		return;

	button_report = (struct koneplus_mouse_report_button const *)data;

	if ((button_report->type == KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_QUICKLAUNCH ||
			button_report->type == KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_TIMER) &&
			button_report->data2 != KONEPLUS_MOUSE_REPORT_BUTTON_ACTION_PRESS)
		return;

	roccat_report.type = button_report->type;
	roccat_report.data1 = button_report->data1;
	roccat_report.data2 = button_report->data2;
	roccat_report.profile = koneplus->actual_profile + 1;
	roccat_report_event(koneplus->chrdev_minor,
510
			(uint8_t const *)&roccat_report);
511 512 513 514 515 516 517 518 519 520 521 522
}

static int koneplus_raw_event(struct hid_device *hdev,
		struct hid_report *report, u8 *data, int size)
{
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	struct koneplus_device *koneplus = hid_get_drvdata(hdev);

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			!= USB_INTERFACE_PROTOCOL_MOUSE)
		return 0;

523 524 525
	if (koneplus == NULL)
		return 0;

526 527 528 529 530 531 532 533 534 535
	koneplus_keep_values_up_to_date(koneplus, data);

	if (koneplus->roccat_claimed)
		koneplus_report_to_chrdev(koneplus, data);

	return 0;
}

static const struct hid_device_id koneplus_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
536
	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEXTD) },
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	{ }
};

MODULE_DEVICE_TABLE(hid, koneplus_devices);

static struct hid_driver koneplus_driver = {
		.name = "koneplus",
		.id_table = koneplus_devices,
		.probe = koneplus_probe,
		.remove = koneplus_remove,
		.raw_event = koneplus_raw_event
};

static int __init koneplus_init(void)
{
	int retval;

	/* class name has to be same as driver name */
555 556 557
	retval = class_register(&koneplus_class);
	if (retval)
		return retval;
558 559 560

	retval = hid_register_driver(&koneplus_driver);
	if (retval)
561
		class_unregister(&koneplus_class);
562 563 564 565 566 567
	return retval;
}

static void __exit koneplus_exit(void)
{
	hid_unregister_driver(&koneplus_driver);
568
	class_unregister(&koneplus_class);
569 570 571 572 573 574
}

module_init(koneplus_init);
module_exit(koneplus_exit);

MODULE_AUTHOR("Stefan Achatz");
575
MODULE_DESCRIPTION("USB Roccat Kone[+]/XTD driver");
576
MODULE_LICENSE("GPL v2");