hid-roccat-arvo.c 11.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Roccat Arvo driver for Linux
 *
 * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
 */

/*
 */

/*
 * Roccat Arvo is a gamer keyboard with 5 macro keys that can be configured in
 * 5 profiles.
 */

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

static struct class *arvo_class;

static ssize_t arvo_sysfs_show_mode_key(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct arvo_device *arvo =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
	struct usb_device *usb_dev =
			interface_to_usbdev(to_usb_interface(dev->parent->parent));
35
	struct arvo_mode_key temp_buf;
36 37 38
	int retval;

	mutex_lock(&arvo->arvo_lock);
39
	retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_MODE_KEY,
40
			&temp_buf, sizeof(struct arvo_mode_key));
41 42
	mutex_unlock(&arvo->arvo_lock);
	if (retval)
43
		return retval;
44

45
	return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.state);
46 47 48 49 50 51 52 53 54
}

static ssize_t arvo_sysfs_set_mode_key(struct device *dev,
		struct device_attribute *attr, char const *buf, size_t size)
{
	struct arvo_device *arvo =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
	struct usb_device *usb_dev =
			interface_to_usbdev(to_usb_interface(dev->parent->parent));
55
	struct arvo_mode_key temp_buf;
56 57 58
	unsigned long state;
	int retval;

59
	retval = kstrtoul(buf, 10, &state);
60
	if (retval)
61
		return retval;
62

63 64
	temp_buf.command = ARVO_COMMAND_MODE_KEY;
	temp_buf.state = state;
65 66

	mutex_lock(&arvo->arvo_lock);
67
	retval = roccat_common2_send(usb_dev, ARVO_COMMAND_MODE_KEY,
68
			&temp_buf, sizeof(struct arvo_mode_key));
69 70
	mutex_unlock(&arvo->arvo_lock);
	if (retval)
71
		return retval;
72

73
	return size;
74
}
75 76
static DEVICE_ATTR(mode_key, 0660,
		   arvo_sysfs_show_mode_key, arvo_sysfs_set_mode_key);
77 78 79 80 81 82 83 84

static ssize_t arvo_sysfs_show_key_mask(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct arvo_device *arvo =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
	struct usb_device *usb_dev =
			interface_to_usbdev(to_usb_interface(dev->parent->parent));
85
	struct arvo_key_mask temp_buf;
86 87 88
	int retval;

	mutex_lock(&arvo->arvo_lock);
89
	retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_KEY_MASK,
90
			&temp_buf, sizeof(struct arvo_key_mask));
91 92
	mutex_unlock(&arvo->arvo_lock);
	if (retval)
93
		return retval;
94

95
	return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.key_mask);
96 97 98 99 100 101 102 103 104
}

static ssize_t arvo_sysfs_set_key_mask(struct device *dev,
		struct device_attribute *attr, char const *buf, size_t size)
{
	struct arvo_device *arvo =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
	struct usb_device *usb_dev =
			interface_to_usbdev(to_usb_interface(dev->parent->parent));
105
	struct arvo_key_mask temp_buf;
106 107 108
	unsigned long key_mask;
	int retval;

109
	retval = kstrtoul(buf, 10, &key_mask);
110
	if (retval)
111
		return retval;
112

113 114
	temp_buf.command = ARVO_COMMAND_KEY_MASK;
	temp_buf.key_mask = key_mask;
115 116

	mutex_lock(&arvo->arvo_lock);
117
	retval = roccat_common2_send(usb_dev, ARVO_COMMAND_KEY_MASK,
118
			&temp_buf, sizeof(struct arvo_key_mask));
119 120
	mutex_unlock(&arvo->arvo_lock);
	if (retval)
121
		return retval;
122

123
	return size;
124
}
125 126
static DEVICE_ATTR(key_mask, 0660,
		   arvo_sysfs_show_key_mask, arvo_sysfs_set_key_mask);
127 128 129 130

/* retval is 1-5 on success, < 0 on error */
static int arvo_get_actual_profile(struct usb_device *usb_dev)
{
131
	struct arvo_actual_profile temp_buf;
132 133
	int retval;

134
	retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_ACTUAL_PROFILE,
135
			&temp_buf, sizeof(struct arvo_actual_profile));
136

137 138
	if (retval)
		return retval;
139

140
	return temp_buf.actual_profile;
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
}

static ssize_t arvo_sysfs_show_actual_profile(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct arvo_device *arvo =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));

	return snprintf(buf, PAGE_SIZE, "%d\n", arvo->actual_profile);
}

