xref: /linux/drivers/hid/hid-roccat-isku.c (revision f9cd49033b349b8be3bb1f01b39eed837853d880)
1 /*
2  * Roccat Isku driver for Linux
3  *
4  * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
5  */
6 
7 /*
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the Free
10  * Software Foundation; either version 2 of the License, or (at your option)
11  * any later version.
12  */
13 
14 /*
15  * Roccat Isku is a gamer keyboard with macro keys that can be configured in
16  * 5 profiles.
17  */
18 
19 #include <linux/device.h>
20 #include <linux/input.h>
21 #include <linux/hid.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/hid-roccat.h>
25 #include "hid-ids.h"
26 #include "hid-roccat-common.h"
27 #include "hid-roccat-isku.h"
28 
29 static struct class *isku_class;
30 
31 static void isku_profile_activated(struct isku_device *isku, uint new_profile)
32 {
33 	isku->actual_profile = new_profile;
34 }
35 
36 static int isku_receive(struct usb_device *usb_dev, uint command,
37 		void *buf, uint size)
38 {
39 	return roccat_common2_receive(usb_dev, command, buf, size);
40 }
41 
42 static int isku_get_actual_profile(struct usb_device *usb_dev)
43 {
44 	struct isku_actual_profile buf;
45 	int retval;
46 
47 	retval = isku_receive(usb_dev, ISKU_COMMAND_ACTUAL_PROFILE,
48 			&buf, sizeof(struct isku_actual_profile));
49 	return retval ? retval : buf.actual_profile;
50 }
51 
52 static int isku_set_actual_profile(struct usb_device *usb_dev, int new_profile)
53 {
54 	struct isku_actual_profile buf;
55 
56 	buf.command = ISKU_COMMAND_ACTUAL_PROFILE;
57 	buf.size = sizeof(struct isku_actual_profile);
58 	buf.actual_profile = new_profile;
59 	return roccat_common2_send_with_status(usb_dev,
60 			ISKU_COMMAND_ACTUAL_PROFILE, &buf,
61 			sizeof(struct isku_actual_profile));
62 }
63 
64 static ssize_t isku_sysfs_show_actual_profile(struct device *dev,
65 		struct device_attribute *attr, char *buf)
66 {
67 	struct isku_device *isku =
68 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
69 	return snprintf(buf, PAGE_SIZE, "%d\n", isku->actual_profile);
70 }
71 
72 static ssize_t isku_sysfs_set_actual_profile(struct device *dev,
73 		struct device_attribute *attr, char const *buf, size_t size)
74 {
75 	struct isku_device *isku;
76 	struct usb_device *usb_dev;
77 	unsigned long profile;
78 	int retval;
79 	struct isku_roccat_report roccat_report;
80 
81 	dev = dev->parent->parent;
82 	isku = hid_get_drvdata(dev_get_drvdata(dev));
83 	usb_dev = interface_to_usbdev(to_usb_interface(dev));
84 
85 	retval = strict_strtoul(buf, 10, &profile);
86 	if (retval)
87 		return retval;
88 
89 	if (profile > 4)
90 		return -EINVAL;
91 
92 	mutex_lock(&isku->isku_lock);
93 
94 	retval = isku_set_actual_profile(usb_dev, profile);
95 	if (retval) {
96 		mutex_unlock(&isku->isku_lock);
97 		return retval;
98 	}
99 
100 	isku_profile_activated(isku, profile);
101 
102 	roccat_report.event = ISKU_REPORT_BUTTON_EVENT_PROFILE;
103 	roccat_report.data1 = profile + 1;
104 	roccat_report.data2 = 0;
105 	roccat_report.profile = profile + 1;
106 	roccat_report_event(isku->chrdev_minor, (uint8_t const *)&roccat_report);
107 
108 	mutex_unlock(&isku->isku_lock);
109 
110 	return size;
111 }
112 
113 static struct device_attribute isku_attributes[] = {
114 	__ATTR(actual_profile, 0660,
115 			isku_sysfs_show_actual_profile,
116 			isku_sysfs_set_actual_profile),
117 	__ATTR_NULL
118 };
119 
120 static ssize_t isku_sysfs_read(struct file *fp, struct kobject *kobj,
121 		char *buf, loff_t off, size_t count,
122 		size_t real_size, uint command)
123 {
124 	struct device *dev =
125 			container_of(kobj, struct device, kobj)->parent->parent;
126 	struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev));
127 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
128 	int retval;
129 
130 	if (off >= real_size)
131 		return 0;
132 
133 	if (off != 0 || count != real_size)
134 		return -EINVAL;
135 
136 	mutex_lock(&isku->isku_lock);
137 	retval = isku_receive(usb_dev, command, buf, real_size);
138 	mutex_unlock(&isku->isku_lock);
139 
140 	return retval ? retval : real_size;
141 }
142 
143 static ssize_t isku_sysfs_write(struct file *fp, struct kobject *kobj,
144 		void const *buf, loff_t off, size_t count,
145 		size_t real_size, uint command)
146 {
147 	struct device *dev =
148 			container_of(kobj, struct device, kobj)->parent->parent;
149 	struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev));
150 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
151 	int retval;
152 
153 	if (off != 0 || count != real_size)
154 		return -EINVAL;
155 
156 	mutex_lock(&isku->isku_lock);
157 	retval = roccat_common2_send_with_status(usb_dev, command,
158 			(void *)buf, real_size);
159 	mutex_unlock(&isku->isku_lock);
160 
161 	return retval ? retval : real_size;
162 }
163 
164 #define ISKU_SYSFS_W(thingy, THINGY) \
165 static ssize_t isku_sysfs_write_ ## thingy(struct file *fp, struct kobject *kobj, \
166 		struct bin_attribute *attr, char *buf, \
167 		loff_t off, size_t count) \
168 { \
169 	return isku_sysfs_write(fp, kobj, buf, off, count, \
170 			sizeof(struct isku_ ## thingy), ISKU_COMMAND_ ## THINGY); \
171 }
172 
173 #define ISKU_SYSFS_R(thingy, THINGY) \
174 static ssize_t isku_sysfs_read_ ## thingy(struct file *fp, struct kobject *kobj, \
175 		struct bin_attribute *attr, char *buf, \
176 		loff_t off, size_t count) \
177 { \
178 	return isku_sysfs_read(fp, kobj, buf, off, count, \
179 			sizeof(struct isku_ ## thingy), ISKU_COMMAND_ ## THINGY); \
180 }
181 
182 #define ISKU_SYSFS_RW(thingy, THINGY) \
183 ISKU_SYSFS_R(thingy, THINGY) \
184 ISKU_SYSFS_W(thingy, THINGY)
185 
186 #define ISKU_BIN_ATTR_RW(thingy) \
187 { \
188 	.attr = { .name = #thingy, .mode = 0660 }, \
189 	.size = sizeof(struct isku_ ## thingy), \
190 	.read = isku_sysfs_read_ ## thingy, \
191 	.write = isku_sysfs_write_ ## thingy \
192 }
193 
194 #define ISKU_BIN_ATTR_R(thingy) \
195 { \
196 	.attr = { .name = #thingy, .mode = 0440 }, \
197 	.size = sizeof(struct isku_ ## thingy), \
198 	.read = isku_sysfs_read_ ## thingy, \
199 }
200 
201 #define ISKU_BIN_ATTR_W(thingy) \
202 { \
203 	.attr = { .name = #thingy, .mode = 0220 }, \
204 	.size = sizeof(struct isku_ ## thingy), \
205 	.write = isku_sysfs_write_ ## thingy \
206 }
207 
208 ISKU_SYSFS_RW(macro, MACRO)
209 ISKU_SYSFS_RW(keys_function, KEYS_FUNCTION)
210 ISKU_SYSFS_RW(keys_easyzone, KEYS_EASYZONE)
211 ISKU_SYSFS_RW(keys_media, KEYS_MEDIA)
212 ISKU_SYSFS_RW(keys_thumbster, KEYS_THUMBSTER)
213 ISKU_SYSFS_RW(keys_macro, KEYS_MACRO)
214 ISKU_SYSFS_RW(keys_capslock, KEYS_CAPSLOCK)
215 ISKU_SYSFS_RW(light, LIGHT)
216 ISKU_SYSFS_RW(key_mask, KEY_MASK)
217 ISKU_SYSFS_RW(last_set, LAST_SET)
218 ISKU_SYSFS_W(talk, TALK)
219 ISKU_SYSFS_R(info, INFO)
220 ISKU_SYSFS_W(control, CONTROL)
221 
222 static struct bin_attribute isku_bin_attributes[] = {
223 	ISKU_BIN_ATTR_RW(macro),
224 	ISKU_BIN_ATTR_RW(keys_function),
225 	ISKU_BIN_ATTR_RW(keys_easyzone),
226 	ISKU_BIN_ATTR_RW(keys_media),
227 	ISKU_BIN_ATTR_RW(keys_thumbster),
228 	ISKU_BIN_ATTR_RW(keys_macro),
229 	ISKU_BIN_ATTR_RW(keys_capslock),
230 	ISKU_BIN_ATTR_RW(light),
231 	ISKU_BIN_ATTR_RW(key_mask),
232 	ISKU_BIN_ATTR_RW(last_set),
233 	ISKU_BIN_ATTR_W(talk),
234 	ISKU_BIN_ATTR_R(info),
235 	ISKU_BIN_ATTR_W(control),
236 	__ATTR_NULL
237 };
238 
239 static int isku_init_isku_device_struct(struct usb_device *usb_dev,
240 		struct isku_device *isku)
241 {
242 	int retval;
243 
244 	mutex_init(&isku->isku_lock);
245 
246 	retval = isku_get_actual_profile(usb_dev);
247 	if (retval < 0)
248 		return retval;
249 	isku_profile_activated(isku, retval);
250 
251 	return 0;
252 }
253 
254 static int isku_init_specials(struct hid_device *hdev)
255 {
256 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
257 	struct usb_device *usb_dev = interface_to_usbdev(intf);
258 	struct isku_device *isku;
259 	int retval;
260 
261 	if (intf->cur_altsetting->desc.bInterfaceProtocol
262 			!= ISKU_USB_INTERFACE_PROTOCOL) {
263 		hid_set_drvdata(hdev, NULL);
264 		return 0;
265 	}
266 
267 	isku = kzalloc(sizeof(*isku), GFP_KERNEL);
268 	if (!isku) {
269 		hid_err(hdev, "can't alloc device descriptor\n");
270 		return -ENOMEM;
271 	}
272 	hid_set_drvdata(hdev, isku);
273 
274 	retval = isku_init_isku_device_struct(usb_dev, isku);
275 	if (retval) {
276 		hid_err(hdev, "couldn't init struct isku_device\n");
277 		goto exit_free;
278 	}
279 
280 	retval = roccat_connect(isku_class, hdev,
281 			sizeof(struct isku_roccat_report));
282 	if (retval < 0) {
283 		hid_err(hdev, "couldn't init char dev\n");
284 	} else {
285 		isku->chrdev_minor = retval;
286 		isku->roccat_claimed = 1;
287 	}
288 
289 	return 0;
290 exit_free:
291 	kfree(isku);
292 	return retval;
293 }
294 
295 static void isku_remove_specials(struct hid_device *hdev)
296 {
297 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
298 	struct isku_device *isku;
299 
300 	if (intf->cur_altsetting->desc.bInterfaceProtocol
301 			!= ISKU_USB_INTERFACE_PROTOCOL)
302 		return;
303 
304 	isku = hid_get_drvdata(hdev);
305 	if (isku->roccat_claimed)
306 		roccat_disconnect(isku->chrdev_minor);
307 	kfree(isku);
308 }
309 
310 static int isku_probe(struct hid_device *hdev,
311 		const struct hid_device_id *id)
312 {
313 	int retval;
314 
315 	retval = hid_parse(hdev);
316 	if (retval) {
317 		hid_err(hdev, "parse failed\n");
318 		goto exit;
319 	}
320 
321 	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
322 	if (retval) {
323 		hid_err(hdev, "hw start failed\n");
324 		goto exit;
325 	}
326 
327 	retval = isku_init_specials(hdev);
328 	if (retval) {
329 		hid_err(hdev, "couldn't install keyboard\n");
330 		goto exit_stop;
331 	}
332 
333 	return 0;
334 
335 exit_stop:
336 	hid_hw_stop(hdev);
337 exit:
338 	return retval;
339 }
340 
341 static void isku_remove(struct hid_device *hdev)
342 {
343 	isku_remove_specials(hdev);
344 	hid_hw_stop(hdev);
345 }
346 
347 static void isku_keep_values_up_to_date(struct isku_device *isku,
348 		u8 const *data)
349 {
350 	struct isku_report_button const *button_report;
351 
352 	switch (data[0]) {
353 	case ISKU_REPORT_NUMBER_BUTTON:
354 		button_report = (struct isku_report_button const *)data;
355 		switch (button_report->event) {
356 		case ISKU_REPORT_BUTTON_EVENT_PROFILE:
357 			isku_profile_activated(isku, button_report->data1 - 1);
358 			break;
359 		}
360 		break;
361 	}
362 }
363 
364 static void isku_report_to_chrdev(struct isku_device const *isku,
365 		u8 const *data)
366 {
367 	struct isku_roccat_report roccat_report;
368 	struct isku_report_button const *button_report;
369 
370 	if (data[0] != ISKU_REPORT_NUMBER_BUTTON)
371 		return;
372 
373 	button_report = (struct isku_report_button const *)data;
374 
375 	roccat_report.event = button_report->event;
376 	roccat_report.data1 = button_report->data1;
377 	roccat_report.data2 = button_report->data2;
378 	roccat_report.profile = isku->actual_profile + 1;
379 	roccat_report_event(isku->chrdev_minor,
380 			(uint8_t const *)&roccat_report);
381 }
382 
383 static int isku_raw_event(struct hid_device *hdev,
384 		struct hid_report *report, u8 *data, int size)
385 {
386 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
387 	struct isku_device *isku = hid_get_drvdata(hdev);
388 
389 	if (intf->cur_altsetting->desc.bInterfaceProtocol
390 			!= ISKU_USB_INTERFACE_PROTOCOL)
391 		return 0;
392 
393 	if (isku == NULL)
394 		return 0;
395 
396 	isku_keep_values_up_to_date(isku, data);
397 
398 	if (isku->roccat_claimed)
399 		isku_report_to_chrdev(isku, data);
400 
401 	return 0;
402 }
403 
404 static const struct hid_device_id isku_devices[] = {
405 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
406 	{ }
407 };
408 
409 MODULE_DEVICE_TABLE(hid, isku_devices);
410 
411 static struct hid_driver isku_driver = {
412 		.name = "isku",
413 		.id_table = isku_devices,
414 		.probe = isku_probe,
415 		.remove = isku_remove,
416 		.raw_event = isku_raw_event
417 };
418 
419 static int __init isku_init(void)
420 {
421 	int retval;
422 	isku_class = class_create(THIS_MODULE, "isku");
423 	if (IS_ERR(isku_class))
424 		return PTR_ERR(isku_class);
425 	isku_class->dev_attrs = isku_attributes;
426 	isku_class->dev_bin_attrs = isku_bin_attributes;
427 
428 	retval = hid_register_driver(&isku_driver);
429 	if (retval)
430 		class_destroy(isku_class);
431 	return retval;
432 }
433 
434 static void __exit isku_exit(void)
435 {
436 	hid_unregister_driver(&isku_driver);
437 	class_destroy(isku_class);
438 }
439 
440 module_init(isku_init);
441 module_exit(isku_exit);
442 
443 MODULE_AUTHOR("Stefan Achatz");
444 MODULE_DESCRIPTION("USB Roccat Isku driver");
445 MODULE_LICENSE("GPL v2");
446