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 = kstrtoul(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 static DEVICE_ATTR(actual_profile, 0660, isku_sysfs_show_actual_profile, 113 isku_sysfs_set_actual_profile); 114 115 static struct attribute *isku_attrs[] = { 116 &dev_attr_actual_profile.attr, 117 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 = kobj_to_dev(kobj)->parent->parent; 125 struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev)); 126 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 127 int retval; 128 129 if (off >= real_size) 130 return 0; 131 132 if (off != 0 || count > real_size) 133 return -EINVAL; 134 135 mutex_lock(&isku->isku_lock); 136 retval = isku_receive(usb_dev, command, buf, count); 137 mutex_unlock(&isku->isku_lock); 138 139 return retval ? retval : count; 140 } 141 142 static ssize_t isku_sysfs_write(struct file *fp, struct kobject *kobj, 143 void const *buf, loff_t off, size_t count, 144 size_t real_size, uint command) 145 { 146 struct device *dev = kobj_to_dev(kobj)->parent->parent; 147 struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev)); 148 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 149 int retval; 150 151 if (off != 0 || count > real_size) 152 return -EINVAL; 153 154 mutex_lock(&isku->isku_lock); 155 retval = roccat_common2_send_with_status(usb_dev, command, 156 (void *)buf, count); 157 mutex_unlock(&isku->isku_lock); 158 159 return retval ? retval : count; 160 } 161 162 #define ISKU_SYSFS_W(thingy, THINGY) \ 163 static ssize_t isku_sysfs_write_ ## thingy(struct file *fp, struct kobject *kobj, \ 164 struct bin_attribute *attr, char *buf, \ 165 loff_t off, size_t count) \ 166 { \ 167 return isku_sysfs_write(fp, kobj, buf, off, count, \ 168 ISKU_SIZE_ ## THINGY, ISKU_COMMAND_ ## THINGY); \ 169 } 170 171 #define ISKU_SYSFS_R(thingy, THINGY) \ 172 static ssize_t isku_sysfs_read_ ## thingy(struct file *fp, struct kobject *kobj, \ 173 struct bin_attribute *attr, char *buf, \ 174 loff_t off, size_t count) \ 175 { \ 176 return isku_sysfs_read(fp, kobj, buf, off, count, \ 177 ISKU_SIZE_ ## THINGY, ISKU_COMMAND_ ## THINGY); \ 178 } 179 180 #define ISKU_SYSFS_RW(thingy, THINGY) \ 181 ISKU_SYSFS_R(thingy, THINGY) \ 182 ISKU_SYSFS_W(thingy, THINGY) 183 184 #define ISKU_BIN_ATTR_RW(thingy, THINGY) \ 185 ISKU_SYSFS_RW(thingy, THINGY); \ 186 static struct bin_attribute bin_attr_##thingy = { \ 187 .attr = { .name = #thingy, .mode = 0660 }, \ 188 .size = ISKU_SIZE_ ## THINGY, \ 189 .read = isku_sysfs_read_ ## thingy, \ 190 .write = isku_sysfs_write_ ## thingy \ 191 } 192 193 #define ISKU_BIN_ATTR_R(thingy, THINGY) \ 194 ISKU_SYSFS_R(thingy, THINGY); \ 195 static struct bin_attribute bin_attr_##thingy = { \ 196 .attr = { .name = #thingy, .mode = 0440 }, \ 197 .size = ISKU_SIZE_ ## THINGY, \ 198 .read = isku_sysfs_read_ ## thingy, \ 199 } 200 201 #define ISKU_BIN_ATTR_W(thingy, THINGY) \ 202 ISKU_SYSFS_W(thingy, THINGY); \ 203 static struct bin_attribute bin_attr_##thingy = { \ 204 .attr = { .name = #thingy, .mode = 0220 }, \ 205 .size = ISKU_SIZE_ ## THINGY, \ 206 .write = isku_sysfs_write_ ## thingy \ 207 } 208 209 ISKU_BIN_ATTR_RW(macro, MACRO); 210 ISKU_BIN_ATTR_RW(keys_function, KEYS_FUNCTION); 211 ISKU_BIN_ATTR_RW(keys_easyzone, KEYS_EASYZONE); 212 ISKU_BIN_ATTR_RW(keys_media, KEYS_MEDIA); 213 ISKU_BIN_ATTR_RW(keys_thumbster, KEYS_THUMBSTER); 214 ISKU_BIN_ATTR_RW(keys_macro, KEYS_MACRO); 215 ISKU_BIN_ATTR_RW(keys_capslock, KEYS_CAPSLOCK); 216 ISKU_BIN_ATTR_RW(light, LIGHT); 217 ISKU_BIN_ATTR_RW(key_mask, KEY_MASK); 218 ISKU_BIN_ATTR_RW(last_set, LAST_SET); 219 ISKU_BIN_ATTR_W(talk, TALK); 220 ISKU_BIN_ATTR_W(talkfx, TALKFX); 221 ISKU_BIN_ATTR_W(control, CONTROL); 222 ISKU_BIN_ATTR_W(reset, RESET); 223 ISKU_BIN_ATTR_R(info, INFO); 224 225 static struct bin_attribute *isku_bin_attributes[] = { 226 &bin_attr_macro, 227 &bin_attr_keys_function, 228 &bin_attr_keys_easyzone, 229 &bin_attr_keys_media, 230 &bin_attr_keys_thumbster, 231 &bin_attr_keys_macro, 232 &bin_attr_keys_capslock, 233 &bin_attr_light, 234 &bin_attr_key_mask, 235 &bin_attr_last_set, 236 &bin_attr_talk, 237 &bin_attr_talkfx, 238 &bin_attr_control, 239 &bin_attr_reset, 240 &bin_attr_info, 241 NULL, 242 }; 243 244 static const struct attribute_group isku_group = { 245 .attrs = isku_attrs, 246 .bin_attrs = isku_bin_attributes, 247 }; 248 249 static const struct attribute_group *isku_groups[] = { 250 &isku_group, 251 NULL, 252 }; 253 254 static int isku_init_isku_device_struct(struct usb_device *usb_dev, 255 struct isku_device *isku) 256 { 257 int retval; 258 259 mutex_init(&isku->isku_lock); 260 261 retval = isku_get_actual_profile(usb_dev); 262 if (retval < 0) 263 return retval; 264 isku_profile_activated(isku, retval); 265 266 return 0; 267 } 268 269 static int isku_init_specials(struct hid_device *hdev) 270 { 271 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 272 struct usb_device *usb_dev = interface_to_usbdev(intf); 273 struct isku_device *isku; 274 int retval; 275 276 if (intf->cur_altsetting->desc.bInterfaceProtocol 277 != ISKU_USB_INTERFACE_PROTOCOL) { 278 hid_set_drvdata(hdev, NULL); 279 return 0; 280 } 281 282 isku = kzalloc(sizeof(*isku), GFP_KERNEL); 283 if (!isku) { 284 hid_err(hdev, "can't alloc device descriptor\n"); 285 return -ENOMEM; 286 } 287 hid_set_drvdata(hdev, isku); 288 289 retval = isku_init_isku_device_struct(usb_dev, isku); 290 if (retval) { 291 hid_err(hdev, "couldn't init struct isku_device\n"); 292 goto exit_free; 293 } 294 295 retval = roccat_connect(isku_class, hdev, 296 sizeof(struct isku_roccat_report)); 297 if (retval < 0) { 298 hid_err(hdev, "couldn't init char dev\n"); 299 } else { 300 isku->chrdev_minor = retval; 301 isku->roccat_claimed = 1; 302 } 303 304 return 0; 305 exit_free: 306 kfree(isku); 307 return retval; 308 } 309 310 static void isku_remove_specials(struct hid_device *hdev) 311 { 312 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 313 struct isku_device *isku; 314 315 if (intf->cur_altsetting->desc.bInterfaceProtocol 316 != ISKU_USB_INTERFACE_PROTOCOL) 317 return; 318 319 isku = hid_get_drvdata(hdev); 320 if (isku->roccat_claimed) 321 roccat_disconnect(isku->chrdev_minor); 322 kfree(isku); 323 } 324 325 static int isku_probe(struct hid_device *hdev, 326 const struct hid_device_id *id) 327 { 328 int retval; 329 330 retval = hid_parse(hdev); 331 if (retval) { 332 hid_err(hdev, "parse failed\n"); 333 goto exit; 334 } 335 336 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 337 if (retval) { 338 hid_err(hdev, "hw start failed\n"); 339 goto exit; 340 } 341 342 retval = isku_init_specials(hdev); 343 if (retval) { 344 hid_err(hdev, "couldn't install keyboard\n"); 345 goto exit_stop; 346 } 347 348 return 0; 349 350 exit_stop: 351 hid_hw_stop(hdev); 352 exit: 353 return retval; 354 } 355 356 static void isku_remove(struct hid_device *hdev) 357 { 358 isku_remove_specials(hdev); 359 hid_hw_stop(hdev); 360 } 361 362 static void isku_keep_values_up_to_date(struct isku_device *isku, 363 u8 const *data) 364 { 365 struct isku_report_button const *button_report; 366 367 switch (data[0]) { 368 case ISKU_REPORT_NUMBER_BUTTON: 369 button_report = (struct isku_report_button const *)data; 370 switch (button_report->event) { 371 case ISKU_REPORT_BUTTON_EVENT_PROFILE: 372 isku_profile_activated(isku, button_report->data1 - 1); 373 break; 374 } 375 break; 376 } 377 } 378 379 static void isku_report_to_chrdev(struct isku_device const *isku, 380 u8 const *data) 381 { 382 struct isku_roccat_report roccat_report; 383 struct isku_report_button const *button_report; 384 385 if (data[0] != ISKU_REPORT_NUMBER_BUTTON) 386 return; 387 388 button_report = (struct isku_report_button const *)data; 389 390 roccat_report.event = button_report->event; 391 roccat_report.data1 = button_report->data1; 392 roccat_report.data2 = button_report->data2; 393 roccat_report.profile = isku->actual_profile + 1; 394 roccat_report_event(isku->chrdev_minor, 395 (uint8_t const *)&roccat_report); 396 } 397 398 static int isku_raw_event(struct hid_device *hdev, 399 struct hid_report *report, u8 *data, int size) 400 { 401 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 402 struct isku_device *isku = hid_get_drvdata(hdev); 403 404 if (intf->cur_altsetting->desc.bInterfaceProtocol 405 != ISKU_USB_INTERFACE_PROTOCOL) 406 return 0; 407 408 if (isku == NULL) 409 return 0; 410 411 isku_keep_values_up_to_date(isku, data); 412 413 if (isku->roccat_claimed) 414 isku_report_to_chrdev(isku, data); 415 416 return 0; 417 } 418 419 static const struct hid_device_id isku_devices[] = { 420 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) }, 421 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKUFX) }, 422 { } 423 }; 424 425 MODULE_DEVICE_TABLE(hid, isku_devices); 426 427 static struct hid_driver isku_driver = { 428 .name = "isku", 429 .id_table = isku_devices, 430 .probe = isku_probe, 431 .remove = isku_remove, 432 .raw_event = isku_raw_event 433 }; 434 435 static int __init isku_init(void) 436 { 437 int retval; 438 isku_class = class_create(THIS_MODULE, "isku"); 439 if (IS_ERR(isku_class)) 440 return PTR_ERR(isku_class); 441 isku_class->dev_groups = isku_groups; 442 443 retval = hid_register_driver(&isku_driver); 444 if (retval) 445 class_destroy(isku_class); 446 return retval; 447 } 448 449 static void __exit isku_exit(void) 450 { 451 hid_unregister_driver(&isku_driver); 452 class_destroy(isku_class); 453 } 454 455 module_init(isku_init); 456 module_exit(isku_exit); 457 458 MODULE_AUTHOR("Stefan Achatz"); 459 MODULE_DESCRIPTION("USB Roccat Isku/FX driver"); 460 MODULE_LICENSE("GPL v2"); 461