static ssize_t arvo_sysfs_set_actual_profile(struct device *dev,
		struct device_attribute *attr, char const *buf, size_t size)
{
	struct arvo_device *arvo =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
	struct usb_device *usb_dev =
			interface_to_usbdev(to_usb_interface(dev->parent->parent));
159
	struct arvo_actual_profile temp_buf;
160 161 162
	unsigned long profile;
	int retval;

163
	retval = kstrtoul(buf, 10, &profile);
164
	if (retval)
165
		return retval;
166

167 168 169
	if (profile < 1 || profile > 5)
		return -EINVAL;

170 171
	temp_buf.command = ARVO_COMMAND_ACTUAL_PROFILE;
	temp_buf.actual_profile = profile;
172 173

	mutex_lock(&arvo->arvo_lock);
174
	retval = roccat_common2_send(usb_dev, ARVO_COMMAND_ACTUAL_PROFILE,
175
			&temp_buf, sizeof(struct arvo_actual_profile));
176 177 178 179 180 181 182
	if (!retval) {
		arvo->actual_profile = profile;
		retval = size;
	}
	mutex_unlock(&arvo->arvo_lock);
	return retval;
}
183 184 185
static DEVICE_ATTR(actual_profile, 0660,
		   arvo_sysfs_show_actual_profile,
		   arvo_sysfs_set_actual_profile);
186 187 188 189 190

static ssize_t arvo_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
191
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
192 193 194 195 196 197 198 199
	struct arvo_device *arvo = 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(&arvo->arvo_lock);
200
	retval = roccat_common2_send(usb_dev, command, buf, real_size);
201 202 203 204 205 206 207 208 209
	mutex_unlock(&arvo->arvo_lock);

	return (retval ? retval : real_size);
}

static ssize_t arvo_sysfs_read(struct file *fp,
		struct kobject *kobj, void *buf, loff_t off,
		size_t count, size_t real_size, uint command)
{
Geliang Tang's avatar
Geliang Tang committed
210
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
211 212 213 214 215 216 217 218 219 220 221
	struct arvo_device *arvo = hid_get_drvdata(dev_get_drvdata(dev));
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	int retval;

	if (off >= real_size)
		return 0;

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

	mutex_lock(&arvo->arvo_lock);
222
	retval = roccat_common2_receive(usb_dev, command, buf, real_size);
223 224 225 226 227 228 229 230 231 232
	mutex_unlock(&arvo->arvo_lock);

	return (retval ? retval : real_size);
}

static ssize_t arvo_sysfs_write_button(struct file *fp,
		struct kobject *kobj, struct bin_attribute *attr, char *buf,
		loff_t off, size_t count)
{
	return arvo_sysfs_write(fp, kobj, buf, off, count,
233
			sizeof(struct arvo_button), ARVO_COMMAND_BUTTON);
234
}
235 236
static BIN_ATTR(button, 0220, NULL, arvo_sysfs_write_button,
		sizeof(struct arvo_button));
237 238 239 240 241 242

static ssize_t arvo_sysfs_read_info(struct file *fp,
		struct kobject *kobj, struct bin_attribute *attr, char *buf,
		loff_t off, size_t count)
{
	return arvo_sysfs_read(fp, kobj, buf, off, count,
243
			sizeof(struct arvo_info), ARVO_COMMAND_INFO);
244
}
245 246
static BIN_ATTR(info, 0440, arvo_sysfs_read_info, NULL,
		sizeof(struct arvo_info));
247

248 249 250 251 252
static struct attribute *arvo_attrs[] = {
	&dev_attr_mode_key.attr,
	&dev_attr_key_mask.attr,
	&dev_attr_actual_profile.attr,
	NULL,
253
};
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268

static struct bin_attribute *arvo_bin_attributes[] = {
	&bin_attr_button,
	&bin_attr_info,
	NULL,
};

static const struct attribute_group arvo_group = {
	.attrs = arvo_attrs,
	.bin_attrs = arvo_bin_attributes,
};

static const struct attribute_group *arvo_groups[] = {
	&arvo_group,
	NULL,
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
};

static int arvo_init_arvo_device_struct(struct usb_device *usb_dev,
		struct arvo_device *arvo)
{
	int retval;

	mutex_init(&arvo->arvo_lock);

	retval = arvo_get_actual_profile(usb_dev);
	if (retval < 0)
		return retval;
	arvo->actual_profile = retval;

