hid-roccat-arvo.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Roccat Arvo driver for Linux
  4. *
  5. * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
  6. */
  7. /*
  8. */
  9. /*
  10. * Roccat Arvo is a gamer keyboard with 5 macro keys that can be configured in
  11. * 5 profiles.
  12. */
  13. #include <linux/device.h>
  14. #include <linux/input.h>
  15. #include <linux/hid.h>
  16. #include <linux/module.h>
  17. #include <linux/slab.h>
  18. #include <linux/hid-roccat.h>
  19. #include "hid-ids.h"
  20. #include "hid-roccat-common.h"
  21. #include "hid-roccat-arvo.h"
  22. static struct class *arvo_class;
  23. static ssize_t arvo_sysfs_show_mode_key(struct device *dev,
  24. struct device_attribute *attr, char *buf)
  25. {
  26. struct arvo_device *arvo =
  27. hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
  28. struct usb_device *usb_dev =
  29. interface_to_usbdev(to_usb_interface(dev->parent->parent));
  30. struct arvo_mode_key temp_buf;
  31. int retval;
  32. mutex_lock(&arvo->arvo_lock);
  33. retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_MODE_KEY,
  34. &temp_buf, sizeof(struct arvo_mode_key));
  35. mutex_unlock(&arvo->arvo_lock);
  36. if (retval)
  37. return retval;
  38. return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.state);
  39. }
  40. static ssize_t arvo_sysfs_set_mode_key(struct device *dev,
  41. struct device_attribute *attr, char const *buf, size_t size)
  42. {
  43. struct arvo_device *arvo =
  44. hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
  45. struct usb_device *usb_dev =
  46. interface_to_usbdev(to_usb_interface(dev->parent->parent));
  47. struct arvo_mode_key temp_buf;
  48. unsigned long state;
  49. int retval;
  50. retval = kstrtoul(buf, 10, &state);
  51. if (retval)
  52. return retval;
  53. temp_buf.command = ARVO_COMMAND_MODE_KEY;
  54. temp_buf.state = state;
  55. mutex_lock(&arvo->arvo_lock);
  56. retval = roccat_common2_send(usb_dev, ARVO_COMMAND_MODE_KEY,
  57. &temp_buf, sizeof(struct arvo_mode_key));
  58. mutex_unlock(&arvo->arvo_lock);
  59. if (retval)
  60. return retval;
  61. return size;
  62. }
  63. static DEVICE_ATTR(mode_key, 0660,
  64. arvo_sysfs_show_mode_key, arvo_sysfs_set_mode_key);
  65. static ssize_t arvo_sysfs_show_key_mask(struct device *dev,
  66. struct device_attribute *attr, char *buf)
  67. {
  68. struct arvo_device *arvo =
  69. hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
  70. struct usb_device *usb_dev =
  71. interface_to_usbdev(to_usb_interface(dev->parent->parent));
  72. struct arvo_key_mask temp_buf;
  73. int retval;
  74. mutex_lock(&arvo->arvo_lock);
  75. retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_KEY_MASK,
  76. &temp_buf, sizeof(struct arvo_key_mask));
  77. mutex_unlock(&arvo->arvo_lock);
  78. if (retval)
  79. return retval;
  80. return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.key_mask);
  81. }
  82. static ssize_t arvo_sysfs_set_key_mask(struct device *dev,
  83. struct device_attribute *attr, char const *buf, size_t size)
  84. {
  85. struct arvo_device *arvo =
  86. hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
  87. struct usb_device *usb_dev =
  88. interface_to_usbdev(to_usb_interface(dev->parent->parent));
  89. struct arvo_key_mask temp_buf;
  90. unsigned long key_mask;
  91. int retval;
  92. retval = kstrtoul(buf, 10, &key_mask);
  93. if (retval)
  94. return retval;
  95. temp_buf.command = ARVO_COMMAND_KEY_MASK;
  96. temp_buf.key_mask = key_mask;
  97. mutex_lock(&arvo->arvo_lock);
  98. retval = roccat_common2_send(usb_dev, ARVO_COMMAND_KEY_MASK,
  99. &temp_buf, sizeof(struct arvo_key_mask));
  100. mutex_unlock(&arvo->arvo_lock);
  101. if (retval)
  102. return retval;
  103. return size;
  104. }
  105. static DEVICE_ATTR(key_mask, 0660,
  106. arvo_sysfs_show_key_mask, arvo_sysfs_set_key_mask);
  107. /* retval is 1-5 on success, < 0 on error */
  108. static int arvo_get_actual_profile(struct usb_device *usb_dev)
  109. {
  110. struct arvo_actual_profile temp_buf;
  111. int retval;
  112. retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_ACTUAL_PROFILE,
  113. &temp_buf, sizeof(struct arvo_actual_profile));
  114. if (retval)
  115. return retval;
  116. return temp_buf.actual_profile;
  117. }
  118. static ssize_t arvo_sysfs_show_actual_profile(struct device *dev,
  119. struct device_attribute *attr, char *buf)
  120. {
  121. struct arvo_device *arvo =
  122. hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
  123. return snprintf(buf, PAGE_SIZE, "%d\n", arvo->actual_profile);
  124. }
  125. static ssize_t arvo_sysfs_set_actual_profile(struct device *dev,
  126. struct device_attribute *attr, char const *buf, size_t size)
  127. {
  128. struct arvo_device *arvo =
  129. hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
  130. struct usb_device *usb_dev =
  131. interface_to_usbdev(to_usb_interface(dev->parent->parent));
  132. struct arvo_actual_profile temp_buf;
  133. unsigned long profile;
  134. int retval;
  135. retval = kstrtoul(buf, 10, &profile);
  136. if (retval)
  137. return retval;
  138. if (profile < 1 || profile > 5)
  139. return -EINVAL;
  140. temp_buf.command = ARVO_COMMAND_ACTUAL_PROFILE;
  141. temp_buf.actual_profile = profile;
  142. mutex_lock(&arvo->arvo_lock);
  143. retval = roccat_common2_send(usb_dev, ARVO_COMMAND_ACTUAL_PROFILE,
  144. &temp_buf, sizeof(struct arvo_actual_profile));
  145. if (!retval) {
  146. arvo->actual_profile = profile;
  147. retval = size;
  148. }
  149. mutex_unlock(&arvo->arvo_lock);
  150. return retval;
  151. }
  152. static DEVICE_ATTR(actual_profile, 0660,
  153. arvo_sysfs_show_actual_profile,
  154. arvo_sysfs_set_actual_profile);
  155. static ssize_t arvo_sysfs_write(struct file *fp,
  156. struct kobject *kobj, void const *buf,
  157. loff_t off, size_t count, size_t real_size, uint command)
  158. {
  159. struct device *dev = kobj_to_dev(kobj)->parent->parent;
  160. struct arvo_device *arvo = hid_get_drvdata(dev_get_drvdata(dev));
  161. struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
  162. int retval;
  163. if (off != 0 || count != real_size)
  164. return -EINVAL;
  165. mutex_lock(&arvo->arvo_lock);
  166. retval = roccat_common2_send(usb_dev, command, buf, real_size);
  167. mutex_unlock(&arvo->arvo_lock);
  168. return (retval ? retval : real_size);
  169. }
  170. static ssize_t arvo_sysfs_read(struct file *fp,
  171. struct kobject *kobj, void *buf, loff_t off,
  172. size_t count, size_t real_size, uint command)
  173. {
  174. struct device *dev = kobj_to_dev(kobj)->parent->parent;
  175. struct arvo_device *arvo = hid_get_drvdata(dev_get_drvdata(dev));
  176. struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
  177. int retval;
  178. if (off >= real_size)
  179. return 0;
  180. if (off != 0 || count != real_size)
  181. return -EINVAL;
  182. mutex_lock(&arvo->arvo_lock);
  183. retval = roccat_common2_receive(usb_dev, command, buf, real_size);
  184. mutex_unlock(&arvo->arvo_lock);
  185. return (retval ? retval : real_size);
  186. }
  187. static ssize_t arvo_sysfs_write_button(struct file *fp,
  188. struct kobject *kobj, struct bin_attribute *attr, char *buf,
  189. loff_t off, size_t count)
  190. {
  191. return arvo_sysfs_write(fp, kobj, buf, off, count,
  192. sizeof(struct arvo_button), ARVO_COMMAND_BUTTON);
  193. }
  194. static BIN_ATTR(button, 0220, NULL, arvo_sysfs_write_button,
  195. sizeof(struct arvo_button));
  196. static ssize_t arvo_sysfs_read_info(struct file *fp,
  197. struct kobject *kobj, struct bin_attribute *attr, char *buf,
  198. loff_t off, size_t count)
  199. {
  200. return arvo_sysfs_read(fp, kobj, buf, off, count,
  201. sizeof(struct arvo_info), ARVO_COMMAND_INFO);
  202. }
  203. static BIN_ATTR(info, 0440, arvo_sysfs_read_info, NULL,
  204. sizeof(struct arvo_info));
  205. static struct attribute *arvo_attrs[] = {
  206. &dev_attr_mode_key.attr,
  207. &dev_attr_key_mask.attr,
  208. &dev_attr_actual_profile.attr,
  209. NULL,
  210. };
  211. static struct bin_attribute *arvo_bin_attributes[] = {
  212. &bin_attr_button,
  213. &bin_attr_info,
  214. NULL,
  215. };
  216. static const struct attribute_group arvo_group = {
  217. .attrs = arvo_attrs,
  218. .bin_attrs = arvo_bin_attributes,
  219. };
  220. static const struct attribute_group *arvo_groups[] = {
  221. &arvo_group,
  222. NULL,
  223. };
  224. static int arvo_init_arvo_device_struct(struct usb_device *usb_dev,
  225. struct arvo_device *arvo)
  226. {
  227. int retval;
  228. mutex_init(&arvo->arvo_lock);
  229. retval = arvo_get_actual_profile(usb_dev);
  230. if (retval < 0)
  231. return retval;
  232. arvo->actual_profile = retval;
  233. return 0;
  234. }
  235. static int arvo_init_specials(struct hid_device *hdev)
  236. {
  237. struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
  238. struct usb_device *usb_dev = interface_to_usbdev(intf);
  239. struct arvo_device *arvo;
  240. int retval;
  241. if (intf->cur_altsetting->desc.bInterfaceProtocol
  242. == USB_INTERFACE_PROTOCOL_KEYBOARD) {
  243. hid_set_drvdata(hdev, NULL);
  244. return 0;
  245. }
  246. arvo = kzalloc(sizeof(*arvo), GFP_KERNEL);
  247. if (!arvo) {
  248. hid_err(hdev, "can't alloc device descriptor\n");
  249. return -ENOMEM;
  250. }
  251. hid_set_drvdata(hdev, arvo);
  252. retval = arvo_init_arvo_device_struct(usb_dev, arvo);
  253. if (retval) {
  254. hid_err(hdev, "couldn't init struct arvo_device\n");
  255. goto exit_free;
  256. }
  257. retval = roccat_connect(arvo_class, hdev,
  258. sizeof(struct arvo_roccat_report));
  259. if (retval < 0) {
  260. hid_err(hdev, "couldn't init char dev\n");
  261. } else {
  262. arvo->chrdev_minor = retval;
  263. arvo->roccat_claimed = 1;
  264. }
  265. return 0;
  266. exit_free:
  267. kfree(arvo);
  268. return retval;
  269. }
  270. static void arvo_remove_specials(struct hid_device *hdev)
  271. {
  272. struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
  273. struct arvo_device *arvo;
  274. if (intf->cur_altsetting->desc.bInterfaceProtocol
  275. == USB_INTERFACE_PROTOCOL_KEYBOARD)
  276. return;
  277. arvo = hid_get_drvdata(hdev);
  278. if (arvo->roccat_claimed)
  279. roccat_disconnect(arvo->chrdev_minor);
  280. kfree(arvo);
  281. }
  282. static int arvo_probe(struct hid_device *hdev,
  283. const struct hid_device_id *id)
  284. {
  285. int retval;
  286. if (!hid_is_usb(hdev))
  287. return -EINVAL;
  288. retval = hid_parse(hdev);
  289. if (retval) {
  290. hid_err(hdev, "parse failed\n");
  291. goto exit;
  292. }
  293. retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
  294. if (retval) {
  295. hid_err(hdev, "hw start failed\n");
  296. goto exit;
  297. }
  298. retval = arvo_init_specials(hdev);
  299. if (retval) {
  300. hid_err(hdev, "couldn't install keyboard\n");
  301. goto exit_stop;
  302. }
  303. return 0;
  304. exit_stop:
  305. hid_hw_stop(hdev);
  306. exit:
  307. return retval;
  308. }
  309. static void arvo_remove(struct hid_device *hdev)
  310. {
  311. arvo_remove_specials(hdev);
  312. hid_hw_stop(hdev);
  313. }
  314. static void arvo_report_to_chrdev(struct arvo_device const *arvo,
  315. u8 const *data)
  316. {
  317. struct arvo_special_report const *special_report;
  318. struct arvo_roccat_report roccat_report;
  319. special_report = (struct arvo_special_report const *)data;
  320. roccat_report.profile = arvo->actual_profile;
  321. roccat_report.button = special_report->event &
  322. ARVO_SPECIAL_REPORT_EVENT_MASK_BUTTON;
  323. if ((special_report->event & ARVO_SPECIAL_REPORT_EVENT_MASK_ACTION) ==
  324. ARVO_SPECIAL_REPORT_EVENT_ACTION_PRESS)
  325. roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_PRESS;
  326. else
  327. roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_RELEASE;
  328. roccat_report_event(arvo->chrdev_minor,
  329. (uint8_t const *)&roccat_report);
  330. }
  331. static int arvo_raw_event(struct hid_device *hdev,
  332. struct hid_report *report, u8 *data, int size)
  333. {
  334. struct arvo_device *arvo = hid_get_drvdata(hdev);
  335. if (size != 3)
  336. return 0;
  337. if (arvo && arvo->roccat_claimed)
  338. arvo_report_to_chrdev(arvo, data);
  339. return 0;
  340. }
  341. static const struct hid_device_id arvo_devices[] = {
  342. { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
  343. { }
  344. };
  345. MODULE_DEVICE_TABLE(hid, arvo_devices);
  346. static struct hid_driver arvo_driver = {
  347. .name = "arvo",
  348. .id_table = arvo_devices,
  349. .probe = arvo_probe,
  350. .remove = arvo_remove,
  351. .raw_event = arvo_raw_event
  352. };
  353. static int __init arvo_init(void)
  354. {
  355. int retval;
  356. arvo_class = class_create(THIS_MODULE, "arvo");
  357. if (IS_ERR(arvo_class))
  358. return PTR_ERR(arvo_class);
  359. arvo_class->dev_groups = arvo_groups;
  360. retval = hid_register_driver(&arvo_driver);
  361. if (retval)
  362. class_destroy(arvo_class);
  363. return retval;
  364. }
  365. static void __exit arvo_exit(void)
  366. {
  367. hid_unregister_driver(&arvo_driver);
  368. class_destroy(arvo_class);
  369. }
  370. module_init(arvo_init);
  371. module_exit(arvo_exit);
  372. MODULE_AUTHOR("Stefan Achatz");
  373. MODULE_DESCRIPTION("USB Roccat Arvo driver");
  374. MODULE_LICENSE("GPL v2");