1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * hwmon driver for Aquacomputer devices (D5 Next, Farbwerk, Farbwerk 360, Octo, 4 * Quadro, High Flow Next) 5 * 6 * Aquacomputer devices send HID reports (with ID 0x01) every second to report 7 * sensor values. 8 * 9 * Copyright 2021 Aleksa Savic <savicaleksa83@gmail.com> 10 * Copyright 2022 Jack Doan <me@jackdoan.com> 11 */ 12 13 #include <linux/crc16.h> 14 #include <linux/debugfs.h> 15 #include <linux/hid.h> 16 #include <linux/hwmon.h> 17 #include <linux/jiffies.h> 18 #include <linux/module.h> 19 #include <linux/mutex.h> 20 #include <linux/seq_file.h> 21 #include <asm/unaligned.h> 22 23 #define USB_VENDOR_ID_AQUACOMPUTER 0x0c70 24 #define USB_PRODUCT_ID_FARBWERK 0xf00a 25 #define USB_PRODUCT_ID_QUADRO 0xf00d 26 #define USB_PRODUCT_ID_D5NEXT 0xf00e 27 #define USB_PRODUCT_ID_FARBWERK360 0xf010 28 #define USB_PRODUCT_ID_OCTO 0xf011 29 #define USB_PRODUCT_ID_HIGHFLOWNEXT 0xf012 30 31 enum kinds { d5next, farbwerk, farbwerk360, octo, quadro, highflownext }; 32 33 static const char *const aqc_device_names[] = { 34 [d5next] = "d5next", 35 [farbwerk] = "farbwerk", 36 [farbwerk360] = "farbwerk360", 37 [octo] = "octo", 38 [quadro] = "quadro", 39 [highflownext] = "highflownext" 40 }; 41 42 #define DRIVER_NAME "aquacomputer_d5next" 43 44 #define STATUS_REPORT_ID 0x01 45 #define STATUS_UPDATE_INTERVAL (2 * HZ) /* In seconds */ 46 #define SERIAL_FIRST_PART 3 47 #define SERIAL_SECOND_PART 5 48 #define FIRMWARE_VERSION 13 49 50 #define CTRL_REPORT_ID 0x03 51 52 /* The HID report that the official software always sends 53 * after writing values, currently same for all devices 54 */ 55 #define SECONDARY_CTRL_REPORT_ID 0x02 56 #define SECONDARY_CTRL_REPORT_SIZE 0x0B 57 58 static u8 secondary_ctrl_report[] = { 59 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x34, 0xC6 60 }; 61 62 /* Register offsets for all Aquacomputer devices */ 63 #define AQC_TEMP_SENSOR_SIZE 0x02 64 #define AQC_TEMP_SENSOR_DISCONNECTED 0x7FFF 65 #define AQC_FAN_PERCENT_OFFSET 0x00 66 #define AQC_FAN_VOLTAGE_OFFSET 0x02 67 #define AQC_FAN_CURRENT_OFFSET 0x04 68 #define AQC_FAN_POWER_OFFSET 0x06 69 #define AQC_FAN_SPEED_OFFSET 0x08 70 71 /* Register offsets for the D5 Next pump */ 72 #define D5NEXT_POWER_CYCLES 0x18 73 #define D5NEXT_COOLANT_TEMP 0x57 74 #define D5NEXT_NUM_FANS 2 75 #define D5NEXT_NUM_SENSORS 1 76 #define D5NEXT_NUM_VIRTUAL_SENSORS 8 77 #define D5NEXT_VIRTUAL_SENSORS_START 0x3f 78 #define D5NEXT_PUMP_OFFSET 0x6c 79 #define D5NEXT_FAN_OFFSET 0x5f 80 #define D5NEXT_5V_VOLTAGE 0x39 81 #define D5NEXT_12V_VOLTAGE 0x37 82 #define D5NEXT_CTRL_REPORT_SIZE 0x329 83 static u8 d5next_sensor_fan_offsets[] = { D5NEXT_PUMP_OFFSET, D5NEXT_FAN_OFFSET }; 84 85 /* Pump and fan speed registers in D5 Next control report (from 0-100%) */ 86 static u16 d5next_ctrl_fan_offsets[] = { 0x97, 0x42 }; 87 88 /* Register offsets for the Farbwerk RGB controller */ 89 #define FARBWERK_NUM_SENSORS 4 90 #define FARBWERK_SENSOR_START 0x2f 91 92 /* Register offsets for the Farbwerk 360 RGB controller */ 93 #define FARBWERK360_NUM_SENSORS 4 94 #define FARBWERK360_SENSOR_START 0x32 95 #define FARBWERK360_NUM_VIRTUAL_SENSORS 16 96 #define FARBWERK360_VIRTUAL_SENSORS_START 0x3a 97 98 /* Register offsets for the Octo fan controller */ 99 #define OCTO_POWER_CYCLES 0x18 100 #define OCTO_NUM_FANS 8 101 #define OCTO_NUM_SENSORS 4 102 #define OCTO_SENSOR_START 0x3D 103 #define OCTO_NUM_VIRTUAL_SENSORS 16 104 #define OCTO_VIRTUAL_SENSORS_START 0x45 105 #define OCTO_CTRL_REPORT_SIZE 0x65F 106 static u8 octo_sensor_fan_offsets[] = { 0x7D, 0x8A, 0x97, 0xA4, 0xB1, 0xBE, 0xCB, 0xD8 }; 107 108 /* Fan speed registers in Octo control report (from 0-100%) */ 109 static u16 octo_ctrl_fan_offsets[] = { 0x5B, 0xB0, 0x105, 0x15A, 0x1AF, 0x204, 0x259, 0x2AE }; 110 111 /* Register offsets for the Quadro fan controller */ 112 #define QUADRO_POWER_CYCLES 0x18 113 #define QUADRO_NUM_FANS 4 114 #define QUADRO_NUM_SENSORS 4 115 #define QUADRO_SENSOR_START 0x34 116 #define QUADRO_NUM_VIRTUAL_SENSORS 16 117 #define QUADRO_VIRTUAL_SENSORS_START 0x3c 118 #define QUADRO_CTRL_REPORT_SIZE 0x3c1 119 #define QUADRO_FLOW_SENSOR_OFFSET 0x6e 120 static u8 quadro_sensor_fan_offsets[] = { 0x70, 0x7D, 0x8A, 0x97 }; 121 122 /* Fan speed registers in Quadro control report (from 0-100%) */ 123 static u16 quadro_ctrl_fan_offsets[] = { 0x37, 0x8c, 0xe1, 0x136 }; 124 125 /* Register offsets for the High Flow Next */ 126 #define HIGHFLOWNEXT_NUM_SENSORS 2 127 #define HIGHFLOWNEXT_SENSOR_START 85 128 #define HIGHFLOWNEXT_FLOW 81 129 #define HIGHFLOWNEXT_WATER_QUALITY 89 130 #define HIGHFLOWNEXT_POWER 91 131 #define HIGHFLOWNEXT_CONDUCTIVITY 95 132 #define HIGHFLOWNEXT_5V_VOLTAGE 97 133 #define HIGHFLOWNEXT_5V_VOLTAGE_USB 99 134 135 /* Labels for D5 Next */ 136 static const char *const label_d5next_temp[] = { 137 "Coolant temp" 138 }; 139 140 static const char *const label_d5next_speeds[] = { 141 "Pump speed", 142 "Fan speed" 143 }; 144 145 static const char *const label_d5next_power[] = { 146 "Pump power", 147 "Fan power" 148 }; 149 150 static const char *const label_d5next_voltages[] = { 151 "Pump voltage", 152 "Fan voltage", 153 "+5V voltage", 154 "+12V voltage" 155 }; 156 157 static const char *const label_d5next_current[] = { 158 "Pump current", 159 "Fan current" 160 }; 161 162 /* Labels for Farbwerk, Farbwerk 360 and Octo and Quadro temperature sensors */ 163 static const char *const label_temp_sensors[] = { 164 "Sensor 1", 165 "Sensor 2", 166 "Sensor 3", 167 "Sensor 4" 168 }; 169 170 static const char *const label_virtual_temp_sensors[] = { 171 "Virtual sensor 1", 172 "Virtual sensor 2", 173 "Virtual sensor 3", 174 "Virtual sensor 4", 175 "Virtual sensor 5", 176 "Virtual sensor 6", 177 "Virtual sensor 7", 178 "Virtual sensor 8", 179 "Virtual sensor 9", 180 "Virtual sensor 10", 181 "Virtual sensor 11", 182 "Virtual sensor 12", 183 "Virtual sensor 13", 184 "Virtual sensor 14", 185 "Virtual sensor 15", 186 "Virtual sensor 16", 187 }; 188 189 /* Labels for Octo and Quadro (except speed) */ 190 static const char *const label_fan_speed[] = { 191 "Fan 1 speed", 192 "Fan 2 speed", 193 "Fan 3 speed", 194 "Fan 4 speed", 195 "Fan 5 speed", 196 "Fan 6 speed", 197 "Fan 7 speed", 198 "Fan 8 speed" 199 }; 200 201 static const char *const label_fan_power[] = { 202 "Fan 1 power", 203 "Fan 2 power", 204 "Fan 3 power", 205 "Fan 4 power", 206 "Fan 5 power", 207 "Fan 6 power", 208 "Fan 7 power", 209 "Fan 8 power" 210 }; 211 212 static const char *const label_fan_voltage[] = { 213 "Fan 1 voltage", 214 "Fan 2 voltage", 215 "Fan 3 voltage", 216 "Fan 4 voltage", 217 "Fan 5 voltage", 218 "Fan 6 voltage", 219 "Fan 7 voltage", 220 "Fan 8 voltage" 221 }; 222 223 static const char *const label_fan_current[] = { 224 "Fan 1 current", 225 "Fan 2 current", 226 "Fan 3 current", 227 "Fan 4 current", 228 "Fan 5 current", 229 "Fan 6 current", 230 "Fan 7 current", 231 "Fan 8 current" 232 }; 233 234 /* Labels for Quadro fan speeds */ 235 static const char *const label_quadro_speeds[] = { 236 "Fan 1 speed", 237 "Fan 2 speed", 238 "Fan 3 speed", 239 "Fan 4 speed", 240 "Flow speed [dL/h]" 241 }; 242 243 /* Labels for High Flow Next */ 244 static const char *const label_highflownext_temp_sensors[] = { 245 "Coolant temp", 246 "External sensor" 247 }; 248 249 static const char *const label_highflownext_fan_speed[] = { 250 "Flow [dL/h]", 251 "Water quality [%]", 252 "Conductivity [nS/cm]", 253 }; 254 255 static const char *const label_highflownext_power[] = { 256 "Dissipated power", 257 }; 258 259 static const char *const label_highflownext_voltage[] = { 260 "+5V voltage", 261 "+5V USB voltage" 262 }; 263 264 struct aqc_data { 265 struct hid_device *hdev; 266 struct device *hwmon_dev; 267 struct dentry *debugfs; 268 struct mutex mutex; /* Used for locking access when reading and writing PWM values */ 269 enum kinds kind; 270 const char *name; 271 272 int buffer_size; 273 u8 *buffer; 274 int checksum_start; 275 int checksum_length; 276 int checksum_offset; 277 278 int num_fans; 279 u8 *fan_sensor_offsets; 280 u16 *fan_ctrl_offsets; 281 int num_temp_sensors; 282 int temp_sensor_start_offset; 283 int num_virtual_temp_sensors; 284 int virtual_temp_sensor_start_offset; 285 u16 power_cycle_count_offset; 286 u8 flow_sensor_offset; 287 288 /* General info, same across all devices */ 289 u32 serial_number[2]; 290 u16 firmware_version; 291 292 /* How many times the device was powered on, if available */ 293 u32 power_cycles; 294 295 /* Sensor values */ 296 s32 temp_input[20]; /* Max 4 physical and 16 virtual */ 297 u16 speed_input[8]; 298 u32 power_input[8]; 299 u16 voltage_input[8]; 300 u16 current_input[8]; 301 302 /* Label values */ 303 const char *const *temp_label; 304 const char *const *virtual_temp_label; 305 const char *const *speed_label; 306 const char *const *power_label; 307 const char *const *voltage_label; 308 const char *const *current_label; 309 310 unsigned long updated; 311 }; 312 313 /* Converts from centi-percent */ 314 static int aqc_percent_to_pwm(u16 val) 315 { 316 return DIV_ROUND_CLOSEST(val * 255, 100 * 100); 317 } 318 319 /* Converts to centi-percent */ 320 static int aqc_pwm_to_percent(long val) 321 { 322 if (val < 0 || val > 255) 323 return -EINVAL; 324 325 return DIV_ROUND_CLOSEST(val * 100 * 100, 255); 326 } 327 328 /* Expects the mutex to be locked */ 329 static int aqc_get_ctrl_data(struct aqc_data *priv) 330 { 331 int ret; 332 333 memset(priv->buffer, 0x00, priv->buffer_size); 334 ret = hid_hw_raw_request(priv->hdev, CTRL_REPORT_ID, priv->buffer, priv->buffer_size, 335 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 336 if (ret < 0) 337 ret = -ENODATA; 338 339 return ret; 340 } 341 342 /* Expects the mutex to be locked */ 343 static int aqc_send_ctrl_data(struct aqc_data *priv) 344 { 345 int ret; 346 u16 checksum; 347 348 /* Init and xorout value for CRC-16/USB is 0xffff */ 349 checksum = crc16(0xffff, priv->buffer + priv->checksum_start, priv->checksum_length); 350 checksum ^= 0xffff; 351 352 /* Place the new checksum at the end of the report */ 353 put_unaligned_be16(checksum, priv->buffer + priv->checksum_offset); 354 355 /* Send the patched up report back to the device */ 356 ret = hid_hw_raw_request(priv->hdev, CTRL_REPORT_ID, priv->buffer, priv->buffer_size, 357 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 358 if (ret < 0) 359 return ret; 360 361 /* The official software sends this report after every change, so do it here as well */ 362 ret = hid_hw_raw_request(priv->hdev, SECONDARY_CTRL_REPORT_ID, secondary_ctrl_report, 363 SECONDARY_CTRL_REPORT_SIZE, HID_FEATURE_REPORT, 364 HID_REQ_SET_REPORT); 365 return ret; 366 } 367 368 /* Refreshes the control buffer and returns value at offset */ 369 static int aqc_get_ctrl_val(struct aqc_data *priv, int offset) 370 { 371 int ret; 372 373 mutex_lock(&priv->mutex); 374 375 ret = aqc_get_ctrl_data(priv); 376 if (ret < 0) 377 goto unlock_and_return; 378 379 ret = get_unaligned_be16(priv->buffer + offset); 380 381 unlock_and_return: 382 mutex_unlock(&priv->mutex); 383 return ret; 384 } 385 386 static int aqc_set_ctrl_val(struct aqc_data *priv, int offset, long val) 387 { 388 int ret; 389 390 mutex_lock(&priv->mutex); 391 392 ret = aqc_get_ctrl_data(priv); 393 if (ret < 0) 394 goto unlock_and_return; 395 396 put_unaligned_be16((u16)val, priv->buffer + offset); 397 398 ret = aqc_send_ctrl_data(priv); 399 400 unlock_and_return: 401 mutex_unlock(&priv->mutex); 402 return ret; 403 } 404 405 static umode_t aqc_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel) 406 { 407 const struct aqc_data *priv = data; 408 409 switch (type) { 410 case hwmon_temp: 411 if (channel < priv->num_temp_sensors + priv->num_virtual_temp_sensors) 412 return 0444; 413 break; 414 case hwmon_pwm: 415 if (priv->fan_ctrl_offsets && channel < priv->num_fans) { 416 switch (attr) { 417 case hwmon_pwm_input: 418 return 0644; 419 default: 420 break; 421 } 422 } 423 break; 424 case hwmon_fan: 425 switch (priv->kind) { 426 case highflownext: 427 /* Special case to support flow sensor, water quality and conductivity */ 428 if (channel < 3) 429 return 0444; 430 break; 431 case quadro: 432 /* Special case to support flow sensor */ 433 if (channel < priv->num_fans + 1) 434 return 0444; 435 break; 436 default: 437 if (channel < priv->num_fans) 438 return 0444; 439 break; 440 } 441 break; 442 case hwmon_power: 443 switch (priv->kind) { 444 case highflownext: 445 /* Special case to support one power sensor */ 446 if (channel == 0) 447 return 0444; 448 break; 449 default: 450 if (channel < priv->num_fans) 451 return 0444; 452 break; 453 } 454 break; 455 case hwmon_curr: 456 if (channel < priv->num_fans) 457 return 0444; 458 break; 459 case hwmon_in: 460 switch (priv->kind) { 461 case d5next: 462 /* Special case to support +5V and +12V voltage sensors */ 463 if (channel < priv->num_fans + 2) 464 return 0444; 465 break; 466 case highflownext: 467 /* Special case to support two voltage sensors */ 468 if (channel < 2) 469 return 0444; 470 break; 471 default: 472 if (channel < priv->num_fans) 473 return 0444; 474 break; 475 } 476 break; 477 default: 478 break; 479 } 480 481 return 0; 482 } 483 484 static int aqc_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 485 int channel, long *val) 486 { 487 int ret; 488 struct aqc_data *priv = dev_get_drvdata(dev); 489 490 if (time_after(jiffies, priv->updated + STATUS_UPDATE_INTERVAL)) 491 return -ENODATA; 492 493 switch (type) { 494 case hwmon_temp: 495 if (priv->temp_input[channel] == -ENODATA) 496 return -ENODATA; 497 498 *val = priv->temp_input[channel]; 499 break; 500 case hwmon_fan: 501 *val = priv->speed_input[channel]; 502 break; 503 case hwmon_power: 504 *val = priv->power_input[channel]; 505 break; 506 case hwmon_pwm: 507 if (priv->fan_ctrl_offsets) { 508 ret = aqc_get_ctrl_val(priv, priv->fan_ctrl_offsets[channel]); 509 if (ret < 0) 510 return ret; 511 512 *val = aqc_percent_to_pwm(ret); 513 } 514 break; 515 case hwmon_in: 516 *val = priv->voltage_input[channel]; 517 break; 518 case hwmon_curr: 519 *val = priv->current_input[channel]; 520 break; 521 default: 522 return -EOPNOTSUPP; 523 } 524 525 return 0; 526 } 527 528 static int aqc_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, 529 int channel, const char **str) 530 { 531 struct aqc_data *priv = dev_get_drvdata(dev); 532 533 switch (type) { 534 case hwmon_temp: 535 if (channel < priv->num_temp_sensors) 536 *str = priv->temp_label[channel]; 537 else 538 *str = priv->virtual_temp_label[channel - priv->num_temp_sensors]; 539 break; 540 case hwmon_fan: 541 *str = priv->speed_label[channel]; 542 break; 543 case hwmon_power: 544 *str = priv->power_label[channel]; 545 break; 546 case hwmon_in: 547 *str = priv->voltage_label[channel]; 548 break; 549 case hwmon_curr: 550 *str = priv->current_label[channel]; 551 break; 552 default: 553 return -EOPNOTSUPP; 554 } 555 556 return 0; 557 } 558 559 static int aqc_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 560 long val) 561 { 562 int ret, pwm_value; 563 struct aqc_data *priv = dev_get_drvdata(dev); 564 565 switch (type) { 566 case hwmon_pwm: 567 switch (attr) { 568 case hwmon_pwm_input: 569 if (priv->fan_ctrl_offsets) { 570 pwm_value = aqc_pwm_to_percent(val); 571 if (pwm_value < 0) 572 return pwm_value; 573 574 ret = aqc_set_ctrl_val(priv, priv->fan_ctrl_offsets[channel], 575 pwm_value); 576 if (ret < 0) 577 return ret; 578 } 579 break; 580 default: 581 break; 582 } 583 break; 584 default: 585 return -EOPNOTSUPP; 586 } 587 588 return 0; 589 } 590 591 static const struct hwmon_ops aqc_hwmon_ops = { 592 .is_visible = aqc_is_visible, 593 .read = aqc_read, 594 .read_string = aqc_read_string, 595 .write = aqc_write 596 }; 597 598 static const struct hwmon_channel_info *aqc_info[] = { 599 HWMON_CHANNEL_INFO(temp, 600 HWMON_T_INPUT | HWMON_T_LABEL, 601 HWMON_T_INPUT | HWMON_T_LABEL, 602 HWMON_T_INPUT | HWMON_T_LABEL, 603 HWMON_T_INPUT | HWMON_T_LABEL, 604 HWMON_T_INPUT | HWMON_T_LABEL, 605 HWMON_T_INPUT | HWMON_T_LABEL, 606 HWMON_T_INPUT | HWMON_T_LABEL, 607 HWMON_T_INPUT | HWMON_T_LABEL, 608 HWMON_T_INPUT | HWMON_T_LABEL, 609 HWMON_T_INPUT | HWMON_T_LABEL, 610 HWMON_T_INPUT | HWMON_T_LABEL, 611 HWMON_T_INPUT | HWMON_T_LABEL, 612 HWMON_T_INPUT | HWMON_T_LABEL, 613 HWMON_T_INPUT | HWMON_T_LABEL, 614 HWMON_T_INPUT | HWMON_T_LABEL, 615 HWMON_T_INPUT | HWMON_T_LABEL, 616 HWMON_T_INPUT | HWMON_T_LABEL, 617 HWMON_T_INPUT | HWMON_T_LABEL, 618 HWMON_T_INPUT | HWMON_T_LABEL, 619 HWMON_T_INPUT | HWMON_T_LABEL), 620 HWMON_CHANNEL_INFO(fan, 621 HWMON_F_INPUT | HWMON_F_LABEL, 622 HWMON_F_INPUT | HWMON_F_LABEL, 623 HWMON_F_INPUT | HWMON_F_LABEL, 624 HWMON_F_INPUT | HWMON_F_LABEL, 625 HWMON_F_INPUT | HWMON_F_LABEL, 626 HWMON_F_INPUT | HWMON_F_LABEL, 627 HWMON_F_INPUT | HWMON_F_LABEL, 628 HWMON_F_INPUT | HWMON_F_LABEL), 629 HWMON_CHANNEL_INFO(power, 630 HWMON_P_INPUT | HWMON_P_LABEL, 631 HWMON_P_INPUT | HWMON_P_LABEL, 632 HWMON_P_INPUT | HWMON_P_LABEL, 633 HWMON_P_INPUT | HWMON_P_LABEL, 634 HWMON_P_INPUT | HWMON_P_LABEL, 635 HWMON_P_INPUT | HWMON_P_LABEL, 636 HWMON_P_INPUT | HWMON_P_LABEL, 637 HWMON_P_INPUT | HWMON_P_LABEL), 638 HWMON_CHANNEL_INFO(pwm, 639 HWMON_PWM_INPUT, 640 HWMON_PWM_INPUT, 641 HWMON_PWM_INPUT, 642 HWMON_PWM_INPUT, 643 HWMON_PWM_INPUT, 644 HWMON_PWM_INPUT, 645 HWMON_PWM_INPUT, 646 HWMON_PWM_INPUT), 647 HWMON_CHANNEL_INFO(in, 648 HWMON_I_INPUT | HWMON_I_LABEL, 649 HWMON_I_INPUT | HWMON_I_LABEL, 650 HWMON_I_INPUT | HWMON_I_LABEL, 651 HWMON_I_INPUT | HWMON_I_LABEL, 652 HWMON_I_INPUT | HWMON_I_LABEL, 653 HWMON_I_INPUT | HWMON_I_LABEL, 654 HWMON_I_INPUT | HWMON_I_LABEL, 655 HWMON_I_INPUT | HWMON_I_LABEL), 656 HWMON_CHANNEL_INFO(curr, 657 HWMON_C_INPUT | HWMON_C_LABEL, 658 HWMON_C_INPUT | HWMON_C_LABEL, 659 HWMON_C_INPUT | HWMON_C_LABEL, 660 HWMON_C_INPUT | HWMON_C_LABEL, 661 HWMON_C_INPUT | HWMON_C_LABEL, 662 HWMON_C_INPUT | HWMON_C_LABEL, 663 HWMON_C_INPUT | HWMON_C_LABEL, 664 HWMON_C_INPUT | HWMON_C_LABEL), 665 NULL 666 }; 667 668 static const struct hwmon_chip_info aqc_chip_info = { 669 .ops = &aqc_hwmon_ops, 670 .info = aqc_info, 671 }; 672 673 static int aqc_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) 674 { 675 int i, j, sensor_value; 676 struct aqc_data *priv; 677 678 if (report->id != STATUS_REPORT_ID) 679 return 0; 680 681 priv = hid_get_drvdata(hdev); 682 683 /* Info provided with every report */ 684 priv->serial_number[0] = get_unaligned_be16(data + SERIAL_FIRST_PART); 685 priv->serial_number[1] = get_unaligned_be16(data + SERIAL_SECOND_PART); 686 priv->firmware_version = get_unaligned_be16(data + FIRMWARE_VERSION); 687 688 /* Physical temperature sensor readings */ 689 for (i = 0; i < priv->num_temp_sensors; i++) { 690 sensor_value = get_unaligned_be16(data + 691 priv->temp_sensor_start_offset + 692 i * AQC_TEMP_SENSOR_SIZE); 693 if (sensor_value == AQC_TEMP_SENSOR_DISCONNECTED) 694 priv->temp_input[i] = -ENODATA; 695 else 696 priv->temp_input[i] = sensor_value * 10; 697 } 698 699 /* Virtual temperature sensor readings */ 700 for (j = 0; j < priv->num_virtual_temp_sensors; j++) { 701 sensor_value = get_unaligned_be16(data + 702 priv->virtual_temp_sensor_start_offset + 703 j * AQC_TEMP_SENSOR_SIZE); 704 if (sensor_value == AQC_TEMP_SENSOR_DISCONNECTED) 705 priv->temp_input[i] = -ENODATA; 706 else 707 priv->temp_input[i] = sensor_value * 10; 708 i++; 709 } 710 711 /* Fan speed and related readings */ 712 for (i = 0; i < priv->num_fans; i++) { 713 priv->speed_input[i] = 714 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + AQC_FAN_SPEED_OFFSET); 715 priv->power_input[i] = 716 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + 717 AQC_FAN_POWER_OFFSET) * 10000; 718 priv->voltage_input[i] = 719 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + 720 AQC_FAN_VOLTAGE_OFFSET) * 10; 721 priv->current_input[i] = 722 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + AQC_FAN_CURRENT_OFFSET); 723 } 724 725 if (priv->power_cycle_count_offset != 0) 726 priv->power_cycles = get_unaligned_be32(data + priv->power_cycle_count_offset); 727 728 /* Special-case sensor readings */ 729 switch (priv->kind) { 730 case d5next: 731 priv->voltage_input[2] = get_unaligned_be16(data + D5NEXT_5V_VOLTAGE) * 10; 732 priv->voltage_input[3] = get_unaligned_be16(data + D5NEXT_12V_VOLTAGE) * 10; 733 break; 734 case quadro: 735 priv->speed_input[4] = get_unaligned_be16(data + priv->flow_sensor_offset); 736 break; 737 case highflownext: 738 /* If external temp sensor is not connected, its power reading is also N/A */ 739 if (priv->temp_input[1] == -ENODATA) 740 priv->power_input[0] = -ENODATA; 741 else 742 priv->power_input[0] = 743 get_unaligned_be16(data + HIGHFLOWNEXT_POWER) * 1000000; 744 745 priv->voltage_input[0] = get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE) * 10; 746 priv->voltage_input[1] = 747 get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE_USB) * 10; 748 749 priv->speed_input[0] = get_unaligned_be16(data + HIGHFLOWNEXT_FLOW); 750 priv->speed_input[1] = get_unaligned_be16(data + HIGHFLOWNEXT_WATER_QUALITY); 751 priv->speed_input[2] = get_unaligned_be16(data + HIGHFLOWNEXT_CONDUCTIVITY); 752 break; 753 default: 754 break; 755 } 756 757 priv->updated = jiffies; 758 759 return 0; 760 } 761 762 #ifdef CONFIG_DEBUG_FS 763 764 static int serial_number_show(struct seq_file *seqf, void *unused) 765 { 766 struct aqc_data *priv = seqf->private; 767 768 seq_printf(seqf, "%05u-%05u\n", priv->serial_number[0], priv->serial_number[1]); 769 770 return 0; 771 } 772 DEFINE_SHOW_ATTRIBUTE(serial_number); 773 774 static int firmware_version_show(struct seq_file *seqf, void *unused) 775 { 776 struct aqc_data *priv = seqf->private; 777 778 seq_printf(seqf, "%u\n", priv->firmware_version); 779 780 return 0; 781 } 782 DEFINE_SHOW_ATTRIBUTE(firmware_version); 783 784 static int power_cycles_show(struct seq_file *seqf, void *unused) 785 { 786 struct aqc_data *priv = seqf->private; 787 788 seq_printf(seqf, "%u\n", priv->power_cycles); 789 790 return 0; 791 } 792 DEFINE_SHOW_ATTRIBUTE(power_cycles); 793 794 static void aqc_debugfs_init(struct aqc_data *priv) 795 { 796 char name[64]; 797 798 scnprintf(name, sizeof(name), "%s_%s-%s", "aquacomputer", priv->name, 799 dev_name(&priv->hdev->dev)); 800 801 priv->debugfs = debugfs_create_dir(name, NULL); 802 debugfs_create_file("serial_number", 0444, priv->debugfs, priv, &serial_number_fops); 803 debugfs_create_file("firmware_version", 0444, priv->debugfs, priv, &firmware_version_fops); 804 805 if (priv->power_cycle_count_offset != 0) 806 debugfs_create_file("power_cycles", 0444, priv->debugfs, priv, &power_cycles_fops); 807 } 808 809 #else 810 811 static void aqc_debugfs_init(struct aqc_data *priv) 812 { 813 } 814 815 #endif 816 817 static int aqc_probe(struct hid_device *hdev, const struct hid_device_id *id) 818 { 819 struct aqc_data *priv; 820 int ret; 821 822 priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL); 823 if (!priv) 824 return -ENOMEM; 825 826 priv->hdev = hdev; 827 hid_set_drvdata(hdev, priv); 828 829 priv->updated = jiffies - STATUS_UPDATE_INTERVAL; 830 831 ret = hid_parse(hdev); 832 if (ret) 833 return ret; 834 835 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); 836 if (ret) 837 return ret; 838 839 ret = hid_hw_open(hdev); 840 if (ret) 841 goto fail_and_stop; 842 843 switch (hdev->product) { 844 case USB_PRODUCT_ID_D5NEXT: 845 priv->kind = d5next; 846 847 priv->num_fans = D5NEXT_NUM_FANS; 848 priv->fan_sensor_offsets = d5next_sensor_fan_offsets; 849 priv->fan_ctrl_offsets = d5next_ctrl_fan_offsets; 850 priv->num_temp_sensors = D5NEXT_NUM_SENSORS; 851 priv->temp_sensor_start_offset = D5NEXT_COOLANT_TEMP; 852 priv->num_virtual_temp_sensors = D5NEXT_NUM_VIRTUAL_SENSORS; 853 priv->virtual_temp_sensor_start_offset = D5NEXT_VIRTUAL_SENSORS_START; 854 priv->power_cycle_count_offset = D5NEXT_POWER_CYCLES; 855 priv->buffer_size = D5NEXT_CTRL_REPORT_SIZE; 856 857 priv->temp_label = label_d5next_temp; 858 priv->virtual_temp_label = label_virtual_temp_sensors; 859 priv->speed_label = label_d5next_speeds; 860 priv->power_label = label_d5next_power; 861 priv->voltage_label = label_d5next_voltages; 862 priv->current_label = label_d5next_current; 863 break; 864 case USB_PRODUCT_ID_FARBWERK: 865 priv->kind = farbwerk; 866 867 priv->num_fans = 0; 868 priv->num_temp_sensors = FARBWERK_NUM_SENSORS; 869 priv->temp_sensor_start_offset = FARBWERK_SENSOR_START; 870 priv->temp_label = label_temp_sensors; 871 break; 872 case USB_PRODUCT_ID_FARBWERK360: 873 priv->kind = farbwerk360; 874 875 priv->num_fans = 0; 876 priv->num_temp_sensors = FARBWERK360_NUM_SENSORS; 877 priv->temp_sensor_start_offset = FARBWERK360_SENSOR_START; 878 priv->num_virtual_temp_sensors = FARBWERK360_NUM_VIRTUAL_SENSORS; 879 priv->virtual_temp_sensor_start_offset = FARBWERK360_VIRTUAL_SENSORS_START; 880 881 priv->temp_label = label_temp_sensors; 882 priv->virtual_temp_label = label_virtual_temp_sensors; 883 break; 884 case USB_PRODUCT_ID_OCTO: 885 priv->kind = octo; 886 887 priv->num_fans = OCTO_NUM_FANS; 888 priv->fan_sensor_offsets = octo_sensor_fan_offsets; 889 priv->fan_ctrl_offsets = octo_ctrl_fan_offsets; 890 priv->num_temp_sensors = OCTO_NUM_SENSORS; 891 priv->temp_sensor_start_offset = OCTO_SENSOR_START; 892 priv->num_virtual_temp_sensors = OCTO_NUM_VIRTUAL_SENSORS; 893 priv->virtual_temp_sensor_start_offset = OCTO_VIRTUAL_SENSORS_START; 894 priv->power_cycle_count_offset = OCTO_POWER_CYCLES; 895 priv->buffer_size = OCTO_CTRL_REPORT_SIZE; 896 897 priv->temp_label = label_temp_sensors; 898 priv->virtual_temp_label = label_virtual_temp_sensors; 899 priv->speed_label = label_fan_speed; 900 priv->power_label = label_fan_power; 901 priv->voltage_label = label_fan_voltage; 902 priv->current_label = label_fan_current; 903 break; 904 case USB_PRODUCT_ID_QUADRO: 905 priv->kind = quadro; 906 907 priv->num_fans = QUADRO_NUM_FANS; 908 priv->fan_sensor_offsets = quadro_sensor_fan_offsets; 909 priv->fan_ctrl_offsets = quadro_ctrl_fan_offsets; 910 priv->num_temp_sensors = QUADRO_NUM_SENSORS; 911 priv->temp_sensor_start_offset = QUADRO_SENSOR_START; 912 priv->num_virtual_temp_sensors = QUADRO_NUM_VIRTUAL_SENSORS; 913 priv->virtual_temp_sensor_start_offset = QUADRO_VIRTUAL_SENSORS_START; 914 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES; 915 priv->buffer_size = QUADRO_CTRL_REPORT_SIZE; 916 priv->flow_sensor_offset = QUADRO_FLOW_SENSOR_OFFSET; 917 918 priv->temp_label = label_temp_sensors; 919 priv->virtual_temp_label = label_virtual_temp_sensors; 920 priv->speed_label = label_quadro_speeds; 921 priv->power_label = label_fan_power; 922 priv->voltage_label = label_fan_voltage; 923 priv->current_label = label_fan_current; 924 break; 925 case USB_PRODUCT_ID_HIGHFLOWNEXT: 926 priv->kind = highflownext; 927 928 priv->num_fans = 0; 929 priv->num_temp_sensors = HIGHFLOWNEXT_NUM_SENSORS; 930 priv->temp_sensor_start_offset = HIGHFLOWNEXT_SENSOR_START; 931 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES; 932 933 priv->temp_label = label_highflownext_temp_sensors; 934 priv->speed_label = label_highflownext_fan_speed; 935 priv->power_label = label_highflownext_power; 936 priv->voltage_label = label_highflownext_voltage; 937 break; 938 default: 939 break; 940 } 941 942 if (priv->buffer_size != 0) { 943 priv->checksum_start = 0x01; 944 priv->checksum_length = priv->buffer_size - 3; 945 priv->checksum_offset = priv->buffer_size - 2; 946 } 947 948 priv->name = aqc_device_names[priv->kind]; 949 950 priv->buffer = devm_kzalloc(&hdev->dev, priv->buffer_size, GFP_KERNEL); 951 if (!priv->buffer) { 952 ret = -ENOMEM; 953 goto fail_and_close; 954 } 955 956 mutex_init(&priv->mutex); 957 958 priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, priv->name, priv, 959 &aqc_chip_info, NULL); 960 961 if (IS_ERR(priv->hwmon_dev)) { 962 ret = PTR_ERR(priv->hwmon_dev); 963 goto fail_and_close; 964 } 965 966 aqc_debugfs_init(priv); 967 968 return 0; 969 970 fail_and_close: 971 hid_hw_close(hdev); 972 fail_and_stop: 973 hid_hw_stop(hdev); 974 return ret; 975 } 976 977 static void aqc_remove(struct hid_device *hdev) 978 { 979 struct aqc_data *priv = hid_get_drvdata(hdev); 980 981 debugfs_remove_recursive(priv->debugfs); 982 hwmon_device_unregister(priv->hwmon_dev); 983 984 hid_hw_close(hdev); 985 hid_hw_stop(hdev); 986 } 987 988 static const struct hid_device_id aqc_table[] = { 989 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_D5NEXT) }, 990 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK) }, 991 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK360) }, 992 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_OCTO) }, 993 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_QUADRO) }, 994 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOWNEXT) }, 995 { } 996 }; 997 998 MODULE_DEVICE_TABLE(hid, aqc_table); 999 1000 static struct hid_driver aqc_driver = { 1001 .name = DRIVER_NAME, 1002 .id_table = aqc_table, 1003 .probe = aqc_probe, 1004 .remove = aqc_remove, 1005 .raw_event = aqc_raw_event, 1006 }; 1007 1008 static int __init aqc_init(void) 1009 { 1010 return hid_register_driver(&aqc_driver); 1011 } 1012 1013 static void __exit aqc_exit(void) 1014 { 1015 hid_unregister_driver(&aqc_driver); 1016 } 1017 1018 /* Request to initialize after the HID bus to ensure it's not being loaded before */ 1019 late_initcall(aqc_init); 1020 module_exit(aqc_exit); 1021 1022 MODULE_LICENSE("GPL"); 1023 MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>"); 1024 MODULE_AUTHOR("Jack Doan <me@jackdoan.com>"); 1025 MODULE_DESCRIPTION("Hwmon driver for Aquacomputer devices"); 1026