1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * corsair-cpro.c - Linux driver for Corsair Commander Pro 4 * Copyright (C) 2020 Marius Zachmann <mail@mariuszachmann.de> 5 * 6 * This driver uses hid reports to communicate with the device to allow hidraw userspace drivers 7 * still being used. The device does not use report ids. When using hidraw and this driver 8 * simultaniously, reports could be switched. 9 */ 10 11 #include <linux/bitops.h> 12 #include <linux/completion.h> 13 #include <linux/debugfs.h> 14 #include <linux/hid.h> 15 #include <linux/hwmon.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/mutex.h> 19 #include <linux/seq_file.h> 20 #include <linux/slab.h> 21 #include <linux/spinlock.h> 22 #include <linux/types.h> 23 24 #define USB_VENDOR_ID_CORSAIR 0x1b1c 25 #define USB_PRODUCT_ID_CORSAIR_COMMANDERPRO 0x0c10 26 #define USB_PRODUCT_ID_CORSAIR_1000D 0x1d00 27 28 #define OUT_BUFFER_SIZE 63 29 #define IN_BUFFER_SIZE 16 30 #define LABEL_LENGTH 11 31 #define REQ_TIMEOUT 300 32 33 #define CTL_GET_FW_VER 0x02 /* returns the firmware version in bytes 1-3 */ 34 #define CTL_GET_BL_VER 0x06 /* returns the bootloader version in bytes 1-2 */ 35 #define CTL_GET_TMP_CNCT 0x10 /* 36 * returns in bytes 1-4 for each temp sensor: 37 * 0 not connected 38 * 1 connected 39 */ 40 #define CTL_GET_TMP 0x11 /* 41 * send: byte 1 is channel, rest zero 42 * rcv: returns temp for channel in centi-degree celsius 43 * in bytes 1 and 2 44 * returns 0x11 in byte 0 if no sensor is connected 45 */ 46 #define CTL_GET_VOLT 0x12 /* 47 * send: byte 1 is rail number: 0 = 12v, 1 = 5v, 2 = 3.3v 48 * rcv: returns millivolt in bytes 1,2 49 * returns error 0x10 if request is invalid 50 */ 51 #define CTL_GET_FAN_CNCT 0x20 /* 52 * returns in bytes 1-6 for each fan: 53 * 0 not connected 54 * 1 3pin 55 * 2 4pin 56 */ 57 #define CTL_GET_FAN_RPM 0x21 /* 58 * send: byte 1 is channel, rest zero 59 * rcv: returns rpm in bytes 1,2 60 */ 61 #define CTL_GET_FAN_PWM 0x22 /* 62 * send: byte 1 is channel, rest zero 63 * rcv: returns pwm in byte 1 if it was set 64 * returns error 0x12 if fan is controlled via 65 * fan_target or fan curve 66 */ 67 #define CTL_SET_FAN_FPWM 0x23 /* 68 * set fixed pwm 69 * send: byte 1 is fan number 70 * send: byte 2 is percentage from 0 - 100 71 */ 72 #define CTL_SET_FAN_TARGET 0x24 /* 73 * set target rpm 74 * send: byte 1 is fan number 75 * send: byte 2-3 is target 76 * device accepts all values from 0x00 - 0xFFFF 77 */ 78 79 #define NUM_FANS 6 80 #define NUM_TEMP_SENSORS 4 81 82 struct ccp_device { 83 struct hid_device *hdev; 84 struct device *hwmon_dev; 85 struct dentry *debugfs; 86 /* For reinitializing the completion below */ 87 spinlock_t wait_input_report_lock; 88 struct completion wait_input_report; 89 struct mutex mutex; /* whenever buffer is used, lock before send_usb_cmd */ 90 u8 *cmd_buffer; 91 u8 *buffer; 92 int target[6]; 93 DECLARE_BITMAP(temp_cnct, NUM_TEMP_SENSORS); 94 DECLARE_BITMAP(fan_cnct, NUM_FANS); 95 char fan_label[6][LABEL_LENGTH]; 96 u8 firmware_ver[3]; 97 u8 bootloader_ver[2]; 98 }; 99 100 /* converts response error in buffer to errno */ 101 static int ccp_get_errno(struct ccp_device *ccp) 102 { 103 switch (ccp->buffer[0]) { 104 case 0x00: /* success */ 105 return 0; 106 case 0x01: /* called invalid command */ 107 return -EOPNOTSUPP; 108 case 0x10: /* called GET_VOLT / GET_TMP with invalid arguments */ 109 return -EINVAL; 110 case 0x11: /* requested temps of disconnected sensors */ 111 case 0x12: /* requested pwm of not pwm controlled channels */ 112 return -ENODATA; 113 default: 114 hid_dbg(ccp->hdev, "unknown device response error: %d", ccp->buffer[0]); 115 return -EIO; 116 } 117 } 118 119 /* send command, check for error in response, response in ccp->buffer */ 120 static int send_usb_cmd(struct ccp_device *ccp, u8 command, u8 byte1, u8 byte2, u8 byte3) 121 { 122 unsigned long t; 123 int ret; 124 125 memset(ccp->cmd_buffer, 0x00, OUT_BUFFER_SIZE); 126 ccp->cmd_buffer[0] = command; 127 ccp->cmd_buffer[1] = byte1; 128 ccp->cmd_buffer[2] = byte2; 129 ccp->cmd_buffer[3] = byte3; 130 131 /* 132 * Disable raw event parsing for a moment to safely reinitialize the 133 * completion. Reinit is done because hidraw could have triggered 134 * the raw event parsing and marked the ccp->wait_input_report 135 * completion as done. 136 */ 137 spin_lock_bh(&ccp->wait_input_report_lock); 138 reinit_completion(&ccp->wait_input_report); 139 spin_unlock_bh(&ccp->wait_input_report_lock); 140 141 ret = hid_hw_output_report(ccp->hdev, ccp->cmd_buffer, OUT_BUFFER_SIZE); 142 if (ret < 0) 143 return ret; 144 145 t = wait_for_completion_timeout(&ccp->wait_input_report, msecs_to_jiffies(REQ_TIMEOUT)); 146 if (!t) 147 return -ETIMEDOUT; 148 149 return ccp_get_errno(ccp); 150 } 151 152 static int ccp_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) 153 { 154 struct ccp_device *ccp = hid_get_drvdata(hdev); 155 156 /* only copy buffer when requested */ 157 spin_lock(&ccp->wait_input_report_lock); 158 if (!completion_done(&ccp->wait_input_report)) { 159 memcpy(ccp->buffer, data, min(IN_BUFFER_SIZE, size)); 160 complete_all(&ccp->wait_input_report); 161 } 162 spin_unlock(&ccp->wait_input_report_lock); 163 164 return 0; 165 } 166 167 /* requests and returns single data values depending on channel */ 168 static int get_data(struct ccp_device *ccp, int command, int channel, bool two_byte_data) 169 { 170 int ret; 171 172 mutex_lock(&ccp->mutex); 173 174 ret = send_usb_cmd(ccp, command, channel, 0, 0); 175 if (ret) 176 goto out_unlock; 177 178 ret = ccp->buffer[1]; 179 if (two_byte_data) 180 ret = (ret << 8) + ccp->buffer[2]; 181 182 out_unlock: 183 mutex_unlock(&ccp->mutex); 184 return ret; 185 } 186 187 static int set_pwm(struct ccp_device *ccp, int channel, long val) 188 { 189 int ret; 190 191 if (val < 0 || val > 255) 192 return -EINVAL; 193 194 /* The Corsair Commander Pro uses values from 0-100 */ 195 val = DIV_ROUND_CLOSEST(val * 100, 255); 196 197 mutex_lock(&ccp->mutex); 198 199 ret = send_usb_cmd(ccp, CTL_SET_FAN_FPWM, channel, val, 0); 200 if (!ret) 201 ccp->target[channel] = -ENODATA; 202 203 mutex_unlock(&ccp->mutex); 204 return ret; 205 } 206 207 static int set_target(struct ccp_device *ccp, int channel, long val) 208 { 209 int ret; 210 211 val = clamp_val(val, 0, 0xFFFF); 212 ccp->target[channel] = val; 213 214 mutex_lock(&ccp->mutex); 215 ret = send_usb_cmd(ccp, CTL_SET_FAN_TARGET, channel, val >> 8, val); 216 217 mutex_unlock(&ccp->mutex); 218 return ret; 219 } 220 221 static int ccp_read_string(struct device *dev, enum hwmon_sensor_types type, 222 u32 attr, int channel, const char **str) 223 { 224 struct ccp_device *ccp = dev_get_drvdata(dev); 225 226 switch (type) { 227 case hwmon_fan: 228 switch (attr) { 229 case hwmon_fan_label: 230 *str = ccp->fan_label[channel]; 231 return 0; 232 default: 233 break; 234 } 235 break; 236 default: 237 break; 238 } 239 240 return -EOPNOTSUPP; 241 } 242 243 static int ccp_read(struct device *dev, enum hwmon_sensor_types type, 244 u32 attr, int channel, long *val) 245 { 246 struct ccp_device *ccp = dev_get_drvdata(dev); 247 int ret; 248 249 switch (type) { 250 case hwmon_temp: 251 switch (attr) { 252 case hwmon_temp_input: 253 ret = get_data(ccp, CTL_GET_TMP, channel, true); 254 if (ret < 0) 255 return ret; 256 *val = ret * 10; 257 return 0; 258 default: 259 break; 260 } 261 break; 262 case hwmon_fan: 263 switch (attr) { 264 case hwmon_fan_input: 265 ret = get_data(ccp, CTL_GET_FAN_RPM, channel, true); 266 if (ret < 0) 267 return ret; 268 *val = ret; 269 return 0; 270 case hwmon_fan_target: 271 /* how to read target values from the device is unknown */ 272 /* driver returns last set value or 0 */ 273 if (ccp->target[channel] < 0) 274 return -ENODATA; 275 *val = ccp->target[channel]; 276 return 0; 277 default: 278 break; 279 } 280 break; 281 case hwmon_pwm: 282 switch (attr) { 283 case hwmon_pwm_input: 284 ret = get_data(ccp, CTL_GET_FAN_PWM, channel, false); 285 if (ret < 0) 286 return ret; 287 *val = DIV_ROUND_CLOSEST(ret * 255, 100); 288 return 0; 289 default: 290 break; 291 } 292 break; 293 case hwmon_in: 294 switch (attr) { 295 case hwmon_in_input: 296 ret = get_data(ccp, CTL_GET_VOLT, channel, true); 297 if (ret < 0) 298 return ret; 299 *val = ret; 300 return 0; 301 default: 302 break; 303 } 304 break; 305 default: 306 break; 307 } 308 309 return -EOPNOTSUPP; 310 }; 311 312 static int ccp_write(struct device *dev, enum hwmon_sensor_types type, 313 u32 attr, int channel, long val) 314 { 315 struct ccp_device *ccp = dev_get_drvdata(dev); 316 317 switch (type) { 318 case hwmon_pwm: 319 switch (attr) { 320 case hwmon_pwm_input: 321 return set_pwm(ccp, channel, val); 322 default: 323 break; 324 } 325 break; 326 case hwmon_fan: 327 switch (attr) { 328 case hwmon_fan_target: 329 return set_target(ccp, channel, val); 330 default: 331 break; 332 } 333 break; 334 default: 335 break; 336 } 337 338 return -EOPNOTSUPP; 339 }; 340 341 static umode_t ccp_is_visible(const void *data, enum hwmon_sensor_types type, 342 u32 attr, int channel) 343 { 344 const struct ccp_device *ccp = data; 345 346 switch (type) { 347 case hwmon_temp: 348 if (!test_bit(channel, ccp->temp_cnct)) 349 break; 350 351 switch (attr) { 352 case hwmon_temp_input: 353 return 0444; 354 case hwmon_temp_label: 355 return 0444; 356 default: 357 break; 358 } 359 break; 360 case hwmon_fan: 361 if (!test_bit(channel, ccp->fan_cnct)) 362 break; 363 364 switch (attr) { 365 case hwmon_fan_input: 366 return 0444; 367 case hwmon_fan_label: 368 return 0444; 369 case hwmon_fan_target: 370 return 0644; 371 default: 372 break; 373 } 374 break; 375 case hwmon_pwm: 376 if (!test_bit(channel, ccp->fan_cnct)) 377 break; 378 379 switch (attr) { 380 case hwmon_pwm_input: 381 return 0644; 382 default: 383 break; 384 } 385 break; 386 case hwmon_in: 387 switch (attr) { 388 case hwmon_in_input: 389 return 0444; 390 default: 391 break; 392 } 393 break; 394 default: 395 break; 396 } 397 398 return 0; 399 }; 400 401 static const struct hwmon_ops ccp_hwmon_ops = { 402 .is_visible = ccp_is_visible, 403 .read = ccp_read, 404 .read_string = ccp_read_string, 405 .write = ccp_write, 406 }; 407 408 static const struct hwmon_channel_info * const ccp_info[] = { 409 HWMON_CHANNEL_INFO(chip, 410 HWMON_C_REGISTER_TZ), 411 HWMON_CHANNEL_INFO(temp, 412 HWMON_T_INPUT, 413 HWMON_T_INPUT, 414 HWMON_T_INPUT, 415 HWMON_T_INPUT 416 ), 417 HWMON_CHANNEL_INFO(fan, 418 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_TARGET, 419 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_TARGET, 420 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_TARGET, 421 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_TARGET, 422 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_TARGET, 423 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_TARGET 424 ), 425 HWMON_CHANNEL_INFO(pwm, 426 HWMON_PWM_INPUT, 427 HWMON_PWM_INPUT, 428 HWMON_PWM_INPUT, 429 HWMON_PWM_INPUT, 430 HWMON_PWM_INPUT, 431 HWMON_PWM_INPUT 432 ), 433 HWMON_CHANNEL_INFO(in, 434 HWMON_I_INPUT, 435 HWMON_I_INPUT, 436 HWMON_I_INPUT 437 ), 438 NULL 439 }; 440 441 static const struct hwmon_chip_info ccp_chip_info = { 442 .ops = &ccp_hwmon_ops, 443 .info = ccp_info, 444 }; 445 446 /* read fan connection status and set labels */ 447 static int get_fan_cnct(struct ccp_device *ccp) 448 { 449 int channel; 450 int mode; 451 int ret; 452 453 ret = send_usb_cmd(ccp, CTL_GET_FAN_CNCT, 0, 0, 0); 454 if (ret) 455 return ret; 456 457 for (channel = 0; channel < NUM_FANS; channel++) { 458 mode = ccp->buffer[channel + 1]; 459 if (mode == 0) 460 continue; 461 462 set_bit(channel, ccp->fan_cnct); 463 ccp->target[channel] = -ENODATA; 464 465 switch (mode) { 466 case 1: 467 scnprintf(ccp->fan_label[channel], LABEL_LENGTH, 468 "fan%d 3pin", channel + 1); 469 break; 470 case 2: 471 scnprintf(ccp->fan_label[channel], LABEL_LENGTH, 472 "fan%d 4pin", channel + 1); 473 break; 474 default: 475 scnprintf(ccp->fan_label[channel], LABEL_LENGTH, 476 "fan%d other", channel + 1); 477 break; 478 } 479 } 480 481 return 0; 482 } 483 484 /* read temp sensor connection status */ 485 static int get_temp_cnct(struct ccp_device *ccp) 486 { 487 int channel; 488 int mode; 489 int ret; 490 491 ret = send_usb_cmd(ccp, CTL_GET_TMP_CNCT, 0, 0, 0); 492 if (ret) 493 return ret; 494 495 for (channel = 0; channel < NUM_TEMP_SENSORS; channel++) { 496 mode = ccp->buffer[channel + 1]; 497 if (mode == 0) 498 continue; 499 500 set_bit(channel, ccp->temp_cnct); 501 } 502 503 return 0; 504 } 505 506 /* read firmware version */ 507 static int get_fw_version(struct ccp_device *ccp) 508 { 509 int ret; 510 511 ret = send_usb_cmd(ccp, CTL_GET_FW_VER, 0, 0, 0); 512 if (ret) { 513 hid_notice(ccp->hdev, "Failed to read firmware version.\n"); 514 return ret; 515 } 516 ccp->firmware_ver[0] = ccp->buffer[1]; 517 ccp->firmware_ver[1] = ccp->buffer[2]; 518 ccp->firmware_ver[2] = ccp->buffer[3]; 519 520 return 0; 521 } 522 523 /* read bootloader version */ 524 static int get_bl_version(struct ccp_device *ccp) 525 { 526 int ret; 527 528 ret = send_usb_cmd(ccp, CTL_GET_BL_VER, 0, 0, 0); 529 if (ret) { 530 hid_notice(ccp->hdev, "Failed to read bootloader version.\n"); 531 return ret; 532 } 533 ccp->bootloader_ver[0] = ccp->buffer[1]; 534 ccp->bootloader_ver[1] = ccp->buffer[2]; 535 536 return 0; 537 } 538 539 static int firmware_show(struct seq_file *seqf, void *unused) 540 { 541 struct ccp_device *ccp = seqf->private; 542 543 seq_printf(seqf, "%d.%d.%d\n", 544 ccp->firmware_ver[0], 545 ccp->firmware_ver[1], 546 ccp->firmware_ver[2]); 547 548 return 0; 549 } 550 DEFINE_SHOW_ATTRIBUTE(firmware); 551 552 static int bootloader_show(struct seq_file *seqf, void *unused) 553 { 554 struct ccp_device *ccp = seqf->private; 555 556 seq_printf(seqf, "%d.%d\n", 557 ccp->bootloader_ver[0], 558 ccp->bootloader_ver[1]); 559 560 return 0; 561 } 562 DEFINE_SHOW_ATTRIBUTE(bootloader); 563 564 static void ccp_debugfs_init(struct ccp_device *ccp) 565 { 566 char name[32]; 567 int ret; 568 569 scnprintf(name, sizeof(name), "corsaircpro-%s", dev_name(&ccp->hdev->dev)); 570 ccp->debugfs = debugfs_create_dir(name, NULL); 571 572 ret = get_fw_version(ccp); 573 if (!ret) 574 debugfs_create_file("firmware_version", 0444, 575 ccp->debugfs, ccp, &firmware_fops); 576 577 ret = get_bl_version(ccp); 578 if (!ret) 579 debugfs_create_file("bootloader_version", 0444, 580 ccp->debugfs, ccp, &bootloader_fops); 581 } 582 583 static int ccp_probe(struct hid_device *hdev, const struct hid_device_id *id) 584 { 585 struct ccp_device *ccp; 586 int ret; 587 588 ccp = devm_kzalloc(&hdev->dev, sizeof(*ccp), GFP_KERNEL); 589 if (!ccp) 590 return -ENOMEM; 591 592 ccp->cmd_buffer = devm_kmalloc(&hdev->dev, OUT_BUFFER_SIZE, GFP_KERNEL); 593 if (!ccp->cmd_buffer) 594 return -ENOMEM; 595 596 ccp->buffer = devm_kmalloc(&hdev->dev, IN_BUFFER_SIZE, GFP_KERNEL); 597 if (!ccp->buffer) 598 return -ENOMEM; 599 600 ret = hid_parse(hdev); 601 if (ret) 602 return ret; 603 604 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); 605 if (ret) 606 return ret; 607 608 ret = hid_hw_open(hdev); 609 if (ret) 610 goto out_hw_stop; 611 612 ccp->hdev = hdev; 613 hid_set_drvdata(hdev, ccp); 614 615 mutex_init(&ccp->mutex); 616 spin_lock_init(&ccp->wait_input_report_lock); 617 init_completion(&ccp->wait_input_report); 618 619 hid_device_io_start(hdev); 620 621 /* temp and fan connection status only updates when device is powered on */ 622 ret = get_temp_cnct(ccp); 623 if (ret) 624 goto out_hw_close; 625 626 ret = get_fan_cnct(ccp); 627 if (ret) 628 goto out_hw_close; 629 630 ccp_debugfs_init(ccp); 631 632 ccp->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "corsaircpro", 633 ccp, &ccp_chip_info, NULL); 634 if (IS_ERR(ccp->hwmon_dev)) { 635 ret = PTR_ERR(ccp->hwmon_dev); 636 goto out_hw_close; 637 } 638 639 return 0; 640 641 out_hw_close: 642 hid_hw_close(hdev); 643 out_hw_stop: 644 hid_hw_stop(hdev); 645 return ret; 646 } 647 648 static void ccp_remove(struct hid_device *hdev) 649 { 650 struct ccp_device *ccp = hid_get_drvdata(hdev); 651 652 debugfs_remove_recursive(ccp->debugfs); 653 hwmon_device_unregister(ccp->hwmon_dev); 654 hid_hw_close(hdev); 655 hid_hw_stop(hdev); 656 } 657 658 static const struct hid_device_id ccp_devices[] = { 659 { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_PRODUCT_ID_CORSAIR_COMMANDERPRO) }, 660 { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_PRODUCT_ID_CORSAIR_1000D) }, 661 { } 662 }; 663 664 static struct hid_driver ccp_driver = { 665 .name = "corsair-cpro", 666 .id_table = ccp_devices, 667 .probe = ccp_probe, 668 .remove = ccp_remove, 669 .raw_event = ccp_raw_event, 670 }; 671 672 MODULE_DEVICE_TABLE(hid, ccp_devices); 673 MODULE_DESCRIPTION("Corsair Commander Pro controller driver"); 674 MODULE_LICENSE("GPL"); 675 676 static int __init ccp_init(void) 677 { 678 return hid_register_driver(&ccp_driver); 679 } 680 681 static void __exit ccp_exit(void) 682 { 683 hid_unregister_driver(&ccp_driver); 684 } 685 686 /* 687 * When compiling this driver as built-in, hwmon initcalls will get called before the 688 * hid driver and this driver would fail to register. late_initcall solves this. 689 */ 690 late_initcall(ccp_init); 691 module_exit(ccp_exit); 692