	return 0;
}

static int arvo_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 arvo_device *arvo;
	int retval;

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			== USB_INTERFACE_PROTOCOL_KEYBOARD) {
		hid_set_drvdata(hdev, NULL);
		return 0;
	}

	arvo = kzalloc(sizeof(*arvo), GFP_KERNEL);
	if (!arvo) {
301
		hid_err(hdev, "can't alloc device descriptor\n");
302 303 304 305 306 307
		return -ENOMEM;
	}
	hid_set_drvdata(hdev, arvo);

	retval = arvo_init_arvo_device_struct(usb_dev, arvo);
	if (retval) {
308
		hid_err(hdev, "couldn't init struct arvo_device\n");
309 310 311
		goto exit_free;
	}

312 313
	retval = roccat_connect(arvo_class, hdev,
			sizeof(struct arvo_roccat_report));
314
	if (retval < 0) {
315
		hid_err(hdev, "couldn't init char dev\n");
316 317 318 319 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
	} else {
		arvo->chrdev_minor = retval;
		arvo->roccat_claimed = 1;
	}

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

static void arvo_remove_specials(struct hid_device *hdev)
{
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	struct arvo_device *arvo;

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			== USB_INTERFACE_PROTOCOL_KEYBOARD)
		return;

	arvo = hid_get_drvdata(hdev);
	if (arvo->roccat_claimed)
		roccat_disconnect(arvo->chrdev_minor);
	kfree(arvo);
}

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

	retval = hid_parse(hdev);
	if (retval) {
349
		hid_err(hdev, "parse failed\n");
350 351 352 353 354
		goto exit;
	}

	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (retval) {
355
		hid_err(hdev, "hw start failed\n");
356 357 358 359 360
		goto exit;
	}

	retval = arvo_init_specials(hdev);
	if (retval) {
361
		hid_err(hdev, "couldn't install keyboard\n");
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
		goto exit_stop;
	}

	return 0;

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

static void arvo_remove(struct hid_device *hdev)
{
	arvo_remove_specials(hdev);
	hid_hw_stop(hdev);
}

static void arvo_report_to_chrdev(struct arvo_device const *arvo,
		u8 const *data)
{
	struct arvo_special_report const *special_report;
	struct arvo_roccat_report roccat_report;

	special_report = (struct arvo_special_report const *)data;

	roccat_report.profile = arvo->actual_profile;
	roccat_report.button = special_report->event &
			ARVO_SPECIAL_REPORT_EVENT_MASK_BUTTON;
	if ((special_report->event & ARVO_SPECIAL_REPORT_EVENT_MASK_ACTION) ==
			ARVO_SPECIAL_REPORT_EVENT_ACTION_PRESS)
		roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_PRESS;
	else
		roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_RELEASE;

396 397
	roccat_report_event(arvo->chrdev_minor,
			(uint8_t const *)&roccat_report);
398 399 400 401 402 403 404 405 406 407
}

static int arvo_raw_event(struct hid_device *hdev,
		struct hid_report *report, u8 *data, int size)
{
	struct arvo_device *arvo = hid_get_drvdata(hdev);

	if (size != 3)
		return 0;

408
	if (arvo && arvo->roccat_claimed)
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
		arvo_report_to_chrdev(arvo, data);

	return 0;
}

static const struct hid_device_id arvo_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
	{ }
};

MODULE_DEVICE_TABLE(hid, arvo_devices);

static struct hid_driver arvo_driver = {
	.name = "arvo",
	.id_table = arvo_devices,
	.probe = arvo_probe,
	.remove = arvo_remove,
	.raw_event = arvo_raw_event
};

static int __init arvo_init(void)
{
	int retval;

	arvo_class = class_create(THIS_MODULE, "arvo");
	if (IS_ERR(arvo_class))
		return PTR_ERR(arvo_class);
436
	arvo_class->dev_groups = arvo_groups;
437 438 439 440 441 442 443 444 445 446

	retval = hid_register_driver(&arvo_driver);
	if (retval)
		class_destroy(arvo_class);
	return retval;
}

static void __exit arvo_exit(void)
{
	hid_unregister_driver(&arvo_driver);
447
	class_destroy(arvo_class);
448 449 450 451 452 453 454 455
}

module_init(arvo_init);
module_exit(arvo_exit);

MODULE_AUTHOR("Stefan Achatz");
MODULE_DESCRIPTION("USB Roccat Arvo driver");
MODULE_LICENSE("GPL v2");